Michel Rueher

A CLP Framework for Computing Structural Test Data

Structural testing techniques are widely used in the unit testing process of softwares. A major challenge of this process consists in generating automatically test data, i.e., in finding input values for which a selected point in a procedure is executed. We introduce here an original framework where the later problem is transformed into a CLP(FD) problem. Specific operators have been introduced to tackle this kind of application. The resolution of the constraint system is based upon entailment techniques. A prototype system -- named INKA -- which allows to handle a non-trivial subset of programs written in C has been developed. First experimental results show that INKA is competitive with traditional ad-hoc methods. Moreover, INKA has been used successfully to generate test data for programs extracted from a real application.

CPBPV: A Constraint-Programming Framework for Bounded Program Verification

This paper studies how to verify the conformity of a program with its specification and proposes a novel constraint-programming framework for bounded program verification (CPBPV). The CPBPV framework uses constraint stores to represent the specification and the program and explores execution paths nondeterministically. The input program is partially correct if each constraint store so produced implies the post-condition. CPBPV does not explore spurious execution paths as it incrementally prunes execution paths early by detecting that the constraint store is not consistent. CPBPV uses the rich language of constraint programming to express the constraint store. Finally, CPBPV is parametrized with a list of solvers which are tried in sequence, starting with the least expensive and less general. Experimental results often produce orders of magnitude improvements over earlier approaches, running times being often independent of the variable domains. Moreover, CPBPV was able to detect subtle errors in some programs while other frameworks based on model checking have failed.

Efficient and Safe Global Constraints for Handling Numerical Constraint Systems

Numerical constraint systems are often handled by branch and prune algorithms that combine splitting techniques, local consistencies, and interval methods. This paper first recalls the principles of {\tt Quad}, a global constraint that works on a tight and safe linear relaxation of quadratic subsystems of constraints. Then, it introduces a generalization of {\tt Quad} to polynomial constraint systems. It also introduces a method to get safe linear relaxations and shows how to compute safe bounds of the variables of the linear constraint system. Different linearization techniques are investigated to limit the number of generated constraints. {\tt QuadSolver}, a new branch and prune algorithm that combines {\tt Quad}, local consistencies, and interval methods, is introduced. {\tt QuadSolver} has been evaluated on a variety of benchmarks from kinematics, mechanics, and robotics. On these benchmarks, it outperforms classical interval methods as well as constraint satisfaction problem solvers and it compares well with state-of-the-art optimization solvers.

Dynamic optimization of interval narrowing algorithms

Abstract Interval narrowing techniques are a key issue for handling constraints over real numbers in the logic programming framework. However, the standard fixpoint algorithm used for computing an approximation of arc consistency may give rise to cyclic phenomena and hence to problems of slow convergence. Analysis of these cyclic phenomena shows: (1) that a large number of operations carried out during a cycle are unnecessary; (2) that many others could be removed from cycles and performed only once when these cycles have been processed. What is proposed here is a revised interval narrowing algorithm for identifying and simplifying such cyclic phenomena dynamically. These techniques are of particular interest for computing stronger consistencies which are often required for a substantial pruning. Experimental results show that such dynamic optimizations improve performance significantly.

Solving Constraints over Floating-Point Numbers

This paper introduces a new framework for tackling constraints over the floating-point numbers. An important application area where such solvers are required is program analysis (e.g., structural test case generation, correctness proof of numeric operations). Albeit the floating-point numbers are a finite subset of the real numbers, classical CSP techniques are ineffective due to the huge size of the domains. Relations that hold over the real numbers may not hold over the floating-point numbers. Moreover, constraints that have no solutions over the reals may hold over the floats. Thus, interval-narrowing techniques, which are used in numeric CSP, cannot safely solve constraints systems over the floats. We analyse here the specific properties of the relations over the floats. A CSP over the floats is formally defined. We show how local-consistency filtering algorithms used in interval solvers can be adapted to achieve a safe pruning of such CSP. Finally, we illustrate the capabilities of a CSP over the floats for the generation of test data.

Exploration of the capabilities of constraint programming for software verification

Verification and validation are two of the most critical issues in the software engineering process. Numerous techniques ranging from formal proofs to testing methods have been used during the last years to verify the conformity of a program with its specification. Recently, constraint programming techniques have been used to generate test data. In this paper we investigate the capabilities of constraint programming techniques to verify the conformity of a program with its specification. We introduce here a new approach based on a transformation of both the program and its specification in a constraint system. To establish the conformity we demonstrate that the union of the constraint system derived from the program and the negation of the constraint system derived from its specification is inconsistent (for the considered domains of values). This verification process consists of three steps. First, we generate a Boolean constraint system which captures the information provided by the control flow graph. Then, we use a SAT solver to solve the Boolean constraint system. Finally, for each Boolean solution we build a new constraint system over finite domains and solve it. The latter system captures the operational part of the program and the specification. Boolean constraints play an essential role since they drastically reduce the search space before the search and enumeration processes start. Moreover, in the case where the program is not conforming with its specification, Boolean constraints provide a powerful tool for finding wrong behaviours in different execution paths of the program. First experimental results on standard benchmarks are very promising.

A Global Constraint Combining a Sum Constraint and Difference Constraints

This paper introduces a new method to prune the domains of the variables in constrained optimization problems where the objective function is defined by a sum y = Σxi, and where variables xi are subject to difference constraints of the form xj - xi ≤ c. An important application area where such problems occur is deterministic scheduling with the mean flow time as optimality criteria. Classical approaches perform a local consistency filtering after each reduction of the bound of y. The drawback of these approaches comes from the fact that the constraints are handled independently. We introduce here a global constraint that enables to tackle simultaneously the whole constraint system, and thus, yields a more effective pruning of the domains of the xi when the bounds of y are reduced. An efficient algorithm, derived from Dikjstras shortest path algorithm, is introduced to achieve interval consistency on this global constraint.

A DISTRIBUTED COOPERATING CONSTRAINTS SOLVING SYSTEM

An appropriate combination of symbolic and numeric solvers often makes it possible to solve problems that none of these solvers can tackle alone. In this paper, we specify a cooperative architecture which allows using concurrently heterogeneous solvers when handling constraints over the reals. This architecture is based upon agents that communicate via asynchronous message passing. Agents are synchronized when a failure or a success occurs. Disjunctive constraints are handled by backtracking. Operational semantics and terminating conditions of such systems are discussed. Implementation issues are addressed. We end the presentation by several examples and give some computational results from a first prototype.

Adapting the wavefront expansion in presence of strong currents

The wavefront expansion is commonly used for path planning tasks and appreciated for its efficiency. However, the existing extensions able to handle currents are subject to incorrectness and incompleteness issues when these currents become strong. That is, they may return physically infeasible paths or no path at all, even if a feasible path exists. This behavior endangers the robot, especially in a dynamic replanning context. That is why we propose a new extension called sliding wavefront expansion. This algorithm, combining an appropriate cost function and continuous optimization techniques, guarantees the existence of a path with an arbitrary precision.

Time-minimal path planning in dynamic current fields

Numerous approaches have been proposed for path planning in dynamic current fields, for a fixed departure time. However, in many applications, the departure time is not necessarily known in advance, but can vary in a time window. In this context, the choice of a good departure time is a critical issue. That is why we introduce in this paper a new approach, called symbolic wavefront expansion, determining both the path and the departure time minimizing the travel time of the vehicle. The key idea of this approach is to propagate and compose functions instead of numerical values, with appropriate operators.