Re: LANG: owl:import - Two Proposals

Jim,

Thanks for the arguments in favor of and against proposal 2. I think it
is important that all the pros and cons be identified and we have a
debate on this so that the WG can truly make the best decision, whether
that be in favor of proposal 1, 2 or something as yet undetermined.

That said, I'd like to discuss your points:

Proposal #1 requires a new MIME type
-------------------------------------
I find this an interesting point. Does the W3C have any documentation
that say when a new MIME type is required or recommended? On one hand, I
don't see why we need a new one because we are just using our own XML
schema to describe the Ontology, imports, etc. tags. Thus, it would seem
we could just use the XML MIME type. Certainly, the W3C doesn't require
a new MIME type for each schema? However, on the other hand, our
language does have special semantics that most XML schemas don't have,
and perhaps the MIME type is used to indicate to applications that they
should process it in a different way. This makes sense, but then it
seems to me, OWL should have its own MIME type regardless. After all, we
have a different semantics from RDF (even if it is just additive). So,
it seems to me either both proposals or neither require the new MIME
type, and I'm leaning toward both of them needing one.


Proposal 1 would require RDF tools to read a document twice to get
import information
--------------------------------------------------------------------------
Any tools that care about import information would use an XML parser to
extract it, and then pass the RDF subtree of the document to an RDF
parser.
There's absolutely no reason to read the document twice. If the
application is a plain-old RDF application that doesn't realize this,
then it will never have heard of imports in the first place and won't
care about imports information.

I can see that there is a slight cost in tools because now all of your
RDF tools need an extra 10 lines of code to write out proper OWL, but I
think that cost is negligible, because the OWL tools that users will
find easiest are those that have some built-in support for OWL. That is,
ontologies will be a central aspect (as opposed to just another class),
the "parseType:Collection" ugliness will be handled automatically for
you, etc.
In other words, in order for OWL to succeed, there will have to be OWL
specific tools anyway.

If people think it is important for RDF to process imports information,
then I suggest we ask RDF Core to consider extending RDF to handle it
correctly. This could be done by first allowing RDF to make statements
about graphs (as opposed to about a resource that we pretend represents
a document or a graph), and then adding an official imports property
that has a new thing called Graph as it's domain and range. We would
also need a way to give an identifier to a graph, which could probably
be done by adding an ID attribute in the <rdf:RDF> tag.


Proposal #1 can't have instances and classes in the same document
------------------------------------------------------------------
Not necessarily. Although my proposal said "class and property
definitions go here," there is no reason why instance statements
couldn't go in the same place, particularly if the instances were
important to the ontology. I don't follow your argument about having to
import the instances if you import the ontology. Why wouldn't you want
to? If someone decides the instances are part of the ontology, then when
you import it, you should import the whole ontology. Note, that in
proposal #2 the same thing is true, because there an imports means you
import the whole document. Thus, if you had classes and instances in the
document, you import both as well.

Proposal #2 will make it easier to convert DAML+OIL to OWL
------------------------------------------------------------
This might be true to some extent, because I believe that as it stands
now, the conversion is simply a series of find and replaces so you could
do it all with a simple Unix script. However, I do not believe that
proposal #1 would require you to save a temporary file in order to do
the conversion. In the worst case, you'd have to do two reads of the
DAML+OIL document: one to collect up the ontology and imports
information, and one to create the OWL document with it in the right
place. However, since the DAML+OIL convention is to put the ontology
stuff at the top, I think a one pass program would work in most if not
all cases. Even so, since conversion tools only need to be used once per
document, the two pass algorithm isn't that expensive.


I look forward to your counter-arguments. I think this is a very useful
and important discussion.

Jeff

Jim Hendler wrote:
> 
> 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.
>

Received on Monday, 30 September 2002 10:46:31 UTC