W3C home > Mailing lists > Public > public-webont-comments@w3.org > July 2003

Re: RDFCore Comments on OWL Reference

From: Jim Hendler <hendler@cs.umd.edu>
Date: Wed, 23 Jul 2003 12:47:50 -0400
Message-Id: <p05200f1fbb446c5da70c@[10.0.1.3]>
To: Brian McBride <bwm@hplb.hpl.hp.com>, public-webont-comments@w3.org

At 5:48 PM +0100 5/2/03, Brian McBride wrote:

>#owlref-rdfcore-owl-class-denotation
>
>It has been suggested to RDFCore that owl:Class is not needed.  RDFCore
>requests the creation of test cases to clearly illustrate the differences
>between owl:Class and rdfs:Class.

Apologies - Pat Hayes wrote a response to this part of your message, 
but I somehow missed it in my issue tracking - thanks to Jeremy 
Carroll for recognizing the omission - below is Pat's answer:

At 12:26 PM -0500 6/12/03, pat hayes wrote:
>
>Why two kinds of class?
>
>RDFS has a notion of 'class'; the class of all RDFS classes is
>rdfs:Class.  OWL also has a notion of 'class', which is called there
>owl:Class. The natural question arises, why not identify these?
>
>A full answer would take a long time, but the brief version is that
>the RDFS and OWL-DL are based on different conceptions of what the
>world is like, and what counts as a 'class'.  The OWL-DL notion of
>what counts as a class is more limited than the RDFS notion.  So
>although owl:Class is a subclass of rdfs:Class, the reverse is not in
>general true.  OWL-DL obeys the rather strict categorization used by
>conventional description logics, where one thinks of the universe as
>consisting of 'individuals' which can be organized into classes but
>are not themselves classes; and in fact they also cannot be
>properties; and properties similarly can apply to individuals but not
>to classes. (RDFS, in contrast, tosses everything into one 'pot' and
>allows classes to contain anything, and properties to apply to
>anything, freely.)  The OWL-DL language is so constructed that it is
>considered a syntax error to write anything which would violate this
>restriction, so that for example
>
>owl:Class rdf:type owl:Class .
>
>is not even legal OWL-DL syntax; and it certainly would not be true,
>even if it could be said. Contrast this with the analogous assertion
>in RDFS:
>
>rdfs:Class rdf:type rdfs:Class .
>
>which is not only legal, but in fact is a logical truth in RDFS. Many
>other examples could be given - there are many such points of
>disagreement between RDFS and OWL-DL - but the general point can be
>made with this single example.
>
>Now consider using the OWL vocabulary in RDFS. There, the first
>example given above would be perfectly legal, but - if the URIref
>"owl:Class" is understood to mean the same as it means in OWL-DL - it
>would simply be false. In fact, owl:Class is a proper subset of
>rdfs:Class:
>
>owl:Class rdfs:subClassOf rdfs:Class .
>
>but not the reverse, in general: as the above shows, owl:Class does
>not contain itself, but rdfs:Class is the class of all RDFS classes,
>so it certainly contains owl:Class. (Note that there is no need to
>distinguish the *relationships* between things in the two languages:
>the subclass and membership relationships (rdfs:subClassOf, rdf:type)
>still hold between the OWL entities, but they are, of course,
>restricted in OWL to the things and classes in the OWL universe. This
>is just like saying that the relation of being a parent in the same
>relation used between humans as it is used between all mammals.)
>
>This is the brief summary of why two notions of 'class' are needed:
>to keep OWL-DL in alignment with RDFS, while preserving the meanings
>of the terminology used in both languages, one needs an RDFS name for
>the OWL-DL sub-universe. The distinctions between rdfs:Resource and
>owl:Thing, and between rdf:Property and owl:ObjectProperty,
>owl:DatatypeProperty, have similar motivations. In each case the OWL
>classes are proper subclasses of the corresponding RDFS classes
>(although this cannot be said in OWL-DL itself). One obvious utility
>of allowing the use of owl:Class in an RDFS ontology might be to
>allow an RDFS inference engine to determine whether some entities
>were indeed suitable for OWL-DL reasoning, by showing (in RDFS) that
>they were in the appropriate OWL subclasses of the RDFS general
>classifications rdfs:Class, rdf:Property and rdfs:Resource: note that
>this would be impossible to establish in OWL-DL itself, since the
>relevant RDFS superclasses cannot even be mentioned.
>
>Now, it is possible to use the OWL vocabulary in RDFS, without the
>OWL-DL syntactic restrictions, while at the same time claiming that
>the RDFS and OWL universes are identical - after all, one can say
>just about anything in RDFS, so it would be easy to assert that
>
>rdfs:Class rdfs:subClassOf owl:Class .
>rdfs:Resource rdfs:subClassOf owl:Thing .
>
>and (using a bit of OWL)
>
>rdf:Property rdfs:subClassOf _:x .
>_:x owl:unionOf _:y .
>_:y rdf:first owl:ObjectProperty .
>_:y rdf:rest _:z .
>_:z rdf:first owl_DatatypeProperty .
>_:z rdf:rest rdf:nil .
>
>And then with these assumptions, we can identify the OWL and RDFS
>universes. This hybrid is called OWL Full. It allows the same
>syntactic freedom as RDFS - it is in fact an RDF semantic extension
>of RDFS - and Peter has proven an ingenious theorem to the effect
>that if one restricts oneself to the OWL-DL syntactic case, then
>being in OWL-DL and being in OWL Full are indistinguishable states,
>as it were, so that OWL-DL is a genuine sublanguage of OWL Full,
>which itself is a genuine RDFS semantic extension.
>
>However, notice that there is a genuine tension here. This Full
>hybrid asserts that the OWL and RDFS universes are identical; but
>they are not, if we understand the OWL terminology according to
>OWL-DL. So OWL Full is constructed so that *either* it must be
>incommensurate with OWL-DL - ie the OWL terminology must have
>different meanings in the two versions of OWL - *or* it is a
>restriction of RDFS to the OWL-DL universe, which makes it
>incommensurate with much of RDFS - for example, many RDFS logical
>truths will be false in OWL Full, under this interpretation. So OWL
>Full either breaks with OWL-DL, or amounts to a grand claim that the
>entire RDFS universe must be understood as conforming to the limited
>OWL-DL 'layered' framework.
>
>It is easy to see that both versions of OWL (DL and Full) could
>safely, each in their own terms, merge the concepts of owl:Class and
>rdfs:Class without actually breaking 'internally': OWL-DL could
>because it is simply unable to express the ways that RDFS classes
>differ from OWL classes - what might be called a 'thought police' way
>of making the vocabularies similar - and OWL Full could simply
>because it is simply asserts that they are identical.  But as I hope
>the above makes clear, this assertion would be troublesome for any
>kind of consistent interaction between OWL-DL and other RDFS
>applications. For example, if OWL-DL were to use the
>rdfs:Class/Resource/rdf:Property terminology while in fact referring
>only to the OWL-DL subsets of these classes, then OWL-DL theorems
>would become sharply false when transcribed into RDFS, and vice
>versa; for example,
>
>_:x rdf:type _:x .
>_:x rdf:type rdfs:Class .
>
>is logically true in RDFS (by rules se1 and se2 from the
>self-membership of rdfs:Class) but would be a logical contradiction
>in OWL-DL if rdfs:Class were identified there with owl:Class. Again,
>many other examples could be given.



-- 
Professor James Hendler				  hendler@cs.umd.edu
Director, Semantic Web and Agent Technologies	  301-405-2696
Maryland Information and Network Dynamics Lab.	  301-405-6707 (Fax)
Univ of Maryland, College Park, MD 20742	  *** 240-277-3388 (Cell)
http://www.cs.umd.edu/users/hendler      *** NOTE CHANGED CELL NUMBER ***
Received on Wednesday, 23 July 2003 12:48:07 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:43:29 GMT