- From: Jos De_Roo <jos.deroo@agfa.com>
- Date: Fri, 13 Jun 2003 00:44:25 +0200
- To: "pat hayes <phayes" <phayes@ihmc.us>
- Cc: Jim Hendler <hendler@cs.umd.edu>, www-webont-wg@w3.org, www-webont-wg-request@w3.org
Pat, I did a test in your "remaining agnostic"
and erased
owl:Class owl:equivalentClass rdfs:Class.
owl:Thing owl:equivalentClass rdfs:Resource.
from the assumptions we made in owl-rules.
All the testcases we could prove before, we
can still prove, actually in 5% fewer steps...
So I guess I remain agnostic ;-)
--
Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/
pat hayes
<phayes@ihmc.us> To: Jim Hendler <hendler@cs.umd.edu>
Sent by: cc: www-webont-wg@w3.org
www-webont-wg-requ Subject: draft response to #owlref-rdfcore-owl-class-denotation
est@w3.org
2003-06-12 07:26
PM
(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 18:44:49 UTC