W3C home > Mailing lists > Public > public-owl-wg@w3.org > February 2008

OWL Full proposal (sort of) - addressing my Action

From: Jim Hendler <hendler@cs.rpi.edu>
Date: Wed, 6 Feb 2008 17:16:05 -0500
Message-Id: <61AE7803-4E67-4466-AB69-611309CC6584@cs.rpi.edu>
To: "Web Ontology Language ((OWL)) Working Group WG" <public-owl-wg@w3.org>

Before I get to something resembling a proposal, I first want to  
outline my "ideal vision" (which I know is not the same as some other  
people's but at least it makes it clear where I'm coming from), then  
"define" what I mean by a couple of the terms with respect to that  
vision, and then make the proposal  and provide a justification-- so  
if you don't care about anything but the latter, drop to the bottom.

Ideal world:  If I could start all over again, there would be one  
language called OWL.  The language would be defined as a set of  
vocabulary terms "owl:xxx" and the definition of an OWL document would  
be any RDF document (by whatever definition of document one uses) that  
includes the use of those terms.  The language would be aimed at being  
a good common denominator for the definition of ontologies, not aimed  
at being a good KR language for AI use (i.e. it's main function would  
be interoperability, more precise and expressive KR languages would  
use it for exchanging at least some of their information where  
possible). The language would be primarily aimed at "modeling", not  
reasoning, and thus the semantics could be less formal than it is now.
  Attached to OWL would be a privileged fragment called OWL DL, which  
would have a very clean semantics.  OWL DL would be intended for  
people whose use of OWL fits one of the important niches OWL can  
handle - which is classification reasoning (via consistency  
checking).  Folks looking for an expressive common denominator with  
good reasoning tools would be drawn towards OWL DL, and they would  
find that most of the documents they created in OWL either already  
worked well with OWL DL tools, or needed a small amount of work to get  
there.  There could also be a number of special extensions to the OWL  
vocabulary (lets call it owldl:xxx) that could be used where they were  
needed for making reasoners better.  The semantics of this fragment,  
which need to be extremely clear and clean, would be very formal.   
Syntaxes for developing documents in this language would still need to  
talk to RDF, since they want to provide URIs that would be of use in  
the Semantic Web (so regular OWL users would have benefit of the clean  
ontologies built in OWL DL)
  There could also be other communities that come to the W3C, or which  
work in other forums, and create other priviledged versions of OWL for  
other KR approaches or for other purposes. These fragments would be  
defined as vocabulary fragments (i.e. the document could contain only  
these terms) or they could have specific semantics -- OWL DL would be  
an obvious candidate for the semantic base of these, since that would  
greatly enhance reuse.


Some (loose) definitions:
  Operational semantics:  I use Java and C all the time.  I have never  
seen any semantics for them other than an "operational semantics" --  
that is one that says what the intended use of the language constructs  
is.  I also have books on Prolog and Lisp and Scheme, which have  
something closer, but in fact when I implemented my own prolog once  
upon a time, the formalism wasn't really what it is today - I used a  
document that said what the various features of the language were and  
how they interacted.  These semantics, like the ones in Java and C  
were written in a language called English.  In fact. most languages  
whether they be programming languages, markup languages, or modeling  
languages are defined against this kind of semantics.  What is called  
a "reference" (for example, the "programming in C" book or the  
"Moonual" for Lisp) is generally the user guide to understanding these  
operational semantics.
  A fallacy about operational semantics: Some on this group keep  
telling me that the difference is that OWL is not a programming  
language.  I happen not to agree, but even if you take that view, I  
point out most other languages including HTML and XML (and, in fact  
SQL) have these semantics.  (SQL also has a mathematical underpinning,  
but it includes a number of features that are not covered by that, and  
are only explaining operationally - what we would call non-semantic  
features).  The fallacy has been that if one says "OWL" and means "OWL  
DL" then they are right that the language is not like a programming or  
markup langauge, it is a KR language and that does indeed need a  
formal semantics.  So what I call OWL in the above is the main  
language, and if it has any semantics at all, it should be operational  
(and maybe we have to abide by the fact that RDF has a semantics - but  
that was a mistake in my opinion).
  An axiomatic semantics - the term has been used in a number of  
different ways.  I think Boris and I came close to agreeing that many  
things in OWL and OWL DL could be defined in a fairly straight forward  
way against traditional rules of logic.  This is using logic as the  
"spec" for the operational semantics -- that is, we could say  (making  
up a simple example)
  A owl:sameInstanceAs B <=> forall(x) P(A,x) -> P(B,x)
there was one of these done in KIF for DAML, so it is pretty clear  
that a great amount of what is in the current OWL Full could be  
defined this way.  Note that this does not mean one necessarily  
should, or could, implement the language by simply inputting these to  
a logic engine (although that is probably possible for at least the  
great bulk of the language) but rather that the axioms are being used  
to provide a more precise description than NL does - but I would still  
claim this is primarily an operational semantic approach.

OK - my proposal.
  I believe we can actually reach the ideal world above with one  
exception - the language called "OWL" is going to have to be called  
OWL Full for historical reasons.

Argument
  We would need to update the OWL reference, which pretty much  
contains the operational semantics for OWL Full to include those new  
constructs we think are of use, and we can remove the part about the  
restrictions for OWL DL (because there is no longer the need for the  
1-1 mapping) - so the OWL 1.0 reference would be extended into the OWL  
Full document.
  We would define OWL DL precisely as we have already and, in my  
opinion, other than cleanup and resolving the OWL DL only issues, much  
of the complexity would disappear - because we could have features  
(and syntax) that are particular to the needs of reasoners that extend  
the above.  The semantics would be aimed at reasoners so and would be  
based on the current model theory.

Interesting observation
  Taking this approach has some nice features:
   1 - we are almost done (we would need to decide which OWL DL  
features need to be added to the OWL Full reference and write them  
up)- I guess we would still need to write a UCR document, but that we  
have in our charter whichever way we go (in fact, we could edit the  
old UCR document into the "OWL Full UCR" document, and just add use  
cases for the OWL DL specific features - so that would also be easier)
   2 - we would be compliant with our charter -we would be defining  
both Full and DL, the feature mapping would be clear where needed.   
Features and syntax of DL that seem not to have Full realization would  
with (a) be added or (b) be declared as "extensions" that are not  
needed in Full.
  3 - We could have fragments like OWL Prime that are defined for OWL  
Full easily.  If we want corresponding fragments in OWL DL, we need to  
do the semantic work, but that is relatively straightforward.   
Fragments of DL, like those in the current fragments document, would  
also be easily derived as they wouldn't necessarily impact the Full  
world.  (Folks who want mappings from OWL to provably polynomial  
fragments would either use the OWL DL semantics, or could invent their  
own - we don't have to do that work for them)

hmm, looks like my ideal world might be closer to realizable than I  
thought...

I look forward to being torn to shreds since I know this was written  
in a language very foreign from that of many in the WG.  On the other  
hand, when we invented Web ontologies at Maryland (SHOE claims  
earliest use of the term), this is the vision I had in mind, so I  
guess I'm at least consistent....

cheers
  JH




"If we knew what we were doing, it wouldn't be called research, would  
it?." - Albert Einstein

Prof James Hendler				http://www.cs.rpi.edu/~hendler
Tetherless World Constellation Chair
Computer Science Dept
Rensselaer Polytechnic Institute, Troy NY 12180
Received on Wednesday, 6 February 2008 22:16:12 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Wednesday, 6 February 2008 22:16:14 GMT