Alan Bundy

Constructing Induction Rules for Deductive Synthesis Proofs

We describe novel computational techniques for constructing induction rules for deductive synthesis proofs. Deductive synthesis holds out the promise of automated construction of correct computer programs from specifications of their desired behaviour. Synthesis of programs with iteration or recursion requires inductive proof, but standard techniques for the construction of appropriate induction rules are restricted to recycling the recursive structure of the specifications. What is needed is induction rule construction techniques that can introduce novel recursive structures. We show that a combination of rippling and the use of meta-variables as a least-commitment device can provide such novelty.

The Use of Explicit Plans to Guide Inductive Proofs

We propose the use of explicit proof plans to guide the search for a proof in automatic theorem proving. By representing proof plans as the specifications of LCF-like tactics, [Gordon et al 79], and by recording these specifications in a sorted meta-logic, we are able to reason about the conjectures to be proved and the methods available to prove them. In this way we can build proof plans of wide generality, formally account for and predict their successes and failures, apply them flexibly, recover from their failures, and learn them from example proofs.

Extensions to the rippling-out tactic for guiding inductive proofs

In earlier papers we described a technique for automatically constructing inductive proofs, using a heuristic search control tactic called rippling-out. Further testing on harder examples has shown that the rippling-out tactic significantly reduces the search for a proof of a wide variety of theorems, with relatively few cases in which all proofs were pruned. However, it also proved necessary to generalise and extend rippling-out in various ways. Each of the various extensions are described with examples to illustrate why they are needed, but it is shown that the spirit of the original rippling-out tactic has been retained.

Rippling: a heuristic for guiding inductive proofs

Abstract We describe rippling: a tactic for the heuristic control of the key part of proofs by mathematical induction. This tactic significantly reduces the search for a proof of a wide variety of inductive theorems. We first present a basic version of rippling, followed by various extensions which are necessary to capture larger classes of inductive proofs. Finally, we present a generalised form of rippling which embodies these extensions as special cases. We prove that generalised rippling always terminates, and we discuss the implementation of the tactic and its relation with other inductive proof search heuristics.

The Oyster-Clam system

O Y S T ER Hor88] is an interactive proof editor closely based on the Cornell NuPRL system, but implemented in Prolog. The object-level logic is a version of Martin-LL of type theory (a higher order constructive logic including induction) in a sequent-calculus formulation. Proofs are constructed in a top-down fashion by application of the rules of inference. Notational deenitions and libraries of theorems are supported. The tactic language for the system is Prolog. Predicates describing properties of a proof under construction are available to the user, who may also include arbitrary Prolog in tactics. Soundness of the system is ensured by the use of an abstract data type of proofs: partial proofs can only be altered by application of the primitive proof rules. Tactics can be combined using system deened tacticals. Prolog pattern-matching and backtracking in tactics have proved useful in the automation of proof search. Since the object-level logic is constructive, terms of an enlarged-calculus can be computed from complete proofs, and these so-called ex tr act terms can then be executed by application on appropriate inputs. This allows the system to be used as a program synthesis environment, since a theorem can be regarded as a speciication which is realised by its extract term. The system is written in some 2000 lines of Prolog, making it considerably more compact than the original NuPRL system, while the speed of the two systems is comparable.

Productive Use of Failure in Inductive Proof

Proof by mathematical induction gives rise to various kinds of eureka steps, e.g., missing lemmata and generalization. Most inductive theorem provers rely upon user intervention in supplying the required eureka steps. In contrast, we present a novel theorem-proving architecture for supporting the automatic discovery of eureka steps. We build upon rippling, a search control heuristic designed for inductive reasoning. We show how the failure if rippling can be used in bridging gaps in the search for inductive proofs.

Towards Ontology Evolution in Physics

We investigate the problem of automatically repairing inconsistent ontologies. A repair is triggered when a contradiction is detected between the current theory and new experimental evidence. We are working in the domain of physics because it has good historical records of such contradictions and how they were resolved. We use these records to both develop and evaluate our techniques. To deal with problems of inferential search control and ambiguity in the atomic repair operations, we have developed ontology repair plans, which represent common patterns of repair. They first diagnose the inconsistency and then direct the resulting repair. Two such plans have been developed to repair ontologies that disagree over the value and the dependence of a function, respectively. We have implemented the repair plans in the galileo system and successfully evaluated galileo on a diverse range of examples from the history of physics.

An Editor for Helping Novices to Learn Standard ML

This paper describes a novel editor intended as an aid in the learning of the functional programming language Standard ML. A common technique used by novices is programming by analogy whereby students refer to similar programs that they have written before or have seen in the course literature and use these programs as a basis to write a new program. We present a novel editor for ML which supports programming by analogy by providing a collection of editing commands that transform old programs into new ones. Each command makes changes to an isolated part of the program. These changes are propagated to the rest of the program using analogical techniques. We observed a group of novice ML students to determine the most common programming errors in learning ML and restrict our editor such that it is impossible to commit these errors. In this way, students encounter fewer bugs and so their rate of learning increases. Our editor, CYNTHIA, has been implemented and is due to be tested on students of ML from September, 1997.

Logic Program Synthesis via Proof Planning

We propose a novel approach to automating the synthesis of logic programs: Logic programs are synthesized as a by-product of the planning of a verification proof. The approach is a two-level one: At the object level, we prove program verification conjectures in a sorted, first-order theory. The conjectures are of the form\( \forall \xrightarrow[{\arg s.}]{}prog(\xrightarrow[{\arg s}]{}) \leftrightarrow spec(\xrightarrow[{\arg s}]{}). \) . At the meta-level, we plan the object-level verification with an unspecified program definition. The definition is represented with a (second-order) meta-level variable, which becomes instantiated in the course of the planning.

Experiments with proof plans for induction

The technique of proof plans is explained. This technique is used to guide automatic inference in order to avoid a combinatorial explosion. Empirical research is described to test this technique in the domain of theorem proving by mathematical induction. Heuristics, adapted from the work of Boyer and Moore, have been implemented as Prolog programs, called tactics, and used to guide an inductive proof checker, Oyster. These tactics have been partially specified in a meta-logic, and the plan formation program, CLAM, has been used to reason with these specifications and form plans. These plans are then executed by running their associated tactics and, hence, performing an Oyster proof. Results are presented of the use of this technique on a number of standard theorems from the literature. Searching in the planning space is shown to be considerably cheaper than searching directly in Oysters search space. The success rate on the standard theorems is high.