Re: OWL descriptions of lists

At some point in the WG deliberations I took it upon myself to argue for 
the inclusion of various things that seem natural enough in RDF that were 
being left out of OWL DL.

In that process, I considered arguing for wider inclusion of rdf:List.
I decided against it.

Here is an attempt to explain why (although I have not had to articulate it 
before, except fairly informally to some HP colleagues who were largely to 
prepared to trust my judgment).

Allowing lists is primarily to allow constructs such as:

   <owl:Restriction>
         <owl:onProperty rdf:resource="&rdf;first"/>
         <owl:allValuesFrom rdf:resource="C"/>
   </owl:Restriction>

It would seem strange to permit this, without also permitting say:

<owl:ObjectProperty rdf:about="&rdf;first">
    <rdfs:range rdf:resource="&my;abc"/>
</owl:ObjectProperty>

and, we have conflict between user vocabulary "&my;abc" and the standard 
use of rdf:first in say a unionOf construct, in which it has an owl:Class 
object.

It might be possible to have syntactically rules for rdf:first and rdf:rest 
that prevent stating range and domain constraints but that seems to be 
making the already overly complicated OWL DL syntax even worse. Having said 
that, I have not thought that through in detail, and if say, Peter and 
Bijan had worked out a solution, I might be convincable.

I think there is nothing much wrong with the solution of cloning the 
rdf:first and rdf:rest syntax within your own vocabulary. You don't get the 
rdf:parseType="Collection" abbreviation, but I am not convinced that it is 
worth worrying about the ugliness that is RDF/XML.

Jeremy


Drew McDermott wrote:

> The following questions arose during an interchange with Bijan Parsia
> and Peter Patel-Schneider.  The basic question is why Owl DL doesn't
> allow descriptions of rdf:List and its accessories.  I won't quote any
> of the e-mail so far, so as not to have to get permission to quote it,
> but Bijan or Peter may want to repeat something they've said already.
> 
> In the Owl Reference (http://www.w3.org/TR/owl-ref/#appD), it says
> that the correct way to restrict a list to have elements all of class
> C is to write
> 
> 
>>  <rdfs:Class rdf:ID="CList">
>>    <rdfs:subClassOf rdf:resource="&rdf;List"/>
>>    <rdfs:subClassOf>
>>      <owl:Restriction>
>>        <owl:onProperty rdf:resource="&rdf;first"/>
>>        <owl:allValuesFrom rdf:resource="C"/>
>>      </owl:Restriction>
>>    </rdfs:subClassOf>
>>    <rdfs:subClassOf>
>>      <owl:Restriction>
>>        <owl:onProperty rdf:resource="&rdf;rest"/>
>>        <owl:allValuesFrom rdf:resource="#CList"/>
>>      </owl:Restriction>
>>    </rdfs:subClassOf>
>>  </rdfs:Class>
>>
> 
> However, it neglects to mention that mentioning rdf:List, rdf:first,
> or rdf:rest moves you from Owl DL to Owl Full.  (See
> http://www.w3.org/TR/owl-semantics/mapping.html#4.2 .)
> I want to know why.
> 
> To elaborate, I would actually like to add a lot of descriptive
> material to the list concept:
> 
> <owl:Class rdf:ID="Nonempty_list">
>    <owl:subClassOf>
>       <owl:Restriction>
>   <owl:onProperty rdf:resource="&rdf;first"/>
>   <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">
>      1</owl:cardinality>
>       </owl:Restriction>
>    </owl:subClassOf>
>    <owl:subClassOf>
>       <owl:Restriction>
>   <owl:onProperty rdf:resource="&rdf;rest"/>
>   <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">
>      1</owl:cardinality>
>       </owl:Restriction>
> </owl:Class>
> 
> <owl:Class rdf:ID="Empty_list">
>    <owl:oneOf>
>       <rdf:List>
>   <rdf:first rdf:resource="&rdf;nil"/>
>   <rdf:rest rdf:resource="&rdf;nil"/>
>       </rdf:List>
>    </owl:oneOf>
> </owl:Class>
> 
> <owl:equivalentClass rdf:about="&rdf;List">
>    <owl:unionOf>
>       <rdf:List>
>   <rdf:first rdf:resource="#Nonempty_list"/>
>   <rdf:rest>
>      <rdf:List>
>         <rdf:first rdf:resource="#Empty_list"/>
>         <rdf:rest rdf:resource="&rdf;nil"/>
>      </rdf:List>
>   </rdf:rest>
>       </rdf:List>
>    </owl:unionOf>
> </owl:equivalentClass rdf:about="&rdf;List">
> 
> <owl:Property rdf:about="&rdf;first">
>    <owl:domain rdf:resource="#Nonempty_list"/>
> </owl:Property>
> 
> <owl:Property rdf:about="&rdf;rest">
>    <owl:domain rdf:resource="#Nonempty_list"/>
>    <owl:range rdf:resource="&rdf;List"/>
> </owl:Property>
> 
> I have avoided using parseType="Collection" so as not to conceal the
> fact that List stuff is occurring as part of the argument conventions
> as well as the constituting the entities being described.
> 
> What precisely is the problem with this description?  As far as I
> know, it is perfectly consistent with the formal semantics of
> rdf:List.  The relevant text from the RDF Model Theory
> (http://www.w3.org/TR/rdf-mt/#Containers) is:
> 
> 
>>Semantic extensions MAY place extra syntactic well-formedness
>>restrictions on the use of this vocabulary in order to rule out such
>>graphs. They MAY exclude interpretations of the collection vocabulary
>>which violate the convention that the subject of a 'linked' collection
>>of two-triple items of the form described above, ending with an item
>>ending with rdf:nil, denotes a totally ordered sequence whose members
>>are the denotations of the rdf:first values of the items, in the order
>>got by tracing the rdf:rest properties from the subject to
>>rdf:nil. This permits sequences which contain other sequences.
>>
>>Note that the RDFS semantic conditions, described below, require that
>>any subject of the rdf:first property, and any subject or object of
>>the rdf:rest property, be of rdf:type rdf:List.
>>
> 
> The only change is that I state that the domain of rdf:first and
> rdf:rest is Nonempty_list.  This doesn't contradict the built-in
> assumption, but strengthens it.  (The built-in assumption strikes me
> as wrong; why should the empty list have a first and rest?)
> 
> Anyway, in case you've forgotten the question, it's: Where exactly
> do my assertions require us to leave Owl DL, and why?
> 
>

Received on Sunday, 11 January 2004 15:14:14 UTC