A Deductive Approach to Program Synthesis
Proceedings of the Sixth International Joint Conference on Artificial Intelligence. .
© 1979 International Joint Conferences on Artificial Intelligence
Abstract
Program synthesis Is the systematic derivation of a program from a given specification. A deductive approt~ch to program synthesis Ia 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.
- Bledsoe, W. W. [HI77], Non-r~solution thtorm proving, Artificial Intelligence Journal, Vol. 9, pp. 1-36.
- Boyer, R. S. and J S. Moore [Jan. 1SI75], Proving thtortms about LISP functions, JACM, Vol. 22, pp. 129-144.
- Buretall, R. M. and J, Darlington [Jan, 1 877], A transformation s'st1m for dlwloping r1cursiv1 programs, JACM, Vol. 24, No.1, pp. 44-67.
- Darlington, J. L. [1888], Automatic thtorem proving with 1quality substitutions and matll1matical induction, Machine Intelligence 3, Edinburgh, Scotland, pp. 113-127.
- Green, C. c. [May 1988], Application of th10r1m proving to probl1m solving, Proceedings of the International Joint Conference on Artificial Intelligence, Washington DC, pp. 219-239.
- Hewitt, C, [Apr. 1971], Dmription and theoretical analysts (using schtmata) of PLANNER: A lanpag• for proving theorems and mantpul~Zttng models ln IZ robot, Ph.D. thesis, MIT, Cambridge, MA.
- Manna, Z. and R. Waldinger [July 1 978], Synthesis: drtflmS ,.. progr~Zms, IEEE Transactions on Software Engineering, Vol. SE-6, No. 4, (to appear).
- Murray, N.
- 978, A proof proctdurt for non-clausfll first-order logic, Technical Report, Syracuse University, Syracuse, NY.
- Nelson, G. and D. C. Oppen [Jan. 1 978], A simplifier based on efficient decision fllgortthms, Proceedings of the Fifth ACM Symposium on Principles of Programming Languages, Tuscon, AZ., pp. 141-160.
- Nll .. on, N.J. [1871], Problem-solving mttltods in ~Zrtiflclalintelllgtnct, McGraw-Hill Book Co., New York, NY (pp. 166- 168].
- Nilsson, N. J, [June 1 978], A production system for automatic deduction, Machine Intelligence 9, Chichester, England (to appear).
- Robinson, J. A. [Jan. 1 966, A machine-oriented logic based on tlt1 resolution princtplt, JACM, Vol. 12, No. 1, pp. 23-41.
- Waldinger, R. J. and R. C. T. Lee [May 1969], PROW: a step toward automatic progr~Zm wrlttng, Proceedings of the International Joint Conference on Artificial Intelligence, Washington, DC, pp. 241•262.
- Wilkins, D. [1073], (pEST--anon-clausal tlt1or1m proving syst1m, M.So. theala, Unlveralty of Eaaex, England.
References were extracted automatically from the PDF and may contain errors.
Full text extracted automatically from the PDF; figures, tables and equations may differ. The PDF is the version of record.
A DEDUCTIVE APPROACH TO PROGRAM SYNTHESIS
Zohar Manna Artificial Intelligence Laboratory Stanford Unlveralty
ABSTRACT
Program synthesis Is the systematic derivation of a program from a given specification. A deductive approt~ch to program synthesis Ia 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.
MOTIVATION
The early work In program synthesis relied strongly on mechanical theorem-proving techniques. The work of Green (1969) and Waldinger and Lee (1969], for example, depended on resolution-based theorem proving; however, the difficulty of representing the principle of mathematical Induction In a resolution framework hampered these systems In the formation of programs with Iterative or recursive loops. More recently, program synthesis and theorem proving have tended to go their separate ways. Newer theorem-proving systems are able to perform proofs by mathematical Induction (e.g., Boyer and Moore [1976)), but are useless for program synthesis because they have sacrificed the ability to prove theorems Involving existential quantifiers. Recent work In program synthesis (e.g., Burstall and Darlington [1977) and Manna and Waldinger [1979)), on the other hand, has abandoned the theorem-proving approach, and has relied Instead on the direct application of transformation or rewriting rules to the program's specifications; In choosing this path, these systems have renounced the use of such theorem-proving techniques as unification or Induction.
In this paper, we describe a framework for program synthesis that again relies on a theorem-proving approach. This approach combines techniques of unification, mathematical Induction, and transformation rules within a single deductive system. We will outline the logical structure of this system without considering the strategic aspects of how deductions are directed. Although no Implementation exists, the approach Is machine oriented and ultimately Intended for Implementation In automatic synthesis systems.
In the next section, we will give examples of specifications accepted by the system. In the succeeding sections, we explain the relation between theorem proving and our approach to program synthesis. This paper Is an abbreviated version of a Stanford Unlvertlty and SRI International technical report, which Includes more detailed discussion and some complete examples to Illustrate the application of the method.
SPECIFICATION
The specification of a program allows us to express the purpose of the desired program, without Indicating an algorithm by which that purpose Ia to be achieved. Specifications may contain high-level constructs that are not computable, but are close to our way of thinking. Typically, specifications Involve such constructs as the quantifiers for all ... and for some ... , the set constructor {x: ... },and the descriptor find z suc!J t!Jat ....
For example, to specify a program to compute the remainder of dividing a nonnegative Integer i by a positive
Integer j, we would write Tlm(t, j) <· ftnd z such that for somt '' t · J · j + z and 0 s z and z < j wlleTI 0 :stand 0 <j Here, the Input condition 0 :s i and 0 <j. expresses the class of legal Inputs to which the program Is expected to apply. The output condition for somt y, l · J · j + z and 0 s z and z s j describes the relation the output z Ia Intended to aatlsfy, (Note that, for simplicity, we omit type requirements such as lntlgtr(i).) In general, we are considering the synthesis of programs whose specifications have the form f(a) <· find z such that R(a, z)
Richard Waldinger Artificial Intelligence Center SRI International or
wllm P(a).
Thus, In this paper we limit our dlscuSIIon to the synthesis of applloatlve programs, which yield an output but produce no side effects. To derive a program from such a apeclflcatlon, we attempt to prove a theorem of the form
for all a,
if P(a)
tlllnfor some%, R(a, z).
The proof of this theorem must be constructive, In the sense that It must tell us how to find an output z satisfying the desired output condition. From such a proof, a program to compute z can be extracted.
BASIC STRUCTURE
The basic structure employed In our approach Is the sequ1nt, which consists of two lists of sentences, the assertlons A 1, A2, ·· . , Am, and the goals G 1, G2, ··· , Gn. With each assertion or goal there may be associated an entry called the output expmston. This output entry has no bearing on the proof Itself, but records the program .segment that has been constructed at each stage of the derivation (ct. the "answer literal" In Green [ 1 969]). We will denote a sequent by a table with three columns: assertions, goals, and output. Each row In the sequent has the form
| asstrtlons | goals | output |
| A 1 (a, x) | t~a. x) |
The meaning of a sequent Is that If all Instances of each of the assertions are true, then some Instance of at least one of the goals Is true; more precisely, the sequent has the same meaning as Ita assodat1d untlnCI
tf for all x, A(a, x)
tllenfor som1 x, G(a, x)
where a denotes all the constants of the sequent, x denotes all the free variables, A(a, x) denotes the conjunction of all the assertions A 1 (a, x), and G(x, a) denotes the disjunction of all the goals G 1 (a, x). (In general, we will denote constants or tuples of constants by a, b, c, ... , nand variables or tuples of variables by u, v, w, .... z.) If some Instance of a goal Is true [or some Instance of an assertion Is false], the corresponding Instance of Its output expression satisfies the given specification. In other words, If some Instance G (a, 1) Is true (or some . ' Instance A 1 (a, e) Is false], then the corresponding Instance t 1 (a, 1) [or t 1 (a, 1)] Is an acceptable output.
Note that: ( 1) an assertion or goal Is not required to have an output entry; (2) an assertion and a goal never occupy the same row of the sequent; (3) the variables In each row are "dummys," which we can systematically rename without changing the meaning of the sequent.
The distinction between assertions and goals Is artificial, and does not Increase the logical power of the deductive system. In fact, If we delete a goal from a sequent, and add Its negation as a new assertion, we obtain an equivalent sequent: similarly, we can delete an assertion from a sequent, and add ita negation as a new goal, without changing the meaning of the sequent. This property is known as dualtt,. Nevertheless, the distinction between assertions and goals makes our deductions easier to understand.
If Initially we are given the specification
f(a) o ftnd z such that R(a, z) wlllrt P(a),
we construct the Initial sequent In other words, we assume that the Input condition P(a) Ia true, and we want to prove that for some z, the goal R(a, z) Ia true; If so, z represents the desired output. Quantifiers have been removed by the usual skolemlzatlon procedure (see, '·I·· Nilsson [1CI71)). The output lis a variable, tor which we can make aubatltutlona, tl'· Input a Ia a constant.
| Ass~rtttms | Goals | Output |
|---|---|---|
| P(a) | R(a, z) | % |
The Input condition P(a) Is not the only assertion In the sequent; typically, simple, basic axioms, such as u = u, are represented as assertions that are tacitly present In all aequenta. Many properties of the subject domain, however, are represented by other means, as we shall see.
The deductive system we describe operates by causing new assertions and goals, and corresponding new output expressions, to be added to the sequent without changing Its meaning. The process terminates If the goal true (or the assertion false) Is produced, whose corresponding output expression consists entirely of primitives from the target programming language; this expression Is the desired program.
Note that this deductive procedure never requires us to establish new sequents or (except for strategic purposes) to delete an existing assertion or goal. In this sense, the approach more resembles resolution than "natural deduction."
In the remainder of this paper we outline the deductive rules of our system, and we present two complete examples Illustrating the application of the system to program synthesis.
SPLITTING RULES
The splitting rules allow us to decompose an assertion or goal Into its logical components. For example, If our sequent contains an assertion of form F and G, we can Introduce the two assertions F and G Into the sequent without changing Its meaning. We will call this the andsplit rult and express It In the following notation:
the andspltt rul1
| ass~rttons | goals | I output |
| F andG | I I | |
| F | I I | |
| a | I |
Similarly, we have the orspltt rr.d1: If our sequent contains a goal of form For a,, we can Introduce the two goals F and 0 Into our sequent; and the lfspltt rtd1: If our sequent contains a goal of form IfF then G, we can Introduce the new assertion F and the new goal G.
There Ia no orspllt rule for assertions or andspllt rule for goals. Note that the output entries for the consequents of the splitting rules are exactly the same as the entries for their antecedents.
TRANSFORMATION RULES
Transformation rules allow one assertion or goal to be derived from another. Typically, transformations are expressed as conditional rewriting rules
meaning that In any assertion, goal, or output expression, a subexpresslon of form r can be replaced by the corresponding expression of forms, provided that the condition P holds. We never write such a rule unless r and s are equal terms or equivalent sentences, whenever condition P holds. for example, the transformation rule
expresses that an element belongs to a nonempty list If It equals the head of the list or belongs to Its tall. (Here,
head(v) denotes the first element of the list v, and tail(v) denotes the list of all but the first element.) The rule
expresses that every nonzero Integer divides zero.
It a rule has the vacuous condition true, we write It with no condition; for example, the logical rule
may be applied to any subexpresslon that matches Its lett-hand side.
Assertions and goals are affected differently by transformation rules. Suppose
Is a transformation rule and F(r') Is an assertion such that Its subexpresslon r' Is not within the scope of any quantifier. Suppose also that there exists a unifier for r and r', i.1., a substitution 8 such that r8 and r'9 are Identical. Hera, r8 denotes the result of applying the substitution 8 to the expression r. We can assume that (J Ia a "most general" unifier (In the sense of Robinson (1965)) of r and r'. (We rename the variables of F(r'), If necessary, to Insure that It has no variables In common with the transformation rule.) By the rule, we can conclude that It p(J holds, then r8 and s8 are equal terms or equivalent sentences. Therefore, we can add the assertion
to our sequent.
For example, suppose we have the assertion
and we apply the transformation rule
taking r' to be a E l and(} to be the substitution [ u .. a; v .. I ]; then we obtain the new assertion
then (a · head( I) or a E tall(l)) and a " 0.
Note that a and l are constants, while u and v are variables, and Indeed, the substitution was made for the variables of the rule but not for the constants of the assertion.
In general , if the given assertion F(r') has an associated output entry t, the new output entry Is formed by applying the substitution 8 tot.
The corresponding dual deduction rule for goals, In our deduction-rule notation, Is

| assertions | goals | output |
| I I | ||
| F(r') | ||
| I I= | ||
| p() and F(s)() | I te |
(Transformation rules can also be applied to output entries In an analogous manner.) For example, suppose we have the goal

and we apply the transformation rule
taking r' to be. alz and 9 to be the substitution [ z .. 0; u .. a ]. Then we obtain the goal and which can be further transformed to Note that applying the transformation rule caused a substitution to be made for the occurrences of the variable :c In the goal and the output entry.
| (tnttgtr(a) and a " 0) and (trul and biO) | 0+1 |
| I tntlgtr(a) and a " 0 and biO |
Transformation rules need not be simple rewriting rules; they may represent arbitrary procedures. For example, r could be an equation j(x) · a, s could be Ita solution x · '· and P could be the condition under which that solution applies. In general, efficient procedures for particular aubtheorles may be represented as transformation rules (see, '·I·· Bledaoe [1977] or Nelson and Oppen [1978]). Some transformation rules effect the removal of quantifiers. Other rulea play the role of the "antecedent theorems" and "consequent theorems" of PLANNER (Hewitt [1Q71]).
RESOLUTION
The original resolution principle (Robinson [ 1965]) applied only to sentences In conjunctive normal form. The version we employ does not make this requirement.
Assume our sequent contains two assertions of form F(P1) and G(P2), whertt P 1 and P 2 are subsentences of these assertions not within the scope of any quantifier. For the time being, let us Ignore the output expressions corresponding to these assertions. Suppose there exists a unifier for P1 and P2, t.1., a substitution 8 such that P18 and Pz8 are Identical. We can take 8 to be the most general unifier. The AA-r~solutton rult allows us to deduce the new assertion
F(trut>8 or G(falst>8,
and add It to the sequent. (Here, F(trul) denotes the result of replacing P1 by true In F(P1). Of course, we may need to do the usual renaming to ensure that F(P1) and G(P2) have no variables In common.) We will call 8 the untbtng substitution and P 18 (·Pz8) the 1liminated subexpmsion; the deduced assertion Is called the rtsolvmt. Note that the rule Ia symmetric, ao the roles of F(P1) and G(P2) may be reversed.
For example, suppose our sequent contains the assertions
The two aubsentences "P(x) and Q(b)" and "P(a) and Q(y)" can be unified by the substitution
Therefore, the AA-reaolutlon rule allows us to eliminate the subexpresslon "P(a) and Q(b)" and derive the conclusion
(tf true tll1n R(a)) or falst,
which reduces to
by application of the appropriate transformation rules.
A "nonclausal" resolution rule similar to ours has been developed by Murray [ 1978]. Other such rules have been proposed by Wilkins [1973] and Nilsson [1979].
THE RESOLUTION RULES
We have defined the M·reaolutlon rule to derive conclusions from assertions· the AA-rtsolutton ru/1
| as11rttons | gOGls |
| F(true)8 or O(falu)() |
where P18 = P28, and 8 Is most general.
By duality, we can regard goals as negated assertions; consequently, we obtain a "GG-resolutlon rule", a "GA resolution rule", and an "AG·resolution rule" as corollaries of the AA-resolutlon rule.
We have Ignored the output expressions of the assertions and goals. However, If at least one of the sentences to which a resolution rule Is applied has a corresponding output expression, the resolvent will also have an output expression. If only one of the sentences has an output expression, say t, then the resolvent will have the output expression t8. On the other hand, If the two sentences F(P1) and O(Pz) have output expressions t 1 and t2, respectively, the resolvent will have the output expression
tf P18 then t 18 tlst t~.
For example, suppose we have derived the two goals
| max(tall(l)) i!: llead(l) and tail(l) • [] not( max(tall(l)) i!: llead(l) and tail(l) " [] | max(tatl(l)) lltad(l) |

A polartt' strategy adapted from Murray [ 1 9 78] restricts the application of the resolution rules. The deductive system we have presented so far, Including the splitting rules, the resolution rules, and an appropriate set of logical transformation rules, has been proved by Murray to constitute a complete system for first-order logic, In the sense that a derivation exists for every valid sentence. (Actually, only the resolution rulea and aome of the logical transformation rules are strictly necessary.)
MATHEMATICAL INDUCTION AND THE fORMATION OF RECURSIVE CALLS
Mathematical Induction Is of special importance for deductive systems Intended for program synthesis, because It Is only by the application of some form of the Induction principle that recursive calls or Iterative loops are Introduced Into the program being constructed. The Induction rule we employ Is a version of the principle of mathematical Induction over a well-founded set.
We may describe this principle as follows: In attempting to prove that a sentence of form F(a) holds for every element a of some well-founded set, we may assume Inductively that the sentence holds for all u that are strictly less than a In the well-founded ordering <. Thus, in trying to prove F(a), the well-founded Induction principle allows us to assume the Induction hypothesis
In the case that the well-founded set Is the nonnegative Integers under the usual < ordering, well-founded Induction reduces to the familiar complete Induction principle: to prove that F(n) holds for every nonnegative lntuger n, we may assume Inductively that the sentence F(u) holds for all nonnegative Integers u such that u < n.
In our Inference system, the principle of well-founded Induction Is represented as a deduction rule (rather than, say, an axiom schema). We present only a special case of this rule here.
Suppose we are constructing a program whose specification Is of form
Then our Initial sequent Is
| assertions | goals | output |
|---|---|---|
| P(a) | I I | |
| R(a, '' z) | I z |
Then we can always add to our sequent a new assertion, the Induction hypothesis
| ifu <a then if P(u) then |
Here, f denotes the program we are trying to construct, and g Is a new skolem function corresponding to the variable y. The well-founded set and the particular well-founded ordering < to be employed In the proof have not yet been determined.
Let us paraphrase: We are attempting to construct a program f such that, for an arbitrary Input a satisfying the Input condition P(a), the output j(a) will satisfy the output condition R(a, y, j(a)), for some y; or, equivalently, R(a, g(a), j(a)). By the well-founded Induction principle, we can assume Inductively that for every u less than a In some well-founded ordering such that the Input condition P(u) holds, the output j(u) will satisfy the same output condition R(u, g(u), j(u)).
In general, we could Introduce an Induction hypothesis corresponding to any subset of the assertions or goals In our sequent, not just the Initial assertion and goal; most of. these Induction hypotheses would not be relevant to the final proof, and the proliferation of new assertions would obstruct our efforts to find a proof. Therefore, we employ the following recurrtnCI stratll'} for determining when to Introduce an Induction hypothesis.
let us restrict our attention to the case where the Induction hypothesis Is derived from the Initial assertion and goal. Suppose that Q(a, y, z) Is some subsentence of the Initial goal; then that goal may be written
Suppose further that at some point In the derivation an assertion or goal of form
Is developed, where t Is an arbitrary term and 'J' and z' are distinct variables. In other words, the newly developed assertion or goal has a subsentence Q(t, 'J', z') that Is a precise Instance of a aubaentence Q(~a, '' z) of the Initial goal. This recurrence motivates us to add the Induction hypothesis
The rationale for Introducing the Induction hypothesis at this point Ia that now we can perform resolution between the Induction hypothesis and the newly developed assertion or go~ I S(Q(t, 'J ', z ')), eliminating the subexpreaalon Q(t' g(t), j(t)).
let us look at an example. Suppose we are constructing a program r~~n(i, j) to compute the remainder of dividing a nonnegative Integer t by a positive Integer J; the specification may be expressed as
Our Initial sequent Is then
| assertions | goals | outputs |
|---|---|---|
| 0 :S i and 0 < j | I | |
| i • 'J-J + z and 0 s z and z < j I | z |
Here, the Inputs i and j are constants, for which we can make no substitution; 'J and the output z are variables. Assume that during the course of the derivation we develop the goal

This goal Ia a precise Instance of the Initial goal
obtained by replacing i by i-j. Therefore, taking Q{i ,J,'J, z) to be the Initial goal itself, we add as a new assertion the Induction hypothesis

Here, g Is a new skolem function corresponding to the variable y, and < Is an arbitrary well-founded ordering. Note that < Is to be defined on pairs because the desired program/ has a pair of Inputs.
We can now apply GA-resolutlon between the goal

and the Induction hypothesis; the unifying substitution 6 Ia
The new goal Is
| tTUI and | wra(i-j, j) |
| not (if (i-j, j) < (i, j) | |
| th1n if 0 s l-j and 0 < j I | |
| '"'"falSI) I |
which reduces to
| (i-j, j) < (l,j) and | wra(l-j, j) |
| 0 s l-j and 0 < j |
Note that the recursive call wn(i-j, j) has been Introduced Into the output entry.
The particular well-founded ordering < to be employed In the proof has not yet been determined. To choose the ordering requires special transformation rules, which describe known well-founded orderings and ways of combining them. In this case, the ordering < Ia chosen to be the< ordering on the first component of the pairs. Ultimately, the following goal Ia obtained:

In other words, In the case thatj s l, the output wn(i-j, j) satisfies the desired program's specification.
We will not discuss here the more general case, where a newly developed assertion or goal has a subsentence that Ia an Instance of a aubsentence not of the Initial goal, but of some Intermediate goal or assertion; this situation accounts for the Introduction of "auxiliary procedures" to be called by the program under construction. We will also not discuss the caae where the new aubsentence Is not a precise Instance of the earlier subsentence, but where both are Instances of a somewhat more general sentence.
Some early efforts toward Incorporating mathematical Induction In a resolution framework were made by J. L. Darlington [ 1 968). His system treated the Induction principle as a second-order axiom schema rather than as a deduction rule; It had a limited ability to perform second-order unifications.
CONCLUSION
Theorem proving was abandoned as an approach to program synthesis when the development of sufficiently powerful automatic theorem provers appeared to flounder. However, theorem provers have been exhibiting a steady Increase In their effectiveness, and program ayntheala Is one of the moat natural applications of these systems.
ACKNOWLEDGMENTS! We would like to thank John Darlington, Chris Goad, Jim King, Nell Murray, Nils Nilsson, and Earl Saoerdotl for valuable dlacuaalona and comments. Thanks are due also to Patte Wood for aid In the preparation of this manuscript.
This research was supported In part by the National Science Foundation under Grants MCS 76-83655 and MCS 78-026Q1, by the office of Naval Research under Contracts N00014-76-C-0687 and N00014-75-C-0816, by the Defense Advanced Research Projects Agency of the Department of Defense under Contract MDA903-76-C-0206, and by the United States-Israel Binational Science Foundation.
REFERENCES a
Bledsoe, W. W. [HI77], Non-r~solution thtorm proving, Artificial Intelligence Journal, Vol. 9, pp. 1-36.
Boyer, R. S. and J S. Moore [Jan. 1SI75], Proving thtortms about LISP functions, JACM, Vol. 22, pp. 129-144.
Buretall, R. M. and J, Darlington [Jan, 1 877], A transformation s'st1m for dlwloping r1cursiv1 programs, JACM, Vol. 24, No.1, pp. 44-67.
- Darlington, J. L. [1888], Automatic thtorem proving with 1quality substitutions and matll1matical induction, Machine Intelligence 3, Edinburgh, Scotland, pp. 113-127.
- Green, C. c. [May 1988], Application of th10r1m proving to probl1m solving, Proceedings of the International Joint Conference on Artificial Intelligence, Washington DC, pp. 219-239.
- Hewitt, C, [Apr. 1971], Dmription and theoretical analysts (using schtmata) of PLANNER: A lanpag· for proving theorems and mantpul~Zttng models ln IZ robot, Ph.D. thesis, MIT, Cambridge, MA.
- Manna, Z. and R. Waldinger [July 1 978], Synthesis: drtflmS ,.. progr~Zms, IEEE Transactions on Software Engineering, Vol. SE-6, No. 4, (to appear).
- Murray, N. [1 978], A proof proctdurt for non-clausfll first-order logic, Technical Report, Syracuse University, Syracuse, NY.
- Nelson, G. and D. C. Oppen [Jan. 1 978], A simplifier based on efficient decision fllgortthms, Proceedings of the Fifth ACM Symposium on Principles of Programming Languages, Tuscon, AZ., pp. 141-160.
- Nll .. on, N.J. [1871], Problem-solving mttltods in ~Zrtiflclalintelllgtnct, McGraw-Hill Book Co., New York, NY (pp. 166168].
- Nilsson, N. J, [June 1 978], A production system for automatic deduction, Machine Intelligence 9, Chichester, England (to appear).
- Robinson, J. A. [Jan. 1 966], A machine-oriented logic based on tlt1 resolution princtplt, JACM, Vol. 12, No. 1, pp. 23-41.
- Waldinger, R. J. and R. C. T. Lee [May 1969], PROW: a step toward automatic progr~Zm wrlttng, Proceedings of the International Joint Conference on Artificial Intelligence, Washington, DC, pp. 241·262.
- Wilkins, D. [1073], (pEST--anon-clausal tlt1or1m proving syst1m, M.So. theala, Unlveralty of Eaaex, England.
@inproceedings{ijcai1979p121,
title = {A Deductive Approach to Program Synthesis},
author = {Manna, Zohar and Waldinger, Richard J.},
booktitle = {Proceedings of the Sixth International Joint Conference on
Artificial Intelligence, {IJCAI-79}},
publisher = {International Joint Conferences on Artificial Intelligence},
editor = {Bruce G. Buchanan},
year = {1979},
month = {8},
url = {https://ijcai.org/proceedings/1979/121},
}
TY - CPAPER TI - A Deductive Approach to Program Synthesis AU - Manna, Zohar AU - Waldinger, Richard J. T2 - Proceedings of the Sixth International Joint Conference on Artificial Intelligence, IJCAI-79 PB - International Joint Conferences on Artificial Intelligence PY - 1979 UR - https://ijcai.org/proceedings/1979/121 ER -Copied
Machine-readable versions of this paper, for tools and AI agents: