W3C home > Mailing lists > Public > www-rdf-logic@w3.org > January 2001

RE: DAML+OIL: Questions & Improvements.

From: Ian Horrocks <horrocks@cs.man.ac.uk>
Date: Sat, 27 Jan 2001 16:22:19 +0000 (GMT)
Message-ID: <14962.62907.361969.524190@excalibur.cs.man.ac.uk>
To: "King . Dany" <DKing@drc.com>
Cc: "'Dickinson, Ian J'" <Ian_J_Dickinson@hplb.hpl.hp.com>, "'www-rdf-logic@w3.org'" <www-rdf-logic@w3.org>, TeamXML <TeamXML@drc.com>
Hi Dany,

On January 26, King . Dany writes:
> Hello Ian,
> 
> Thanks for your comments...  I agree that RDF is a meta-language; however
> it's purpose is to describe resources on the web.  DAML+OIL, on the other
> hand, is meta-language for defining ontologies.  DAML+OIL could be
> implemented in a number of ways.  At the moment, the DAML+OIL is being
> implemented with RDF.  It is my understanding that the use of RDF is for
> syntax only, because the semantics of DAML+OIL differs greatly from mere
> resource description. Thus, the root DAML+OIL ontology should contain the
> primitives of the meta-language used to define it (rdfs:Class, rdf:Property,
> rdf:ID, etc.).  However, instances of DAML+OIL (ontologies built using the
> DAML+OIL meta-language and their resulting instances) should only contain
> DAML+OIL primitives (see question @@ in original email). Although there is a
> 1 to 1 mapping on many  of the DAML+OIL primitives to the RDF primitives
> (this is true only because RDF syntax is being used), there is at least one
> case which has no mapping: the concept of a class.

The thinking behind the use of RDFS is that it already has the basic
elements of an ontology language - classes, properties, constraints,
and subclass and subproperty relations - and that DAML+OIL should
clarify (semantically) and extend (in some respects) what is there
already. DAML+OIL tries to maximise backwards compatibility by using
as much of RDFS as possible and only extending it where necessary. For
example, DAML+OIL uses the RDFS subClassOf relationship to (partially)
order the classes in an ontology. The advantage with this is that a
DAML+OIL ontology is partly accessible to any agent that understands
RDFS. The reason for defining the daml equivalent classes and
properties was simply to save users from having to use namespace
prefixes (in which they fail anyway, unless the ontology is defined in
the same namespace as the daml+oil language definition).

> An RDF class is both structurally and semantically different from a DAML+OIL
> class.   The base class in RDF is a "rdfs:Resource" which is of "rdf:type",
> "rdfs:Class".  In RDF there is no concept of a "NoResource", the complement
> of the base class.  Semantically speaking, in DAML+OIL the base class is
> "Thing" which is defined as being the union of "Nothing" and the complement
> of "Nothing".  Syntactically speaking, "Thing", "Nothing", and the
> complement of "Nothing" are built from "rdfs:Class".   Thus, using
> "rdfs:Class" to instantiate a DAML+OIL class doesn't make sense.
> Conceptually I agree that every modeled concept in DAML+OIL is a "Thing",
> however this must be explicitly defined in the syntax.  Otherwise, there
> would be no need to define a DAML+OIL "Thing" in the first place.    

An RDFS class can be anything from a simple class of objects up to the
paradoxical class of all classes. DAML+OIL gives a semantics to the
simplest incarnation of rdfs:Classes (classes of objects), each of
which is an instance of rdfs:Class in its capacity as the class of
classes. Two classes that are often of particular interest are the
empty class and the class of all objects, and in daml+oil.daml it is
asserted that these classes are equivalent to Nothing and Thing
respectively, both of which are otherwise ordinary DAML+OIL
classes. In fact there is no need to define Thing (or Nothing) as the
union (intersection) of any class and its complement can be used
instead - Thing and Nothing are simply provided as a syntactic
convenience. So if by "base class" you mean the class which is a
superclass of all daml+oil classes, then that is daml+oil:Thing; if
you mean the class of classes that is the type of all daml+oil
classes, then that is rdfs:Class.

> Also, I agree that every modeled concept in DAML+OIL should be a subclass of
> the base class, "Thing".  However, this should be an inherited property of
> every modeled concept. In other words, there should be no need to explicitly
> define a subClassOf relation to a "Thing".  In Solution B, I described a
> means of instantiating DAML+OIL concepts by using "Thing".  Per RDF syntax,
> concepts modeled in this way would be of "rdf:type", "Thing".  Though it is
> not a subClassOf relation, it may be as close as the RDF syntax will allow
> us to get.  One way to implement it may be to add a subClassOf relation of
> "Thing" to "Thing".  That is, make "Thing" a subclass of "Thing".  Hence
> everything of "rdf:type", "Thing" would be a subclass of "Thing".  (see
> attachment: Thing2.ppt, Solution B prime, figure 4)

Every modeled concept in DAML+OIL is a subClassOf Thing by
definition. It is true that this may not be explicit, but this can be
the case for DAML+OIL subClassOf relations in general (i.e., they can
be implied from the semantics). If you want to make this particular
relationship explicit, simply assert it for every class in the
ontology (or for every class that isn't already asserted to be a
subClassOf some other class). It is easy to get a tool to do this - in
fact if you use OilEd to design your ontologies you can choose to add
explicit subClassOf relations for all subsumption relations implied by
the semantics. Asserting daml+oil classes to be of type Thing makes
Thing a class of classes, and thus no longer a daml+oil class (in the
sense that daml+oil provides no semantic interpretation for such a
class).

Regards, Ian
Received on Saturday, 27 January 2001 12:13:35 GMT

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