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.

Programs operating on inductively defined data structures, such as lists, are naturally defined by recursive programs, while programs operating on `indexable' data structures, such as arrays, are naturally defined by iterative programs. It has recently been shown how many recursive programs can be transformed or compiled to iterative programs operating on arrays. Such transformed programs can be run more efficiently than the original programs, particularly on parallel computers. The present work is aimed at providing means for writing such iterative programs directly, using available language constructs of first order predicate calculus. The paper proposes the introduction of `bounded quantifications' in logic programming languages. These formulas offer a natural way to express programs operating on arrays and other `indexable' data structures. `Bounded quantifications' are similar to `array comprehensions' in functional languages such as Haskell. They are inherently concurrent and can...

Concurrent logic/constraint programming is a simple and elegant formalism of concurrency that can potentially address a lot of important future applications including parallel, distributed, and intelligent systems. Its basic concept has been extremely stable and has allowed e#cient implementations. However, its uniqueness makes this paradigm rather di#cult to appreciate. Many people consider concurrent logic/constraint programming to have rather little to do with the rest of logic programming. There is certainly a fundamental di#erence in the view of computation, but careful study of the di#erences will lead to the understanding and the enhancing of the whole logic programming paradigm by an analytic approach. As a model of concurrency, concurrent logic/constraint programming has its own challenges to share with other formalisms of concurrency as well. They are: (1) a counterpart of #-calculus in the field of concurrency, (2) a common platform for various non-sequential forms of computing, and (3) type systems that cover both logical and physical aspects of computation.

It is proposed to add bounded quantifications to Prolog. The main reason is one of natural expression, many algorithms are expressed more elegantly in a declarative way using bounded quantifications than using existing means, i.e., recursion. In particular this is true for numerical algorithms, an area where Prolog has been virtually unsuccessful so far. Moreover, bounded quantification has been found to be at least as efficient as recursion, when applicable. We outline an implementation of some bounded quantifications through an extension of Warren's abstract Prolog machine and give performance figures relative to recursion. Finally, we have shown elsewhere that bounded quantification has a high potential for parallel implementation and we conclude in this paper that one can often run the same program efficiently on a sequential computer as well and on several kinds of parallel computers. 2 1 Introduction Barklund and Millroth [6] and Voronkov [25, 26] have proposed bounded quant...

The origins of this work go back to research on building systems for the automatic synthesis of programs from specifications, extending the capabilities of existing ones, making several systems cooperate, and integrating them into a larger programming environment. The experiences were rather frustrating. Program synthesis systems tend to be ad hoc implementations rather than being built systematically and well structured. It is not surprising that they have the same problems as other software products: there are all kinds of unexpected bugs, maintanance and modifications become increasingly difficult, and cooperation with other synthesizers is nearly impossible despite of the fact that ideas behind the synthesis strategies show many similarities if explained verbally. Apart from human shortcomings the main reason for this problem lies in a lack of formality in the steps from describing an idea on paper to its realization on a computer. Such formality, however, is difficult to achieve, extremely time consuming, and slows down the initial progress of a synthesis system. This is a price which many scientists are not willing to pay. On the other hand, the insufficiencies of current “ad hoc ” systems are hardly acceptable — and there are no exceptions — and there is a need for tools supporting the systematic and

In an earlier paper, we described a method for synthesising recursive logic procedures from their first-order logic specifications. The method is practical because it is strictly top-down and has been implemented as part of a user-guided synthesis system in Prolog. We have used the system to synthesise procedures for a wide variety of algorithms, including a large family of recursive sorting procedures. In this paper we describe the synthesis of this family of procedures. 1 Introduction Although much theoretical work has been done in logic program derivation, most notably by Clark, Hansson, Hogger, and Tarnlund [3, 4, 7, 9], there has been relatively little work in mechanising logic program synthesis. The recent work of Sato and Tamaki [15, 14] is one of the few examples. Independently, we worked on designing and implementing a practical system for mechanised program synthesis. The result is a method for top-down synthesis of recursive logic procedures from their specifications in fir...

Abstract. We review a logic-based modeling language PRISM and report recent developments including belief propagation by the generalized inside-outside algorithm and generative modeling with constraints. The former implies PRISM subsumes belief propagation at the algorithmic level. We also compare the performance of PRISM with state-of-theart systems in statistical natural language processing and probabilistic inference in Bayesian networks respectively, and show that PRISM is reasonably competitive. 1

. It is clearly desirable that logical specifications and the programs that implement them should be as close as possible. Such a claim is often made in support of the logic programming paradigm. However, SLD-resolution, the basic procedural semantics for logic programming, is only defined for programs whose statements are Horn clauses. Most research for extending the Horn clause framework has been concerned with allowing negative literals in the bodies of the statements where SLD-resolution is extended with negation-as-failure. However, one of the main components of first order logic not allowed in clauses is (explicit) quantification. This paper addresses this problem by showing how SLDresolution can be extended to allow for universally quantified implication formulas as conjuncts in the body of the statements. It will be shown that this technique includes negation-as-failure as a degenerate case. 1 Introduction A logic program is composed of program statements which in their simple...

Declarative meta-programming is vital, since it is the most promising means by which programs can be made to reason about other programs. A metaprogram is a program that takes another program, called the object program, as data. A declarative programming language is a programming language based on a logic that has a model theory. A meta-program operates on a representation of an object...

Abstract. PRISM is a probabilistic extension of Prolog. It is a high level language for probabilistic modeling capable of learning statistical parameters from observed data. After reviewing it from various viewpoints, we examine some technical details related to logic programming, including semantics, search and program synthesis. 1