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

Re: LANG: owl:import - Two Proposals

From: Jim Hendler <hendler@cs.umd.edu>
Date: Fri, 27 Sep 2002 13:55:08 -0400
Message-Id: <p0511170bb9ba42caae0f@[10.0.1.2]>
To: Jeff Heflin <heflin@cse.lehigh.edu>, WebOnt <www-webont-wg@w3.org>

Jeff - good summary -but I think you miss something I said previously 
-- proposal 1  has SIGNIFICANT problems with RDF interoperability 
(mandating a new MIME type!)   i.e. what I was referring to a couple 
of days back is this - the Revised RDF syntax document defines a 
specific grammar for the application/rdf+xml MIME type.  When it is 
that MIME type it MUST have rdf:RDF as a root element [1] and [2]. 
This means we would have to create a new MIME type for OWL documents 
which would be a controversial step.
    Further, it means that any document read with an RDF tool and 
turned into a triple store would now have to be reread with an OWL 
tool to get import information.   This would be particularly 
problematic with any tool that creates a triple store directly, 
instead of creating an intermediate document (a number of the current 
RDF authoring tools work this way) which means one could not use 
those as OWL creation tools without modification.

  Another disdvantage of proposal 1 against our current semantics is 
that one could not keep instances and classes in the same document 
anymore - unless we change our semantics in some way to make the 
instances part of the ontology -- consider

<owl:ontology ...>
   <rdf:RDF ...>

     <owl:class rdf:ID="Elephant" />

     <:Elephant rdf:ID="Clyde" />
   </rdf:RDF>
</owl:ontology>

this would mean the ontology graph contains both the instances and 
the classes and thus anything that imports the ontology also imports 
the instances.  We would either have to mandate a separation of class 
and instance documents (in different MIME types no less!), create a 
semantics that can differentiate these things, include instance data 
in any ontology imports, or some other significant departure from the 
DAML+OIL way of doing things.


***Chair neutrality off***
  I believe the above (factual and non-opinion) is a VERY serious 
problem with proposal 1.
*** return to neutral ***

  -JH
p.s. one of my students points out another advantage of proposal 2 -- 
it will be easier to do conversion of DAML+OIL documents to OWL 
automatically - especially in cases where the ontologies were 
generated by a tool which has already done something outside the 
<rdf:RDF> tag (which some do).  We discussed it and decided it wasn't 
a whole lot harder when we were just going document to document - but 
finding something in a <rdf:RDF> context and then moving it into a 
different place in the output means we could no longer use a one pass 
in line program or script -- in particular, that means some tools 
which now read DAML+OIL into OWL (we have several) would need to be 
rewritten to create a file where they currently don't have to -- this 
means, for example, things deployed as applets (ie. without write 
permission) wouldn't be able to work on DAML files anymore.  This is 
clearly less important than the above, since we want people to move 
from DAML to OWL, but it does have implications for the many DAML 
current DAML users (close to 20,000 web pages the crawler knows about 
to date)



[1] http://www.w3.org/TR/rdf-syntax-grammar/#start
[2] Dave Beckett, editor of RDF syntax, personal communication, 27 Sept 2002.

At 11:05 AM -0400 9/27/02, Jeff Heflin wrote:
>As requested at yesterday's telecon, I have prepared two proposals for
>adding imports to OWL. Both of these proposals describe syntax,
>semantics and pros and cons.
>
>
>Proposal #1
>------------
>Syntax:
>The imports syntax is outside of the RDF domain of discourse. This is
>accomplished by having imports (and versioning) information be declared
>outside of RDF. In particular, there is an owl:Ontology tag that wraps
>all OWL ontologies. The content of this tag is import and versioning
>tags followed by the RDF content of the ontology. This has the nice side
>effect that the content of an ontology is finally nested within an
>ontology element.
>
>Here's an example:
>
><owl:Ontology xmlns="...">
>    <!-- multiple imports are allowed in separate elements -->
>    <owl:imports resource="..." />
>    <owl:imports resource="..." />
>    ...
>    <owl:priorVersion version="..." />
>    <owl:backCompatWith version="..." />
>
>    <rdf:RDF>
>         <!-- all of our class and property statements go here -->
>         ...
>    </rdf:RDF>
></owl:Ontology>
>
>Thus, RDF parsers can just ignore the surrounding XML content and still
>get "partial understanding" of it. OWL tools can use this extra
>information in whatever ways are deemed fit for OWL. Note that this
>is a perfectly valid use of RDF according to both the current
>recommendation and the new syntax under consideration by RDF Core.
>
>OWL data documents can also import ontologies using the following
>syntax:
>
><owl:Data xmlns="...">
>    <!-- multiple imports are allowed in separate elements -->
>    <owl:imports resource="..." />
>    <owl:imports resource="..." />
>    ...
>    <rdf:RDF>
>         <!-- all of the RDF statements go here -->
>         ...
>    </rdf:RDF>
></owl:Data>
>
>Semantics:
>If an OWL document A contains an imports tag for document B, then if
>B OWL entails P, then A OWL entails P. This could
>be implemented by simply merging the graph of B with that of A,
>and applying the OWL semantics to the merged graph.
>
>Pros:
>- Any potential misuse of imports is syntactically prohibited
>
>- Solution extends nicely to accommodate ontology versioning information
>
>- Having the contents of an ontology enclosed by the <Ontology> tags is
>very intuitive
>
>- Syntax is acceptable to most existing RDF parsers
>
>- Imports and versioning information actually describe the graph (which
>cannot be represented in RDF itself, since RDF does not provide the
>ability to make statements about graphs)
>
>
>Cons:
>- Can't access imports and versioning information from within RDF.
>
>
>Proposal #2
>-----------
>Syntax:
>The imports syntax is in the domain of discourse of RDF, but not OWL.
>Essentially we have a class called owl:Ontology and a property
>owl:imports which can hold between a pair of Resources. Statements
>are made about the current document using an empty URI reference
>(this assumes that this expands to the current URI context).
>The meaning of any statements which include
>owl:imports as a subject or object is undefined. Syntactically, this
>approach is the same as that of DAML+OIL. For example:
>
><rdf:RDF xmlns="..." ...>
><owl:Ontology about="">
>   <owl:imports resource="..." />
>   <owl:imports resource="..." />
>   ...
></owl:Ontology>
>
><!-- all class and property statements go here -->
>...
>
></rdf:RDF>
>
>Data documents can imports other documents with the following variation
>of the syntax:
>
><rdf:RDF xmlns="..." ...>
><rdf:Description about="">
>   <owl:imports resource="..." />
>   <owl:imports resource="..." />
>   ...
></rdf:Description>
>
><!-- all other RDF statements go here -->
>...
>
></rdf:RDF>
>
>Semantics:
>As far as RDF is concerned, owl:Ontology is just another class, and
>owl:imports is just another property. The following triples are
>defined in the OWL namespace:
>
>owl:Ontology rdf:type rdfs:Class
>owl:imports rdf:type rdf:Property
>owl:imports rdfs:domain rdfs:Resource
>owl:imports rdfs:range rdfs:Resource
>
>In OWL, any other statements which include owl:Ontology or owl:imports
>as a
>subject or object are undefined. The semantics are as follows:
>
>If a graph contains a triple of the form:
>
>A owl:imports B
>
>then graph A entails P iff the merge of graphs A and B entail P
>(where merge is as defined in the draft RDF model theory [1]).
>
>Pros:
>- It is possible to query an RDF graph to obtain information about
>what resources are ontologies and which ontologies import others.
>
>Cons:
>- Having valid syntax that has undefined semantics may lead to reduced
>interoperability. In particular, some users may build ontologies that
>rely on the arbitrary decisions made by their favorite tool vendors.
>
>- It is unclear what it should mean if a document C contains the
>statement A owl:imports B. Should this be another undefined construct?
>If so, how can you determine from a graph if the subject of an imports
>statement is the URI of the document from which the imports statement
>comes?
>
>- The fact that an ontology's classes and properties do not occur
>between the <Ontology> tags is unintuitive
>
>- The use of about="" to make statements about the enclosing document
>seems like a hack. In particular is seems like we could be confusing the
>notion of a document that describes an ontology and the concept of an
>ontology itself.
>
>- The approach only partially succeeds in its goals, because although it
>represents ontologies and their properties, it loses the ability to
>recognize the boundaries of an ontology (i.e., what it contains) as soon
>as two or more graphs are merged together. In particular, if this
>approach is extended for use with versioning, then we lose the ability
>to know which statements come from which version of an ontology.
>
>
>Note:
>-------
>Implicit in both of these proposals is that if an ID is mentioned
>without importing the ontology from which it comes, then the statements
>of the ontology are NOT necessarily entailed.
>
>
>Recommendation:
>---------------
>Given the pros and cons of each proposal, I have a strong preference for
>proposal #1, but could live with proposal #2 if the WG was certain that
>its benefits outweighs its numerous costs.
>
>Jeff
>
>[1] http://www.w3.org/TR/rdf-mt/


-- 
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
Received on Friday, 27 September 2002 13:55:17 GMT

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