W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > October 2002

Re: rdf:first/rest/nil/List: syntax-only at the RDF level

From: pat hayes <phayes@ai.uwf.edu>
Date: Wed, 30 Oct 2002 11:20:33 -0600
Message-Id: <p05111b1eb9e5be684445@[]>
To: Dan Connolly <connolly@w3.org>
Cc: w3c-rdfcore-wg@w3.org

>The rdf:collection stuff was decided 31May
>but that record doesn't show the "there are no interesting
>entailments around rdf:first/rest" comment that I thought
>I made and I thought we agreed to.
>Jeremy remembers it that way, though...
>"My understanding was that RDF Core agreed to provide the List syntax,
>the List vocabulary (rdf:List, rdf:first, rdf:next rdf:nil); but not to
>provide any (formal) semantics for these terms."

That wasn't my understanding, or memory. But my memory is admittedly 
rather blurry.

>Today I took an action to clarify by way of test case and
>to explain why this is OK...
>Consider this conjecture:
>   eg:myBrothers rdf:first eg:paul.
>   eg:paul eg:hairColor "brown".
>   eg:myBrothers rdf:first eg:jon.
>   eg:jon eg:height "tallish".
>   _:somebody eg:hairColor "brown".
>   _:somebody eg:height "tallish".
>I don't want that entailment to be justified by the RDF
>nor RDFS MTs;

That one would not in fact be justified by my proposed semantics, if 
it is stated carefully; though I see that as a snag in the semantics, 

>we have a bunch of code (Jeremy
>enumerated some stuff, plus there's cwm, Euler,
>Jan's graph matcher, ...) that implements
>rdf simple entailment now, and that code would be
>invalidated by such a change.

I would like to see a more detailed explanation of why the code could 
not be modified to accommodate to this, before agreeing to hamstring 
RDF lists. Seems to me that you are here arguing that because y'all 
havn't implemented lists, that therefore RDF should not support 
lists. I don't find that a very persuasive argument; but in any case, 
if you were going to argue this way, why didn't you object to 
including lists in RDF in the first place? Seems to me that we are 
now committed, so y'all will have to write some more code.

>Likewise this one:
>   eg:s eg:p eg:o.
>   _:something rdf:first eg:s.

.... but that one would.

>Now... webont's use of first/rest would seem to need these.
>But it doesn't.

Well, the issue which was responsible for bringing lists into RDF in 
the first place does, however. That states that the ordinal-property 
containers 'do not support recursive processing' as in Prolog. In 
order to support recursion you need unique 'firsts' and a unique and 
recognizable 'nil'. (Multiple 'rests' are OK; you just get a tree to 
backtrack through.)

>I agree that it needs
>   eg:C1 owl:intersectionOf _:these.
>   _:these rdf:first eg:A.
>   _:these rdf:first eg:B.
>   eg:A owl:sameAs eg:B.
>   eg:A owl:sameClassAs eg:B.
>As I proposed[23Oct] to WebOnt, this follows because
>the range of owl:intersectionOf is a class, owl:List,
>which is specified to have maxCardinality 1 for rdf:first
>and rdf:rest.

Was that proposal accepted? I was unaware of this idea. I thought 
that there was no class owl:List, precisely because Webont thought 
that OWL could now use the RDF list vocabulary. That is what Peter 
and I have been doing for some time now.

>Hmm... this seems straightforward, but maybe it's worth working
>out the details... (yes, found one bug: I was
>saying cardinality, but I meant maxCardinality... fixed that...).
>OK, worked out the details:
>Jos, I was gonna test that with Euler to show the proof,
>but my Euler installation seems to have fallen apart.
>Would you mind?
>Ah; another detail: we'll need owl:NilList ala:
>	owl:NilList owl:oneOf (rdf:nil);
>		rdfs:subClassOf [ owl:onProperty rdf:first;
>			owl:maxCardinality "0"],
>			[ owl:onProperty rdf:rest;
>			owl:maxCardinality "0"].
>And the stuff about all lists existing will just
>have to be a constraint on all owl interpretations
>that you invoke whenever you invoke any owl properties.

This is just a silly cop-out. If we are going to do this, then we 
just should tell Webont that we don't have lists in RDF and they have 
to go back to doing it themselves. What kind of a weird entity is 
this: a list which uses RDF vocabulary for first and rest, but OWL 
vocabulary for its classification and its NIL? This is ridiculous.

>Now at one point, I think Brian phrased my action as explaining
>why this syntax-only position wouldn't expose us to the
>risk that PatH observed, which is that folks out there would specify
>conflicting semantics for rdf:first/rest/nil. I don't
>claim this risk is eliminated; only that it's manageable.

I disagree: I think it is dangerous precisely because people will 
*expect* that RDF lists are lists, and will write code on that basis. 
If they aren't lists, then we should call them something else.

>Yes, somebody could write a document that claimed something
>has two different rdf:first's... the RDF spec would
>say "oh; really? interesting". The WebOnt spec wouldn't
>mind unless you had said that thing was an owl:List;
>then it would say "no, you have contradicted yourself".

In other words, OWL still has to have a list vocabulary of its own. 
So why are these things in the RDF namespace? In fact, I was under 
the impression that owl:List would no longer be in OWL, since OWL has 
decided to use the RDF list vocabulary. We have been using rdf:List 
in the OWL semantics for some time now.

>And if you said that rdf:nil had an rdf:first, then
>you wouldn't have to explicitly point to owl at
>all in order to be inconsistent with it; i.e. if
>your document says rdf:nil contains something,
>and mix it with any owl stuff, you'll get
>a contradiction. (more technically: if you
>appeal to the webont spec to justify any conclusions
>from such a document, your argument won't hold much water because
>it will rest on contradictory premises.)
>But I think this is just life in the semantic web;
>ther RDF spec also says "oh, really? interesting"
>to claims such as
>	ex:x rdf:type ex:C1.
>	ex:x rdf:type ex:C2.
>	ex:C1 owl:disjointFrom ex:C2.

Because owl:disjointFrom is not in the RDF namespace. But if RDF 
agrees to introduce the list vocabulary, then in my view it should 
agree to give it the intended (and universally agreed) semantics. 
Otherwise, we should simply say that the list vocabulary is not in 
the RDF space.

>So Jan/Jeremy/Jos, if you agree, please add the two tests
>above to our test collection (or just say you agree and
>maybe I'll find time to add them).
>PatH, if you agree, please whack the relevant stuff
>out of the RDF model theory, and please help me advocate
>this position in WebOnt.

No, I emphatically do not agree. I will take this out of the RDF 
model theory, under protest, if the WG decides that is what we should 
do, but you are on your own in Webont. I will restrict myself to 
making sarcastic comments about the extra work caused by RDF-WG not 
having the balls to do the obviously correct thing because nobody 
wanted to write some new code.


IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola              			(850)202 4440   fax
FL 32501           				(850)291 0667    cell
phayes@ai.uwf.edu	          http://www.coginst.uwf.edu/~phayes
s.pam@ai.uwf.edu   for spam
Received on Wednesday, 30 October 2002 12:21:14 EST

This archive was generated by hypermail pre-2.1.9 : Wednesday, 3 September 2003 09:52:34 EDT