- From: Drew McDermott <drew.mcdermott@yale.edu>
- Date: Fri, 5 Apr 2002 17:40:35 -0500 (EST)
- To: www-rdf-logic@w3.org, www-rdf-rules@w3.org
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