W3C home > Mailing lists > Public > semantic-web@w3.org > February 2007

Re: Rich semantics and expressiveness

From: Michael Schneider <m_schnei@gmx.de>
Date: Thu, 22 Feb 2007 17:32:38 +0100
Message-ID: <45DDC5A6.2050601@gmx.de>
To: hans.teijgeler@quicknet.nl
CC: semantic-web@w3.org, richard@cyganiak.de

Hi Hans!

hans.teijgeler@quicknet.nl wrote on Wed, 21 Feb 2007:

> In my experience relational schema often has more implicit 
 > data than OWL ontologies. With implicit I mean that a lot is
 > left out because the user or the application software is supposed
 > to be able to fill the gaps.

I first want to be sure if I correctly understand what you mean by 
"implicit" here. Say, we have the following table "People" with 
attributes "name" and "age":

   People
   ------
   name : STRING [PRIMARYKEY]
   age : INT

Now, I would like to model an ISA relationship between the concept 
"People" and the more specific concept "Adult", where AdultS have an 
additional boolean "isMarried" attribute. I would approximate this by 
adding the following table "Adult":

   Adult
   -----
   personName : STRING [FOREIGNKEY(People.name)]
   isMarried : BOOL

 From this RDB scheme alone, the best I could tell is that there is 
/some/ relationship between both concepts (via the foreignkey 
specification). But it needs extra interpretation to regard this as an 
ISA-relationship. This extra interpretation has to be done outside the 
RDB schema, for example within the software which uses such a database.

I would call this an example for "implicit semantics". Hopefully, this 
is what you mean by this term, too.

> The way we implement OWL does not allow such gaps.

But you can also have implicit semantics in OWL ontologies. Say, we were 
only allowed to use OWL-Lite to define our ontologies, where there is no 
direct support to talk about complements of classes. This doesn't stop 
us from introducing a /custom/ property for making assertions about 
complements of classes:

   ext:isComplementClassOf a owl:AnnotationProperty .

   :C a owl:Class .

   :NotC a owl:Class ;
         ext:isComplementClassOf :C .

An OWL-Lite reasoner, which is a reasoner that conforms to the 
/explicit/ semantics of OWL-Lite, would not complain about such an 
ontology. But it would also not support us in any way regarding our 
intended meaning of such complement-axioms. For instance, if we were 
adding the following axiom to our ontology:

   :NotC owl:equivalentClass :C .

our OWL-Lite reasoner would say "ok", but we really would assume that 
this ontology isn't satisfiable anymore. So, what we have to do here is 
to create additional software for handling such custom 
complement-axioms, similar as we had to create additional software for 
handling ISA-relationships in the RDB example above.

> Does this implicity/explicity play a role in your opinion?

I only was trying to compare what I would call the /explicit/ semantics 
for both ontologies (as given for the OWL sublanguages in the OWL 
semantics spec [1]) and RDB schemes (as given, hopefully, in typical 
textbooks on relational databases).

I would not try to compare, for instance, OWL-Lite ontologies by their 
explicit semantics on the one hand, with RDB schemes by their /possible/ 
implicit semantics on the other hand. Such a comparison would not be a 
fair one. While there is no direct support in RDB for many of the 
features of OWL-Lite (e.g. ISA relationships), it is possible to define 
some serialization format for OWL-Lite ontologies in terms of a 
relational scheme, so that one can store and retrieve OWL-Lite 
ontologies from relational databases. The full interpretation of such a 
serialization would then be up to some (de)serialization software.

Using such an approach, every explicitly given semantics can be beaten.

Cheers,
Michael

[1] OWL Web Ontology Language Semantics and Abstract Syntax
     http://www.w3.org/TR/owl-semantics/
Received on Thursday, 22 February 2007 16:32:55 UTC

This archive was generated by hypermail 2.4.0 : Thursday, 24 March 2022 20:41:02 UTC