W3C home > Mailing lists > Public > www-webont-wg@w3.org > June 2003

draft response to #owlref-rdfcore-owl-class-denotation

From: pat hayes <phayes@ihmc.us>
Date: Thu, 12 Jun 2003 12:26:05 -0500
Message-Id: <p05210619bb0e67d77c61@[10.0.100.24]>
To: Jim Hendler <hendler@cs.umd.edu>
Cc: www-webont-wg@w3.org


(I sent this to Jim CCd to Webont on 6/6/03, but it seems not to have 
made it into the archives.  So here it is again.
-Pat)
-------------------

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.

------

Pat

-- 
---------------------------------------------------------------------
IHMC			(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.		(850)202 4416   office
Pensacola               			(850)202 4440   fax
FL 32501            			(850)291 0667    cell
phayes@ai.uwf.edu	          http://www.ihmc.us/users/phayes
s.pam@ai.uwf.edu   for spam
Received on Thursday, 12 June 2003 13:26:06 GMT

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