Re: Interpretation of RDF reification

* Lars Marius Garshol <> [2006-03-22 21:37+0100]
> I've been trying to read the answer to this answer out of the RDF  
> specs, and I think I've got it, but would like to make 100% certain.
> If I create an RDF node that reifies the statement
>   (winston, married-to, clementine)
> what does that node represent? Specifically, does it represent the  
> *statement* that these two are married, or does it represent the  
> *marriage* relationship between them? That is, if the reifying RDF  

OK, going back to the start of this thread, and picking up a theme 
live in various blog posts on lately, ... I tried 
working thru an example. Afraid it's not at the stage where I've tested
it with tools yet, but might be useful. Pasting it in here (below) for now, 
will blog when the examples are more machine-readable. --Dan

OK, let me try sketching some test cases around reification, which could
(sorry, not there yet - help
welcomed) be plugged into OWL reasoners and SPARQL query engines. Forget
superman; our scenario is 
more worldy. We are web detectives, on the trail of a would-be bigamist,
whose multiple identifiers 
aren't all familiar to the registrars who have been busy marrying him
off. Imagine that the registrars
publish their official records in RDF, and that we're consuming those
records, alongside some
other trusted evidence, with an OWL-aware software system. Further
imagine that we export some
hopefully-useful RDF from the OWL system and query it using SPARQL, with
the intent of asking questions
like "which registrar said what?". A lot of folks try to use RDF
reification in such scenarios;
I'm not convinced it works. 


 <> <>
<> .

# the resource called <> has a 'wife' that
# is the resource 
# called <>


 <> <>
<> .

# the resource called <> has a 'wife'
# that is the resource 
# called <>


# <> and
# <> are URI names for the same resource

# trying to keep track of these different claims using RDF reification
# vocab. 
# (this is the thing I don't think does what people hope it does...)

 _:s1 rdf:type rdf:Statement .
 _:s1 rdf:predicate <> . 
 _:s1 rdf:subject <> .
 _:s1 rdf:object <> .
 _:s1 <> <registrar-1.rdf> .

 _:s2 rdf:type rdf:Statement .
 _:s2 rdf:predicate <> . 
 _:s2 rdf:subject <> .
 _:s2 rdf:object <> .
 _:s2 <> <registrar-2.rdf> .

So, at face value, who-said-what.rdf captures an RDF description 
of the claims in both registrar-1.rdf and registrar-2.rdf, and
associates them with simple provenance information - in this case, 
by identifying a "dc:source" document, associated with 
some described RDF statement.

However, what happens if we believe the (perfectly reasonable) 
document,, which tells us that two 
URIs denote the same resource? ie. that the thing called  
<> is the owl:sameAs thing 
as that called <>.

My understanding (sorry I can't quote chapter-and-verse here) is that 

 _:s1 rdf:subject <> .
combined with 
gives us an extra triple,
 _:s1 rdf:subject <> .

...since the two URIs are names for the same thing, there is nothing
true of 
the thing called <>  that is not also
true of the
thing called  <>. Similarly, we should get
extra triple, 
 _:s2 rdf:subject <> .

At this point, if who-said-what.rdf and nndb-example-bio.rdf are 
considered true descriptions, and we honour OWL's built-in semantics 
for owl:SameAs, we end up with an expanded bunch of triples
that use RDF reification vocabulary:

(please correct me if this is wrong - though i can't see how it could

 _:s1 rdf:type rdf:Statement .
 _:s1 rdf:predicate <> . 
 _:s1 rdf:subject <> .
 _:s1 rdf:subject <> .
 _:s1 rdf:object <> .
 _:s1 <> <registrar-1.rdf> .

 _:s2 rdf:type rdf:Statement .
 _:s2 rdf:predicate <> . 
 _:s2 rdf:subject <> .
 _:s2 rdf:subject <> .
 _:s2 rdf:object <> .
 _:s2 <> <registrar-2.rdf> .

So, loading up who-said-what.rdf (ostensibly, a useful file giving a
skeptical account of
which RDF documents made which claims), alongside nndb-example-bio.rdf
(another useful file,
documenting some cases in which there are multiple URI names for the
same thing), we 
get a description that can be queried with SPARQL.

 _:s1 rdf:type rdf:Statement .
 _:s1 rdf:predicate <> . 
 _:s1 rdf:subject <> .
 _:s1 rdf:subject <> .
 _:s1 rdf:object <> .
 _:s1 <> <registrar-1.rdf> .

Let's ask it if the resource <registrar-1.rdf> is the dc:source of an
that has a predicate 'wife', subject
<> and
object <>:



	PREFIX rdf:  <>
	PREFIX dc:   <>

	{ ?s rdf:subject    <>  .
	  ?s rdf:predicate  <>  .
	  ?s rdf:object     <> .
	  ?s dc:source     <registrar-1.rdf> .

My understanding is that we'd get a 'yes' back from this query, but that
lots of folk would expect to get a 'no', since they read this 
as "DOes <registrar-1.rdf> contain the charlie/wife/alice triple?".

The RDF Semantics spec does contain some warning of this, 
Note that this way of understanding the reification vocabulary does not 
interpret reification as a form of quotation. Rather, the reification 
describes the relationship between a token of a triple and the resources 
that triple refers to. The reification can be read intuitively as saying 
"'this piece of RDF talks about these things" rather than "this piece 
of RDF has this form".
]], in our scenario, it is true that registrar-1.rdf *does* talk
the thing that has a URI name <>, even
though that URI doesn't itself appear anywhre in the registrar-1.rdf

Combined with the RDFCore decision on statings vs statements which
distinct different statements to share the same predicate, subject and 
object, RDF developers may be tempted to use RDF's reification
to keep track of "who said what". However, such descriptions interact in
unfortunate ways with core RDF and OWL facilities, and can give 
counter-intuitive resources. 

(Note that doing all this in pure RDF, we have no problem; owl:sameAs is
just another triple, to an RDF triplestore. It's only when the 
OWL meaning of owl:sameAs kicks in, do we get to these issues. But RDF
OWL systems live in the same Web; documents published from an RDF-only
may be consumed, interpreted, queried etc. by OWL systems and the
re-published on the Web as plain RDF...)

My preference is simply to never use the W3C RDF reification vocab, and
use other mechanisms for keeping track of 'who said what'....

Aside: note also that in the openworld, nobody has assured us that 
<> and <>
different individuals. Also that this would be a lot more complicated to 
think about if we were using bnodes and reference-by description instead
simple URI identifiers for people.

Received on Thursday, 23 March 2006 19:41:55 UTC