W3C home > Mailing lists > Public > www-rdf-comments@w3.org > July to September 2002

Re: question about new-style RDF lists

From: pat hayes <phayes@ai.uwf.edu>
Date: Mon, 23 Sep 2002 12:02:20 -0500
Message-Id: <p05111b31b9b4e7d337fb@[]>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: www-rdf-comments@w3.org

>From: pat hayes <phayes@ai.uwf.edu>
>Subject: Re: question about new-style RDF lists
>Date: Fri, 20 Sep 2002 21:02:30 -0500
>>  >Pat Hayes has recently
>>  >(http://www.w3.org/Archives/Public/w3c-rdfcore-wg/2002Sep/0185.html)
>>  >proposed a semantics for the new-style RDF lists.
>>  >
>>  >This semantics is a divergence from the general RDF and RDFS philosophy
>>  >that minimal solutions are to be preferred.
>>  I disagree: see below.
>>  >  (This is evident in the
>>  >semantics for rdfs:domain and rdfs:range, in particular.)  Why would a
>>  >strong semantics for new-style lists, where all lists exist in all
>>  >interpretations, be chosen over a weak semantics for new-style lists,
>>  >particularly as RDF containers exhibit a very weak semantics?
>>  It all depends on what you mean by 'weak' and 'strong'. Seems to me
>>  that the style in the draft is in fact the weaker of the
>>  alternatives, since it doesn't go beyond first-order assumptions in
>>  the models.  Assuming that lists have to be finite takes us into
>>  recursion theory.
>A weak theory of lists is just like the weak theory of containers in RDF.
>No lists are assumed to exist at all, except the empty list.  This seems to
>me to be consistent with the RDF/RDFS philosophy, and appears to me to be a
>viable theory of lists.

I agree its consistent with a very ascetic view of the RDF 
philosophy, but I don't think it is viable. See below.

>>  We have to assume that containers exist, in order to provide
>>  interpretations of the container constructions in the language.
>Huh?  Which containers have to exist in RDF?  I don't see any requirement
>that any container exists in the RDF MT.

The container properties can always be applied to anything. That is 
the sense in which containers exist. I agree its a pretty wimpy 
sense, but then the container-property style of describing containers 
is pretty wimpy.

>>  The
>>  non-list (old) RDF container vocabulary does not provide any
>>  general-purpose recursive accessing mechanism; each 'place' in a
>>  container has its unique property for accessing it.  Thus, most
>>  (all?) of the 'structure' of the containers is hidden in the domain
>>  of properties. RDF domains are required to contain an infinite set of
>>  container properties, and nobody seems to find this particularly
>>  difficult to swallow.
>The container properties do have to exist in RDF.  However, containers
>themselves do not.

All a container is, is something to which the container properties 
apply. You can apply the container properties to anything. If you 
were to assert that

PatHayes :_3  ex:Fluffy .

then I would be a container, even though I wouldn't feel anything. So 
of course containers exist.

>>  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? 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. 
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 

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). 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.  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. 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 

>  > The suggested MT only requires an
>>  interpretation to contain *some* set of lists over the domain: in
>>  effect, it reproduces the recursive idea implicit in the Sexpression
>>  syntax but phrases it as a recursion over the universe.
>But there is no RDF need for any lists to exist beforehand.

See above.

>>  It might be worth emphasizing that simply requiring the semantic
>>  domain to *contain* some large, even infinite, set is not a very
>>  strong semantic requirement in itself. Datatyping for example
>>  routinely requires semantic domains to contain infinite sets of
>>  integers, strings and so on.
>Sure, it is not a strong requirement, but it is a requirement, and can have
>noticable consequences.

Well, the consequences are that the existence of the elements is 
enough to ensure that any list containing them exists. This allows 
inference processes to 'construct' lists as well as human beings 
writing RDF triples. Scare quotes because in fact no actual 
construction gets done: what both the human writer and the inference 
process do is to claim that lists exist. The proposed semantics just 
makes sure they will always be right.


IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
Received on Monday, 23 September 2002 13:02:15 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Friday, 21 September 2012 14:16:30 GMT