SOFTWARE VERIFICATION RESEARCH CENTRE DEPARTMENT OF COMPUTER SCIENCE THE UNIVERSITY OF QUEENSLAND. Queensland 4072 Australia TECHNICAL REPORT. No.

Transcription

1 SOFTWARE VERIFICATION RESEARCH CENTRE DEPARTMENT OF COMPUTER SCIENCE THE UNIVERSITY OF QUEENSLAND Queensland 4072 Australia TECHNICAL REPORT No. 190 Higher Level Meta Programming in Qu-Prolog 3.0 A.S.K. Cheng, P.J. Robinson and J. Staples October 1990 Phone: Fax:

2 Higher Level Meta Programming in Qu-Prolog 3.0 Anthony S.K. Cheng, Peter J. Robinson and John Staples Software Verication Research Centre Department of Computer Science University of Queensland, 4072, Australia Abstract For representing high level knowledge, such as the mathematical knowledge used in interactive theorem provers and verication systems, it is desirable to extend Prolog's concept of data object. A basic reason is that Prolog data objects Herbrand objects are terms of a minimal object language, which does not include its own object variables, or quantication over those variables. Qu-Prolog (Quantier Prolog) is an extended logic programming concept which takes as its data objects, object terms which may include object level variables, free or bound, and arbitrary quantiers to bind those variables. Qu-Prolog is unique in allowing its data objects to include free occurrences of object variables. This paper describes Qu-Prolog's data objects and its facilities for computing on those objects. The Qu-Prolog unication algorithm unies Qu- Prolog terms up to changes of bound variables. The power of Qu-Prolog unication is greatly increased by the inclusion in the language of an evaluable substitution operator which correctly substitutes at unication time for free occurrences of object variables. Some related Qu-Prolog facilities for implementing theorem proving algorithms are described, including a new method for persisting data across queries. Qu-Prolog 3.0 is a compiled implementation which is in experimental use, supporting the development of interactive reasoning systems. 1 Introduction Prolog-like languages are highly successful theorem provers, within the scope of their vocabulary and inference algorithms; but how good are Prolog-like languages for implementing theorem provers in general, and other symbolic algorithms? A basic limitation of most Prolog-like languages, considered as a means for implementing symbolic algorithms, is that Prolog's symbolic data objects Herbrand objects have minimal syntactic structure, which does not directly represent very much of the structure of knowledge in logic, mathematics and science. For example, Prolog does not directly compute with symbolic objects which have their own object variables, and quantiers 1

3 binding those variables. It is of course possible to represent these structures logically in Prolog (for example, the `ground representation' of Prolog terms in meta-programming), but that leads to poor eciency, clumsy low level algorithms and a failure to exploit in the language primitives, the inherent structure of the data. Qu-Prolog (Quantier Prolog) is an extended logic programming concept which takes as its data objects, object terms which may include object level variables, free or bound, and arbitrary quantiers to bind those variables. More precisely, Qu-Prolog objects are equivalence classes of such terms, where the equivalence relation is -equivalence, that is equivalence up to changes of bound variables. The basic semantics for Qu-Prolog is in the same style as for Prolog: a Qu-Prolog program is a free-variable, rst order theory of a specic, well-known universe of discourse (equivalence classes of object level terms). The Clark semantics of Qu-Prolog programs is dened in essentially the same way as for Prolog. The main dierence is that in the Qu-Prolog case, the axioms for equality in the completion of the program, and which characterise the deductive power of unication, are more complex. Partly that is because -equivalence of quantied terms is a more complex concept than identity of ground, free-variable terms. A more important reason however is that Qu-Prolog unication performs much more powerful pattern matching than does Prolog unication. That is because the vocabulary used to describe schemes of Qu-Prolog terms includes a parallel substitution operator which is evaluated at unication time. This operator describes substitution of object terms for object variables. It formalises a notation which is widely used in meta level reasoning, and is at the heart of the deductive power of Qu-Prolog. It is beyond the scope of this paper to discuss the Clark semantics of Qu- Prolog in detail, but see [13] for properties of Qu-Prolog equality which are suitable as axioms for the completion of Qu-Prolog programs. Note however that [13] refers to a previous version, Qu-Prolog 2.0; the version described here requires stronger equality axioms. Since Prolog and Qu-Prolog semantics are dierent, it is not to be expected that their properties will be identical. For example, Qu-Prolog uni- cation is undecidable [10]; it is made practical by delaying dicult unication subproblems. Accordingly, Qu-Prolog does not have the same strong completeness properties as Prolog. A weaker notion of completeness can be dened and established, however. It is beyond the scope of this paper to discuss that in detail, but see [11]. The representation of terms in Qu-Prolog is described in section 2. Section 3 discusses the unication of Qu-Prolog terms. The use of Qu-Prolog terms is demonstrated in section 4. Qu-Prolog's persistent variables, and the language's support for them are described in section 5.

4 2 The Language Qu-Prolog uses Edinburgh Prolog syntax for constants and structures, and for ordinary variables which are intended to range over arbitrary object level terms. These variables will be referred to as meta variables, in recognition of the meta level status of the Qu-Prolog language relative to the object language. In addition, Qu-Prolog introduces syntax to represent object level variables and quantiers, as follows. 2.1 Object Variables Since object level variables are simply part of the object level syntax, it might seem natural to name them at the Qu-Prolog (meta) level by constants. Instead, Qu-Prolog 3.0 refers to object level variables only by a type of Qu-Prolog (meta) level variable, called object-var variables. The semantics of object-var variables is that they range over object level variables. The success of this approach reects the well-known intuition that object level variables are interchangeable. The phrase `object variable' is commonly used to abbreviate `object-var variable' since it has no other use in describing Qu-Prolog syntax. For an occasional reference to a variable of the object language, the phrase `object level variable' will be used. Qu-Prolog 3.0 object variables have the same lexical conventions as constants. In order to distinguish them, object variable notations must be declared by object var/1. The declaration convention is that an explicit declaration of an object variable name also implicitly declares all variant names derived by appending an underscore followed by a positive integer. Warning: This lexical convention for object variables makes it easy to think that object variables are meta level constants. That is not so, as explained above. As each object variable is intended to range over all object level variables, it is important to know whether two object variables denote the same object level variable. This information can be supplied implicitly or by explicit use of the predicate distinct from/2. For example, x distinct from y asserts that x and y do not denote the same object level variable. By default, all object variables occurring in the same clause/query are distinct from each other. Distinctness of object level variables is a special case of more fundamental relationship between object level variables x and object level terms t in general: that x does not occur free in t. To represent this relationship Qu-Prolog 3.0 uses the built-in predicate not free in/2. The predicate distinct from/2 can be regarded as being dened by the following, where x and y are assumed to be declared as object variable names: x distinct from y :- x not free in y.

5 For eciency reasons however, this is not the actual implementation of distinct from in Qu-Prolog 3.0. Remark: In fact Qu-Prolog 3.0 makes internal use of some meta level constants representing object level variables. These terms, called local object variables, are discussed below. Their key role is as `new' variables, for use when changing bound variables. This newness is implemented by a convention that they are excluded from instantiations of user accessible meta variables and object-var variables. 2.2 Quantiers Qu-Prolog can reason about object level terms which include arbitrary quantiers, in much the same way that Prolog can reason about terms which include arbitrary function symbols. The user declares quantier notations as needed. So, it is possible to have representations of R for integral calculus as well as 8; 9 for rst order logic. This capability is demonstrated later (section 4) in a Qu-Prolog interpreter for the full (type-free) lambda calculus, by declaring a lambda quantier. Distinct quantier notations in Qu-Prolog represent distinct object level quantiers. Qu-Prolog uses the traditional prex notation for quantied terms. Quantiers are declared explicitly by executing op(precedence; quant; Q) where Q is the representation for the quantier; Q must have the same lexical structure as a Prolog constant. Qu-Prolog treats quantiers as arbitrary binders of object variables, whereas Prolog [6] treats its quantiers as labelled lambda abstractions. Both these languages should be distinguished from NU-Prolog [8] and Meta Prolog [1], in which specic (meta level) quantiers (e.g. 8) form part of the programming language, but are not part of the object level syntax. 2.3 Substitutions Throughout logical reasoning, the need for substitutions arises naturally. Qu-Prolog directly supports parallel substitution for free occurrences of object level variables. By contrast, Prolog implicitly supports substitution by supporting reduction of beta redexes in the lambda calculus. The syntax for substitutions in Qu-Prolog is [t 1 =x 1 ; : : :; t n =x n ] term where x 1 ; : : : ; x n are object variables and t 1 ; : : : ; t n are arbitrary Qu-Prolog terms. As an example, consider an inference rule If 8 x A is a theorem then for each B, [B=x] A is a theorem.

6 This can be represented directly by a Qu-Prolog rule such as theorem([b/x] * A) :- theorem(forall x A). Qu-Prolog substitutions are evaluated at unication time, in accordance with the standard concept of correct substitution into quantied terms, which substitutes only for free occurrences of variables and which changes bound variables to avoid capture of free variables from the substituted terms. For a term s 1 : : : s n y where s 1 ; : : :; s n is a sequence of substitutions, the substitutions are applied from right to left. That is, s n is applied to y rst. The eect of applying a substitution to a term can be observed with this example [t 1 =x 1 ; : : :; t n =x n ] y: After applying the substitution, the result will be: t i if for some i = 1; : : : ; n; x i = y, or y if for all i = 1; : : :; n; x i distinct from y. It is also possible that there is insucient information at a particular stage to determine which of these cases applies. In that case evaluation of the substitution will be delayed. That may lead to delaying of unication subproblems, perhaps extending beyond the current unication call. To clarify this idea, consider [b=x 0 ] [f(x 0 )=x 1 ; g(x 0 )=x 2 ] y. One of the following will result: g(b) if y = x 2. f(b) if y distinct from x 2 and y = x 1. b if y distinct from x 1 and y distinct from x 2 and y = x 0. y if y distinct from x 0 and y distinct from x 1 and y distinct from x 2. [b=x 0 ] y if y distinct from x 1 and y distinct from x 2 and no information is known about the relationship between y and x 0. [b=x 0 ] [f(x 0 )=x 1 ; g(x 0 )=x 2 ] y if no information is known about the relationship between y and x 1, x 2. As well as substitutions appearing in user inputs, the system can generate substitutions via unication. For example, the problem has the solution A = [x=y] B. forall x A = forall y B

7 3 Unication Qu-Prolog extends Prolog unication to cover the new data objects in the language, and to take account of the evaluation of the substitution operation. Since unication for Prolog terms is not changed (except that Qu-Prolog includes occurs checking), our discussion will concentrate on the new features. 3.1 Object Variables Since an object variable is intended to range over object level variables, and since object variables are the only Qu-Prolog terms of this type, an object variable can be instantiated only to another object variable. Further, unication fails if the object variables denote distinct object level variables. Also, whenever a meta variable is unied with an object variable, the meta variable is bound to the object variable. 3.2 Quantiers To motivate the treatment of unication for quantied terms, consider forall x x = forall y y Intuitively, the two terms are uniable without instantiation of x or y, because the terms are the same up to change of bound variable. To unify x and y would destroy the completeness of Qu-Prolog's unication. Hence during quantier unication, Qu-Prolog uses substitution to rename the bound variables to a common bound variable. The bound variable must not appear in the unied terms. This is where the local object variables mentioned previously are used. Once bound variables for both terms are renamed to the same local variable, the two substituted terms are unied. Here is how the approach applies to the example, ( is a local object variable). forall x x = forall y y forall [=x] x = forall [=y] y As another example, consider [=x] x = [=y] y = (success) forall x A = forall y y It is initially simplied to [=x] A = [=y] y

8 Unication should produce the answer A = x. Qu-Prolog inverts substitutions containing only local object variables. In this example inversion results in A = [x=] [=y] y and the correct answer A = x is obtained after evaluating the substitution. As a further example, consider f orall x A = f orall y x. Since x does occur free on the right and cannot occur free on the left, this unication problem should fail. In Qu-Prolog unication, that failure is detected when, at the time of calculation of A = [x=] [=y] x, the constraint x not free in [=y] x is generated and tested; and after substitution evaluation, this test fails. Such not f ree in constraints may be delayed, as discussed below, if they cannot be immediately decided. 3.3 Occurs Check and Delayed Problems Unlike Prolog, occurs checking is included as standard in Qu-Prolog unication. Implementation of occurs checking uses two tests for occurrence called direct and static occurrence, as described below. Direct occurrence is a suf- cient condition for occurrence and so causes failure of unication. On the other hand `no static occurrence' is sucient for `no occurrence'. If occurs checking is not resolved, delaying of the unication sub-problem occurs. A meta variable X directly occurs in a term t (in which substitutions have been evaluated as far as possible) if t = s X, or t = f(t 1 ; : : :; t n ) and X directly occurs in one of t 1 ; : : : ; t n, or t = q x t 0 where q is a quantier, and X directly occurs in t 0. The unication of X and t fails if t is not of the form sx and X directly occurs in t. But, for example, it is impossible to determine whether X occurs in the term [X=y] Z without knowing more information about Z. If Z is bound to y, X occurs in the term. On the other hand, if Z is bound to a constant c, X does not occur. A meta variable X statically occurs in a term t (in which substitutions have been evaluated as far as possible) if t = s X, or t = f(t 1 ; : : :; t n ) and X statically occurs in one of t 1 ; : : :; t n, or t = q x t 0 where q is a quantier, and X statically occurs in t 0, or t = s [t 1 =x 1 ; : : : ; t n =x n ] Y where Y is a meta variable other than X, and X statically occurs in one of in s t 1 ; : : : ; s t n. t = s [t 1 =x 1 ; : : : ; t n =x n ] x 0 and X statically occurs in one of s t 1 ; : : :; s t n.

9 Occurs checking is not the only source of delayed problems in Qu-Prolog unication. As a simple example, consider the unication problem [X=y] Z = c, where c is a constant. The unication can succeed in one of two ways: Imitation: Z = c. Here the substitution has a null eect on Z. Projection: Z = y and X = c. Hence it is impossible to determine a unique most general unier. Rather than branch the unication problem, Qu-Prolog delays it until the binding of Z is known. Delayed problems are not restricted to unication. They may also arise during not f ree in checks. For example, the unication problem forall x A = forall y [x=z] Z gives the solution A = [x=] [=y] [x=z] Z provided : x not free in [=y] [x=z] Z Without knowing more information about Z, the not free in test must be delayed. Paterson [10] has shown that Qu-Prolog unication is semi-decidable, but not decidable. On the other hand, Qu-Prolog's ability to delay dicult unication sub-problems enables unication to be useful in practice. 4 An Example a Lambda Calculus Interpreter As a small illustration of the capabilities of Qu-Prolog, a Qu-Prolog implementation of a lambda calculus interpreter is presented. The naturalness of the Qu-Prolog approach is indicated by the fact that the interpreter code is virtually identical to the standard theoretical denition of lambda evaluation. Because the traditional notation (t u) for lambda application is not available in Qu-Prolog syntax, the list notation [t; u] is used. To be denite, we give rst a recogniser of lambda terms. This too is virtually identical to a standard theoretical recursive denition of lambda terms.?- op(525, quant, lambda). % define lambda as a quantifier?- object_var(x). % define x as an object variable name

10 lambda_term(x). lambda_term(lambda x T) :- lambda_term([t, U]) :- lambda_term(t), lambda_term(u). % each object variable is a lambda term lambda_term(t). Recall that we are using the phrase `object variable' loosely, to refer to object-var variables. An object-var variable is a type of meta level variable which is intended to range over object level variables. Hence the above clause lambda term(x), with x declared as a notation for an object-var variable, asserts that all object level variables are lambda terms. Leftmost-outermost lambda reduction is chosen for the interpreter. This is determined by the order in which the clauses of the reduction predicate are arranged.?- op(600, xfx, =>*). % reduction?- op(600, xfx, =>). % single reduction step A =>* B :- A => C, C =>* B. A =>* A. [lambda x T, U] => [U/x]*T. % reduction lambda x [A, x] => A :- x not_free_in A. % reduction lambda x T => lambda x U :- T => U. [T, U] => [V, U] :- T => V. [T, U] => [T, V] :- U => V. These Qu-Prolog clauses show a remarkable correspondence to the standard theoretical denition of lambda evaluation. Here are some examples of the operations of the interpreter. 1. [lambda y y, z] =>* Result. The query matches with the rst clause of =>/2. T binds to x and U binds to z. The substitution is formed and evaluated and the answer z is obtained. 2. lambda w [lambda y lambda z y, w] =>* lambda u lambda z u. After applying the second clause of =>/2 (i.e. reduction), the query is simplied to lambda y lambda z y =>* lambda u lambda z u. At this point, the second clause of the predicate =>*/2 applies since lambda y lambda z y and lambda u lambda z u are uniable.

11 5 Persistent Variables in Qu-Prolog 3.0 Prolog's orientation towards closed worlds and complete databases has to be reconciled with a need in many applications to accumulate additional knowledge. Qu-Prolog's persistent variables [12] provide a simple mechanism for achieving a reconciliation. Intuitively, in a program in which persistent variables appear, the scope of a persistent variable is the whole program and all queries that depend on it. The program may be thought of as a scheme of ordinary programs. More specic instances of the scheme may be selected by instantiating the persistent variables. To provide a logical semantics for persistent variables, we recall that the Clark semantics for Prolog [4] considers processing of a query Q(X) where X stands for all the query variables can be considered as a proof of the assertion P! Q(X), where P stands for the completed program and is a closed formula. This semantics may be extended to cover persistent variables as follows. The processing of a query Q(X; #Y ) where #Y stands for all the persistent variables which occur in the program and query can be considered as a proof of the assertion P (#Y )! Q(X; #Y ). Here P (#Y ) stands for the completed program, in much the same way as for the Clark semantics, but without binding of the persistent variables. Qu-Prolog's persistent meta variables and persistent object variables are distinguished from ordinary variables by having a # prex. Wherever a persistent variable with the same name is mentioned, the same persistent variable is being referred to. A data structure that is bound to a persistent variable can be accessed randomly by the name of the persistent variable. Consider the following program:?- op(600, xfx, likes). amy likes #X. #X likes bo. The program states that Amy likes someone who likes Bo. The query Y likes Y will return Y = amy and Y = bo as (alternative) results. As illustrated by this query, persistent variables behave identically to ordinary variables during unication. Beyond the basic logical semantics of persistent variables outlined above, some pragmatic (non-logical) predicates are provided in Qu-Prolog 3.0, primarily to manage the accumulation of knowledge within bindings of persistent variables. For example, bindings of persistent variables created during processing of a query are not carried forward by default to the next query. In order to maintain the bindings, the user must issue the commit command. All variables contained in the committed term will be promoted to persistent status. Successive calls on commit create a sequence of commit stages; the initial stage is 0. The current commit stage is returned by the command

12 commit_stage(n). When the current bindings of persistent variables are no longer needed, they can be discarded by giving the command back_to(m), where M is a non-negative integer; the bindings between M+1 and the current commit stage will be removed and the persistent variables bound during those stages will reset to unbound. The following is a Qu-Prolog session with the above program which demonstrates the use of the commit mechanism.?- commit_stage(n). N = 0; no (more) solutions?- #X = carol, commit, commit_stage(n). N = 1, #X = carol; no (more) solutions?- Y likes Z. Z = carol, Y = amy; Z = bo, Y = carol; no (more) solutions?- back_to(0). yes?- Y likes Z. Z = #X, Y = amy; Z = bo, Y = #X; no (more) solutions The predicates commit/0, commit_stage/1 and back_to/1 allow an orderly management of persistent bindings, independent of the depth rst backtracking mechanism in Qu-Prolog. Moat and Gray [7] proposed a persistent data store, which is similar to persistent variables in some respects. They interfaced Prolog to an external database into which the committed terms are stored. Committed terms are determined by a table where the user enters name:reference pairs and the terms are managed by normal dynamic database predicates (i.e. assert/1 and retract/1). Thus, the management of the respective schemes are different. The only similarity is the global naming. The approach of [7] lacks Qu-Prolog's commit facilities for managing persistent bindings. Davison's [3] survey of object orientation in logic programming reviews some proposals related to Qu-Prolog's persistent variables. In particular,

13 Newton and Watkins [9] proposed global variables for a logic programming based object oriented language. An implementation of the idea was done by McCabe [5]. Clauses in the language are grouped together into objects which can have parameters. When an object is called, the actual value of the parameter of the object will be known to all the clauses in this object, but not to other objects. For example, there may be two objects triangle and square, which have the parameter Side. When an object square(10) is called, all the clauses in square will have Side instantiated to 10, while the parameter in triangle is not aected. The persistent variables of Qu-Prolog 3.0 are not supported by such a modular structure, but on the other hand [9] lacks Qu-Prolog's commit mechanism for managing persistent instantiations. An integration of these two capabilities would seem desirable. 6 Conclusion Qu-Prolog's enhanced data objects are full quantied terms, which support natural and powerful knowledge representation and logic programming, as illustrated by the above implementation of a lambda calculus interpreter. Qu-Prolog's unication algorithm provides powerful pattern-matching appropriate to the extended vocabulary. Persistent variables allow incomplete databases and non-separable data which persists across queries. A compiler for Qu-Prolog 3.0 has been implemented in the SUN 3 environment, based on an appropriate extension [2] of the Warren Abstract Machine [15]. The extended abstract machine will be discussed separately. The language, including the extensions and features mentioned here, has been motivated particularly by the need to rapidly prototype interactive proof systems. Currently it is the implementation language for a substantial experimental proof system [14]. Acknowledgements Ross Paterson and Gerard Ellis have made substantial contributions to the design and implementation of Qu-Prolog 3.0. This research was supported by the Australian Research Council. References [1] K.A. Bowen and T. Weinberg. A Meta Level Extension of Prolog. Proc. of IEEE 2nd International Symposium on Logic Programming, Boston, July [2] A.S.K. Cheng and R.A. Paterson. The Qu-Prolog Abstract Machine. Technical Report No. 149, Key Centre for Software Technology, Department of Computer Science, University of Queensland, February 1990.

14 [3] A. Davison. Design Issues for Logic Programming Based Object Oriented Languages. Research Report, Department of Computing, Imperial College, London, England, Jan [4] J.W. Lloyd. Foundations of Logic Programming. Springer-Verlag, [5] F.G. McCabe. Logic and Objects. Research Report DOC 86/9, Department of Computing, Imperial College, London, England, May [6] D. Miller and G. Nadathur. A Logic Programming Approach to Manipulating Formulas and Programs. Proc. of IEEE 4th Symposium on Logic Programming, pp. 379{388, San Francisco, Sept [7] D.S. Moat and P.M.D. Gray. Interfacing Prolog to a Persistent Data Store. Proc. of 3rd International Conference on Logic Programming, pp. 577{584, London, July [8] L. Naish. Negation and Quantiers in NU-Prolog. Proc. of 3rd International Conference on Logic Programming, pp.624{634, London, July [9] M. Newton and J. Watkins. The Combination of Logic and Objects for Knowledge Representation. Journal of Object Oriented Programming, 1:7{10, Nov [10] R.A. Paterson. Unication of Schemes of Quantied Terms. Technical Report No. 154, Key Centre for Software Technology, Department of Computer Science, University of Queensland, Dec [11] R.A. Paterson and J. Staples. Unication and Constraint Solution for Meta-Programming: an Overview. Proc. of the Second Workshop on Meta-Programming in Logic, pp. 367{380, (ed. M. Bruynooghe), K.U. Leuven, [12] J. Staples, P.J. Robinson and G.R. Ellis. Persistent Variables in Qu- Prolog. Australian Computer Science Communications, pp. 362{369, 12, [13] J. Staples, P.J. Robinson, R.A. Paterson, R.A. Hagen, A.J. Craddock and P.C. Wallis. Qu-Prolog: an Extended Prolog for Meta Level Programming. Meta Programming in Logic Programming, pp , (eds. H. Abramson and M.H. Rogers), MIT Press, [14] T.G. Tang, P.J. Robinson and J. Staples. The Demonstration Proof Editor Demo2. Technical Report No. 175, Key Centre for Software Technology, Department of Computer Science, University of Queensland, Oct

15 [15] D.H.D. Warren. An Abstract Prolog Instruction Set. Technical Note 309, Articial Intelligence Center, Computer Science and Technology Division, SRI International, 1983.