Di erential Logic Programming A. Bossi M. Bugliesi Dipartimento di Matematica P&A Universita di Padova Via Belzoni 7, 35131 Padova, Italy fmichele@blues,
[email protected]
Abstract In this paper we de ne a compositional semantics for a generalized composition operator on logic programs. Static and dynamic inheritance as well as composition by union of clauses can all be obtained by specializing the general operator. The semantics is based on the notion of di erential programs, logic programs annotated with declarations that establish the programs' external interfaces.
1 Introduction
The power of Horn clause logic as a programming language was pointed out for the rst time in [16] and since then it has gained the interest of a still growing research community. The most appealing features of logic programming as a programming language are to be found both in the elegance of its semantic characterization and in the declarativity of its computational model. As best summarized by Zaniolo in [31], the rule based reasoning of logic, combined with adequate tools for eciently storing and retrieving large amounts of information could provide a realistic basis for the development of ecient knowledge base systems. As a matter of fact, its use in the development of knowledge base applications has promptly disclosed This work has been supported by \Progetto Finalizzato Sistemi Informatici e Calcolo Parallelo" of C.N.R. under grant n. 9100880.PF69 and by the Esprit Basic Research Action 3012 Compulog
In
Proc. 20th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 1994 ACM
c
M. Gabbrielli G. Levi M. C. Meo Dipartimento di Informatica Universita di Pisa, Corso Italia 40, 56100 Pisa, Italy fgabbri,levi,
[email protected] one major weakness of Horn clause logic as a programming language. In fact, in spite of its declarativity, logic programming turns out not to scale very well when it comes to designing practical applications. Its unit of abstraction { relations { appears to be too ne grained to support the development and the maintenance of large programs. This need for a more structured approach to software development has motivated a wide research effort in the logic programming community during the last decade. Inspired to the experience gained in related elds, several approaches have been taken and di erent solutions have been proposed in the recent literature. One of the currently most promising directions in this area, is based on the idea of integrating into a logical framework some of the distinguishing notions of the Object-Oriented programming paradigm: abstraction and inheritance (late binding). From a logical point of view, an object { the OO unit of abstraction { has a natural interpretation as a logic theory: an object is simply a collection of axioms which describe what is true about the object itself. Under this assumption, the design of a coherent semantic model for a logic language extended to incorporate the notion of inheritance can be attempted at di erent levels. At the operational level, it amounts to de ning a new inference system which combines this mechanism with the deductive process of resolution. At the declarative level, it rises two interesting issues: rstly the problem of characterizing inheritance in terms of the standard notions of satis ability and truth found in classical logic; secondly, the problem of capturing the compositional properties inherent in the incremental approach to software development entailed by inheritance. Inheritance. Our view of inheritance conforms with the one nowadays widely accepted in the ObjectOriented community. An intuitive justi cation for such interpretation is contained in [7]. Inheritance is viewed as a mechanism for di erential programming, i.e. a mechanism for constructing new program components by specifying how they di er from the existing ones. Di erential programming is achieved by
using lters to modify the external behaviour of existing components. Accordingly, a modi ed version of a component is obtained by de ning a new component that performs some special operations and possibly calls the original one. This idea is illustrated by the following example.
WhoAreYou -
6
self
Figure 2 also provides a justi cation for inheritance as a mechanism for deriving modi ed versions of recursive structures. This characterization constitutes the main motivation to Cook's approach in [7]. In an independent study [27], Reddy adopts a similar approach and develops an incremental study of di erent forms of inheritance where the interpretation given by gure 2 is classi ed as dynamic inheritance { a la Smalltalk [15] { as opposed to the static mechanism exhibited by languages like Simula-67 and depicted in gure 1. The approach we take in this paper follows Reddy's classi cation. Compositionality. The adequacy of a semantic characterization for a language is typically measured on the account of how e ective the semantics is for de ning the meaning for programs written in the language. More generally though, in view of a modular approach to program development, the semantics of a language should actually aim at characterizing the meaning of program fragments rather than of simple programs. This is in fact crucial to be able to de ne the meaning of a composite program on the account of the meaning of its components. A semantics with these properties is said to be homomorphic or compositional. More precisely, we say that the semantics [ ] is compositional with respect to a composition operation if, given two program components C and D, the relation [ C D]] = [ C]] () [ D]] holds for a suitable choice of the homomorphism which maps the syntactic operator onto the corresponding semantic operator (). In the context of a hierarchical composition of program based on inheritance, a natural interpretation of the above relation is that D is a given hierarchy, C is a new component and is the specialization operator. Therefore, the hierarchical composition Cn C2 C1 should be understood as the sequence of compositions Cn ( (C2 C1) ), or equivalently, is to be thought of as right-associative.
CLASS cs-student INHERIT student whoAmI = print(\aCsStudent00 ) aStudent := NEW student anotherStudent := NEW cs-student We have two classes, student and cs-student, and two corresponding instances. Class cs-student is a subclass of student and rede nes one of its superclass' methods. The invocation NEW class returns an instance of class whereas the expression object : message denotes the request for object to execute the method associated with message. We are interested in the answers to the two following message-sents. (a) aStudent : WhoAreYou: (b) anotherStudent : WhoAreYou: The result of evaluating (a) is straightforward. The message is sent to aStudent and the answer is: "a Student". Case (b) is more interesting. Now the result depends on what the self-reference SELF refers to. We have two choices and two corresponding answers. The rst is to interpret SELF as the object in which the self-reference occurs: aStudent. The corresponding answer, exempli ed in gure 1, shows that the modi cation csStudent only partially a ects the external behaviour of the the original component students. What
student self
\aStudent"
student
Figure 2: Correct Interpretation of Self
CLASS student whoAmI = print(\aStudent00) whoAreYou = SELF : whoAmI
-
-
"aCsStudent"
Example 1.1 Consider the following de nitions:
WhoAreYou- cs-student self
cs-student self
6
Figure 1: Naive interpretation of Self
Outline of the paper. The purpose of this paper is to make a contribution towards the integration of Object-Orientation and logic programming. The approach we follow enables results in two major outcomes. The rst is generality: we introduce a gener-
we actually expect here is that SELF refers to the composite object obtained by applying the modi cation to the original component. This is achieved through the interpretation illustrated in gure 2.
360
alized composition operator on logic programs which captures the semantics of several specialized mechanisms such as static and dynamic inheritance as well as composition by union of clauses. The second is compositionality: programs are looked at as independent fragments to be combined to form larger programs and, dually, the semantics of a composite program is obtained by combining the semantics of its components. The approach is based on the notion of di erential programs, logic programs annotated in order to make their external interfaces explicit. The semantic characterization is de ned following the general approach described in [11]. In that paper, the idea is to accommodate in the programs' interpretations more syntactic objects in order to achieve an accurate declarative characterization of the programs' operational behaviour. Along the same guidelines, here we introduce the notion of context-sensitive interpretations (cs-interpretations) which enables us to achieve the compositional property we are looking for. The rest of the paper is organized as follows. In section 2 we introduce the idea of di erential programs and the associated composition operator. In section 3, we de ne the declarative semantics for di erential programs and show its compositional properties. Finally in section 4 we discuss the relation of our approach with the existing literature in the eld.
distinction between the two sets and re ects the distinction between two di erent forms of inheritance we would like to coexist. The idea is that a program P is to be understood as part of a structured context of the form C isa P isa D and that the evaluation of a goal depends on the annotation of its predicate symbol. A -predicate is evaluated in P using P's local de nition or any de nition inherited from the context D. The local de nition, if there is any, overrides the inherited one. Hence, any occurrence in P of a goal for a static predicate which is also de ned in P, is bound to the local de nition independently of the context in which P occurs. Conversely, the evaluation of -predicate in P uses the local de nition or the inherited one, only if no de nition for the same predicate name is provided by the context C. If C does provide a de nition, than this de nition overrides in P the local or inherited one. The annotation models an orthogonal composition mechanism de ned with an extension semantics whereby local de nitions are extended with inherited ones. Therefore, the de nition of a -predicate in P can be extended (not overridden) with the de nition of C and of D.
2.1
-hierarchies of Programs
Isa
We can make this informal description precise by formally de ning the rules for evaluating a goal in a generic isa-hierarchy of di erential programs. Let HP be the hierarchy Pn isa Pn?1 isa isa P1 . It follows from the previous discussion that the evaluation of a goal in HP is well de ned if and only if every predicate symbol occurring in the Pi s has a unique identity in terms of membership to the corresponding annotations is, is and i s. The following condition ensures this property.
2 Di erential Logic Programs A di erential program is a program P annotated by three sets of exported predicate symbols: : statically inherited predicates (-predicates); : dynamically inherited predicates (-predicates); : extensible predicates (-predicates). We assume the three sets are mutually disjoint, and their union is contained in the set (P) of the predicate symbols occurring in P. The remaining predicates, (P) n ( [ [ ) will be henceforth referred to as internal predicates and denoted with (P). We assume that the symbols for internal predicates range over an alphabet = which is disjoint from the alphabets used for , and predicates. For any program we also de ne the set (P) of the predicates de ned in P (p is de ned in P if there exists a clause in P whose head's predicate symbol is p) and the set Open(P) = ( n (P)) [ [ . The quali cation Open is used here to emphasize that the de nition for these predicates can be modi ed by composing P with other programs. This is not the case for internal predicates and, as explained below, for static predicates de ned in P. Statically and dynamically inherited predicates are evaluated according to an overriding semantics. The
De nition 2.1 (compatibility) Let hP ; P ; P i-P and hQ ; Q; Q i-Q be two di er-
ential programs. P and Q are said to be compatible provided that the following condition holds:
(P) \ (Q) = (P \ Q ) [ (P \ Q ) [(P \ Q) [ ((P) \ (Q)): We will henceforth consider only hierarchies of compatible programs and de ne the evaluation of goals whose predicate symbols are exported by at least one of the component programs. Internal predicates are thus thought of as encapsulated within the components and hence their de nition not is exported by the hierarchies. The evaluation rules are given below in Natural Deduction style extending those reported in [5]. If G is a conjunctive goal, then evaluating G in HP amounts to evaluating in HP each of the conjuncts. 361
2.2 Syntactic Program Composition
Namely:
The operational semantics of isa-hierarchies of differential programs has an alternative and equivalent characterization in terms of the semantics of a generalized composition operator { < { whose de nition can be given in a purely syntactic fashion. The de nition of
q(a) q 2 (x):-h 1 (x) > : h 1 (a) t(b) where the renaming 2 2 fqg;fq;s;r;t;h 1 g and the nal annotation is = fq; tg, = frg and = fsg. We mentioned earlier in this section that < provides an alternative and equivalent characterization for the isa-composition. This equivalence follows from the tight correspondence existing between isa-proofs and successful SLD-derivations. We can in fact establish a one-to-one mapping between the steps of a successful SLD derivation in any j, 363
(p) = l (p) i p 62 (Pl ) [ [ (Pj +1) if p 2 Pj [ Pj and p 2 (Pj < < P1), then j (p) = p. The following property for the composition HP/ follows from the above properties of the renamings and from the de nition of j;
The proof highlights one important property of the renamings used in the
