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 04:31:44 UTC