Of "reification" (and sealing wax?)

Pat,

I thought I had been converging on some understanding of these issues, but 
my attempts to bridge the (mis)understandings seem to keep "bouncing off" 
some fundamental block...

At 11:22 PM 6/23/01 -0500, you wrote:
>>A part of this will be deciding about the role of "reification", or maybe 
>>some replacement idea.  I happen to think this is a key area, because the 
>>issues of provenance/trust/logic depend on being able to use a statement 
>>without asserting it.  (I am skeptical that this can be retro-fitted to a 
>>core RDF consisting of just asserted triples.)
>
>This is probably going beyond the scope of this working group, but I would 
>like to reiterate an opinion I have already voiced on RDF-logic. The 
>previous paragraph seems to accept a view that seems to be built into RDF 
>1.0, but shouldn't be, since it is  profoundly and totally mistaken. This 
>is the view that an expression  must be either asserted or described 
>(reified), so that anything that is not asserted must be reified. This 
>view is so utterly wrong that I find it hard to understand how it ever got 
>built into RDF. Every logic ever invented, from Aristotelian logic 
>forwards, has used propositional expressions in ways other than asserting 
>them, until RDF.  RDF, uniquely in the history of human language design, 
>provides no way to use an expression other than to assert it. In effect, 
>it has no propositional syntax. Reification does not provide a way to add one.
>
>To see why this assumption is wrong, consider any simple propositional 
>assertion which is more complicated than an atomic fact, eg say the 
>negation of an atomic fact. If someone asserts (not P), they obviously do 
>not assert P. However, they also do not *mention* P or *describe* P; they 
>use the expression P in *exactly the same way in the same sense* as 
>someone who asserts P simpliciter. Both asserting and denying are about 
>the truth-value of the expression.
>
>There are two different contrasts one needs to keep distinct: between 
>using and mentioning an expression, and between an assertion and other 
>uses of an expression. Denying P , or claiming that P implies Q, or that 
>one of P, Q or R is true, all *use* 'P' in the same way that asserting P 
>itself uses the expression. In modern boolean logic, they are all done by 
>asserting some propositional expressions (respectively (not P), (implies P 
>Q) and (or P Q R).) None of these involve mentioning or reifying the 
>(sub)expressions which are being used.
>
>All the model theories that have been suggested for RDF either ignore 
>reification or treat it, correctly, as indicating that a statement exists. 
>But if I assert (not P), ie if I deny P, I am not saying that P exists, 
>still less that P doesn't exist: I am saying the world is such as to make 
>P false, just as when I assert P I am saying the word is such as to make 
>it true. In both cases I USE the expression to say something about the 
>world, not MENTION it to say something about it.
>
>I am not arguing that reification should be abandoned or forbidden (though 
>I would shed no tears if it were). It may have some utility. But it should 
>not, and indeed I think cannot coherently, be used as a tool to encode 
>non-assertional uses of subexpressions. In particular, it cannot be used 
>to encode negation, disjunction, quantification or any of the rest of 
>'normal' logic, nor to encode modalities (such as indirect speech, as in 
>transcribing "Ora said that Bill was Danish"; contrast direct quotation, 
>as in "Ora said: 'Bill was Danish' " where Ora's actual words are cited, 
>rather than the propositional content of what Ora said. The latter does 
>indeed involve reification of a statement, indicated in English as in many 
>technical languages by the use of quotation.) In brief: reification is a 
>technical device of very limited utility; in particular, it cannot be used 
>to 'retrofit' most aspects of a richer assertional language into RDF.

I'd like to try a little "thought experiment":

1.  Suppose we have a language, say RDF[0], whose *only* primitive 
construct is the quadruple of triples that we call "reification":
     id rdf:type rdf:Statement .
     id rdf:predicate p .
     id rdf:subject s .
     id rdf:object o .
It's not very expressive -- using this, you can't say anything meaningful 
about the world.  It simply allows one to bind a binary predicate to an 
identifier:  (= id (p s o) )

2.  Now suppose that we have a new language, RDF[1], which is the same as 
RDF[0] but has an additional primitive construct:
     or id id .
which means, if id is bound as above, (or (p s o) (p s o) ), which (under 
the usual meaning of or) is the same as (p s o).

This RDF[1] seems to me to have the same expressive power as RDF.  But, as 
far as I can see, it establishes a framework for *use* of a predicate that 
is bound using the construct that RDF calls "reification".

I can't see what I am missing when you say, categorically, that "[RDF] has 
no propositional syntax. Reification does not provide a way to add 
one".  Is the problem with the term "reification", or is it fundamental in 
the structure suggested?

(This is the kind of thing I have been trying to pursue with my "abstract 
syntax" and subsequent attempt at a semantics.)

I'm trying to capture that the following:
     id rdf:type rdf:Statement .
     id rdf:predicate was .
     id rdf:subject Bill .
     id rdf:object Danish .
     Ora said id .
can mean
     "Ora said that Bill was Danish"
rather than
     "Ora said: 'Bill was Danish' "

(My goal here is not that this should become "the RDF way", but to bridge 
some views expressed by TimBL, et al, with the kind of logical concerns 
that have been well-aired.)

#g


------------
Graham Klyne
(GK@ACM.ORG)

Received on Tuesday, 26 June 2001 07:15:48 UTC