262 research outputs found
Middle-Out Reasoning for Logic Program Synthesis
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 8args \Gamma\Gamma\Gamma\Gamma! : prog(args \Gamma\Gamma\Gamma\Gamma! ) $ spec(args \Gamma\Gamma\Gamma\Gamma! ). 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
Proof planning for logic program synthesis
The area of logic program synthesis is attracting increased interest. Most efforts
have concentrated on applying techniques from functional program synthesis to
logic program synthesis. This thesis investigates a new approach: Synthesizing
logic programs automatically via middle-out reasoning in proof planning.[Bundy et al 90a] suggested middle-out reasoning in proof planning. Middleout
reasoning uses variables to represent unknown details of a proof. UnificaÂŹ
tion instantiates the variables in the subsequent planning, while proof planning
provides the necessary search control.Middle-out reasoning is used for synthesis by planning the verification of an
unknown logic program: The program body is represented with a meta-variable.
The planning results both in an instantiation of the program body and a plan for
the verification of that program. If the plan executes successfully, the synthesized
program is partially correct and complete.Middle-out reasoning is also used to select induction schemes. Finding an
appropriate induction scheme in synthesis is difficult, because the recursion in
the program, which is unknown at the outset, determines the induction in the
proof. In middle-out induction, we set up a schematic step case by representing
the constructors applied to the induction variables with meta-variables. Once
the step case is complete, the instantiated variables correspond to an induction
appropriate to the recursion of the program.The results reported in this thesis are encouraging. The approach has been
implemented as an extension to the proof planner CUM [Bundy et al 90c], called
Periwinkle, which has been used to synthesize a variety of programs fully automatically
Middle-out reasoning for logic program synthesis
Logic programs can be synthesized as a by-product of the planning of their verification proofs. This is achieved by using higher-order variables at the proof planning level, which become instantiated in the course of planning. We illustrate two uses of such variables in proof planning for program synthesis, one for synthesis proper and one for the selection of induction schemes. We demonstrate that the use of these variables can be restricted naturally in such a way that terms containing them form a tractable extension of first-order terms
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 . 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. This technique is an application of the Clam proof planning system. Clam is currently powerful enough to plan verification proofs for given programs. We show that, if Clam's use of middle-out reasoning is extended, it will also be able to synthesize programs
Inductive logic program synthesis with dialogs
DIALOGS (Dialogue-based Inductive and Abductive LOGic program Synthesizer) is a schema-guided synthesizer of recursive logic programs; it takes the initiative and queries a (possibly computationally naive) specifier for evidence in her/his conceptual language. The specifier must know the answers to such simple queries, because otherwise s/he wouldn't even feel the need for the synthesized program. DIALOGS call be used by any learner (including itself) that detects, or merely conjectures, the necessity of invention of a new predicate. Due to its foundation on a powerful codification of a ârecursion-theoryâ (by means of the template and constraints of a divide-and-conquer schema), DIALOGS needs very little evidence and is very fast. © Springer-Vertag Berlin Heidelberg 1997
Relational Rippling: a General Approach
We propose a new version of rippling, called relational rippling. Rippling is a heuristic for guiding proof search, especially in the step cases of inductive proofs. Relational rippling is designed for representations in which value passing is by shared existential variables, as opposed to function nesting. Thus relational rippling can be used to guide reasoning about logic programs or circuits represented as relations. We give an informal motivation and introduction to relational rippling. More details, including formal definitions and termination proofs can be found in the longer version of this paper, [Bundy and Lombart, 1995]
A Framework for Program Development Based on Schematic Proof
Often, calculi for manipulating and reasoning about programs can be recast as calculi for synthesizing programs. The difference involves often only a slight shift of perspective: admitting metavariables into proofs. We propose that such calculi should be implemented in logical frameworks that support this kind of proof construction and that such an implementation can unify program verification and synthesis. Our proposal is illustrated with a worked example developed in Paulson's Isabelle system. We also give examples of existent calculi that are closely related to the methodology we are proposing and others that can be profitably recast using our approach
Derivation of sorting programs
Program synthesis for critical applications has become a viable alternative to program verification. Nested resolution and its extension are used to synthesize a set of sorting programs from their first order logic specifications. A set of sorting programs, such as, naive sort, merge sort, and insertion sort, were successfully synthesized starting from the same set of specifications
A Semantic Basis for Specialising Domain Constraints
This paper formalises an analysis of finite domain programs and the resultant program transformation. The analysis adds low valency (domain) constraints to clauses in order to reduce search. The technique is outlined with a worked example and then formalised using abstract interpretation. Correctness of the analysis and of the transformation is proved
- âŠ