Jean-Louis Lassez

Constraint logic programming

We address the problem of designing programming systems to reason with and about constraints. Taking a logic programming approach, we define a class of programming languages, the CLP languages, all of which share the same essential semantic properties. From a conceptual point of view, CLP programs are highly declarative and are soundly based within a unified framework of formal semantics. This framework not only subsumes that of logic programming, but satisfies the core properties of logic programs more naturally. From a users point of view, CLP programs have great expressive power due to the constraints which they naturally manipulate. Intuition in the reasoning about programs is enhanced as a result of working directly in the intended domain of discourse. This contrasts with working in the Herbrand Universe wherein every semantic object has to be explicitly coded into a Herbrand term; this enforces reasoning at a primitive level. Finally, from an implementors point of view, CLP systems can be efficient because of the exploitation of constraint solving techniques over specific domains.

Fixed point theorems and semantics: a folk tale☆

In this paper we search for the theorem on which the fixed point theory of recursion is based. This leads us to a variety of sources, and the difficulties encountered suggest that we are in the presence of a folk theorem as defined by David Hare1 [ 181. In Section 2 we examine eight textbooks which are likely to be primary source information for people interested in the so called fixed point theory of recucsion. In these 3ooks a more or less formalized fixed point theorem is mentioned as the basis for the semantics of recursive definitions. However there is substantial disagreement on what exactly this theorem is, when it was written and by whom. In Section 3 we look for the original works referred to in the textbooks. We expose the factors creating these problems and finally explain most of the discrepancies. In Section 4 we discuss an extension of the folk theorem, for which we find similar problems. The further theorems found are also relevant to Section 3. In this paper we only talk about various theorems, so only an intuitive understanding of mathematical notions such as continuity and partial ordering is necessary. The interested reader will find definitions in the references.

Explicit representation of terms defined by counter examples

Anti-unification guarantees the existence of a term which is an explicit representation of the most specific generalization of a collection of terms. This provides a formal basis for learning from examples. Here we address the dual problem of computing a generalization given a set of counter examples. Unlike learning from examples an explicit, finite representation for the generalization does not always exist. We show that the problem is decidable by providing an algorithm which, given an implicit representation will return a finite explicit representation or report that none exists. Applications of this result to the problem of negation as failure and to the representation of solutions to systems of equations and inequations are also mentioned.

Closures and fairness in the semantics of programming logic

Abstract We use the notions of closures and fair chaotic iterations to give a semantics to logic programs. The relationships between the semantics of individual rules and the semantics of the whole program are established and an application to parallel processing is mentioned. A chaotic fixed point theorem is given, which carries the non-determinism inherent to resolution. Finally, we introduce a general definition of finite failure and the concept of fair SLD resolution, and show that this procedure is sound and strongly complete with respect to both success and finite failure, thus extending a result of Apt and Van Emden (1982).

A theory of complete logic programs with equality

Abstract Incorporating equality into the unification process has added great power to automated theorem provers. We see a similar trend in logic programming where a number of languages are proposed with specialized or extended unification algorithms. There is a need to give a logical basis to these languages. We present here a general framework for logic programming with definite clauses, equality theories, and generalized unification. The classic results for definite clause logic programs are extended in a simple and natural manner. The extension of the soundness and completeness of the negation-as-failure rule for complete logic programs is conceptually more delicate and represents the main result of this paper.

A canonical form for generalized linear constraints

Abstract The integration of the constraint solving paradigm in programming languages raises a number of new issues. Foremost is the need for a useful canonical form for the representation of constraints. In the context of an extended class of linear arithmetic constraints we develop a natural canonical representation and we design polynomial time algorithms for deciding solvability and generating the canonical form. Important issues encountered include negative constraints, the elimination of redundancy and parallelism. The canonical form allows us to decide by means of a simple syntactic check the equivalence of two sets of constraints and provides the starting point for a symbolic computation system. It has, moreover, other applications and we show in particular that it yields a completeness theorem for constraint propagation and is an appropriate tool to be used in connection with constraint based programming languages.

Querying constraints

The design of languages to tackle constraint satisfaction problems has a long history. Only more recently the reverse problem of introducing constraints as primitive constructs in programming languages has been addressed. A main task that the designers and implementers of such languages face is to use and adapt the concepts and algorithms from the extensive studies on constraints done in areas such as Mathematical Programming, Symbolic Computation, Artificial Intelligence, Program Verification and Computational Geometry. In this paper, we illustrate this task in a simple and yet important domain: linear arithmetic constraints. We show how one can design a querying system for sets of linear constraints by using basic concepts from logic programming and symbolic computation, as well as algorithms from linear programming and computational geometry. We conclude by reporting briefly on how notions of negation and canonical representation used in linear constraints can be generalized to account for cases in term algebras, symbolic computation, affine geometry, and elsewhere.

On Fourier's algorithm for linear arithmetic constraints

In the 1820s Fourier provided the first algorithm for solving linear arithmetic constraints. In other words, this algorithm determines whether or not the polyhedral set associated with the constraints is empty. We show here that Fouriers algorithm has an important hidden property: in effect it also computes the affine hull of the polyhedral set. This result is established by making use of a recent theorem on the independence of negative constraints.

Practical issues on the projection of polyhedral sets

Projection of polyhedral sets is a fundamental operation in both geometry and symbolic computation. In most cases, however, it is not practically feasible to generate projections as the size of the output can be exponential in the size of the input. Even when the size of the output is manageable, we still face two serious problems: overwhelming redundancy and degeneracy. Here, we address these problems from a practical point of view. We discuss three algorithms based on algebraic and geometric techniques and we compare their performance in order to assess the feasibility of these approaches.

Most specific logic programs

More specific versions of definite logic programs are introduced. These are versions of a program in which each clause is further instantiated or removed and which have an equivalent set of successful derivations to those of the original program, but a possibly increased set of finitely failed goals. They are better than the original program because failure in a non-successful derivation may be detected more quickly. Furthermore, information about allowed variable bindings which is hidden in the original program may be made explicit in a more specific version of it. This allows better static analysis of the programs properties and may reveal errors in the original program. A program may have several more specific versions but there is always a most specific version which is unique up to variable renaming. Methods to calculate more specific versions are given and it is characterized when they give the most specific version.