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

Why reification doesn't make sense (was: Re: PRIMER: PrimerReificationSection)

From: Pat Hayes <phayes@ai.uwf.edu>
Date: Tue, 23 Oct 2001 22:53:16 -0500
Message-Id: <p05101050b7fbe2f06b8e@[205.160.76.193]>
To: "dehora" <dehora@eircom.net>
Cc: w3c-rdfcore-wg@w3.org
>A draft of the reification section is attached. Apologies, no images
>yet.

Very nice prose. I have a problem with what it says, however. (Sorry, 
I've pasted the html directly in giving the examples below)

The example it gives introduces a 'statement'

  &lt;rdfprimer&gt;   &lt;editor&gt;   "eric".

That looks like a triple to me. (My criterion is the trailing dot. :-)

What exactly IS a 'statement' ? Is it a particular  syntactic token, 
or a data structure, or something more like an expression? For 
example, if two different documents contain identical triples, how 
many statements is that? Two (that are isomorphic in some sense) , or 
one (that has two tokens) ?

You go on to explain how to say something about that statement:

How would we go about doing this?  Well we know that the subject of a RDF
statement is a resource denoted by a URI or an anonymous resource, and we know
that these can also be the object of an RDF statement. So the thing to do would
be associate the statement with a URI or an anonymous resource and use that in
place of the statement directly. Here we'll use an anonymous resource, called
'stmt'.

Wait a minute; a miracle occurred in there somewhere. We have a 
triple (above) and we have a bNode which is 'associated' with it. 
How?? What is the nature of this 'association', and where and how is 
it recorded in RDF?

What you say next doesn't answer this question:

  Now how do
we associate the statement with stmt? To let us do this, RDF provides four
properties, each of which will be used as a property of the reified statement
(stmt). These are: (subject, predicate, object, type <Statement>).

and we get the example of the reification

  _:stmt    &lt;type&gt;       &lt;Statement&gt;.
    _:stmt    &lt;subject&gt;    &lt;rdfprimer&gt;.
    _:stmt    &lt;predicate&gt;  &lt;editor&gt;
    _:stmt    &lt;object&gt;     "eric"  

of the triple given first. Now, that is a *description* of a 
'generic' such triple, right? It says that a thing exists which is a 
Statement and has these three property values. (Incidentally, it says 
that the subject is rdf:primer, not "rdf:primer", so it actually 
doesn't make sense; but let's leave that for now.) But that isn't 
enough to pin down any particular statement with this form (the one 
in this particular document, say, or this particular file). 
Obviously, another statement with exactly the same form might be at 
this very moment being transmitted from somewhere in Iraq to 
somewhere in Turkey, and this description could be referring to that 
one instead of the one in my document. So, to repeat, HOW does RDF 
'associate' this description, or possibly the _:stmt name used in it 
(which, by the way, isn't even part of RDF syntax, so hardly seems 
suitable for the rather central role it ought to have), with the 
*actual statement* that it is supposed to be a reification of? Is 
there some kind of secret labelling process going on under the hood, 
which somehow attaches this anonymous node to the statement, thereby 
making it into a reified statement?

OR have I got the wrong idea about statements altogether? If the 
answer to my original question is that two identical triples in two 
different documents are really only one statement, so that a 
statement is a class of tokens all with the same syntactic form, then 
the reification of a statement in four triples does indeed uniquely 
specify a single statement. But with THIS sense of 'statement', it 
doesn't make sense to say things like 'eric is the author of' a 
statement, since statements in this sense don't have authors (or 
perhaps, can have infinitely many authors), and similarly it doesn't 
make sense to say that document contains a statement (as opposed to a 
token of the statement, which does make sense but cannot be said in 
RDF).

There is a basic mismatch, either way: RDF reifications describe 
syntactic forms, but the things people want to use it for require it 
to refer to tokens of forms, not the forms themselves; and RDF 
reification provides no way to refer to a statement token.

Pat Hayes
-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Tuesday, 23 October 2001 23:53:22 EDT

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