Print

Print


Let me try (and probably fail) to clarify a few basic concepts.

[It may be helpful to think of blank nodes as being like variables in
algebra.  A homework assignment might have several questions:

One might ask for the value of x when x-3=0.
Another might ask for the value when x-1=2.
A third might ask for the value when x-5=0.

In the first two cases, the value happens to be the same; in the third it
happens to be different. Each equation would have the same solutions if you
renamed the variables to i, j, and k.]

1. Within the context of a *single* reading of a *single* RDF document, a
blank node x ("_:x") always refers to the same thing.

  This is why you can assert multiple property values about the thing
referred to by "_:x" , and use "_:x" as a property value,  knowing that
each of these uses will be referring to the same thing.

2. If you read the same RDF document twice, the thing referred to by "_:x"
the first time *might* not be the same thing referred to by "_:x" in the
second reading.

3. Because you can have multiple names for the same thing they may not
always be different, but without additional information you can't assume
one way or the other.

For example, you might have an OWL axiom that says that a concept in a
thesaurus can only have a single preferred label, and you see two
statements about the same concept that use different names for the
preferred label, you can infer that the two names must refer to the same
thing, even if the name of the label is a blank node- e.g. :

Given the OWL axiom  FunctionalObjectProperty(:prefLabel),
reading the statements below twice will make the potentially different
things that the blank node in each reading might refer to in fact be the
same.

_:x :literalForm "Weasels--Homes and Haunts"@en.
ex:weaselHH :prefLabel _:x.

If we didn't have the OWL axiom, ex:weaselHH might have two different
values for :prefLabel.

4. There is no problem with a SPARQL  query binding a variable to a blank
node; however it can be difficult to use the value in second query.

5. It can be difficult to use SPARQL to update an entity that is identified
by a blank node.  It is necessary to construct a WHERE clause that will
bind the blank node naming the entity to be modified to some variable.
This may be awkward if it hard to uniquely select the blank named entity.

6. It is not possible to make additional assertions about a blank node
named entity using only RDF.
It is usually possible to do so using OWL,  though the process may be very
awkward.

7. There are several features in OWL that only work for named individuals.
The most obvious example are HasKey axioms, which let you define a set
properties that work like a primary key for instances of a particular
class- if all of the key properties associated with two names are
identical, the two names refer to the same entity.

8. If you use blank nodes with linked data you're gonna have a bad time.
http://youtu.be/ynxPshq8ERo

Simon