Variables in rules

I am posting a lightly edited e-mail interchange between me and
Charlie Abela (with his permission).  The topic is representation of
variables in rules.  I am posting to two mailing lists because I don't
know which one is more appropriate; feedback appreciated.

   [Charlie]
   After reading through that paper it seems to me that the idea I
   presented lacks some important issues.  For one the relator should
   point to a property and not a string as in the example.  As regards
   the variables identification, is there no other means apart from
   reification that can be used.  For example would defining a
   variable as being a subject or object be enough? In this case then
   a conclusion or premise would be made up of a triple (pred, subj,
   obj).

No, I don't think this makes sense, if I understand you correctly.
There has to be a clear distinction between a variable and an
identifier.  

If you mean something like: An object can be declared to be of
rdf:Type variable, then Yes, such a variable could then be used as an
ordinary subject or object.  (That's what we do, in essence, but
before people start pointing out the pitfalls please read 
http://cs-www.cs.yale.edu/homes/dvm/papers/McDermottDou02.pdf to see
what I actually mean.)

I believe that the success of Prolog has caused people to
focus obsessively on the case of *free* variables, not explicitly
scoped by a quantifier.  This is a serious error for several reasons:

1) Free variables are universally quantified.  Existentials must be
represented by a different device, such as Skolemization.
Skolemization is a wonderful thing, but it has many problems,
including the fact that it captures the semantics of existentials only
under narrow circumstances (refutation theorem proving) that often do
not actually obtain.

2) The Prolog encoding of logic is centered on a particular task:
top-down, programmer-guided, theorem proving.  If all you want to do
is *state* a bunch of facts, then the encoding is treacherous.  Given
an explicitly quantified conjunction of facts, I can negate the
conjunction or any subset by just putting a not-sign in front of it,
and then moving it deeper into the quantifier stack if I so desire.
The negation of a set of Prolog clauses is damnably difficult to
define, let alone compute.  (If you know which functions are to be
treated as Skolem functions, then there are "de-Skolemization"
algorithms, but they are nightmarishly complex in the most general
case.)

3) Explicit quantifiers can be a declaration mechanism; you can state
the types of variables explicitly (in logics where types are part of
the syntax).  With explicit quantifiers you can tell the user about
unbound variables.  I fail to see why, when almost every programming
language on earth requires users to declare variables, and rewards
them for doing so, the Prolog (or "rules") community thinks this is a
pointless burden.

4) The Prolog notation is a frigging *abbreviation*, for chrissake.
Prolog itself is a clean, consistent, and very concise language, where
this abbreviation blends in perfectly.  But on the Semantic Web?  The
place where ")" is abbreviated "</foo>"?  Why in the world insist on
abbreviating quantifiers?

                                             -- Drew McDermott

Received on Friday, 5 April 2002 17:40:48 UTC