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