Designing effective policies for minimal agents

A policy for a minimal reactive agent is a set of condition-action rules used to determine its response to perceived environmental stimuli. When the policy pre-disposes the agent to achieving a stipulated goal we call it a teleo-reactive policy. This paper presents a framework for constructing and evaluating teleo-reactive policies for one or more minimal agents, based upon discounted-reward evaluation of policy-restricted subgraphs of complete situation-graphs. The main feature of the method is that it exploits explicit and definite associations of the agent’s perceptions with states. The combinatorial burden that would potentially ensue from such associations can be ameliorated by suitable use of abstractions. The framework allows one to plan for a number of agents by focusing upon the behaviour of a single representative of them. It allows for varied behaviour to be modelled, including communication between agents. Simulation results presented here indicate that the method affords a good degree of scalability and predictive power

On completeness of logic programs

Program correctness (in imperative and functional programming) splits in logic programming into correctness and completeness. Completeness means that a program produces all the answers required by its specification. Little work has been devoted to reasoning about completeness. This paper presents a few sufficient conditions for completeness of definite programs. We also study preserving completeness under some cases of pruning of SLD-trees (e.g. due to using the cut). We treat logic programming as a declarative paradigm, abstracting from any operational semantics as far as possible. We argue that the proposed methods are simple enough to be applied, possibly at an informal level, in practical Prolog programming. We point out importance of approximate specifications.Comment: 20 page

Logic Program Synthesis via Proof Planning

We propose a novel approach to automating the synthesis of logic programs: Logic programs are synthesized as a by-product of the planning of a verification proof. The approach is a two-level one: At the object level, we prove program verification conjectures in a sorted, first-order theory. The conjectures are of the form $\forall \vec{args}. \; prog(\vec{args}) \leftrightarrow spec(\vec{args})$. At the meta-level, we plan the object-level verification with an unspecified program definition. The definition is represented with a (second-order) meta-level variable, which becomes instantiated in the course of the planning. This technique is an application of the Clam proof planning system. Clam is currently powerful enough to plan verification proofs for given programs. We show that, if Clam's use of middle-out reasoning is extended, it will also be able to synthesize programs

Designing teleo-reactive programs

A teleo-reactive program is a condition action sequence used to control a reactive robot in response to stimuli in its environment, but in such a way as to enable the robot to achieve a pre-defined goal under normal conditions. This paper presents a systematic procedure for constructing teleo-reactive programs. It extends the authors' previous work, in particular by considering the multiple-robot case and inter-robot communication

Towards Stepwise, Schema-Guided Synthesis of Logic Programs

We present a general strategy for stepwise, sound and progressive synthesis of logic programs from specifications by examples and properties. We particularize this to schema-guided synthesis, and state a generic synthesis theorem. We justify some design choices for the development of a particular synthesis mechanism that is guided by a Divide-and-Conquer schema, is inductive and deductive, is interactive, and features a non-incremental presentation of examples. Some crucial steps of this mechanism are explained, and illustrated by a sample synthesis. We draw some conclusions on our results so far, state some related work, and outline future research directions

From Programs to Object Code using Logic and Logic Programming

A compiler may be specified by a description of how each construct of the source language is translated into a sequence of object code instructions. If the machine that interprets the object code is specified in the source language itself, then the compiler may be verified using algebraic laws about the programming language constructs. By adopting a subset of the programming language occam, we can benefit from the large number of existing laws which have already been proved for this language. The compiling specification theorems are all Horn clauses in general. Thus it is possible to produce an executable compiler prototype almost directly from this specification in the form of a logic program. The target object code for the transputer has variable-length instruction sequences. Thus in some cases it is necessary to transform the theorems into a form which can be more efficiently executed by avoiding unnecessary backtracking, particularly when there are jumps in the code

The representation of program synthesis in higher order logic

Systems built for automated program construction aim at the formalization of the programming process in order to produce better software. Their implementations, however, suffer from problems similar to those they are intended to solve. Due to a lack of abstraction in the formalization of deductive mechanisms involved in programming reasoning tools for the development of program synthesizers are not yet available. For that, systems capable of formal reasoning about both programs and programming methods are needed. In this paper we develop principles of a formal theory on reasoning about programs and program construction within a unified higher order framework. By an exemplified formalization of principal approaches to program synthesis we will show that a higher degree of abstraction leads to clearer insights into the meta-mathematics of program construction. Ridding the representation of deductive methods from superfluous context also results in simpler, sometimes almost trivial, proofs. Simplicity is one of the most important features of the formal theory and quite valuable if one considers the wide range of intended applications. We present the theory in a highly formalized form built on top of Intuitionistic Type Theory. This allows us to straightforwardly implemented the concepts developed here with a proof system for Type Theory and derive verified implementations of deductive mechanisms from mechanically proven theorems