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

Re: Lang: owl:ontolgy (was RE: LANG: syntactic version for imports (and other things))

From: pat hayes <phayes@ai.uwf.edu>
Date: Tue, 17 Sep 2002 18:48:33 -0500
Message-Id: <p05111b0cb9ad6ba4b923@[65.217.30.172]>
To: Jeff Heflin <heflin@cse.lehigh.edu>
Cc: www-webont-wg@w3.org

Jeff, thanks for stating this so succinctly so that I can ask you why 
you believe these things. I simply do not follow your reasoning.

>Actually, this isn't as nice as it might appear. A minor issue is the
>redundancy that it introduces in documents. When a user writes an
>ontology, why should they have to write the definition and then later
>say, oh by the way, this definition is in the ontology that is
>represented by the document in which I wrote it? I think we'll have a
>hard time explaining this awkwardness to users.
>
>However, a more fundamental issue is that it doesn't really do what we
>need it to do. Your approach seems to imply that you can say that a
>particular class or property is defined by a particular ontology.
>However, in RDF, a class or property can be defined by many ontologies.
>The descriptions of these object may be distributed across the Web.

OK so far, and I agree...

>In
>order to manage reasoning with these things, it is absolutely essential
>that we know which descriptions come from which ontologies.

WHY??? Why do I need to know where the information came from? I can 
see that for some 'advanced' purposes - for example, suppose I don't 
trust all my sources and I want to keep track of what follows from 
what authorities, or I expect to find inconsistencies and want to do 
truth-maintenance - that such meta-information might be important, 
but the basic inferential model of RDF and DAML+OIL and OWL is surely 
that in which I have many sources of information, and I draw 
conclusions from them about the things they refer to. For this I 
don't need to know where the information *comes from*.

>In many
>cases, we do not want to reason with all the descriptions that everybody
>ever said about a class

Of course not....

>(this is why imports is so important).

Seems to me it is why 'imports' is irrelevant. Look, you just said, 
we do not want to reason with all the descriptions... OK, so why do 
we need a pointer to more descriptions? This seems like saying that 
we don't want all the water, so we need to know where more water is. 
This just doesn't seem to follow: theres a premiss missing somewhere. 
(OK, Ian's point on todays phone call about completeness is well 
taken; but you aren't making that point here, right?)

>The only
>way to distinguish between what was said in each ontology is to
>associate RDF statements (not resources) with the ontology. Thus, each
>subclassOf statement, subPropertyOf statement, owl:Restriction
>statement, etc. must be associated with the ontology in which it is
>stated.

WHY?? What purpose does this serve for a basic, vanilla RDF/OWL 
reasoner? What conclusion can it draw (or not draw) with these tags 
present, that it could not (or could) draw if they were absent? What 
entailments do they effect? Seems to me, the only possible answer is, 
none whatsoever.

Pat


>
>Jeff
>
>Jim Hendler wrote:
>>
>>  Seems to me today's phone call revealed a problem.  We want to be
>>  able to define an ontology as a "container" in which a set of
>>  statements lives.  This doesn't necessarily imply that this container
>>  is either closed or immutable (this message doesn't want to address
>>  those issues) but rather to give you a place that makes statements
>>  about the ontology (heretofore called its metadata) and also to say
>>  what URIs are in it (not necessarily uniquely).  I've been discussing
>>  this with a researcher in my lab, Bijan Parsia, and he's come up with
>>  a solution that is relatively elegant, consistent with the RDF
>>  approach to the world, and has a precedent in RSS, a widely used
>>  language.  I think this is similar to what Mike Smith was talking
>>  about today with using XMLbase, but might be more RDF friendly and
>>  also a little easier to implement (since everything can stay in the
>  > graph)
>  >
>  > The idea is that we can simply extend the owl:ontology to define its
>  > classes in a manner similar to how RSS defines a channel (for those
>  > who know that) -- that is, we create an owl:ontology statement that
>>  includes a pointer to the set of URIs which it includes (could be
>>  just class definitions, could be more).  This would look something
>>  like this:
>>
>>  <rdf:RDF  {namespaces} >
>>
>>  <owl:class rdf:ID="foo">
>>     <restriction ... (etc) />
>>  </owl:class>
>>
>>  <owl:class rdf:ID="bar">
>>     <restriction ... (etc) />
>>  </owl:class>
>>
>>  <owl:class rdf:ID="baz">
>>     <restriction ... (etc) />
>>  </owl:class>
>>
>>  <owl:Ontology rdf:ID="OntologyName">
>>    <owl:ontologyDefines rdf:parsetype="collection">
>>       <owl:ontologyClass :foo />
>>       <owl:ontologyClass :bar />
>>       <owl:ontologyClass :baz />
>>    </owl:ontologyDefines>
>>     <dc:creator rdf:ID="me" />
>>        {other metadata}
>>  </owl:Ontology>
>>
>>  </rdf:RDF>
>>
>>  The beauty of this is that I could now handle imports in various ways
>>  - I could import an entire ontology with an imports statement within
>>  this
>>
>>  <owl:Ontology ...>
>>     <owl:imports URI2 />
>>
>>  and extend it
>>
>>     <owl:Defines ...>
>>       <owl:ontologyClass :notInURI2>
>>     </owl:defines>
>>  ...
>>  <owl:Ontology>
>>
>>  I could include classes from other ontologies (Without importing the
>>  whole thing) by simply including them in my owl:ontologyDefines
>>  collection
>>     <owl:OntologyClass cyc:dog>
>>
>>  and I get for free some new properties that seem quite desirable - in
>>  particular, I could create multiple ontologies in a document by
>>  including pointers to different subsets
>>
>>  <owl:ontology rdf:ID="Pets">
>>     ...
>>     <owl:ontologyDefines>
>>         ... dog
>>         ... cat
>>     </owl:ontologyDefines></owl:ontology>
>>
>>  <owl:ontology rdf:ID="Felines">
>>     ...
>>     <owl:ontologyDefines>
>>         ... lion
>>             cat
>>             tiger
>>     </owl:ontologyDefines></owl:ontology>
>>
>>  I think that version info could also be handled in here, although
>>  still working on details.
>>
>>  I also think this works syntactically whether we put ontologies into
>>  the domain of discourse or not -- I personally wouldn't prefer to,
>>  but could go either way.
>>
>>    -JH
>>  p.s. For the RDFS fans, the owl:ontologyDefines would be invertible
>>  into rdfs:isDefinedBy statements - which is a nice bonus.
>>  p.p.s. If we really want to get fancy, we could let the
>>  owl:ontologyDefines statement be any RDF collection, meaning an
>>  ontology designer could use either a collection, making it closed, or
>>  a bag, making it open - thus letting the user have some ability to
>>  control how extensible the solution is.
>>
>>  --
>>  Professor James Hendler                           hendler@cs.umd.edu
>>  Director, Semantic Web and Agent Technologies     301-405-2696
>>  Maryland Information and Network Dynamics Lab.    301-405-6707 (Fax)
>>  Univ of Maryland, College Park, MD 20742          240-731-3822 (Cell)
>>  http://www.cs.umd.edu/users/hendler


-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Tuesday, 17 September 2002 19:48:37 GMT

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