Evelyne Contejean

Introducing global constraints in CHIP

The purpose of this paper is to show how the introduction of new primitive constraints (e.g., among, diffn, cycle) over finite domains in the constraint logic programming system CHIP result in finding very rapidly good solutions for a large class of difficult sequencing, scheduling, geometrical placement and vehicle routing problems. The among constraint allows us to specify sequencing constraints in a very concise way. For the first time, the diffn constraint allows us to express and to solve directly multi-dimensional placement problems, where one has to consider nonoverlapping constraints between n-dimensional objects (e.g., rectangles, parallelepipeds). The cycle constraint makes it possible to specify a wide range of graph partitioning problems that could not yet be expressed by using current constraint logic programming languages. One of the main advantages of all these new primitives is to take into account more globally a set of elementary constraints. Finally, we point out that all the previous primitive constraints enhance the power of the CHIP system significantly, allowing us to solve real life problems that were not within reach of constraint technology before.

Mechanically Proving Termination Using Polynomial Interpretations

For a long time, term orderings defined by polynomial interpretations were scarcely used in computer-aided termination proof of TRSs. But recently, the introduction of the dependency pairs approach achieved considerable progress w.r.t. automated termination proof, in particular by requiring from the underlying ordering much weaker properties than the classical approach. As a consequence, the noticeable power of a combination dependency pairs/polynomial orderings yielded a regain of interest for these interpretations. We describe criteria on polynomial interpretations for them to define weakly monotonic orderings. From these criteria, we obtain new techniques both for mechanically checking termination using a given polynomial interpretation and for finding such interpretations with full automation. With regard to automated search, we propose an original method for solving Diophantine constraints. We implemented these techniques into the CiME rewrite tool, and we provide some experimental results that show how useful polynomial orderings actually are in practice.

Certification of Automated Termination Proofs

Nowadays, formal methods rely on tools of different kinds: proof assistants with which the user interacts to discover a proof step by step; and fully automated tools which make use of (intricate) decision procedures. But while some proof assistants can checkthe soundness of a proof, they lack automation. Regarding automated tools, one still has to be satisfied with their answers Yes / No / Do not know , the validity of which can be subject to question, in particular because of the increasing size and complexity of these tools. In the context of rewriting techniques, we aim at bridging the gap between proof assistants that yield formal guarantees of reliability and highly automated tools one has to trust. We present an approach making use of both shallow and deep embeddings. We illustrate this approach with a prototype based on the CiME rewriting toolbox, which can discover involved termination proofs that can be certified by the Coq proof assistant, using the Coccinelle library for rewriting.

CiME: Completion Modulo E

Completion is an algorithm for building convergent rewrite systems from a given equational axiomatization. The story began in 1970 with the well-known KnuthBendix completion algorithm [8]. Unfortunately, this algorithm was not able to deal with simple axioms like commutativity (z + y = y + x) because such equations cannot be oriented into a terminating rewrite system. This problem have been solved by the so-called AC-completion algorithm of Lankford and Ballantyne [9] and Peterson and Stickel [14], which is able to deal with any permutative axioms, the most popular being assoeiativity and commutativity. In 1986, Jouannand and Kirchner [6] introduced a general T-completion algorithm which was able to deal with any theory T provided that T-congruence classes are finite, and in 1989, Bachmair and Dershowitz extended it to the case of any T such that t h e subterm relation modulo T is terminating. Because of these restrictions, these algorithms are not able to deal with the most interesting cases, AC plus unit (z + 0 = x denoted ACU) being the main one. The particular case of ACU has been investigated first in 1989 by Peterson, Baird and Wilkerson [1]: they used constrained rewriting to avoid the non-termination problem; and an ACU-completion algorithm has been described then by Jouannand and March~ in 1990 [7]. Independently from this story, in the domain of computer algebra, an algorithm for computing Gr6bner bases of polynomial ideals has been found by Buchberger in 1965 [3] and much later than that, in 1981, Loos and Buchberger [11, 4] remarked that this algorithm and the previous completion algorithms behave in a very similar way. The problem of unifying these two algorithms into a common general one arised. In 1993, using the ideas introduced for ACU-completion, Marchd described a new completion algorithm based on a variant of rewriting modulo T: normalized rewriting [12, 13], where terms have to be normalized with respect to a convergent rewrite system S equivalent to T. Of course, this assumes the existence of such an S, but this appears to be true for the examples we were interested in: AC plus unit, AC plus idempotence (x + x = x), nilpotence (x + x = 0), Abelian group theory, commutative ring theory, Boolean ring theory, finite fields theory.

CC(X): Semantic Combination of Congruence Closure with Solvable Theories

We present a generic congruence closure algorithm for deciding ground formulas in the combination of the theory of equality with uninterpreted symbols and an arbitrary built-in solvable theory X. Our algorithm CC(X) is reminiscent of Shostak combination: it maintains a union-find data-structure modulo X from which maximal information about implied equalities can be directly used for congruence closure. CC(X) diverges from Shostaks approach by the use of semantic values for class representatives instead of canonized terms. Using semantic values truly reflects the actual implementation of the decision procedure for X. It also enforces to entirely rebuild the algorithm since global canonization, which is at the heart of Shostak combination, is no longer feasible with semantic values. CC(X) has been implemented in Ocaml and is at the core of Ergo, a new automated theorem prover dedicated to program verification.

Automated Certified Proofs with CiME3

We present the rewriting toolkit CiME3. Amongst other original features, this version enjoys two kinds of engines: to handle and discover proofs of various properties of rewriting systems, and to generate Coq scripts from proof traces given in certification problem format in order to certify them with a skeptical proof assistant like Coq. Thus, these features open the way for using CiME3 to add automation to proofs of termination or confluence in a formal development in the Coq proof assistant.

Rewrite Systems for Natural, Integral, and Rational Arithmetic

We give algebraic presentations of the sets of natural numbers, integers, and rational numbers by convergent rewrite systems which moreover allow efficient computations of arithmetical expressions. We then use such systems in the general normalised completion algorithm, in order to compute Grobner bases of polynomial ideals over ℚ.

A3PAT, an approach for certified automated termination proofs

Software engineering, automated reasoning, rule-based programming or specifications often use rewriting systems for which termination, among other properties, may have to be ensured.This paper presents the approach developed in Project A3PAT to discover and moreover certify, with full automation, termination proofs for term rewriting systems. It consists of two developments: the Coccinelle library formalises numerous rewriting techniques and termination criteria for the Coq proof assistant; the CiME3 rewriting tool translates termination proofs (discovered by itself or other tools) into traces that are certified by Coq assisted by Coccinelle. The abstraction level of our formalisation allowed us to weaken premises of some theorems known in the literature, thus yielding new termination criteria, such as an extension of the powerful subterm criterion (for which we propose the first full Coq formalisation). Techniques employed in CiME3 also improve on previous works on formalisation and analysis of dependency graphs.

A new AC unification algorithm with an algorithm for solving systems of diophantine equations

A novel AC-unification algorithm is presented. A combination technique for regular collapse-free theories is provided along the line developed by A. Boudet et al. (1989). The number of calls to the diophantine equations solver is bounded by the number of AC symbols times the number of shared variables. The rest of the algorithm being linear, this gives a much better idea of how the complexity of AC unification is related to the complexity of solving linear diophantine equations. The termination proof is surprisingly easy. Finally, systems of constraint linear diophantine equations can be solved, rather than one equation at a time, using an algorithm which extends Fortenbachers algorithm to an arbitrary dimension. This allows a much more efficient use of the constraints than in the standard case.<<ETX>>

A simplex-based extension of fourier-motzkin for solving linear integer arithmetic

This paper describes a novel decision procedure for quantifier-free linear integer arithmetic. Standard techniques usually relax the initial problem to the rational domain and then proceed either by projection (e.g.Omega-Test) or by branching/cutting methods (branch-and-bound, branch-and-cut, Gomory cuts). Our approach tries to bridge the gap between the two techniques: it interleaves an exhaustive search for a model with bounds inference. These bounds are computed provided an oracle capable of finding constant positive linear combinations of affine forms. We also show how to design an efficient oracle based on the Simplex procedure. Our algorithm is proved sound, complete, and terminating and is implemented in the alt-ergo theorem prover. Experimental results are promising and show that our approach is competitive with state-of-the-art SMT solvers.