W3C home > Mailing lists > Public > www-rdf-interest@w3.org > March 2004

a bnode URI scheme?!

From: Adam Souzis <adam-l@souzis.com>
Date: Thu, 11 Mar 2004 13:43:43 -0800
Message-ID: <4050DD8F.60001@souzis.com>
To: www-rdf-interest@w3.org

The idea of a bNode URI scheme seems, at first glance, oxymoronic to say 
the least, but I think there times where you might really need one. I 
haven't head of this before, I wonder if anyone has thought about this?

I started thinking about bNode uris for my my RxPath project, which maps 
the RDF model to the XPath data model -- it introduces relative bNode 
URLs (e.g. 'bnode:identifier') as a syntatic trick: disjoint sets of 
bNodes and URIs in RDF are translated in RxPath to the disjoint sets of 
URLs with the bnode scheme and all other URIs.  But upon reflection it 
seems that absolute, externally referenced bNodes URLs have a place too.

Consider the address bnode example in the RDF Primer 
There may be times when you want to reference that address externally 
(e.g. from another model) but the common sense approach to enable that 
by just replacing the bNode with a URI reference has a couple of problems:
* it changes the meaning of the model: bNodes serve as existential 
variables -- if you replace two distinct bNodes x and y with 2 different 
URIs you are adding information to the model: because there is nothing 
in the model that says x and y might not be equal but the two URIs that 
replace are indeed not equal (since RDF uses intensional semantics for 
* even in the case where adding this information is satisfactory it 
might not be desirable to do that, especially in the context of the Web. 
If I give the addresss bnode with a URI reference I am commiting 
everyone else in the world to know that URI reference I gave it if they 
want to refer to that address. But if I just use a bNode then any RDF 
processor, *without any schema knowledge*, just by applying graph 
equivalancy, can infer that another model that contains a bNode or URI 
reference with the same extension is refering to the same entity.
Of course, equivalency can happen at a higher level: given a schema we 
could infer that two different URI resources are in fact equivalant.  
(E.g. in OWL, define an equivalency class for the address based on 
property restrictions). But this requires that both the schema itself 
and machinery to process it be available, and, especially on the web, it 
is desireable to minimize assumptions about what is available.

Thus there are indeed times where it would be useful to externally 
reference a bNode via an URI.  I imagine an absolute bNode would like 
something like:
bnode:///<URL encoding of the model URI>/bNodeIdentifier
(and a relative bnode like bnode:bNodeIdentifier)

Here's my technical reasoning behind this. Let me know if  this reveals 
any misunderstandings about RDF semantics.

BNodes are defined by their extension: this is implied by the simple 
entailment rule (or, to put another way, a non-lean graph contains no 
more information than a lean instance of the graph) and by the graph 
equivalency rule.   Similarly, two distinct bNodes do not imply two 
distinct entities: Consider the model

_:x <p1> <a>
_:y <p2> <b>

How many entities can we conclude may exist, given the basic assumption 
of RDF that the model might be incomplete  (no closed world)? At least 
one, but not two. The model merely says there exists something with the 
property /value (<p1>, <a>) and there also exists something with (<p2>, 
<b>), but not that those 2 somethings are necessarily distinct from each 

(a "proof":  :_x <p2> <b> is added to the model. This new model is a 
non-lean instance of:
_:x <p1> <a>
:_x <p2> <b>
(_:y <p2> <b> becomes redundent)
Which clearly only implies one distinct entity.)

Received on Thursday, 11 March 2004 16:43:27 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:44:48 UTC