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: Dan Connolly <connolly@w3.org>
Date: 30 Oct 2002 12:33:10 -0600
To: Pat Hayes <phayes@ai.uwf.edu>
Cc: w3c-rdfcore-wg@w3.org
Message-Id: <1036002790.24110.9736.camel@dirk>

technical bits first, then some process/social malarky...

On Wed, 2002-10-30 at 11:20, pat hayes wrote:
> >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'.

Indeed, the design I have in mind doesn't provide everything
you need to do prolog-style recursion; it only provides
a RDF/XML short-hand syntax for first/rest/nil, not the
semantics to support recursion.

But I suggest that syntactic shorthand support is necessary
and sufficient for the RDF layer; it's necessary because
users require straightforward syntax for lists, and
WebOnt can't change RDF/XML syntax (nor can anybody else
but this WG, i.e. the WG that edits the RDF/XML syntax
spec); and it's sufficient because the unique first constraint
can be layered on top, using owl:cardinality, rdfs:range,

Note that such a layering is *impossible* with
the older rdf:Seq/rdf:li syntax.

An alternative to consider is moving FunctionalProperty
into RDFS... but that would only get it as far
as RDFS, not into the RDF layer, so it doesn't
really help...

Another alternative is to back this change out altogether,
since, as you point out, having the syntax suggest
semantics that aren't there can be confusing in its
own right. I don't think there's sufficient new
information to go that far, but I wouldn't mind
talking it over.

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

Isn't it pretty obvious that the code to implement
graph matching (i.e. RDF simple entailment) is very
different from code to implement the sort of reasoning
with equality involved with a functional rdf:first

If not, then I hope Jeremy or Jan or Graham or
maybe Jos can elaborate; I'm not in a good position to do so
just now.

Now as to process/social stuff...


> >The rdf:collection stuff was decided 31May
> >http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2002May/0159.html
> >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,
> >and
> >the List vocabulary (rdf:List, rdf:first, rdf:next rdf:nil); but not to
> >provide any (formal) semantics for these terms."
> >http://lists.w3.org/Archives/Public/www-webont-wg/2002Oct/0138.html
> That wasn't my understanding, or memory. But my memory is admittedly 
> rather blurry.

Indeed, that's why we have meeting records: we agreed to what
the record says we agreed; you're not bound to my recollection
of the meeting, only to the record we all reviewed and
approved over the next week(s). I guess
I was negligent in reviewing the record, now that I see
that Jeremy and Graham remember it that way too.

> >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, 
> myself....

and I admit I haven't read your proposal in detail...

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

No, I didn't make myself clear.

If you happen to be on the phone with Jeremy or Graham, please
discuss it with them. I'm not sure I've explained my
position very well.

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

As discussed above, we are committed to what the meeting
record says, and the meeting record doesn't say we
are committed to this sort of semantics.

> >I agree that it needs
> >this:
> >
> >   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?

No, not yet...

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

Right; the editors are working out the design details.

Formally, WebOnt hasn't yet decided to close its list
issue, but the expectation is that the editors' proposal
will get adopted. RDFCore *has* decided the issue,
and whatever the editors come up with is what we'll
go with, unless somebody can (a) argue that it
conflicts with recorded decisions or (b) brings
up new information that merits re-opening the issue.

> >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:
> >
> >http://www.w3.org/2000/10/swap/test/list/listlayerP.n3
> >http://www.w3.org/2000/10/swap/test/list/listlayerC.n3
> >
> >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.

I don't think so. I don't think Jeremy thinks so either.

I think it's important that semantically, the RDF layer
is just the existential-conjuctive fragment of FOL.

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

Your point is well made, but I, for one, considered it before we
made the 31May decision, and I maintain that the risk
is manageable.

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

Yes, when I look at it closely, I think so.

> So why are these things in the RDF namespace?

So that RDF/XML parsers know their names without looking
in the OWL spec.

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

rdf:List (i.e. the semantics-free one I have in mind
that comes from from parseType="Collection") isn't very interesting
to me. Mike Dean argued for
it on some implementation grounds that I'm not very clear on.
I think it's in the syntax document, and I don't have much
of an argument for taking it out, now that it's there.


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

I hope you find the position in the middle coherent, if not
convincing. Jeremy, maybe you have some time to try to convince

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

Now why don't you tell us how you *really* feel, Pat?

Dan Connolly, W3C http://www.w3.org/People/Connolly/
Received on Wednesday, 30 October 2002 13:32:52 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:16 UTC