W3C home > Mailing lists > Public > public-owl-dev@w3.org > October to December 2007

RE: [OWLWG-COMMENT] ISSUE-55 (owl:class)

From: Hans Teijgeler <hans.teijgeler@quicknet.nl>
Date: Sat, 8 Dec 2007 18:41:55 +0100
To: "'Michael Schneider'" <schneid@fzi.de>
Cc: "'Owl Dev'" <public-owl-dev@w3.org>, <hendler@cs.rpi.edu>, <alanruttenberg@gmail.com>, <boris.motik@comlab.ox.ac.uk>, <pfps@research.bell-labs.com>, <ian.horrocks@comlab.ox.ac.uk>, <dlm@ksl.stanford.edu>
Message-ID: <000501c839c1$a45c8fa0$6c7ba8c0@hans>

Hi Michael,

Clear analysis, perhaps with some conflicting statements:
1) "If one creates a new OWL ontology, one always should use 'owl:Class'
instead of 'rdfs:Class'";
2) "Assume 'rdfs:Class' in RDFS ontologies, assume 'owl:Class' in OWL
3) "OWL-Full is meant to be a semantic extension to RDFS. Thus, in OWL-Full
owl:Class is the same as rdfs:Class."  

So what's the final outcome?

We have built, and are still building, OWL ontologies in which "instance-of"
chains are possible. So we deal with OWL Full. So be it.
But does this mean that we'd have to change owl:Classes back to
rdfs:Classes, following the rationale:
- "OWL Full is a semantic extension of RDFS";
- hence an OWL Full ontology is an RDFS ontology;
- "assume rdfs:Class in RDFS ontologies" ?
Or am I completely off-track?


-----Original Message-----
From: Michael Schneider [mailto:schneid@fzi.de] 
Sent: Saturday, December 08, 2007 16:20
To: Owl Dev
Cc: hendler@cs.rpi.edu; alanruttenberg@gmail.com;
boris.motik@comlab.ox.ac.uk; pfps@research.bell-labs.com;
ian.horrocks@comlab.ox.ac.uk; dlm@ksl.stanford.edu;
Subject: [OWLWG-COMMENT] ISSUE-55 (owl:class)

[public comment to OWL-WG discussion
also posting to WG members involved in the discussion]


In the OWL-WG mailing list, there is an ongoing debate about whether the
class owl:Class should be identifed with rdfs:Class in OWL-1.1-DL. The
argumentation, according to James Hendler, is that many existing OWL
ontologies are in OWL-Full only because they use rdfs:Class instead of
owl:Class. See the respective issue:


The reason for having so many OWL ontologies containing rdfs:Class seems to
be that many people do not fully understand, when to use 'owl:Class' and
when to use 'rdfs:Class'.

There has already been some discussion in the WG list about the problems
with the request for changing rdfs:Class to owl:Class. So my comment will
focus more on trying to explain where the difference between rdfs:Class and
owl:Class come from. I will also make a few recommendations on how to cope
with the situation.

In order to understand the difference between owl:Class and rdfs:Class in
OWL-DL, one has to go to the RDF semantics [1]. In RDF semantics, the
universe of all entities, about which one can make assertions, is
rdfs:Resource. So everything is a resource, even classes. Classes are those
resources, which happen to have a "class extension". The class extension of
a class resource C is just the set of all resources x, for which the

  x rdf:type C

holds. Because in the RDF view of the world, classes are itself resources,
they may be contained in the class extension of other class resources. In
principle, there may be arbitrary length "instance-of" chains like:

  C1 rdf:type C2 rdf:type C3 rdf:type C4 ...

The subset of rdfs:Resource, which consists of all class resources, is
called 'rdfs:Class'. Note that 'rdfs:Class' is defined in the RDF semantics
document (section 4.1 in [1]), not in the OWL spec! On the one hand,
rdfs:Class is a /resource/, simply because it is just an entity of the
world, about which one can make assertions. On the other hand, rdfs:Class is
a /class/, because it has a class extension, which consists of all class
resources. But being itself a class resource means that rdfs:Class is itself
an instance of rdfs:Class, so the following statement is true in RDF(S):

  rdfs:Class rdf:type rdfs:Class

OWL-DL demands a clear separation between individuals and classes, so in
OWL-DL it is not allowed that some class can itself be an instance of
another class. This means that in OWL-DL the class rdfs:Class must *not* be
the class of all classes. Instead, a subclass of rdfs:Class, called
'owl:Class', has been introduced in OWL, which is meant to be the class of
all "allowed" OWL classes. This has the following consequences:

* In OWL-DL, the class owl:Class is a /strict/ subclass of rdfs:Class,
because if it were equivalent to rdfs:Class, the following assertion would
need to be true in OWL-DL according to the discussion above:

  owl:Class rdf:type owl:Class # does NOT hold in OWL-DL!

* In OWL-Full, the "allowed" classes are just all RDF(S) class resources,
because OWL-Full is meant to be a semantic extension to RDFS. Thus, in
OWL-Full owl:Class is the same as rdfs:Class.  

So from this discussion it should become clear that it would be an error to
identify owl:Class with rdfs:Class in OWL-DL(-1.1). Using rdfs:Class within
an OWL ontology is a little bit like saying: "Hereby I adopt the RDF(S) view
of the world." And from this point of view it seems to be ok that the
resulting ontology then falls into OWL-Full, which is, as said above, a
semantic extension to RDFS.

Now, finally, here are my recommendations how to cope with the situation,
based on the above discussion:

* If one creates a new OWL ontology, one always should use 'owl:Class'
instead of 'rdfs:Class'. This will always be the right thing, because it is
the only possibility in OWL-DL, and in OWL-Full owl:Class is the same as
rdfs:Class, anyway. So there is /never/ a situation in OWL where the use of
'rdfs:Class' is necessary.

* The following recommendation is less conservative: OWL reasoners (even
OWL-Full reasoners) should always silently change occurrences of
'rdfs:Class' to 'owl:Class', for pretty much the same reasons as given in
the previous point. The only dangerours situation, which I can see, would be
if one accidentally uses an OWL-DL reasoner with an ontology, which is
intended to be an OWL-Full ontology. In this case, changing occurrences of
'rdfs:Class' to 'owl:Class' would be an error. But, AFAICS, this would only
become a real problem, if in this ontology some class is used as an
individual (metamodelling). But in such a case, even after changing
rdfs:Class to owl:Class, the resulting ontology would still be an OWL-Full
ontology: There would, for example, be an 'rdf:type' triple with some class
being at the individual position, or a class with an object or data property
attached. The OWL-DL reasoner would refuse to work in such a situation, of
course. So it looks to me that this recommendation is save.

Or to summarize these recommendations in a simple rule of thumb: Assume
'rdfs:Class' in RDFS ontologies, assume 'owl:Class' in OWL ontologies.


[1] RDF Semantics

Dipl.-Inform. Michael Schneider
FZI Forschungszentrum Informatik Karlsruhe Abtl. Information Process
Engineering (IPE) Tel  : +49-721-9654-726 Fax  : +49-721-9654-727
Email: Michael.Schneider@fzi.de
Web  : http://www.fzi.de/ipe/eng/mitarbeiter.php?id=555

FZI Forschungszentrum Informatik an der Universität Karlsruhe
Haid-und-Neu-Str. 10-14, D-76131 Karlsruhe
Tel.: +49-721-9654-0, Fax: +49-721-9654-959 Stiftung des bürgerlichen Rechts
Az: 14-0563.1 Regierungspräsidium Karlsruhe
Vorstand: Rüdiger Dillmann, Michael Flor, Jivka Ovtcharova, Rudi Studer
Vorsitzender des Kuratoriums: Ministerialdirigent Günther Leßnerkraus

No virus found in this incoming message.
Checked by AVG Free Edition. 
Version: 7.5.503 / Virus Database: 269.16.17/1177 - Release Date: 07-Dec-07

No virus found in this outgoing message.
Checked by AVG Free Edition. 
Version: 7.5.503 / Virus Database: 269.16.17/1177 - Release Date: 07-Dec-07
Received on Saturday, 8 December 2007 17:42:20 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:58:16 UTC