Abstract not found

This paper presents an overview and a survey of logic program synthesis. Logic program synthesis is interpreted here in a broad way; it is concerned with the following question: given a specification, how do we get a logic program satisfying the specification? Logic programming provides a uniquely nice and uniform framework for program synthesis since the specification, the synthesis process and the resulting program can all be expressed in logic. Three main approaches to logic program synthesis by formal methods are described: constructive synthesis, deductive synthesis and inductive synthesis. Related issues such as correctness and verification as well as synthesis by informal methods are briefly presented. Our presentation is made coherent by employing a unified framework of terminology and notation, and by using the same running example for all the approaches covered. This paper thus intends to provide an assessment of existing work and a framework for future research in logic program synthesis.

Program transformation is a methodology for deriving correct and efficient programs from specifications. In this chapter, we will look at the so called 'rules + strategies' approach, and we will report on the main techniques which have been introduced in the literature for that approach, in the case of logic programs. We will also present some examples of program transformation, and we hope that through those examples the reader may acquire some familiarity with the techniques we will describe.

We propose a transformation system for Constraint Logic Programming (CLP) programs and modules. The framework is inspired by the one of Tamaki and Sato for pure logic programs [37]. However, the use of CLP allows us to introduce some new operations such as splitting and constraint replacement. We provide two sets of applicability conditions. The first one guarantees that the original and the transformed programs have the same computational behaviour, in terms of answer constraints. The second set contains more restrictive conditions that ensure compositionality: we prove that under these conditions the original and the transformed modules have the same answer constraints also when they are composed with other modules. This result is proved by first introducing a new formulation, in terms of trees, of a resultants semantics for CLP. As corollaries we obtain the correctness of both the modular and the non-modular system w.r.t. the least model semantics. AMS Subject Classification (1991)...

Abstract not found

At present, the field of declarative programming is split into two main areas based on different formalisms; namely, functional programming, which is based on lambda calculus, and logic programming, which is based on firstorder logic. There are currently several language proposals for integrating the expressiveness of these two models of computation. In this thesis we work towards an integration of the methodology from the two research areas. To this end, we propose an algebraic approach to reasoning about logic programs, corresponding to the approach taken in functional programming. In the first half of the thesis we develop and discuss a framework which forms the basis for our algebraic analysis and transformation methods. The framework is based on an embedding of definite logic programs into lazy functional programs in Haskell, such that both the declarative and the operational semantics of the logic programs are preserved. In spite of its conciseness and apparent simplicity, the embedding proves to have many interesting properties and it gives rise to an algebraic semantics of logic programming. It also allows us to reason about logic programs in a simple calculational style, using rewriting and the algebraic laws of combinators. In the embedding, the meaning of a logic program arises compositionally from the meaning of its constituent subprograms and the combinators that connect them. In the second half of the thesis we explore applications of the embedding to the algebraic transformation of logic programs. A series of examples covers simple program derivations, where our techniques simplify some of the current techniques. Another set of examples explores applications of the more advanced program development techniques from the Algebra of Programming by Bird and de Moor [18], where we expand the techniques currently available for logic program derivation and optimisation. To my parents, Sandor and Erzsebet. And the end of all our exploring Will be to arrive where we started And know the place for the first time.

This paper discusses correctness of a simple transformation system for logic programs. The transformation system is based on Unfold/Fold transformations, but differs in the form of folding from Tamaki and Sato’s system. We present three progressively stronger forms of this system and prove progressively weaker forms of correctness. We give attention to the effects of transformation on finite failure as well as on successful computations. 1

An Unfold/Fold transformation system is a source-to-source rewrit-ing methodology devised to improve the efficiency of a program. Any such transformation should preserve the main properties of the initial program: among them, termination. When dealing with logic programs such as PRO-LOG programs, one is particularly interested in preserving left termination i.e. termination wrt the leftmost selection rule, which is by far the most widely employed of the search rules. Unfortunately, the most popular Unfold/Fold transformation systems ([TS84, Sek91]) do not preserve the above termina-tion property. In this paper we study the reasons why left termination may be spoiled by the application of a transformation operation and we present a transformation system based on the operations of Unfold, Fold and Switch which- if applied to a left terminating programs- yields a program which is left terminating as well.

. We show how logical frameworks can provide a basis for logic program synthesis. With them, we may use first-order logic as a foundation to formalize and derive rules that constitute program development calculi. Derived rules may be in turn applied to synthesize logic programs using higher-order resolution during proof that programs meet their specifications. We illustrate this using Paulson's Isabelle system to derive and use a simple synthesis calculus based on equivalence preserving transformations. 1 Introduction Background In 1969 Dana Scott developed his Logic for Computable Functions and with it a model of functional program computation. Motivated by this model, Robin Milner developed the theorem prover LCF whose logic PP used Scott's theory to reason about program correctness. The LCF project [13] established a paradigm of formalizing a programming logic on a machine and using it to formalize different theories of functional programs (e.g., strict and lazy evaluation) and the...

In this paper we study unfold/fold transformations for constraint logic programs (CLP) with dynamic scheduling and for concurrent constraint programming (ccp). We define suitable applicability conditions for this transformations which ensure us that the original and the transformed program have the same results of successful computations and have the same deadlocked derivations. The possible applications of these results are twofold. On one hand we can use the unfold/fold system to optimize CLP and ccp programs while preserving their intended meaning and in particular without the risk of introducing deadlocks. On the other hand, unfold/fold transformations can be used for proving deadlock freedom for a class of queries in a given program: to this aim it is sufficient to specialize the program with respect to the given queries in such a way that the resulting program is trivially deadlock free. As shown by several interesting examples, this yields a methodology for proving deadlock free...