Recently well-quasi orders in general, and homeomorphic embedding in particular, have gained popularity to ensure the termination of program analysis, specialisation and transformation techniques. In this paper,

The so called “cogen approach” to program specialisation, writing a compiler generator instead of a specialiser, has been used with considerable success in partial evaluation of both functional and imperative languages. This paper demonstrates that this approach is also applicable to partial evaluation of logic programming languages, also called partial deduction. Self-application has not been as much in focus in logic programming as for functional and imperative languages, and the attempts to self-apply partial deduction systems have, of yet, not been altogether that successful. So, especially for partial deduction, the cogen approach should prove to have a considerable importance when it comes to practical applications. This paper first develops a generic offline partial deduction technique for pure logic programs, notably supporting partially instantiated datastructures via binding types. From this a very efficient cogen is derived, which generates very efficient generating extensions (executing up to several orders of magnitude faster than current online systems) which in turn perform very good and non-trivial specialisation, even rivalling existing online systems. All this is supported by extensive benchmarks. Finally, it is shown how the cogen can be extended to directly support a large part of Prolog’s declarative and non-declarative features and how semi-online specialisation can be efficiently integrated.

Partial deduction strategies for logic programs often use an abstraction operator to guarantee the finiteness of the set of goals for which partial deductions are produced. Finding an abstraction operator which guarantees finiteness and does not lose relevant information is a difficult problem. In earlier work Gallagher and Bruynooghe proposed to base the abstraction operator on characteristic paths and trees, which capture the structure of the generated incomplete SLDNF-tree for a given goal. In this paper we exhibit the advantages of characteristic trees over purely syntactical measures: if characteristic trees can be preserved upon generalisation, then we obtain an almost perfect abstraction operator, providing just enough polyvariance to avoid any loss of local specialisation. Unfortunately, the abstraction operators proposed in earlier work do not always preserve the characteristic trees upon generalisation. We show that this can lead to important specialisation losses as well as to non-termination of the partial deduction algorithm. Furthermore, this problem cannot be adequately solved in the ordinary partial deduction setting. We therefore extend the expressivity and precision of the Lloyd and Shepherdson partial deduction framework by integrating constraints. We provide formal correctness results for the so obtained generic framework of constrained partial deduction. Within this new framework we are, among others, able to overcome the above mentioned problems by introducing an alternative abstraction operator, based on so called pruning constraints. We thus present a terminating partial deduction strategy which, for purely determinate unfolding rules, induces no loss of local specialisation due to the abstraction while ensuring correctness o...

Integrity constraints are very useful in many contexts, such as, for example, deductive databases, abductive and inductive logic programming. However, fully testing the integrity constraints after each update or modification can be very expensive and methods have been developed which simplify the integrity constraints. In this paper, we pursue the goal of writing this simplification procedure as a meta-program in logic programming and then using partial deduction to obtain pre-compiled integrity checks for certain update patterns. We argue that the ground representation has to be used to write this metaprogram declaratively. We however also show that, contrary to what one might expect, current partial deduction techniques are then unable to specialise this meta-interpreter in an interesting way and no pre-compilation of integrity checks can be obtained. In fact, we show that partial deduction (alone) is not able to perform any (sophisticated) specialisation at the object-level for meta...

Abstract not found

In [23] we presented a partial evaluation scheme for a "real life" subset of Prolog, containing first-order built-in's, simple side-effects and the operational predicate if-then-else. In this paper we apply this scheme to specialise integrity checking in deductive databases. We present an interpreter which can be used to check the integrity constraints in hierarchical deductive databases. This interpreter incorporates the knowledge that the integrity constraints were not violated prior to a given update sad uses a technique to lift the ground representation to t,e non-ground one for resolution. By partially evaluating this mots-interpreter for certain transaction patterns we are able to obtain very efficient specialised update procedures, executing substantially faster than the original mots-interpreter. The partial eval- uation scheme presented in [23] seems to be capable of tomatically generating highly specialised update procedures for deductive databases.

We present the basic principles and possible applications of systems capable of meta-reasoning and reflection. After a discussion of the seminal approaches, we outline our own perception of the state of the art, mainly but not only in computational logic and logic programming. We review relevat successful...

Abstract. Offline partial evaluation techniques rely on an annotated version of the source program to control the specialisation process. These annotations guide the specialisation and have to ensure termination of the partial evaluation. We present an algorithm for generating these annotations automatically. The algorithm uses state-of-the-art termination analysis techniques, combined with a new type-based abstract interpretation for propagating the binding types. This algorithm has been implemented as part of the logen partial evaluation system, and we report on performance of the algorithm on a series of benchmarks. 1

Abstract. Offline partial evaluation techniques rely on an annotated version of the source program to control the specialisation process. These annotations guide the specialisation and ensure the termination of the partial evaluation. We present an algorithm for generating these annotations automatically. The algorithm uses state-of-the-art termination analysis techniques, combined with a new type-based abstract interpretation for propagating the binding types. This algorithm has been implemented as part of the logen partial evaluation system, along with a graphical annotation visualiser and editor, and we report on the performance of the algorithm for a series of benchmarks. 1

The term meta-programming... In this paper we aim to specify conditions on the meta-interpreters that imply that termination of the object program with respect to some goal is improved or preserved. We start by identifying popular classes of meta-interpreters, such as extended meta-interpreters [7], and then develop a methodology to prove the desired. Our approach is based on two observations. First, termination of logic programs can be proved via general term-orderings, similar to those used to prove termination of term-rewrite systems [9]. Second, if is an ordering such that termination of a meta-program, obtained from "vanilla" and an object program P , with respect to a goal solve(G) can be proved via it, then termination of P with respect to G can be proved via >, where > is de ned as A > B if solve(A) solve(B). This is not necessary true for more practical applications of meta-interpreters, such as debuggers, since they also are required to produce some additional output or to perform some additional tasks during the execution, such as constructing proof trees. These extensions can and usually will influence termination properties of the meta-interpreter. However, for the specified classes of meta-interpreters we can state conditions that imply a simple relation between an ordering proving termination of a meta-program and an ordering proving termination of an object program. These conditions imply termination improvement or preservation