Re: question about new-style RDF lists

From: pat hayes <phayes@ai.uwf.edu>
Subject: Re: question about new-style RDF lists
Date: Mon, 23 Sep 2002 12:02:20 -0500

[...]

> >>  Lists are different, however. Allowing
> >>  arbitrary S-expression constructions in the syntax (which is what the
> >>  rdf:first/rest/nil/List effectively does) requires that we have
> >>  things in the domain which can serve to be denotations of all such
> >>  expressions; if we did not, then the list 'constructors' might have
> >>  nothing to construct.
> >
> >Why?  If you say
> >	_:x rdf:first ex:foo .
> >	_:x rdf:rest rdf:nil .
> >you have just constructed an RDF list, just as
> >	_:y rdf:type rdf:Bag .
> >	_:y rdf:_1 foo .
> >constructs an RDF bag.
> 
> The point is: HAVE you in fact constructed a list? You have asserted 
> that a list exists, but where is there any guarantee that what you 
> said is true? 

Just as much of a guarantee as when I say

     ex:John ex:loves ex:Mary .

> With your weak semantics, there could be 
> interpretations in which that list didnt exist, and then what you say 
> above would be false. 

> Now, this doesnt matter if that is being 
> asserted by someone, since the assertion forces the list to exist. 

Agreed.

> But the primary reason for introducing lists is to provide a 
> technique for encoding syntax of other languages (as you know :-) and 
> in that case - and in others - we want to be able to freely *infer* 
> that lists exist. For example, consider the OWL entailment written in 
> RDF:
> 
> Peter rdf:type ex:Human .
> Peter rdf:type ex:Employee .
> 
> |=
> 
> Peter rdf:type _:x .
> _:x owl:intersectionOf _:l1 .
> _:l1 rdf:first owl:Human .
> _:l1 rdf:rest _:l2 .
> _:l2 rdf:first owl:Employee .
> _:l2 rdf:rest rdf:nil
> 
> The OWL closure conditions guarantee that the intersection class 
> exists, but they do not guarantee that the list exists (which the 
> conclusion requires). 

But OWL could be written in a way that guarantees that such lists exist.

> In order for inferences like this to go through 
> smoothly RDF needs to supply lists to order, as it were, even if they 
> havn't been mentioned explicitly in any antecedents.  

RDF doesn't need to do this.  Any other formalism using RDF lists could do
this for itself.  As it would have to if it wanted to use RDF containers.

> And it seems to 
> me that this 'supplying to order' is what the list vocabulary is 
> usually taken to mean; one doesn't usually worry about whether lists 
> exist: of *course* they exist, that goes without saying. 

But exactly the same thing could be said about bags and sequences.  
RDF and RDFS do not provide preconstructed bags and sequences.

> Talking 
> (slightly misleadingly) in terms of 'constructing' lists, this is 
> like saying that its always kosher to construct any list you like: 
> you don't have to worry that any list construction is illegal or 
> forbidden. This seems to me to be just like the freedom one has to 
> assert that a container property holds between anything and anything 
> else.

I see the analogy completely differently.  To me, the container properties
of RDF are analogous to rdf:first, rdf:rest, and rdf:nil.  

[...]

> 
> Pat


Peter F. Patel-Schneider
Bell Labs Research

Received on Monday, 23 September 2002 13:14:04 UTC