The inductive synthesis of recursive logic programs from incomplete information, such as input/output examples, is a challenging subfield both of ILP (Inductive Logic Programming) and of the synthesis (in general) of logic programs from formal specifications. We first overview past and present achievements, focusing on the techniques that were designed specifically for the inductive synthesis of recursive logic programs, but also discussing a few general ILP techniques that can also induce non-recursive hypotheses. Then we analyse the prospects of these techniques in this task, investigating their applicability to software engineering as well as to knowledge acquisition and discovery.

The intent of this special issue was to bring together developments in inductive programming that have a direct bearing on software development, and to promote a broader use of the term. Inductive programming, in our view, is not a return to the overly ambitious, and thus ultimately unworkable, schemes of automatically generating large software systems. Inductive programming is thus not just programming-by-example, nor just programming-by-demonstration, nor a panacea for software development-in-the-large. It is a mix of more subtle uses of induction to assist the software developer in a variety of ways.

We consider the problem of synthesizing loop-free programs that implement a desired functionality using components from a given library. Specifications of the desired functionality and the library components are provided as logical relations between their respective input and output variables. The library components can be used at most once, and hence the library is required to contain a reasonable overapproximation of the multiset of the components required. We solve the above component-based synthesis problem using a constraint-based approach that involves first generating a synthesis constraint, and then solving the constraint. The synthesis constraint is a first-order ∃ ∀ logic formula whose size is quadratic in the number of components. We present a novel algorithm for solving such constraints. Our algorithm is based on counterexample guided iterative synthesis paradigm and uses off-the-shelf SMT solvers. We present experimental results that show that our tool Brahma can efficiently synthesize highly nontrivial 10-20 line loop-free bitvector programs. These programs represent a state space of approximately 20 10 programs, and are beyond the reach of the other tools based on sketching and superoptimization.

We reconsider the concept of specification in order to bring new insights into the debate of formal versus non-formal methods in computer science. In our view, the correctness of a useful program corresponds to an objective fact, which must have a simple, precise, and understandable formulation. As a consequence, a specification can (and must) only make precise the link existing between the program (formality) and its purpose (informality). Moreover, program correctness can be argued only by means of non-formal reasonings, which should be as explicit as possible. This allows us to explain why specifications cannot be written in a strictly formal language. Our view of specifications does not imply a rejection of all ideas put forward in the literature on formal methods. On the contrary, we agree with the proponents of formal methods on most of their arguments, except on those following from the assumption that specifications could (or should) be formal. Finally, we examine why...

Given a high-level specification and a low-level programming language, our goal is to automatically synthesize an efficient program that meets the specification. In this paper, we present a new algorithmic methodology for inductive synthesis that allows us to do this. We use Second Order logic as our generic high level specification logic. For our low-level languages we choose small application-specific logics that can be immediately translated into code that runs in expected linear time in the worst case. We explain our methodology and provide examples of the synthesis of several graph classifiers, e.g, linear-time tests of whether the input graph is connected, acyclic, etc. In another set of applications we automatically derive many finite differencing expressions equivalent to ones that Paige built by hand in his thesis [Pai81]. Finally we describe directions for automatically combining such automatically generated building blocks to synthesize efficient code implementing more complicated specifications. The methods in this paper have been implemented in Python using the SMT solver Z3 [dMB].

The prospects of inductive logic programming (ILP) with respect to automatic programming (program synthesis) are discussed. We argue that logic program synthesis from incomplete information is but a niche of ILP, and study consequences of this statement. Then, three approaches are described: schema-driven synthesis of logic programs from incomplete specifications, the role of transformation techniques in ILP, and interactive assumption-based inductive learning.

We consider how different kinds of and aspects of declarative programming languages --- logic, functional, type system --- make them suitable for use in the context of inductive synthesis of programs. Then we formulate the inductive synthesis problem for functional programs and outline an algorithm for solving it. We conclude that higher-order definitions and type systems are very useful in inductive synthesis. 1 Introduction Deductive reasoning techniques are well established in program synthesis and transformation [ 15; 4 ] . They are concerned with making a complete specification operational or making some initial program more efficient without changing its semantics. There has been far less interest in inductive (unsound) reasoning techniques in program synthesis; Smith surveys some early work [ 17 ] . With the recent interest in inductive logic programming (ILP) [ 14 ] machine learning researchers have investigated the use of induction in logic program synthesis. The goal is to (...

interpretation of logic programs using magic transformations. The Journal of Logic Programming, 18(2):149--176, February 1994. [7] Y. Deville and K.-K. Lau. Logic program synthesis. The Journal of Logic Programming, 19 & 20:321--350, May 1994. [8] M. Ducass'e and J. Noy'e. Logic programming environments: Dynamic program analysis and debugging. The Journal of Logic Programming, 19 & 20:351--384, May 1994. [9] J. Jaffar and M. J. Maher. Constraint logic programming: A survey. The Journal of Logic Programming, 19 & 20:503--582, May 1994. [10] B. Le Charlier and P. Van Hentenryck. Experimental evaluation of a generic abstract interpretation algorithm for Prolog. ACM Transactions on Programming Languages and Systems (TOPLAS), 16(1):35--101, January 1994. [11] K. Marriott, H. Søndergaard, and N. D. Jones. Denotational abstract interpretation of logic programs. ACM Transactions on Programming Languages and Systems (TOPLAS), 16(3):607--648, May 1994. [12] B. Martens, D. De Schreye, and T...

In deductive object-oriented databases, both classes and attributes may be defined by rules. We will show how inductive logic programming can help in synthesis of those rules. New approach to the object-oriented database modelling by means of inductive logic programming is introduced. Experimental results obtained by WiM \Gamma D system are discussed.

INDUCTIVE SYNTHESIS OF RECURSIVE LOGIC PROGRAMS Serap Ylmaz M.S. in Computer Engineering and Information Science Supervisor: Ass't Prof. Pierre Flener August 1997 The learning of recursive logic programs (i.e. the class of logic programs where at least one clause is recursive) from incomplete information, such as input/output examples, is a challenging subfield both of ILP (Inductive Logic Programming) and of the synthesis (in general) of logic programs from formal specifications. This is an extremely important class of logic programs, as the recent work on constructive induction shows that necessarily invented predicates have recursive programs, and it even turns out that their induction is much harder than the one of non-recursive programs. We call this inductive program synthesis. We introduce a system called DIALOGS-II (Dialogue-based Inductive and Abductive LOgic Program Synthesizer-II) whose ancestor is DIALOGS. It is a schema-guided, interactive, and non-incremental synthe...