RE: Rich semantics and expressiveness

Hi Michael,

One example of "implicit" would be the stuff you mentioned: name, age,
isMarried, etc. That implies information that was valid at the (often
unknown) time of recording, but it is not valid eternally. Your name may
change, your age certainly does, and 30% of the marriages fail.

Other (simple) examples are to record:
- a price without recording the currency (e.g. in software that is
predominantly used in the US)
- a size (e.g. of a pipe) without the unit of measure (e.g. inch)
- referring to "the" president without specifying of what country
- information about an object that actually is only indirectly related to
that object (e.g. the kind of lube oil you must use for an engine)
- etc

Documents and data bases are full of implicit information. 

All this is OK because the assumption is made that the person or system
reading it knows the context and is conversant with the domain of expertise.
Program software may help to provide the context, but that software is not
available when you exchange the data.

In a global setting, like that of the Semantic Web, one cannot safely assume
that the recipient person or software knows the context, and therefore one
must express oneself more explicitly. 

The reasoning capabilities of OWL may help in filling the gaps, although I
doubt whether the correctness of the reasoning results will be such that any
manager can be convinced to rely on them blindly when taking decisions. At
best these results can be used for decision support (which alone is reason
enough to embrace the SW).

Regards,
Hans

PS I keep being annoyed by the fact that too many publications on the web
are without showing the time of recording. If the subject is new to the
reader (if it were not new he/she wouldn't need to read it) the information
may very well be out of date, and that outdated information is then taken
for granted and absorbed.


-----Original Message-----
From: Michael Schneider [mailto:m_schnei@gmx.de] 
Sent: Thursday, February 22, 2007 17:33
To: hans.teijgeler@quicknet.nl
Cc: semantic-web@w3.org; richard@cyganiak.de
Subject: Re: Rich semantics and expressiveness

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/

--
No virus found in this incoming message.
Checked by AVG Free Edition.
Version: 7.5.441 / Virus Database: 268.18.3/698 - Release Date: 23-Feb-07
4:39
 

-- 
No virus found in this outgoing message.
Checked by AVG Free Edition.
Version: 7.5.441 / Virus Database: 268.18.3/698 - Release Date: 23-Feb-07
4:39

Received on Friday, 23 February 2007 10:45:30 UTC