W3C home > Mailing lists > Public > www-webont-wg@w3.org > March 2002

how to proceed with building OWL [was Re: semantics: layering ...]

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Fri, 01 Mar 2002 08:00:21 -0500
To: www-webont-wg@w3.org
Cc: connolly@w3.org
Message-Id: <20020301080021X.pfps@research.bell-labs.com>
		Constructing Web Ontology Languages 
				or
	Why Jumping on Four Horses is a Good Recipe for Quartering


NB:  This is actually a response to Dan Connolly as to what I had in mind
in suggesting a discussion of the layering document.  This may not be
evident until the end, but please bear with me for a while.

I just spent some time thinking about three things:
1/ the suggestion from the WG chairs to split up into four processes, 
2/ how to respond to Pat Hayes's latest message on semantic paradoxes, and
3/ how to get the WG members to read and understand the layering document.
I came up with the conclusion that everything is connected to everything.


Let's take an example - the language feature that OWL be able to express
complex definitions of classes, including boolean combinations of classes.
To me this means that given two classes, say A and B, OWL has to be able to
express the disjunction of these two classes, A union B.

This then produces several (informal) test cases, such as 
     A and B are classes and John is in A 
	     entails
     John is in the (or a) union of A and B.  
Next, there has to be some syntax in OWL for such disjunctions (and
other boolean combinations of classes).  This then permits the
formalization of the test cases.

But before the particular syntax for disjunctions in OWL can be determined,
there needs to be a decision on the parameters for OWL syntax.  For
example, is all OWL syntax N-triples or is it any sort of XML?

Then the semantics has to support these test cases.  However, the semantics
can only be generated if there is a decision on how the layering is to
proceed.  The semantics also depends on how the OWL syntax is going to be
developed.

But the syntax for OWL also depends on the semantics, because certain ways
of proceeding are going to require semantic rules that require the presence
of certain classes or restrictions in interpretations.  For example, the
semantics might have to have something like ``If A and B are classes in an
interpretation, then the interpretation also contains a class that is the
union of A and B''.  This, in turn, has consequences in the test cases.

This then goes back to the requirements, as (I feel that) the combination
of these rules and certain requirements is going to lead to semantic
paradoxes.


Let's take another example - defaults.  It does no good for the language
feature process or the methodological guidelines process to come up with a
feature for defaults if there are not both test cases to show how this
feature is supposed to work and a story of how this feature fits in the
semantics of OWL.  As the semantics of OWL is (somewhat) constrained by any
layering decision, anyone who wants to propose a feature for defaults has
to understand the implications of the layering options.


So, in some sense, all aspects of OWL depend on all other aspects of OWL.

This is not to say that progress cannot be made except by producing
fully-worked-out complete proposals for OWL.  However, all the processes
have to know how their proposals will affect the other portions of OWL.

I believe that it is possible to work in the following way:

1/ Some of the basic notions of OWL are determined, such as the general way
   its syntax is going to look and how it layers on top of RDF(S).

2/ A core portion of the language is specified by the language features
   process, being very careful to stick to things that are known to be
   possible and to stay within the syntax and layering solutions already
   determined.  The test cases and semantics processes then work on this
   core to produce a complete specification.

3/ The language features process proposes a general kind of functionality
   to add to the core, along with some informal test cases to show how it
   is supposed to work and perhaps along with some abstract syntax.  The
   test cases and semantics processes determine if they can support this
   functionality.  If so, the language features process firms up the
   functionality, including a proposed syntax.  Then the test cases and
   semantics processes firm up their support of the functionality.  If
   there is a failure somewhere, then the language features process has to
   come up with a different proposal.

4/ Repeat as necessary.


To get this process started I believe it is necessary for everyone involved
to understand the implications of the various syntax possibilities and the
various layering possibilities (i.e., adding semantics into the mix).  As I
see it, the possibilities come down to the following.  (I am ignoring
various aspects of ontologies here---just assume that they have been dealt
with in some other layer for now.)

Syntax:

1/ OWL syntax is RDF graphs.  
   a) All RDF graphs are valid OWL KBs.  (This is the DAML+OIL situation.)
   b) OWL places some restrictions on RDF graphs, such as OWL lists have to
      be well formed or that restrictions have to have certain forms.
2/ OWL syntax is XML syntax.
   a) OWL syntax is exactly valid RDF/XML.
   b) OWL syntax is a proper subset of valid RDF/XML.
   c) OWL syntax is a proper superset of valid RDF/XML.
   c) OWL syntax is a neither a subset nor a superset of valid RDF/XML.
3/ OWL syntax is something completely different.

Semantics:

1/ Internal view
   a) OWL interpretations are RDF(S) interpretations with some extra
      conditions.
   b) OWL interpretations are generalizations of RDF(S) interpretations.
      (This is roughly the DAML+OIL situation.)
   c) OWL interpretations are different from RDF(S) interpretations.
      i) OWL interpretations treat some stuff as syntax, but correspond
         with RDF(S) interpretations on all other stuff.
      ii) OWL interpretations differ on (some of) the other stuff as well. 
2/ External view
   a) All RDF(S) entailments are valid OWL entailments.
   b) Some RDF(S) entailments are not valid OWL entailments.
      i) A significant portion of the RDF(S) entailments are retained.
      ii) Almost all of the RDF(S) entailments are lost.

The implications of the various syntax possibilities should not be too hard
to determine, except in combination with some of the semantics
possiblities.  For example, I (still) believe that making the DAML+OIL
situation work ends up with semantic paradoxes.  (There are some simple
fixes available, such as letting DAML+OIL extend the syntax of RDF or
giving the DAML+OIL syntactic constructs a different semantics than given
to them by RDFS.  Other, potentially better fixes, are also available.)


So I think that a *decision* on layering needs to be made before we can
make much in the way of progress, and that anyone who expects to be
participating in any of the language features process, the test cases
process, or the semantics process needs to understand the implications
of the layering decision.  I hope that a discussion of the layering
document would help in both of these.


Peter F. Patel-Schneider
Bell Labs Research


PS:  Here are a few informal inferences (entailments) that might be
produced during step 1 of the above proposed process:

1/ If John is in both A and B, then John is in the (an) intersection of A
   and B. 

2/ If John is a resource, then John is in the (a) singleton class (or
   restriction) whose sole instance is John.  

3/ If John has a child that is a Person, then John belongs to the (a)
   restriction that requires that its members have a child that is a
   Person.

4/ If John is in a restriction R whose p's all belong to R, then John is in
   some restriction whose p's all belong to the restriction itself.  

5/ If Bill has no p's, then then Bill is in any restriction whose p's all
   belong to the restriction itself. 
Received on Friday, 1 March 2002 08:01:50 GMT

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