François Fages

Associative-commutative unification

Unification in equational theories, that is, solving equations in varieties, is of special relevance to automated deduction. Major results in term rewriting systems, as in (Peterson & Stickel, 1981; Hsiang, 1982), depend on unification in presence of associative-commutative functions. (Stickel, 1975; Stickel, 1981) gave an associative-commutative unification algorithm, but its termination in the general case was still questioned. The first part of this paper is an introduction to unification theory, the second part concerns the solving of homogeneous linear diophantine equations, and the third contains a proof of termination and correctness of the associative-commutative unification algorithm for the general case.

Constructive negation by pruning

Abstract We show that a simple concurrent pruning mechanism over standard SLD derivation trees, called constructive negation by pruning, provides a complete operational semantics for normal constraint logic programs (CLP) w.r.t. Fitting-Kunens three-valued logic semantics. The principle of concurrent pruning is the only extra machinery needed to handle negation; in particular, there is no need for considering complex subgoals with explicit quantifiers outside the constraint part. The main result of the paper is the definition of a fixpoint semantics for normal CLP programs which is fully abstract for the observation of computed answer constraints. This allows to generalize the s-semantics approach to normal CLP programs, and provides a fixpoint characterization of Kunens semantics. The definition is based on a nonground continuous finitary version of Fittings operator. We relate also these results to an important aspect of CLP programming practice: optimization. We investigate various forms of goal optimization within CLP languages, and provide both declarative and operational semantics for them via a translation to normal CLP programs. We show that constructive negation by pruning specializes for these classes of programs to a more efficient concurrent branch and bound like procedure.

A new fixpoint semantics for general logic programs compared with the well-founded and the stable model semantics

We study a new fixpoint semantics for logic programs with negation. Our construction is intermediate between Van Gelder’s well-founded model and Gelfond and Lifschitz’s stable model semantics. We show first that the stable models of a logic programP are exactly the well-supported models ofP, i.e. the supported models with loop-free finite justifications. Then we associate to any logic programP a non-monotonic operator over the semilattice of justified interpretations, and we define in an abstract form its ordinal powers. We show that the fixpoints of this operator are the stable models ofP, and that its ordinal powers after some ordinala are extensions of the well-founded partial model ofP. In particular ifP has a well-founded model then that canonical model is also an ordinal power and the unique fixpoint of our operator. We show with examples of logic programs which have a unique stable model but no well-founded model that the converse is false. We relate also our work to Doyle’s truth maintenance system and some implementations of rule-based expert systems.

Associative-Commutative Unification

Unification in equational theories, that is solving equations in varieties, is of special relevance to automated deduction. Recent results in term rewriting systems, as in [Peterson and Stickel 81] and [Hsiang 82], depend on unification in presence of associative-commutative functions. Stickel [75,81] gave an associative-commutative unification algorithm, but its termination in the general case was still questioned. Here we give an abstract framework to present unification problems, and we prove the total correctness of Stickel’s algorithm.

Experiments in reactive constraint logic programming

Abstract In this paper we study a reactive extension of constraint logic programming (CLP). Our primary concerns are search problems in a dynamic environment, where interactions with the user (e.g. in interactive multi-criteria optimization problems) or interactions with the physical world (e.g. in time evolving problems) can be modeled and solved efficiently. Our approach is based on a complete set of query manipulation commands for both the addition and the deletion of constraints and atoms in the query. We define a fully incremental model of execution which, contrary to other proposals, retains as much information as possible from the last derivation preceding a query manipulation command. The completeness of the execution model is proved in a simple framework of transformations for CSLD derivations, and of constraint propagation seen as chaotic iteration of closure operators. A prototype implementation of this execution model is described and evaluated on two applications.

Handling Preferences in Constraint Logic Programming with Relational Optimization

In many Constraint Logic Programming (CLP) applications one needs to express not only strict requirements but also preferences. Constraint hierarchies are one way of describing preferred criteria in the statement of a problem. In [18] CLP was extended to integrate constraint hierarchies resulting in Hierarchical Constraint Logic Programming (HCLP). We propose an alternative approach for describing preferred criteria in CLP as a problem of relational optimization (RO). In this approach the programmer defines a preference relation which indicates when a solution is better than another solution. We study several schemes based on pruning for optimizing an objective function, and we show how these schemes can be generalized to handle preference relations defined by CLP programs, while preserving a straightforward logical semantics. Further we show on some examples that the greater flexibility of the relational optimization scheme is not at the cost of efficiency.

Phase semantics and verification of concurrent constraint programs

The class CC of concurrent constraint programming languages and its non-monotonic extension LCC based on linear constraint systems can be given a logical semantics in Girards intuitionistic linear logic for a variety of observables. In this paper we settle basic completeness results and we show how the phase semantics of linear logic can be used to provide simple and very concise semantical proofs of safety properties for GC or LCC programs.

Combining explicit negation and negation by failure via Belnap's logic

Abstract This paper deals with logic programs containing two kinds of negation: negation as failure and explicit negation. This allows two different forms of reasoning in the presence of incomplete information. Such programs have been introduced by Gelfond and Lifschitz and called extended programs. We provide them with a logical semantics in the style of Kunen, based on Belnaps four-valued logic, and an answer sets semantics that is shown to be equivalent to that of Gelfond and Lifschitz. The proofs rely on a translation into normal programs, and on a variant of Fittings extension of logic programming to bilattices.

Average-case analysis of unification algorithms

Unification in first-order languages is a central operation in symbolic computation and logic programming. Many unification algorithms have been proposed in the past, however there is no consensus on which algorithm is the best to use in practice. While Paterson and Wegmans linear unification algorithm has the lowest time complexity in the worst case, it requires an important overhead to be implemented. This is true also, although less importantly, for Martelli and Montanaris algorithm [MM82], and Robinsons algorithm [Rob71] is finally retained in many applications despite its exponential worst-case time complexity. There are many explanations for that situation: one important argument is that in practice unification subproblems are not independent, and linear unification algorithms do not perform well on sequences of unify-deunify operations [MU86]. In this paper we present average case complexity theoretic arguments. We first show that the family of unifiable pairs of binary trees is exponentially negligible with respect to the family of arbitrary pairs of binary trees formed over l binary function symbols, c constants and v variables. We analyze the different reasons for failure and get asymptotical and numerical evaluations. We then extend the previous results of [DL89] to these families of trees, we show that a slight modification of Herbrand-Robinsons algorithm has a constant average cost on random pairs of trees. On the other hand, we show that various variants of Martelli and Montanaris algorithm all have a linear average cost on random pairs of trees. The point is that failures by clash are not sufficient to lead to a constant average cost, an efficient occur check (i.e. without a complete traversal of subterms) is necessary. In the last section we extend the results on the probability of the occur check in presence of an unbounded number of variables.

Concurrent Constraint Programming and Non-commutative Logic

This paper presents a connection between the intuitionistic fragment of a non-commutative version of linear logic introduced by the first author (NLI) and concurrent constraint programming (CC). We refine existing logical characterizations of operational aspects of CC, by providing a logical interpretation of finer observable properties of CC programs, namely stores, successes and suspensions.