W3C home > Mailing lists > Public > www-rdf-logic@w3.org > May 2001

Re: What do the ontologists want?

From: pat hayes <phayes@ai.uwf.edu>
Date: Tue, 15 May 2001 16:44:16 -0500
Message-Id: <v0421010fb7274d63de88@[205.160.76.173]>
To: Uche Ogbuji <uche.ogbuji@fourthought.com>
Cc: www-rdf-logic@w3.org
> > All of the above, with the possible exception of the Eliot quotation
> > example (which havers between direct and indirect quotation by its
> > literary usage of "says"), involve reference not to the form of an
> > expression, but to its meaning or content. The way to refer to the
> > meaning of an expression is to USE it, not to MENTION it, which is
> > what quotation/reification do.
>
>Our messages crossed in the mail.  I later realized that you and I are not
>talking about the same thing when we say "quoting".  Your interest seems to be
>linguistics.  I'm almost never interested in linguistics when constructing an
>RDF model.  I'm interested RDF statements basically as logical predicates.

I am also interested in logic, but the basic conceptual distinctions 
of language description - the contrasts between syntax and semantics, 
and use and mention - apply just as cogently to logical languages as 
to natural langauges. In fact they apply to all meaningful usages of 
symbols in any medium.

>So while you attacked the Engish semantics of the examples I gave for
>reification, I think it's an argument without an opponent because I was
>strictly talking about logical predicates

I was also talking about logical structure, rather than linguistic 
issues. But notice that examples like the Eliot quotation are 
intrinsically linguistic, or even literary, in nature. If you want to 
talk logic, you should accept the need to unpack such linguistic 
phenomena in enough detail to uncover their true logical form, which 
in cases like indirect attribution can be extremely subtle.

>that could be interpreted as the
>English form I presented, for example (using an invented
>declarative/functional syntax):
>
>X := is_own_season(midwinter_spring)
>says(X, eliot)
>
>The satisfaction of X over the universal quantifier is what I view as
>reification.  Hopefully you can fill in the rest of the examples from that.

No, and let me tell you why. As you have written it, what exactly is 
the intended value of X? You are here mixing two different formal 
conventions: assignment from programming languages, which associates 
a variable with an *expression* (like instantiating a quantified 
variable with a term in logic); and universal quantification from 
logic, which takes a variable to range over a semantic space (which 
in general does not consist of expressions, but the things that 
expressions denote.)

I really do not know what you mean by 'the satisfaction of X over the 
universal quantifier', since you presumably do not mean to 
universally quantify the variable X; but more to the point, do you 
here mean X to denote an expression, or to denote something like a 
proposition? Do you mean to say:

Eliot said: "is_own_season(midwinter_spring)",

(which is unlikely, knowing what little I do of Eliot) or:

Eliot said that is_own_season(midwinter_spring)

If, as I suspect, you meant something more like the latter, then your 
proposed logical form doesn't cut the mustard, since the only way to 
refer to the *content* of what Eliot said is to de-reify the 
expression referring to that content, ie the logical form you need 
would look more like
says(meaning(X), Eliot)
where 'meaning' maps an expression back to what the expression means, 
ie is a kind of truth-predicate.

There is a very basic point here. Once you reify an expression, it 
becomes an object. Objects - even those made from expressions - are 
just objects. To make them refer, to bring them back to logical life, 
you have to de-reify them somehow. De-reifying is the dangerous part 
of this business, since once you have that much power in your 
notation to bring objects to life, as it were, you have the power to 
instantly create paradox (courtesy, one way or another, of the lying 
Cretan), so you now need to find a way to keep this monster under 
control.  This can indeed be done, with care: KIF for example has a 
pretty full-blooded reification capability and is consistent. But it 
needs special syntax, greatly complicates the semantics, and is 
generally a nuisance, and in practice is almost never used, since any 
sane programmer will use a scripting language to mess with the syntax 
if they really need to do that, rather than write logical 
expressions. And for for almost all normal logical purposes, there is 
no need to wake the monster up in the first place. Logicians didnt 
fail to use reification for negation, quantification, attribution, 
modality and so on just because they were too dim to see how; they 
avoided it because they had about 30 years of hard work trying to 
deal with the damage it caused after Russell let it loose.

Pat Hayes

---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes
Received on Tuesday, 15 May 2001 17:44:23 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:45:37 UTC