# Re: Of "reification" (and sealing wax?)

From: Graham Klyne <Graham.Klyne@Baltimore.com>
Date: Thu, 28 Jun 2001 17:56:34 +0100
Message-Id: <5.0.2.1.2.20010628170041.03891240@joy.songbird.com>
To: pat hayes <phayes@ai.uwf.edu>

```At 10:51 AM 6/28/01 -0500, pat hayes wrote:
>Yes, and I was here assuming that the inner triples in the reification
>were intended to be RDF. I still think they should be, but lets go along

Thanks... this is intended as an exploration of an idea, not a proposal.

>>I now see that my use of the notation (p s o) was wrong.
>>
>>I was intending to use (p s o) as a function application in this
>>case.  Thus, I was trying to say something like:
>>
>>  I(" id rdf:type rdf:Statement .
>>      id rdf:predicate p .
>>      id rdf:subject s .
>>      id rdf:object o . " )
>>
>>      = (= id (I("p") I("s") I("o")))      [NOTE1] [NOTE2]
>>
>>where I("p"), I("s") and I("o") are provided by some other part of the
>>interpretation, and I("p") is a binary predicate.  In words, the
>>quadruple above means that the symbol "id" is bound to some binary
>>predicate associated with "p" applied to argument values associated with
>>"s" and "o" respectively.
>
>OK, but what does that mean? In normal logic, the result of applying a
>binary predicate to two arguments is a truthvalue (T if the pair of
>arguments is in the extension of the relation, F otherwise.) So do you
>mean here to identify id with a truthvalue? (I doubt it :-)

Yes, that was what I intended... "id" is identified with the truthvalue
obtained by evaluating (I("p") I("s") I("o")). ...

>  Or do you mean to say that id is the sentence? Or do you mean something
> else, like a proposition? (Exactly what a proposition is, is debateable,
> but one widely used notion is that it is a function from possible worlds
> to truthvalues.) The only thing that actually has the *syntax* still
> intact is the sentence (in one form or another: we could quibble about
> whether a sentence is a string or a set of triples or whatever, but let's
> not.)  It's just like a function call in a programming language: once you
> actually evaluate the thing, all you have is the value. If you want to
> keep the code around, then you'd better not call it.

... but this is interesting.  If the original "s" and "o" are constants
then I don't think anything is gained by preserving information about the
structure of the expression.  But if they are variables (i.e. their
denotation is not defined by the Interpretation alone) then I suppose the
interpretation has to take this into account.

(This takes me back into the part of model theory that I'm struggling to
fully comprehend.  The pieces make sense, but I fail to quite grasp how
they all work together.)

The closest I can come at this time is that the interpretation (I("p")
I("s") I("o")) is not so much a truth value as a "recipe" for obtaining a
truth value, which may depend on a variable substitution function.  Let D
be the domain of interpretation, then:
I("p") : D -> ( D -> TruthValue )
I("s") : D
I("o") : D

If "s" is a constant, then I("s") is a value defined directly by the domain.
If "s" is a (free) variable, then I("s") is a value defined by some
variable subtitition, say V("s").  Then, given some variable substitution
function V, (I("p") I("s") I("o")) evaluates as a TruthValue.  Similarly
for "o".

The Scott/Strachey approach to programming language semantics uses
something like this:

I("s") : N+D
I("o") : N+D
I("p") : D -> ( D -> ( V -> TruthValue ) )
{ so (I("p") Vsub) yields a TruthValue, for any variable
substitution Vsub }

where:
D is the domain of interpretation
N is a domain of variable names
V : N+D -> D   is a domain of variable substitutions

Then:

I(" id rdf:type rdf:Statement .
id rdf:predicate p .
id rdf:subject s .
id rdf:object o . " )

=  (= I("id") ((lambda (v)) (I("p") (v I("s")) (v I("o")))))

Now, the interpretation of "id" is bound to a function from a variable
substition to a TruthValue:

I("id") : V -> TruthValue

>>[NOTE1] I'm assuming here that I("id") = id -- that identifiers in the
>>language represent the same identifier in the domain of interpretation --
>>is this valid?
>
>Well, we can define I in any way we like; but this is, shall we say, unusual.

>>Then using your definition (lambda (x y)(if x then T else y)) for 'or',
>>and 'id' as above:
>>
>>  (or id id) = (or (I("p") I("s") I("o")) (I("p") I("s") I("o")) )
>>               ((lambda (x y)(if x then T else y))
>>                        (I("p") I("s") I("o"))
>>                        (I("p") I("s") I("o")))
>>               ... etc.
>
>You stopped just when it was getting interesting. Now evaluate that
>lambda-expression. You bind x and y both to (I("p") I("s") I("o")), then
>you ask if x, ie (I("p") I("s") I("o")), is true. Well, is it? If that
>denotes a truthvalue the question at least makes sense, but what if it
>does not?

Before I introduced variable substitutions, I think this would have worked
just fine, as a truthvalue was intended.  Now I think I'd need to define an
alternative version of "or" here that accepts and applies the variable
subsitution:

(lambda (x y)
(lambda (v) (if (v x) then T else (v y))))

#g

------------------------------------------------------------
Graham Klyne                    Baltimore Technologies
Strategic Research              Content Security Group
<Graham.Klyne@Baltimore.com>    <http://www.mimesweeper.com>
<http://www.baltimore.com>
------------------------------------------------------------
```
Received on Thursday, 28 June 2001 13:23:38 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:02 UTC