We present our work on the representation and correctness of program schemas, in the context of logic program synthesis. Whereas most researchers represent schemas purely syntactically as higher-order expressions, we shall express a schema as an open first-order theory that axiomatises a problem domain, called a specification framework, containing an open program that represents the template of the schema. We will show that using our approach we can define a meaningful notion of correctness for schemas, viz. that correct program schemas can be expressed as parametric specification frameworks containing templates that are steadfast, i.e. programs that are always correct provided their open relations are computed correctly.

Schema-based logic program transformation has proven to be an effective technique for the optimisation of programs. This paper results from the research that began by investigating the suggestions in [11] to construct a more general database of transformation schemas for optimising logic programs at the declarative level. The proposed transformation schemas fully automate accumulator introduction (also known as descending computational generalisation), tupling generalisation (a special case of structural generalisation), and duality laws (which are extensions to relational programming of the first duality law of the fold operators in functional programming). The schemas are proven correct. A prototype schema-based transformation system is evaluated.

Since the early days of programming and automated reasoning, researchers have developed methods for systematically constructing programs from their specifications. Especially the last decade has seen a flurry of activities including the advent of specialized conferences, such as LOPSTR, covering the synthesis of programs in computational logic. In this paper we analyze and compare three state-of-the-art methods for synthesizing recursive programs in computational logic. The three approaches are constructive/deductive synthesis, schema-guided synthesis, and inductive synthesis. Our comparison is carried out in a systematic way where, for each approach, we describe the key ideas and synthesize a common running example. In doing so, we explore the synergies between the approaches, which we believe are necessary in order to achieve progress over the next decade in this field.

Abstract. This paper presents an approach to learning programming by novice programmers through a web-based adaptive educational system called ALEA (Adaptive LEArning). ALEA supports learning programming by generating sequences of program examples that serve as exercises for a learner. The sequence is adapted to the needs of individual learners. At present, ALEA contains more than a hundred Lisp and Prolog program examples. The program examples are presented as specific instances of program schemata which facilitate understanding of basic programming principles. We have been using the program schemata in teaching an introductory course on functional and logic programming for nearly ten years. Until the ALEA system was developed, the program schemata constituted an important part of the lectures. At present ALEA enables effective acquisition of basic programming skills through usage of program schemata and adapted sequences of program examples. We also discuss our experience in using web-based support for teaching programming.

The use of schemas is a classical way of synthesizing, transforming and analyzing logic programs. Operations on schemas are needed, in particular, the semi-unification of schemas with programs. Since schemas are second-order objects, the related semi-unification is the second-order semi-unification, which is decidable but NP-complete. The non-determinism implied by the NP-completeness slows down the search for a substitution. The present paper expresses the semi-unification process over schemas as rewriting and reduction rules. Global and local constraints are associated to the schema to extend the expressivity of schema description and to fasten the search for a second-order substitution between programs and schemas. CLP techniques and notations are used. 1 Introduction In logic programming, the use of program schemas is a very promising technique. In program synthesis, program schemas can formalize particular resolution methods (divide-and-conquer, generate-and-test approaches...),...

The main contribution of the thesis is to develop a comprehensive framework for developing logic programs using #ve program schemata and some basic data types, and to evaluate its suitability for developing sizable programs. The schemata are intended to capture design decisions made by a programmer during top-down re#nement of a predicate. The schemata are completely independent from the data types, and have associated types and modes. The method of construction is to start from an initial typed moded call, and proceed using precisely defined refinement operations until primitive data type operations are introduced. It is shown that the construction method produces programs that are polymorphic many-sorted formulas, and that computations using the programs cannot result in type or mode errors. The framework is compared with previous schema-based program development methods from the literature, and we argue that this method is better suited to the developmentof non-trivial programs, and is more amenable to computerised support. The introduction of types and modes into schemata is a significant addition, not previously reported. An approach to program veri#cation is also introduced, in which the proof of correctness of a program is built from proof schemata corresponding to the program schemata used in the design of the program. Finally an implementation of the system is described and its use is illustrated on some sizable programs. The implementation incorporates a static analysis algorithm for checking the validity of the modes during the development of the program.

this paper we concentrate on problems related to list processing. A list is a basic data type in both Lisp and Prolog. When a list is to be processed, generally a method of processing recursively all the elements of the list is used. First, several examples of typical list processing problems and their solutions are presented to students. As an example, let us assume the classical task to find a sum of all the elements of an arbitrary list of integers. Standard Lisp and Prolog programs which solve the task can be written:

Program schemas should capture not only structured program design principles, but also domain knowledge, both of which are of crucial importance for hierarchical program synthesis. However, most researchers represent schemas as purely syntactic constructs, which can provide only a program template, bu...

SCHEMA-BASED LOGIC PROGRAM TRANSFORMATION Halime Buyukyildiz M.S. in Computer Engineering and Information Science Supervisor: Ass't Prof. Pierre Flener August 1997 In traditional programming methodology, developing a correct and efficient program is divided into two phases: in the first phase, called the synthesis phase, a correct, but maybe inefficient program is constructed, and in the second phase, called the transformation phase, the constructed program is transformed into a more efficient equivalent program. If the synthesis phase is guided by a schema that embodies the algorithm design knowledge abstracting the construction of a particular family of programs, then the transformation phase can also be done in a schema-guided fashion using transformation schemas, which encode the transformation techniques from input program schemas to output program schemas by defining the conditions that have to be verified to have a more efficient equivalent program. Seven program schemas ar...

Abstract not found