We present a novel approach to automatic synthesis of loopfree programs. The approach is based on a combination of oracle-guided learning from examples, and constraint-based synthesis from components using satisfiability modulo theories (SMT) solvers. Our approach is suitable for many applications, including as an aid to program understanding tasks such as deobfuscating malware. We demonstrate the efficiency and effectiveness of our approach by synthesizing bitmanipulating programs and by deobfuscating programs. Categories and Subject Descriptors

One of the most challenging subfields, and a still little researched niche of machine learning, is the inductive synthesis of recursive programs from incomplete specifications, such as examples for the desired input/output behavior [1–4]. The special appeal of an inductive approach to automated program construction is

Abstract. We describe a technique for inducing recursive functional programs over algebraic datatypes from few non-recursive and only positive ground example-equations. Induction is data-driven and based on structural regularities between example terms. In our approach, functional programs are represented as constructor term rewriting systems containing recursive rewrite rules. In addition to the examples for the target functions, background knowledge functions that may be called by the induced functions can be given in form of ground equations. Our algorithm induces several dependent recursive target functions over arbitrary user-defined algebraic datatypes in one step and automatically introduces auxiliary subfunctions if needed. We have implemented a prototype of the described method and applied it to a number of problems. 1

Abstract. Inductive machine learning suggests an alternative approach to the algebraic specification of software systems: rather than using test cases to validate an existing specification we use the test cases to induce a specification. In the algebraic setting test cases are ground equations that represent specific aspects of the desired system behavior or, in the case of negative test cases, represent specific behavior that is to be excluded from the system. We call this inductive equational logic programming. We have developed an algebraic semantics for inductive equational logic programming where hypotheses are cones over specification diagrams. The induction of a hypothesis or specification can then be viewed as a search problem in the category of cones over a specific specification diagram for a cone that satisfies some pragmatic criteria such as being as general as possible. We have implemented such an induction system in the functional part of the Maude specification language using evolutionary computation as a search strategy. 1

Program reasoning consists of the tasks of automatically and statically verifying correctness and inferring properties of programs. Program synthesis is the task of automatically generating programs. Both program reasoning and synthesis are theoretically undecidable, but the results in this dissertation show that they are practically tractable. We show that there is enough structure in programs written by human developers to make program reasoning feasible, and additionally we can leverage program reasoning technology for automatic program synthesis. This dissertation describes expressive and efficient techniques for program reasoning and program synthesis. Our techniques work by encoding the underlying inference tasks as solutions to satisfiability instances. A core ingredient in the reduction of these problems to finite satisfiability instances is the assumption of templates. Templates are user-provided hints about the structural form of the desired artifact, e.g., invariant, pre- and postcondition templates for reasoning; or program templates for synthesis. We propose novel algorithms, parameterized by suitable templates, that reduce the inference of these artifacts to satisfiability. We show that fixed-point computation—the key technical challenge in program reasoning— is encodable as SAT instances. We also show that program synthesis can be viewed as generalized

Inductive programming—the use of inductive reasoning methods for programming, algorithm design, and software development—is a currently emerging research field. A major subfield is inductive program synthesis, the (semi-)automatic construction of programs from exemplary behavior. Inductive program synthesis is not a unified research field until today but scattered over several different established research fields such as machine learning, inductive logic programming, genetic programming, and functional programming. This impedes an exchange of theory and techniques and, as a consequence, a progress of inductive programming. In this paper we survey theoretical results and methods of inductive program synthesis that have been developed in different research fields until today. 1.

All rights reserved.

Analytical inductive programming and evolutionary inductive programming are two opposing strategies for learning recursive programs from incomplete specifications such as input/output examples. Analytical inductive programming is data-driven, namely, the minimal recursive generalization over the positive input/output examples is generated by recurrence detection. Evolutionary inductive programming, on the other hand, is based on searching through hypothesis space for a (recursive) program which performs sufficiently well on the given input/output examples with respect to some measure of fitness. While analytical approaches are fast and guarantee some characteristics of the induced program by construction (such as minimality and termination) the class of inducable programs is restricted to problems which can be specified by few positive examples. The scope of programs which can be generated by evolutionary approaches is, in principle, unrestricted, but generation times are typically high and there is no guarantee that such a program is found for which the fitness is optimal. We present a first study exploring possible benefits from combining analytical and evolutionary inductive programming. We use the analytical system Igor2 to generate skeleton programs which are used as initial hypotheses for the evolutionary system Adate. We can show that providing such constraints can reduce the induction time of Adate.

Inductive Programming (IP) refers to the automated generation of computer programs from incomplete specifications, such as input-output examples. We introduce a new technique called Incremental Inductive Programming (IIP), which combines IP with transfer learning, as a way to get IP to scale up to more complex problems. Using a simple, brute-force search based IP system implemented for the purpose, we perform a set of experiments comparing the performance of IIP versus standard non-incremental IP. IIP

We share a vision of connecting the topics of bidirectional transformation and inductive program synthesis, by proposing to use the latter in approaching problematic aspects of the former. This research perspective does not present accomplished results, rather opening discussion and describing experiments designed to explore the potential of inductive program synthesis for bidirectionalization (the act of automatically producing a backwards from a forwards transformation), in particular to address the issue of integrating programmer intentions and expectations. Categories and Subject Descriptors I.2.2 [Artificial Intelligence]: Automatic Programming—Program synthesis; D.1.2 [Programming