Re: RDF as a syntax for OWL (was Re: same-syntax extensions to RDF)

Hi, Peter

I will have to come back later when I have more running
code to sharply illustrate what I found feasable.

The example I gave was from
http://www.w3.org/2003/08/owl-systems/test-results-out#table_6_Extra 
Credit DL
where all implementations at that moment gave undecided.
(I still wanted to check that case as I had some doubts :))

Anyhow, what I did was simply rewriting the OWL/RDF/XML
in RDF/N3 and then transcribe that in TSTP and run it as
eprover -l4 --tstp-in inconsistent502.tstp | epclextract --tstp-out
The reverse transcribing of the TSTP proof is what I'm
interested in to see as (swebized) RDF/N3 to connect
it with other pieces of RDF/N3, in which for instance
{} values are used instead of URI reference to lemmas.


-- 
Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/




"Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
05/01/2005 05:31

 
        To:     Jos De_Roo/AMDUS/MOR/Agfa-NV/BE/BAYER@AGFA
        cc:     www-rdf-logic@w3.org
        Subject:        RDF as a syntax for OWL (was Re: same-syntax extensions to RDF)


I am trying to determine just what is being demonstrated here.

Are you saying that you find it easy to build a complete parser (i.e.,
translator) for OWL in RDF/XML?  Are you saying that you find it easy to
build an incomplete parser for OWL in RDF/XML?  Are you saying that you
find it easy to build a species validator for OWL in RDF/XML?


As a data point, here is size information (from wc output) for a complete
parser for a surface syntax version of the OWL abstract syntax, including 
a
Lex lexer and a Yacc parser.

 Lines  Words  Chars File                                Purpose
    79    397   2433 abstractLex.mll             Lex lexer for OWL DL 
ontologies
   200   1080   7491 abstractYacc.mly            Yacc parser for OWL DL 
ontologies
    63    351   2823 ontologySyntax.ml           Abstract OWL ontologies 
as output from Yacc
   245   1206  11217 abstractParse.ml            OWL parsing code

Here is size information for a parser for OWL (and SWRL, although SWRL
doesn't add much to the size) in RDF/XML.  Note that this code takes as
input a DOM-like data structure, i.e., it requires the use of an XML 
parser

 Lines  Words  Chars File                                Purpose
   542   2799  22930 rdfxml.ml                           RDF/XML to RDF 
graph translator
    62    329   2074 rdfGraph.ml                 RDF graph data structure
   179    996   7379 categories.ml               Names and categories for 
OWL syntax tokens
  1067   6554  47938 owl.ml                              Turn an RDF graph 
into an abstract OWL ontology

The code uses a common data structure for ontologies from the following
file (most of which is a pretty-printer for OWL DL ontologies)

 Lines  Words  Chars File                                Purpose
   347   1617  14921 ontology.ml                 Datastructure for OWL DL 
ontologies

The largest and trickiest, by far, part of all this code is the part that
turns an RDF graph into an abstract OWL ontology. 

In summary, taking an RDF graph (totally parsed and in a nice internal 
data
structure) and turning it into an OWL DL ontology is much more difficult
than taking a UTF8-encoded ASCII file and turning it into an OWL DL
ontology.

Peter F. Patel-Schneider
Bell Labs Research







From: jos.deroo@agfa.com
Subject: Re: same-syntax extensions to RDF
Date: Wed, 5 Jan 2005 02:57:17 +0100

> 
> waw Bijan!
> I haven't experienced most of your issues, both as developer and
> as user i.e. even not a while ago
> http://lists.w3.org/Archives/Public/www-archive/2004Aug/0024.html
> 
> [[
> found a proof using the E prover
> http://www4.informatik.tu-muenchen.de/~schulz/WORK/eprover.html
> for the OWL test case
> http://www.w3.org/2002/03owlt/description-logic/inconsistent502.rdf
> which we translated into
> http://lists.w3.org/Archives/Public/www-archive/2004Aug/att-0024/inconsistent502.tstp
> and the proof is
> http://lists.w3.org/Archives/Public/www-archive/2004Aug/att-0024/inconsistent502-proof.tstp
> 
> (both are in the TSTP format
> http://www.cs.miami.edu/~tptp/TSTP/
> but that can be connected to the "proof bus" using N3)
> ]]
> 
> we can't find that proof with euler but can convert it
> back to N3 and use it's triples, well given that
> {{:a :b :c} :d :e. {:f :g :h} :i :j} :k {{:l :m :n} :o :p}.
> is 1 triple with nested triples and respecting
> 
>   whenever, in a sentence, we wish to say something
>   about a certain thing, we have to use, in this
>   sentence, not the thing itself but its name or
>   designation -- Alfred Tarski
> 
> So I believe that all those "certain things" are
> rdfs resources, wether they be {} or literal values
> or URI referenced things, the names are just
> different designations.
> 
> -- 
> Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/
> 
> 
> 
> 
> Bijan Parsia <bparsia@isr.umd.edu>
> Sent by: www-rdf-logic-request@w3.org
> 04/01/2005 13:43
> 
> 
>         To:     www-rdf-logic@w3.org
>         cc:     (bcc: Jos De_Roo/AMDUS/MOR/Agfa-NV/BE/BAYER)
>         Subject:        Re: same-syntax extensions to RDF
> 
> 
> 
> Sandro Hawke <sandro@w3.org>  wrote:
> > "R.V.Guha" <guha@guha.com> wrote:
> [snip]
> >>  This infatuation with reducing everything to RDF is at best
> >>  amusing.
> >
> > Really?
> 
> Nope. I would say that it's not even at best amusing.
> 
> > Don't you find it useful that so much can be stated in RDF?
> 
> And this evidences why: not much *can* be *stated* in RDF. That so much 
> is required to be straightjacketed (aka, encoded) in RDF is just 
> painful, not merely useless. What exactly is it useful for?
> 
> It complicates almost *everything*. If you aren't feeling the pain then 
> I would submit that you are cheating somewhere. I speak as implementor 
> or co-implementor of a number of tools, both purely research and 
> nigh-production.
> 
> What's really distressing is how much time ends up RDFing about syntax, 
> something RDF is especially poor at (both at being and at expressing). 
> Instead of eliminating the need to write parsers, it complicates the 
> parser writing task enormously *AND* robs us of almost all our tools! 
> (XML stylesheets...anyone?) As an example, I challenge you to write a 
> program to convert the concepts in an owl ontology into negation normal 
> form. This is a *trivial* transformation, but a very important one. In 
> fact, almost any straightforward normalization task is made way more 
> complicated.
> 
> >  I find
> > RDF data very nice to work with.
> 
> I've found that not to be true for either implementors or users or 
> developers (using RDF toolkits). Where it is true, the tasks in 
> question are either ABoxy tasks (so things are fine) or involve either 
> misunderstanding or a cheat (often unknowingly).
> 
> When we use RDF this way we treat it as if it were XML. XML without 
> DTDs even. Without well-formedness!
> 
> (Note that I've not even touched how brutally tiresome it makes the 
> semantics, even when the semantics works.)
> 
> (Note that I've not even touched how painful it is for people I've 
> taught. We almost always end up falling back on standard logic syntax. 
> This is not Turtle vs. RDF/XML...it's not the awful xml serialization 
> alone, it's the relentless triplization.)
> 
> So, it sucks for authoring; in sucks for 
> parsing/rendering/tranforming/reasoning/storing/querying; it sucks for 
> reading; it sucks for teaching; it sucks for extending; it sucks for 
> metatheory.
> 
> Cheers,
> Bijan Parsia.
> 
> 
> 
> 
>

Received on Wednesday, 5 January 2005 13:22:48 UTC