Richard J. Waldinger

A Deductive Approach to Program Synthesis

Program synthesis is the systematic derivation of a program from a given specification. A deductive approach to program synthesis is presented for the construction of recursive programs. This approach regards program synthesis as a theorem-proving task and relies on a theorem-proving method that combines the features of transformation rules, unification, and mathematical induction within a single framework.

Synthesis: Dreams → Programs

Deductive techniques are presented for deriving programs systematically from given specifications. The specifications express the purpose of the desired program without giving any hint of the algorithm to be employed. The basic approach is to transform the specifications repeatedly according to certain rules, until a satisfactory program is produced. The rules are guided by a number of strategic controls. These techniques have been incorporated in a running program-synthesis system, called DEDALUS.

Knowledge and reasoning in program synthesis

Abstract Program synthesis is the construction of a computer program from given specifications. An automatic program synthesis system must combine reasoning and programming ability with a good deal of knowledge about the subject matter of the program. This ability and knowledge must be manifested both procedurally (by programs) and structurally (by choice of representation). We describe some of the reasoning and programming capabilities of a projected synthesis system. Special attention is paid to the introduction of conditional tests, loops, and instructions with side effects in the program being constructed. The ability to satisfy several interacting goals simultaneously proves to be important in many contexts. The modification of an already existing program to solve a somewhat different problem has been found to be a powerful approach. We illustrate these concepts with hand simulations of the synthesis of a number of pattern-matching programs. Some of these techniques have already been implemented, some are in the course of implementation, while others seem equivalent to well-known unsolved problems in artificial intelligence.

The Logic of Computer Programming

Techniques derived from mathematical logic promise to provide an alternative to the conventional methodology for constructing, debugging, and optimizing computer programs. Ultimately, these techniques are intended to lead to the automation of many of the facets of the programming process.

Problematic features of programming languages: a situational-calculus approach

SummaryCertain features of programming languages, such as data structure operations and procedure call mechanisms, have been found to resist formalization by conventional program verification techniques. An alternate approach is presented, based on a “situational calculus,” which makes explicit reference to the states of a computation. For each state, a distinction is drawn between an expression, its value, and the location of the value.Within this conceptual framework, the features of a programming language can be described axiomatically. Programs in the language can then be synthesized, executed, verified, or transformed by performing deductions in this axiomatic system. Properties of entire classes of programs, and of programming languages, can also be expressed and proved in this way. The approach is amenable to machine implementation.In a situational-calculus formalism it is possible to model precisely many “problematic” features of programming languages, including operations on such data structures as arrays, pointers, lists, and records, and such procedure call mechanisms as call by reference, call by value, and call by name. No particular obstacle is presented by aliasing between variables, by declarations, or by recursive procedures.In this paper, we introduce our conceptual framework and present an axiomatic definition of the assignment statement. If suitable restrictions on the programming language are imposed, the well-known Hoare assignment axiom can then be proved as a theorem. However, our definition can also describe the assignment statement of unrestricted programming languages, for which the Hoare axiom does not hold. In forthcoming papers, we apply the situational-calculus framework to the description of data structure operations and procedure call mechanisms.

The automatic synthesis of recursive programs

We describe a deductive technique for the automatic construction of recursive programs to meet given input-output specifications. These specifications express what conditions the output of the desired program is expected to satisfy. The deductive technique involves transforming the specifications by a collection of rules, summoned by pattern-directed function invocation. Some of these transformation rules express the semantics of the subject domain; others represent more general programming techniques. The rules that introduce conditional expressions and recursive calls into the program are discussed in some detail. The deductive techniques described are embedded in a running system called SYNSYS. This system accepts specifications expressed in high-level descriptive language and attempts to transform them into a corresponding LISP program. The transformation rules are expressed in the QLISP programming language. The synthesis of two programs performed by the system are presented. This research was supported in part by the Advanced Research Projects Agency of the Department of Defense under Contract MDA903-76-C-0206, by the National Science Foundation under Grant DCR72-03737 A01, by the Office of Naval Research under Contracts N00014-76-C-0687 and N00014-75-C-0816; and by a grant from the United States-Israel Binational Science Foundation (BSF), Jerusalem, Israel. The views and conclusions contained in this document are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of Stanford University, Stanford Research Institute, or the U.S. Government.

PROVING PROPERTIES OF RULE-BASED SYSTEMS

Rule-based systems are being applied to tasks of increasing responsibility. Deductive methods are being applied to their validation, to detect flaws in these systems and to enable us to use them with more confidence. Each system of rules is encoded as a set of axioms that define the system theory. The operation of the rule language and information about the subject domain are also described in the system theory. Validation tasks, such as establishing termination, unreachability, or consistency, or verifying properties of the system, are all phrased as conjectures. If we succeed in establishing the validity of the conjecture in the system theory, we have carried out the corresponding validation task. If the proof is restricted to be sufficiently constructive, we may extract from it information other than a simple yes/no answer. For example, we may obtain a description of a situation in which an error or anomaly may occur. A method for the gradual formulation of specifications based on the attempted proof of a series of conjectures has been found to be suitable for rule-based systems. Such a specification can serve as the basis for a reengineering of the system using conventional software technology. Validation conjectures are proved or disproved by a new theorem-proving system, SNARK, which implements (nonclausal) resolution and paramodulation, an optional constructive restriction, and some facilities for proof by induction. The system has already been applied to prove properties of a number of simple rule-based systems.

Whatever happened to deductive question answering

Deductive question answering, the extraction of answers to questions from machine-discovered proofs, is the poor cousin of program synthesis. It involves much of the same technology–theorem proving and answer extraction–but the bar is lower. Instead of constructing a general program to meet a given specification for any input–the program synthesis problem–we need only construct answers for specific inputs; question answering is a special case of program synthesis. Since the input is known, there is less emphasis on case analysis (to construct conditional programs) and mathematical induction (to construct looping constructs), those bugbears of theorem proving that are central to general program synthesis. Program synthesis as a byproduct of automatic theorem proving has been a largely dormant field in recent years, while those seeking to apply theorem proving have been scurrying to find smaller problems, including question answering.

Pointing to places in a deductive geospatial theory

Issues in the description of places are discussed in the context of a logical geospatial theory. This theory lies at the core of the system GeoLogica, which deduces answers to geographical questions based on knowledge provided by multiple agents.

The bomb in the toilet

logical form deductively by using an assertional database that includes definitions of possible relations (e.g., containerts) A jluidty) 3 can-contain(x,y) and can-contain(x,y) r) N N ( y , x ) ) . Various proofs provide different possible explanations of the relations in the prelogical form. Sometimes additional assumptions must be made to complete a proof, e.g., that wine is a fluid, if this is not already known. These assumptions could be said to be abductively inferred if the explanation corresponding to the proof is accepted. The assertional database includes all the possible assumptions that might be necessary. However, these assertions are weighted in the database so that, roughly speaking, those proofs that are based upon the least or least costly assumptions will be discovered first. Reiters diagnosis from first principles (Reiter 1985) also provides a deductive procedure for abductive reasoning. In fault diagnosis, a contradiction is derived (e.g., by a resolution theorem prover) from formulas that specify the assumed correct functioning of the system along with additional formulas that specify the actual incorrect behavior. Analysis of the proofs reveals sources of the contradiction, that is, the failure of which components could explain the failure of the system itself.