The "Contraintes" group investigates the logical foundations, design, implementation, programming environments and applications of constraint programming languages.

Constraint Programming is a field born during the mid 80s from Logic Programming, Linear Programming coming from Operations Research, and Constraint Propagation techniques coming from Artificial Intelligence. Its foundation is the use of relations on mathematical variables to compute with partial information.

The successes of Constraint Programming in industrial applications are related to the bringing of new local consistency techniques
and of declarative languages which allow an easier control on the mixing of heterogeneous resolution techniques: numerical, symbolic, deductive, heuristic, etc.

The study of Concurrent Constraint languages is a core aspect of the project as they provide a conceptual framework for analyzing different issues of Constraint Programming, like constraint resolution techniques, concurrent modeling, reactive applications, etc. The main application domains investigated are combinatorial optimization and bioinformatics.

The class of Concurrent Constraint programming languages (CC) was introduced a decade ago by Vijay Saraswat as a unifying framework for constraint logic programming and concurrent logic programming. The CC paradigm constitutes a representative abstraction of constraint programming languages, and thus allows a fine grained study of their fundamental properties.

CC generalizes the Constraint Logic Programming framework (CLP) by introducing a synchronization primitive, based on constraint entailment. It is a model of concurrent computation, where agents communicate through a shared store, represented by a constraint, which expresses some partial information on the values of the variables involved in the computation. The variables play the role of transmissible dynamically created communication channels.

One of the big successes of CC has been the simple and elegant reconstruction of finite domain constraint solvers, and the cooperation of several models to solve a single combinatorial problem. On the other hand, to use CC for programming reactive applications forces one to abandon the hypothesis of monotonic evolution of the constraint store; this is a strong motivation for new extensions of CC languages.

There are strong completeness theorems relating the execution of a CLP program and its translation in classical logic, which provide smooth reasoning techniques for such programs. However these theorems are broken by the synchronization operation of CC.
Looking for a logical semantics of CC programs in the general paradigm of logic programming, program = formula, execution = proof search, leads to a translation in Jean-Yves Girard's linear logic. This allows the recovery of some completeness results about successes and stores; even suspensions may be characterized with the non-commutative logic of Ruet and Abrusci.

It is thus possible to address important issues for Constraint Programming:

verifying CC programs;

combining CLP and state-based programming;

dealing with local search inside a global constraint solving procedure.

The last two cases rely on a natural extension of CC languages, called Linear Concurrent Constraint languages (LCC), which simply replaces constraint systems built onto classical logic by constraint systems built onto linear logic. This allows us to represent state changes thanks to the consumption of resources during the synchronization action, modeled by the linear implication.

Our domains of application use quite different constraint systems:

finite domains (bounded natural numbers): primitive constraint of some finite domain membership, numerical, symbolic, higher order and global constraints;

reals: Simplex algorithm for linear constraints and interval methods otherwise;

terms: subtyping constraints and ontologies.

The project works on both the constraint resolution methods and their cooperation. The main focus is the efficiency of constraint propagation methods, and their combination with local search methods.

Handling hundreds of thousands of heterogeneous constraints on as many variables is impossible without tools specially designed to show the different views of the execution.

The DiSCiPl ESPRIT project showed the use of declarative diagnosis methods based on the logical semantics of programs for interactive debugging systems, and developed tools to visualize the execution of CLP programs: showing the effect of propagation, the shape of the search space (detection of symmetries), the impact of heuristics, etc. We have pursued this research with our partners of the RNTL project OADymPPaC. The main results of this project are a generic trace format for constraint programming languages and a large investigation of visualization tools.

Semantics based debugging, static and dynamic typing, and more generally validation of CC programs are also studied in the project. Concerning typing issues in constraint programming, the usual coercions between constraint domains (e.g. between booleans and integers, lists and terms) offer a particularly challenging task to type systems design.

The number and economic impact of combinatorial optimization problems found in the industrial world are constantly increasing. They cover:

resource allocation;

placement;

scheduling;

parallelization;

transport;

etc.

The last forty years have brought many improvements in Operations Research resolution techniques. In this framework, Constraint Programming can be seen as providing, on the one hand, local coherence techniques that can be applied to various numerical or symbolic constraints, and on the other hand, declarative languages. This last point is crucial for quickly developing complex combinations of algorithms, which is not possible without a language with a high level of abstraction. It allowed for better results, for instance in scheduling problems, than traditional methods, and is promised to an even better future when thinking about cooperation of global resolution and local propagation techniques.

The project builds upon its knowledge of CC languages, constraint solvers and their implementation to work in these directions. The LCC languages offer a framework for theoretical analysis; and the soft constraints framework gives a new way to tackle over-constrained problems. The work on programming environments helps to integrate the Constraint Programming tools into this application domain.

In recent years, Biology began a work of elucidation of high
level biological processes in terms of their biochemical bases at the
molecular scale. At the end of the Nineties, research in
Bioinformatics evolved, passing from the analysis of the genomic
sequence to the analysis of various data produced in mass by
post-genomic technologies (expression of ARN and
proteins, SNP and haplotypes, protein-protein interactions, 3D
structures, etc). The complexity of the systems concerned
requires a large research effort to develop the
symbolic notation of biological processes and data.

In 2002 , we have started a Collaborative Research Initiative ARC CPBIO on ``Process Calculi and Biology of Molecular Networks''. By working with biologists on well understood biological models, we seek:

to identify in the family of competitive models coming from the Theory of Concurrency (Pi-calculus, Join-calculus and their derivatives) and from Logic Programming (Constraint Logic Programming, Concurrent Constraint languages and their extensions to discrete and continuous time, TCC, HCC), the ingredients of a language for the modular and multi-scale representation of biological processes;

to provide a series of examples of biomolecular processes transcribed in formal languages, and a set of biological questions of interest about these models;

to design and apply to these examples formal computational reasoning tools for the simulation, the analysis and the querying of the models.

An experimental version called

The Biochemical Abstract Machine

In its initial version BIOCHAM 0.1 is composed of:

a simple rule-based language for modeling biochemical systems at a boolean abstraction level,

a simple simulator,

a powerful query language based on temporal logic CTL for querying the temporal properties of the model,

an interface to the NuSMV model checker for evaluating CTL queries.

An experimental interface to LOTOS has been developed in collaboration with the VASY project-team.
A repository of computational models of biological systems called CMBSlib
aimed at comparing models as well as formalisms,
is currently under construction in collaboration with our partners of the

This is a C

list(A)), subtyping (e.g. list(A) $<$term) and overloading (e.g.

Now that the theory of LCC languages in Linear Logic is well established,
we have started the development of a first implementation of this paradigm. The system named
Silcc (pronounce ``silk'', meaning ``Silcc Is LCC'') is a complete implementation of LCC
based on GNU-Prolog native code compiling technology.
Silcc is an extensible and modular constraint programming system
which is based on a small kernel language, called LCC(K)

imperative features unified with constraints,

powerful synchronization primitives,

capability of defining new constraint systems,

accompanying verification tools.

While a program-structuring feature is required for a production programming
language, the current proposals for the inclusion of modules in the ISO Prolog
standard are not very consensual. We have thus investigated an alternative
solution based on Contextual Logic Programming (CxLP). Informally, the main
point of CxLP is that programs are structured as sets of predicates
(units) which can be dynamically combined in an execution attribute
called a context. Goals are seen just as in regular Prolog, except
for the fact that the matching predicates are to be located in all the units
which make up the current context. We extended CxLP to attach
arguments to units: these serve the dual purpose of acting as
``unit-global'' variables and as state placeholders in actual contexts. CxLP
clearly carries a higher overhead than regular Prolog, as the context must be
searched at run-time for the unit that defines a goal's predicate, a process
which requires at least one extra indirection compared to straight Prolog;
this kind of situation has become more usual and less of a performance issue
in recent systems, in Object-Oriented and even in procedural languages, for
instance as a result of using dynamically-loaded shared libraries. We have
built a prototype implementation of a Contextual Logic Programming language
inside GNU-Prolog

We have shown the decidability and NP-completeness of the
satisfiability problem for non-structural subtyping constraints in
quasi-lattices

These results directly apply to our system TCLP for type inferencing
in constraint logic programming

We have designed a new global constraint for cutset problems.
A cutset in a directed graph

We have re-implemented the Adaptive Search method as a C-based framework
library

This adaptive search method has been combined with genetic algorithms
in a multi-user system, developed in collaboration with the
Fractale/Complex team, for assigning offices to project-teams at
INRIA Rocquencourt. In this experimental system, sets of solutions
satisfying preference constraints are computed by adaptive search, and
the preferences of users are learned by genetic algorithms through
their notation of the solutions proposed by the system

Symmetries in constraint satisfaction problems are an important issue.
They may lead to a lot of redundant computations and dramatically
increase the size of the search space (for example simple instances of the
Balanced Incomplete Block Design problem have more than 10

Debugging tools are essential to help tune constraint solving programs
and each platform has its own environment tools. However, at present,
these tools are specific and have to be redesigned and re-implemented
for each constraint solver whereas much could be factorized. We
propose a generic framework to enable debugging tools to be defined
almost independently from finite domain solvers, and conversely,
tracers to be built independently from these tools. We have designed a generic trace schema based on a generic observational
semantics which formalizes relevant aspects of constraint
programming and solving. We have developed Codeine, a tracer for the
GNU-Prolog platform, that implements this schema

Using generic trace format allows us to develop solvers and debugging tools independently.
It is a way to incentivate the creation of new and more powerful debugging tools.
To validate this approach we experimented several combinations of new debugging tools
(from the OADymPPaC project partners) with some
solvers, especially GNU-Prolog and PaLM which handle
constraint propagation in different ways

We have investigated a constraint programming approach to a 3D placement problem (placing hardware in an office)
combined with virtual reality tools for the visualization of the problem and complex interactions.
The idea is to explore the concept of constraint programming as a paradigm of augmented virtual reality.
The user interacts with the placement system through a representation of the scene
in virtual reality, augmented with a representation of distance constraints

In

The biochemical abstract machine BIOCHAM 0.2 is based on these concepts

Collaboration within the RNTL project

Technology transfer of the generic trace format for the CHIP product.

Technology transfer of the CLPGUI software for the dynamic visualization of CHIP program execution.

Collaboration within the RNTL pre-competitive project Manifico (Feb. 2003 - Feb. 2006, 150 Keuros) on non intrusive metacompilation of matching with constraints in rule based languages

Collaboration within the RNTL project

RNTL project MANIFICO (Sep. 2003-2006) on the compilation of rules and constraints. with LORIA PROTHEO and ILOG coord.

INRIA cooperative research initiative

ARC CPBIO (2002-2004) on ``Process Calculi and Molecular Networks Biology'', with LORIA MODBIO, CNRS PPS lab. of University Paris 7 and Genoscope Evry, coord. F. Fages INRIA Rocquencourt.RNTL project

OADymPPaC (Nov. 2000 - May 2004) ``Tools for Dynamic Analysis and Debugging of Constraint Programs'' with IRISA LANDES/INSA, INRIA-Futurs, Ecole des Mines de Nantes, University of Orléans, COSYTEC and ILOG, coord. P. Deransart INRIA Rocquencourt.

6th PCRD STREP

APRIL II ``Applications of probabilistic inductive logic programming'', coord. Prof. L. de Raedt, University of Freiburg.6th PCRD Network of Excellence REWERSE ``Reasoning with rules and semantics'', coord. Prof. F. Bry, Ludwig Maximillian's University in Munich.

5th PCRD Network of Excellence

COLOGNET ``Computational logic network'', area of constraint logic programming coord. F. Rossi, University of Padova.ERCIM working group on

Constraints , coord. F. Fages, INRIA Rocquencourt.

Prof. Stephen Muggleton from the Computational Bioinformatics Group at Imperial College in London, visited our group in August.

Contraintes is affiliated to the Doctoral school EDITE of the University of Paris 6.

All Ph.D. students and some members of Contraintes teach in the first or second cycles of Universities or Engineering schools. Our involvement in third cycle cursus is the following:

DEA SPL ``Sémantique, Preuve et Langages'', ENS, X, University Paris 6, 7, 11: course ofprogrammation par contraintes , François Fages 10h, Sylvain Soliman 10h.DEA IARFA, University Paris 6: Philippe Codognet 20h.

DEA Informatique, University of Orléans: François Fages 3h.

DESS Informatique, University Paris Sorbonne: Daniel Diaz 30h.

Ecole Jeunes Chercheurs en Programmation , course ofprogrammation par contraintes , François Fages 6h.

Pierre Deransart is the General Secretary, past Chairman, of the ``Association Française pour la Programmation en Logique et la programmation par Contraintes''

AFPLC , and member of the Steering Committee ofPPDP . He is in charge of international relationships of INRIA with Brazil and Portugal. He is the manager of the OADymPPaC project.François Fages is the Chairman of the ERCIM Working Group on

Constraints , the Chairman of the ``Association Française pour la Programmation en Logique et la programmation par Contraintes''AFPLC , a member past-Chairman of the Steering Committee of the ACM International Conference on Principles and Practice of Declarative Programming,PPDP , and a member of the Scientific Council of the French-RussianLiapunov Institute .Sylvain Soliman is the Secretary of the ERCIM Working Group on

Constraints .