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

Re: LANG: OWL non-xml syntax

From: Jonathan Borden <jonathan@openhealth.org>
Date: Tue, 26 Mar 2002 17:00:12 -0500
Message-ID: <04fd01c1d511$9c9008d0$0a2e249b@nemc.org>
To: "Frank van Harmelen" <Frank.van.Harmelen@cs.vu.nl>, <www-webont-wg@w3.org>
Frank,

>
> > class ex:baz (
> >         oneOf(
> >                     property ex:a,
> >                     property ex:b,
> >                     property ex:c
> >         )
> >
> > would not _have been_ immediately obvious to me,
>
>
> this is not a legal construction in our proposal for OWL [1] (nor is it in
> DAML+OIL [2]). In both of these, oneOf defines a class by enumerating all
its
> instances. That's not what the above does.

woops, the example I intended to make was:

class ex:bar (
        intersectionOf(
                    property ex:a,
                    property ex:b,
                    property ex:c
        )
)

that is s/oneOf/intersectionOf/

the point is that wrapping "property ex:a" in "class( property ex:a )"
better transmits the intention that the class is the intersection of the
classes ...

>
> General point:
> --------------
> Forgive me for asking, but I'm a bit at a loss as to the goal of your
efforts.
> - Is your goal to make a better abstract syntax for the proposal in [1]?
> - If so, better in what sense? Easier to XML-ise? Easier to parse?
>    By machines? By humans?
> - Or making our proposal in [1] more like DAML+OIL? In what way.
>
> Can you explain (or perhaps: repeat) what you are aiming for?
> Sorry if this is a question I should have known the answer to,
>

The goal is to produce a concrete syntax for OWL which is _based on_ the
abstract syntax in [1]

The strategy of the _concrete syntax_ is to closely resemble the abstract
syntax such that the mapping between constructs in the concrete syntax and
the abstract syntax are immediately obvious.

The use of such a concrete syntax is that it may serve as a shorthand
notation in which we can transmit examples.

A property of the non-XML concrete syntax is that a parser generator can
convert the syntax into RDF/XML, given a precise mapping between OWL and
RDF/XML.

I am in the process of writing a JavaCC grammar for this purpose:
http://www.openhealth.org/WOWG/ONX.jj this is not yet complete, and I give
the URI to show how such a grammar may be used. In the meantime, I have
given a set of examples demonstrating how constructs in the non-XML syntax
are represented in RDF/XML e.g. DAML+OIL.

The charter of the WOWG indicates that DAML+OIL should be used as a starting
point, for which deviations need to be justified. I think it should be fair
to say that to the extent that the proposed OWL abstract syntax has a
clearcut and defined mapping to the DAML+OIL concrete syntax, that any
discussions of constructs in [1] should be considered as discussions of the
equivalent RDF/XML constructs.

Furthermore, to the extent that any abstract syntax proposals for OWL _do_
result in changes to the DAML+OIL syntax, we need a concrete way to evaluate
these. I am proposing that a JavaCC grammar (for example) is a concrete way
to accomplish this.

Sorry if this motivation wasn't more obvious.

Jonathan


[1] http://www.cs.vu.nl/~frankh/spool/OWL-first-proposal/frame.html
Received on Tuesday, 26 March 2002 17:03:19 GMT

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