LANG: daml:collection and owl:seq, owl:set, owl:oneOf

The use case for this proposal relates to the integration/interpretation of
non-RDF multimedia (including arbitrary XML) as RDF, particularly the
description of abstract syntax trees as RDF. My experience in this area
relates to the RDF represenation of MIME (XMTP) and as well as work on representation of
EBNF syntax descriptions in XML: . What I
have realized is that the language "XSet" defines, takes some liberties with
RDF that roughly (almost exactly) correspond to

rdf:parseType="daml:collection" is slowly growing on me. It solves several
tricky problems with RDF, particularly the expansion into daml:List,
daml:first, daml:rest allows the _syntactic_ assertion of lists in RDF onto
which a semantic OWL interperation is defined.

For example: <daml:oneOf><Thing rdf:resource="#a"/> ...</daml:oneOf> results
in the expansion into a host of RDF triples, none of which are interpreted
(entailed?). Call it what you will, it is clear to me that the DAML
interpretation of <oneOf> is not in any way derived from RDF triples that
are generated. That is to say "oneOf" has a DAML meaning "layered" on the
RDF meaning of the triples (gulp)

There are a number of advantages to having a list based syntax/recursively
define structure in OWL. I must admit that it is somewhat painful for me to
look at the RDF triples expansion of a simple list, however I see the real
benefit of providing a purely syntactic encoding of a list. It _is_ in RDF
syntax, so that fits with our charter. In any case the <daml:oneOf>
structure has an obvious utility and I would like to round out this idiom.

I propose that we:

1) Refine the intended use of daml:List

The expansion of the construct:

<daml:oneOf rdf:parseType="daml:collection>
        <Thing rdf:resource="#a"/>
        <Thing rdf:resource="#b"/>
        <Thing rdf:resource="#c"/>

       <daml:first rdf:resource="#a">
                <daml:List> ...

expresses the idiom:

sentence :== term.List

where the term 'oneOf' is applied to the List.

In other cases I might want members of the list in any order, e.g. treat the
list as a set:

<daml:Set rdf:parseType="daml:collection">
    <Thing rdf:resource="#a"/>
    <Thing rdf:resource="#b"/>

in other cases I would like to treat the list as a sequence:

<daml:Sequence rdf:parseType="daml:collection">
        <Thing rdf:resource="#a"/>
        <Thing rdf:resource="#b"/>
        <Thing rdf:resource="#c"/>

Generally for sentence := term.List, the OWL interpretation (?) of the List
is a function of the _term_ applied to it. (This of course is all old hat to
s-expression folks, I just wanted to state it here for the record.).

Introduction of owl:Seq and owl:Set, along with owl:oneOf, will enable the
representation of ASTs and grammars of the form:

<oneOf>a b c d</oneOf> (where "a" is shorthand for <Thing
rdf:resource="#a"/> ) ->
 (a | b | c | d)

<sequence>a b c d</sequence> ->

<set>a b c d</set> (used to represent <interleave>) ->
(a & b & c & d)

these, along with <minCardinality>0</minCardinality> ->

(a | b | c)*

and <minCardinality>1</minCardinality>

(a | b | c)+

The goal of this work is to allow OWL to define information sparing
transforms, e.g. from an arbitary multimedia type (or even generic XML) into
RDF. This could be used, for a simple example, in order to declare an HTML
RDF scraping transform e.g. this HTML isEquivalentTo this RDF (or something
to that effect). Or to say "this DNA sequence represents this set of genes",
"this DNA sequence is present in oneOf these diseases" etc.


Received on Wednesday, 13 March 2002 17:25:44 UTC