CAVEAT:  this message is about a way a thinking of blank nodes, but it is
not a proposal or even a comment on the current language.  Think of it as
"Another Blind Man's Perspective on the Elephant". It's mostly for the fun
of it, but I think this perspective has a kind of intuitive clarity and
simplicity that might be useful.  I think it mostly maps cleanly to the
standard language, although I haven't worked out the details.  Naturally I'd
be grateful for any feedback.

The problem is how to get rid of quantifiers.  The idea hinges on two

1.  indexicals
2.  the type/token distinction

Background:  there are two related items of interest from the history of

Russell's "definite description operator" (inverted iota): the term "iota(x)
Px" means "the x such that P x".  (See In the Z specification
language (ISO 13568:2002<>)
this is called the mu operator.

Hilbert's "epsilon
picks out a "witness" for an existential quantifier:  "eps(x) P" denotes
"some x satisfying P, if there is one;" this eliminates the quantifier.

An "indexical" is a linguistic expression whose meaning is
context-dependent; examples include the personal pronouns (I, he, she,
etc.); adverbs like "here" and "now"; and in particular the demonstrative
pronouns like "this".   The analysis of indexicals gets complicated (see but the basic idea is simple
and intuitive: e.g. the meaning of "I" depends on who is speaking; the
meaning of "this" depends on what the speaker is "pointing" at, and so

This suggests a simple way of thinking about blank nodes.  Instead of
existential quantification, we use "thisiness" (apologies to Steven
Colbert).  We extend RDF with the term "rdf:This", which takes an optional
query argument (e.g. rdf:This?foo).  Then "rdf:This" is treated as an
indexical combining the meanings of "I" and "this"; it has a different
meaning everywhere it is used.  Think of the term as pointing to itself and
saying "I mean this".  If it is parameterized, then it is treated as a
"dependent" indexical:  "rdf:This?foo" has the same meaning (dependent on
"foo") within the local scope (to be defined), but different meanings in
different scopes.  Think of each occurence of a dependent "this" term within
a given scope as pointing to the same "foo" (within scope) and saying "I
mean this 'foo'".

This can be given precise formal semantics using the type/token distinction.
 "Type" is to be construed as the abstraction of symbols, not "data type"
(e.g. Int) as in programming languages.  For example, each occurence of the
letter 'a' in this message is a token of its type, which we can also call
'a'; for clarity, we can say "a-tok" and "a-typ", respectively.

Ordinary URIs are tokens of their types; since each URI token of a given
type has the same meaning, the locus of signification must be the type
rather than the token.  Each token *exemplifies* its type but does not
denote; that is the type's job.

Each rdf:This-tok, by contrast, has a different meaning; hence the locus of
signification must be the token, not its type.  Each token still exemplifies
its type, but now the burden of meaning has shifted from the type to the

A parameterized rdf:This token such as rdf:This?foo combines type and token
signification.  I think the intuition is clear enough - "this foo", where
each scope has its own foo - but I haven't yet worked out the mechanics of
signification.  It isn't yet clear to me how to meet halfway between the
abstract/global (type signification) and the particular (token
signification) in order to get locally scoped signification.  It would be
nice if this could be handled without introducing scope as a third formal
element but I don't see how to do that.

In any case, blank nodes could be managed in practice by extending RDF by
defining "rdf:This" as a (metalinguistic) term construction operator.
 Ordinary URIs are also term constructors; they just construct themselves.
 By contrast, rdf:This constructs a globally unique term as a synonym of
itself; think of "rdf:Term" as pointing to that constructed term and saying
"I mean that", where "that term" and "this" have the same meaning.
 Parameterized rdf:This just constructs a unique term that depends on its
argument and the scope.

Semantically one could probably find some way of using Russell's iota or
Hilbert's epsilon, but I'm not sure one needs them.  If rdf:This is a term
construction operator, then blank nodes can be treated just like any other
node, except with a contingent label.

(BTW, there are no unlabeled nodes; what seem to be unlabeled nodes are in
fact anaphorically or indexically labeled.  An unlabeled circle in a diagram
is still a symbol, a kind of indexical label; where nesting is used
syntactically to indicate a blank node, the syntactic device of nesting can
be taken as a kind of indexical label or symbol.  In other words, the
difference is not between labeled and unlabeled, but between persistently
and transiently labeled (or: between rigidly and contigently labeled)

Note that rdf:This is essentially equivalent to an unlabeled circle (node)
in a graphic diagram of a graph.  In other words, such unlabeled circles
function as indexicals meaning "this node".  Two different unlabeled circles
will never be confused, since we can tell by inspection that they are
different circles.  Same goes for two different rdf:This tokens.



Received on Friday, 25 March 2011 11:39:09 UTC