Re: bNodes as local constants

Jos writes:
> > In RDF we have
> > 
> > john rdf:type Person   entails   _:x rdf:type Person
> > 
> > where _:x is a bNode. The entailment relationship holds because there is
> > an assignment for _:x which is the same as the   interpretation of the
> > constant john.
> > 
> > 
> > If we would translate _:x to a local constant, say, x, then this
> > entailment relation no longer holds:
> > 
> > john rdf:type Person   not-entails   x rdf:type Person
> > 
> > Although john and x may denote the same individual in some
> > interpretation, this is by no means the case in every interpretation
> > which is a model of    john rdf:type Person.

Michael Kifer replies:
> Actually this is not a good example. A better way to approximate bnodes is
> to translate them into skolem in the head and into existentials in the
> body. This is how it is done in FLORA-2 and (I think I saw somewhere) cwm.
> 
> In your example _:x rdf:type Person to the right of "entails"
> is a query, i.e., it is a body literal. So, it is translated into an
> existential and everything is hunky-dori. (Existentials in rule bodies are
> fine.)
> 
> This is not to say that this simulation is completely adequate, but this
> particular case is not a problem.

I understood Jos to only be talking about facts (not rules) in this
example.   Is that also your understanding?    When you talk about
"entails" as if it were a rule, are you making an analogy?

If so, then I think I agree.  Jos, your example manifests the difference
only when RIF Core is used to express what is entailed, and we never
need to to do that.  Use FOL to talk about what is entailed, and we
don't see a difference, do we?

   rif("john rdf:type f:Person")   |= exists x triple(x, rdf:type, f:Person)
   rdf("_:john rdf:type f:Person") |= exists x triple(x, rdf:type, f:Person)

(Neither "john" nor "_:john" can be named in the entailments, since they
are both in a sense local, and so not in scope for use elsewhere.)

You mentioned that SPARQL result sets include b-Node identifiers, but
those are only in-scope for a particular result set (like the x in my
entailments).   They are not actually revealing the local names which
might have been used in the data-being-queried:

         There need not be any relation between a label _:a in the
         result set and a blank node in the data graph with the same
         label. 

         An application writer should not expect blank node labels in a
         query to refer to a particular blank node in the data. 

                -- Current SPARQL Draft [1]

So I don't see a problem there.  (I'm also kind of baffled on how the
semantics of local names in RIF are supposed to be different from the
semantics of file-scope existentials.  Example anyone?  I think it's the
same question.)

   -- Sandro


[1] http://www.w3.org/TR/2007/WD-rdf-sparql-query-20070326/#BlankNodesInResults

Received on Wednesday, 25 April 2007 03:29:01 UTC