Abstract not found

We present and evaluate an automatic tool for extracting algebraic specifications from Java classes. Our tool maps a Java class to an algebraic signature and then uses the signature to generate a large number of terms. The tool evaluates these terms and based on the results of the evaluation, it proposes equations. Finally, the tool generalizes equations to axioms and eliminates many redundant axioms. Since our tool uses dynamic information, it is not guaranteed to be sound or complete. However, we manually inspected the axioms generated in our experiments and found them all to be correct.

In explanation-based learning, a specific problem's solution is generalized into a form that can be later used to solve conceptually similar problems. Most research in explanation-based learning involves relaxing constraints on the variables in the explanation of a specific example, rather than generalizing the graphical structure of the explanation itself. However, this precludes the acquisition of concepts where an iterative or recursive process is implicitly represented in the explanation by a fixed number of applications. This paper presents an algorithm that generalizes explanation structures and reports empirical results that demonstrate the value of acquiring recursive and iterative concepts. The BAGGER2 algorithm learns recursive and iterative concepts, integrates results from multiple examples, and extracts useful subconcepts during generalization. On problems where learning a recursive rule is not appropriate, the system produces the same result as standard explanation-based ...

This paper defines a new computational model of inductive learning, called U-learnability (Universal Learnability), that is well-suited for rich representation languages, most notably for universal (Turing equivalent) representations. It is motivated by three observations. Firstly, existing computational models of inductive learning---the best known of which are identification in the limit and PAC-learnability---either fail to provide guarantees of accuracy and computational efficiency or require severely restricted representation languages. Secondly, practical machine learning programs use rich representations yet often perform efficiently and achieve high degrees of accuracy. Thirdly, these machine learning programs often make assumptions about the underlying probability distribution over target concepts; such an assumption provides a soft bias for learning. This contrasts with existing computational models of inductive learning, which incorporate only language biases, or hard bias...

In this position paper, we give a critical analysis of the deductive and inductive approaches to program synthesis, and of the current research in these fields. From the shortcomings of these approaches and works, we identify future research directions for these fields, as well as a need for cooperation and cross-fertilization between them.

Modern programs make extensive use of reusable software libraries. For example, we found that 17 % to 30 % of the classes in a number of large Java applications use the container classes from the java.util package. Given this extensive code reuse in Java programs, it is important for the reusable interfaces to have clear and unambiguous documentation. Unfortunately, most documentation is expressed in English, and therefore does not always satisfy these requirements. Worse yet, there is no way of checking that the documentation is consistent with the associated code. Formal specifications present an alternative which does not suffer from these problems; however, formal specifications are notoriously hard to write. To alleviate this difficulty, we have implemented a tool which automatically derives documentation in the form of formal specifications. Our tool probes Java classes by invoking them on dynamically generated tests and captures the information observed during their execution as algebraic axioms. While the tool is not complete or correct from a formal perspective we demonstrate that it discovers many useful axioms when applied to container classes. These axioms then form an initial formal documentation of the class they describe. 1

) William W. Cohen AT&T Laboratories, 600 Mountain Avenue Murray Hill, NJ 07974 wcohen@research.att.com Abstract We consider a dual version of the DFA paclearning problem, in which concepts are strings over a fixed alphabet, examples are DFAs, and a string s represents the set of all DFAs that accept it. It is shown that solving this problem is as hard as learning log-depth boolean circuits, even if the example DFAs are are always acyclic, leveled, and of logarithmic level width. Thus under cryptographic assumptions the dual DFA learning problem is hard. This result implies the hardness of several other more natural learning problems, including learning the description logic Classic from subconcepts, and learning arity-two "determinate" functionfree Prolog clauses from ground clauses. The result also implies the hardness of two formal problems that are similar to problems studied in the area of "programming by demonstration ": learning straightline programs over a fixed operator set ...

. In this paper we suggest a mechanism that improves significantly the performance of a top-down inductive logic programming (ILP) learning system. This improvement is achieved at the cost of giving to the system extra information that is not difficult to formulate. This information appears in the form of an algorithm sketch: an incomplete and somewhat vague representation of the computation related to a particular example. We describe which sketches are admissible, give details of the learning algorithm that exploits the information contained in the sketch. The experiments carried out with the implemented system (SKIL) have demonstrated the usefulness of the method and its potential in future applications. 1 INTRODUCTION Construction of medium size programs remains still somewhat out of reach of many ILP systems, despite many significant advances in this area. It appears that more information needs to be given besides describing the admissible/inadmissible combinations of input and ...

. We present a supervised, interactive learning technique that infers control structures of computer programs from user-demonstrated traces. A two-stage process is applied: #rst, a minimal deterministic #- nite automaton #DFA# M labeled by the instructions of the program is learned from a set of example traces and membership queries to the user. It accepts all pre#xes of traces of the target program. The number of queries is bounded by O#k #jMj#, with k being the total number of instructions in the initial example traces. In the second step we parse this automaton into a high-level programming language in O#jM j 2 # steps, replacing jumps by conditional control structures. 1

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.