Constraint Logic Programming supports a great ambition for programming: the one of making of programming essentially a modeling task, with equations, constraints and logical formulas.

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 for solving combinatorial
optimization problems in industry or commerce are related to the bringing of new local consistency techniques and of
*declarative languages*which allow control on the mixing of heterogeneous resolution techniques: numerical, symbolic, deductive and heuristic.

The "Contraintes" group investigates the logical foundations, design, implementation, programming environments and applications of constraint programming languages. 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 problems and computational system biology. In bioinformatics, our objective is not to work on structural biology problems, which has been the main trend up to now, but to attack the great challenge of systems biology, namely to model the function, activity and interaction of molecular systems in living cells, with logic programming concepts and program verification technologies.

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 = logical 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;

temporal constraints: CTL and LTL formulae, either propositional or with numerical constraints.

The project works on constraint resolution methods and their cooperation. The main focus is the declarativeness of the constraint solver (e.g. implemented by CHR rules), the efficiency of constraint propagation methods, the design of global constraints and the combination of constraint propagation with local search methods.

Systems biology is a cross-disciplinary domain involving biology, computer science, logics, mathematics, and physics to elucidate the high-level functions of the cell from their biochemical bases at the molecular level.

At the end of the Nineties, research in Bioinformatics evolved, passing from the analysis of the genomic sequence to the analysis of post-genomic interaction networks (expression of RNA and proteins, protein-protein interactions, etc). The complexity of these networks requires a large research effort to develop symbolic notation and analysis tools for biological processes and data. In order to scale-up, and get over the complexity walls to reason about biological systems, there is a general feeling that beyond providing tools to biologists, computer science has much to offer in terms of concepts and methods.

We are interested in the modeling and analysis of complex molecular processes in the cell, at different levels of abstraction, qualitative and quantitative. The most original aspect of our research can be summarized by the following identifications:

*biological model = transition system,*

*biological property = temporal logic formula,*

*biological validation = model-checking.*

Our main research axis is thus the application of logic programming concepts and circuit or program verification techniques to the analysis of complex biochemical processes in the cell.

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

resource allocation;

placement;

scheduling;

planing;

transport;

etc.

The last forty years have brought many improvements in Operations Research resolution techniques. In this context, Constraint Programming can be seen as providing, on the one hand, local consistency 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 the cooperation of global resolution, local consistency techniques and search methods.

The project builds upon its knowledge of CC languages, constraint solvers and their implementation to work in these directions. The LCC paradigm offers at the same time a theoretical framework for analysis, and a valuable guide for practical language design and implementation. The work on programming environments helps to integrate the Constraint Programming tools into this application domain.

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

to identify in the family of competitive models coming from the Theory of Concurrency

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.

This work lead us to the design and implementation of the Biochemical Abstract Machine BIOCHAM that has the unique feature of providing formal languages corresponding to different qualitative and quantitative levels of abstraction, for, on the one hand, modeling biomolecular interaction diagrams with reaction rules, and on the other hand, modeling the biological properties of the system in temporal logic. This double formalization of both the model and the biological properties of the system at hand opens several new research avenues on the design and systematic validation of biological models.

We participate in two European Projects of the 6th PCRD. First the STREP APrIL IIwhere the main objective is to apply probabilistic inductive logic programming techniques to bioinformatics applications. Our main focus is on the regulatory and metabolic networks in the cell, and the semi-automatic completion or revision of models from observed temporal properties of the system . Second, the Network of Excellence REWERSE, in which we focus, among other themes, on bioinformatics as a field of application of the new Semantic Web technologies based on rules and constraints. In this context we intend to use the biological knowledge stored in online ontologies like GOin order to improve the re-use and composition of models, as well as the semi-automatic correction/completion of models. In this respect, we developped type inference and abstract interpretation techniques to extract information from reaction models .

We coordinate the ARC MOCA(2006-2008) on ``MOdularity, Compositionality and Abstraction in gene and protein networks'', and collaborate in this framework with Denis Thieffry, Claudine Chaouyia, Univ. Marseille, Anne Siegel and Ovidiu Radulescu, IRISA SYMBIOSE and IHES, Ralf Blossey IRI and Vincent Danos CNRS Paris, on the exploration of different techniques and methods allowing semi-automatic composition, decomposition, simplification and refinement of biological models. More precisely, we study the formal links between logical and numerical models of some parts of the cell cycle and the decomposition in modules based on control theory intuitions.

This technology developed in the last years is now applied to new biological questions that we investigate in partnerships with biologists in two new projects. First, the EU STREP project TEMPO on ``temporal genomics for patient tailored chornotherapeutics'', coordinated by Francis Levi INSERM Villejuif, where, in partnership with Jean Clairambault of the BANG project-team, we develop in BIOCHAM coupled models of the cell cycle, the circadian cycle and the effect of cytotoxic drugs in cancer therapies. Second, the INRA AgroBi project, coordinated by Eric Reiter INRA Tours, where, in partnership with Frédérique Clément of the SOSSO2 project-team, we develop in BIOCHAM models of FSH signaling networks in mammalian cells.

The Biochemical Abstract Machine BIOCHAMis a modeling and validation environment for molecular systems biology. BIOCHAM provides precise semantics to biomolecular interaction maps at three abstraction levels:

the boolean semantics of molecules presence and absence,

the continuous semantics of molecular concentrations,

the stochastic semantics of molecule populations.

Based on this formal framework, BIOCHAM offers:

a compositional rule-based language for modeling biochemical systems, allowing patterns and kinetic expressions when numerical data are available;

numerical and boolean simulators;

a temporal logic language (CTL for qualitative models and LTL with numerical constraints for quantitative models) for formalizing biological properties such as reachability, checkpoints, oscillations or stability, and checking them automatically with model-checking techniques;

automatic search procedures to infer interaction rules and parameter values from known temporal properties of the system.

BIOCHAM is fully implemented in GNU-Prolog and interfaced to the state-of-the-art symbolic model checker NuSMVfor evaluating boolean CTL queries in large models over several hundreds of variables. BIOCHAM models can be imported from, and exported to, the standard Systems Biology Markup Language SBML.

TCLPis a
prescriptive type system for Constraint Logic Programming, currently: ISO-Prolog, GNU-Prolog, SICStus Prolog and the constraint programming libraries of SICStus Prolog. TCLP can also type check
constraint solvers written in the
*Constraint Handling Rules*(CHR) language.

The flexibility of the TCLP type system is obtained by the combination of three kinds of polymorphism: parametric polymorphism (e.g.
*list(A)*), subtyping (e.g.
*list(A)
<term*) and overloading (e.g.
*-:num
*num
num*and
*-:A
*B
pair(A,B)*). No type declaration are required, thanks to a type inference algorithm for predicates and to a default
*term*type for function symbols.

GNU Prologis a free Prolog compiler with constraint solving over finite domains developed by Daniel Diaz. GNU Prolog accepts Prolog extended with primitives for constraint programming and produces native binaries (like gcc does from a C source). The Prolog part conforms to the ISO standard for Prolog with many practical extensions (global variables, OS interface, sockets,...). GNU Prolog also includes an efficient constraint solver over Finite Domains (FD), giving the user the combined power of constraint programming and the declarativity of logic programming.

An experimental version, called GNU-Prolog-RH, is developed as an extension introducing concurrency, attributed variables, and constraint solving over the reals. This version greatly extends the expressive and modeling power of GNU-Prolog. It is also used to prototype the design and implementation of our new SiLCC language.

CLPGUIis a generic graphical user interface written in Java for constraint logic programming. It is available for GNU-Prolog and SICStus Prolog. CLPGUI has been developed both for teaching purposes and for debugging complex programs. The graphical user interface is composed of several windows: one main console and several dynamic 2D and 3D viewers of the search tree and of finite domain variables. With CLPGUI it is possible to execute incrementally any goal, backtrack or recompute any state represented as a node in the search tree. The level of granularity of the search tree is defined by annotations in the CLP program.

Following the former OADymPPaC project, we have set up with J.-D Fekete a new open source project called Tra4CP(Traces for Constraint Programming). The main objective of this open project is to build a repository of constraint resolution traces and analysis tools.

The purpose is to pursue dissemination the results of the former OADymPPaCproject, to facilitate contacts and working exchanges between researchers in the field of complex problem solving using constraint programming, and mainly to promote new analysis methods. Following this idea, the project allowed to integrate recent developments related to the use of the generic trace format Gentra4CP for constraint programming to produce trace analysis based on music (work of Jeremie Vautard Tra4CP). The creation of a working group on constraint problem XML repsesentation and its integration in the Gentra4CP is also considered.

We are developing SiLCC an imperative and concurrent constraint programming language based on a single paradigm: the one of Vijay Saraswat's concurrent constraint programming extended with constraint systems based on Jean-Yves Girard's Linear Logic. In the late 90's we developed the theory of this extension and we have now begun its implementation.

From a constraint programming point of view, the unique combination of constraint programming with imperative features opens many new possibilities, among which:

the capability of programming constraint solvers in the language, making them extensible by the user,

making a fully bootstrapped implementation of a constraint programming language (for the first time since Prolog)

combining constraint reasoning with state change;

proving program correctness using Linear Logic.

Our current implementation of SiLCC uses GNU-Prolog-RHas temporary kernel language, on top of which a module system and the first bootstrapping libraries have been developed. The objective is to define a small kernel language as an instance of LCC over a simple constraint domain of labelled graphs, on top of which the complete SiLCC language will be built by bootstrapping. Bootstrapping is a fundamental step for getting over the current limits of today constraint programming tools, concerning their extensibility, robustness, and teaching. The main step realized this year has been the definition of the module system.

Module systems are an essential feature of programming languages as they facilitate the re-use of existing code and the development of general purpose libraries. However, there has been no
consensual module system for Prolog, hence no strong development of libraries, in sharp contrast to what exists in Java for instance. One difficulty comes from the
*call*predicate which interferes with the protection of the code, an essential task of a module system. In
, by distinguishing the called module code
protection from the calling module code protection, we have reviewed the existing syntactic module systems for Prolog and shown that no module system ensures both forms of code protection, with
the noticeable exceptions of Ciao-Prolog and XSB. We presented a formal module system for logic programs with calls and closures, defined its operational semantics and formally proved the code
protection property. Interestingly, we also provided an equivalent logical semantics of modular logic programs without calls nor closures, which shows how they can be translated into constraint
logic programs over a simple module constraint system.

The module system of SiLCC goes however beyond the one we propose for Prolog-like languages. There are indeed two somewhat contradictory ways of looking at modules in a given programming language. On the one hand, module systems are largely independent of the particulars of programming languages, and several examples of module systems have indeed been adapted to different programming languages. On the other hand, the module constructs often interfere with the programming constructs, and may be redundant with other scope mechanisms of programming languages, such as closures for instance. There is therefore a need to unify the programming concepts and constructs that are similar, and retain a minimum number of essential constructs to avoid arbitrary programming choices. In we realize this aim in the framework of linear logic concurrent constraint programming (LCC) languages. We first show how declarations and closures can be internalized as agents in LCC. We then present a modular version of LCC (MLCC), where modules are referenced by variables and where implementation hiding is obtained with the usual hiding operator for variables. We develop the logical semantics of MLCC in linear logic, and show the completeness of the operational semantics for the observation of successes and accessible stores.

The
*Constraint Handling Rules*(CHR) are an untyped rewrite rule language, initially designed for implementing constraint solvers. In order to benefit from type programming for the development
of larger programs, we have designed a generic type system for CHR
. CHR being a high-level extension of a host
language, such as Prolog or Java, the type system is parameterized by the type system of the host language. The consistency of the type system has been shown for the operational semantics of
CHR, as well as for the extended execution model CLP+CHR, for the case where the host language is a constraint logic programming language. This type system has been implemented as an extension
of our type checker TCLP which is itself implemented in CLP+CHR. It has been successfully evaluated on twelve CHR solvers and programs, including TCLP itself.

In the framework of computational systems biology, and in particular for the BIOCHAM modeling environment, we developed type inference and abstract interpretation techniques to either type check reaction models or infer types from reaction models . In this approach the types can represent various information such as the categories of proteins (kinase, phosphtase, etc.) the function of the proteins (activations and inhibitions) or the topology of compartments for instance.

Semantics based debugging, static and dynamic typing, and more generally validation of CC programs are also studied in the project.

We started to study theoretical questions issued from the former OADymPPaC project (RNTL ended in 2004) by trying to clarify the notions of trace exchanged between observed and observing processees and their semantics called "observational semantics". We wanted also to better formalize the interactions between these processes in order to be able to optimize their communications in particular by formalizing the introduction of Tracer Driver and Analyser Manager respectively added to the oberserved and observing processes. Finally the question of extending the domain of application of the approach to other domains than constraints solvers is considered by introducing the concept of "generic obervational semantics" and "generic trace scheme".

This work is the continuation of the work started with Mireille Ducassé and Ludovic langevine on these topics during the OADymPPaC project. First developments have been published in .

Global constraints provide a way to introduce redundant constraints from which tighter propagation mechanisms may be infered, for instance by re-using a wide area of algorithms from graph theory. In , we describe a global constraint and a filtering algorithm for a pure graph property : computing cutsets in a graph (i.e. sets of vertices to remove to make the graph acyclic). This global constraint is compared to mixed integer programming and applied to a reconciliation problem in nomadic applications, originating from a previous study we did with Microsoft Research Cambridge.

In collaboration with TOTAL, we study an optimization problem of crude oil blending in refineries. The problem is to find a plan of transfer and mixing of crude oil, from the boats to the distillation units through storage and mixing tanks, under various constraints of product concentrations, continuous distillation, schedule, and optimization criteria. This NP-hard problem is the combination of a planning problem (for choosing the transfer tasks and quantities) with a scheduling problem.

Previous approaches based on Mixed-Integer Linear Programming (MILP) rely on a discretization of time that may give infeasible or suboptimal solutions. On the other hand, a constraint programming approach is appealing for its capability to treat efficiently the scheduling part of the problem without time discretization, We have developed such a solution with ILOG tools, by introducing a global constraint of scheduling with concentration constraints, and using heuristics for the planning part of the problem. A filtering algorithm for this global constraint is currently developed as a generalization of the multi-resource cumulative constraint.

Because of the importance of the heuristics part on real-size data, we have also considered a constraint-based local search method for this problem . For this study we used the Comet system of Van Hentenryck developed at Brown University, and a collaboration with Pascal Van Hentenryck is planned on this difficult problem.

Similar methods are also investigated in collaboration with Evelyne Lutton (COMPLEX Team) for multi-user distributed resource allocation problems and for the implementation of the CONSENSUS system.

BIOCHAM(the BIOCHemical Abstract Machine) is a software environment for modeling biochemical systems , . It is based on two aspects: (1) the analysis and simulation of boolean, differential and stochastic reaction models and (2) the formalization of biological properties in temporal logic. BIOCHAM provides tools and languages for describing protein networks with a straightforward syntax, and for integrating biological properties into the model. It then becomes possible to analyze, query, verify, and maintain the model w.r.t. those properties. For kinetic models, BIOCHAM can search for appropriate parameter values in order to reproduce a specific behavior observed in experiments and formalized in temporal logic. Coupled with other methods such as bifurcation diagrams, this search assists the modeler/biologist in the modeling process.

In the differential semantics, the time series obtained from numerical integration allows us to use model-checking techniques for LTL queries with numerical constraints . A model-checker incorporated in BIOCHAM and implemented in GNU-Prolog, enables the automatic verification of quantifier free first-order LTL formulae (about concentrations and their derivatives) but also of some specific quantified first-order formulae, such as periods of oscillations for instance .

Current work involves:

using this model-checking features for learning parameter values, as explained in section ;

identifying precisely which fragment of first-order LTL is wanted;

formalizing, as an abstraction, the relationship between the continuous and boolean semantics;

defining more precisely the relationship with the stochastic semantics;

using bifurcation theory to gain information about possible parameter values for certain behaviors of the system, and elucidating how to connect LTL with ``types of bifurcations''.

The formalization of biomolecular interactions in BIOCHAM syntax, and the specification of the observed behavior of the system in temporal logic (CTL or LTL) make it possible to develop machine learning algorithms to automatically correct or complete existing models. It is worth noting that structural learning of reaction rules from temporal logic properties is quite new, both from the machine learning perspective and from the systems biology perspective.

In the framework of the APrIL II STREP, we first applied state-of-the-art inductive logic programming tools to simple reachability properties. The objective was to complete a boolean BIOCHAM
model to satisfy a CTL specification. We developed a more powerful search algorithm for learning new reaction rules from general temporal logic properties. This algorithm evolved into a theory
revision algorithm, taking into account that ACTL and ECTL formulae (i.e. those where the only path operator is respectively
Aand
E) can guide the search for the addition or deletion of rules. In the quantitative case, the same strategy can be applied to learn kinetic parameter values. Once the
biological properties of a system under various initial conditions, are described both qualitatively and quantitatively with LTL formulae and constraints, an enumerative algorithm can be
applied to estimate parameter values by model-checking
. This provides an interesting tool to the
biologist/modeler who has to proceed in part by trial and error.

These algorithms are currently improved in BIOCHAM by applying various optimizations, such as :

compressing the simulation trace used by the LTL model checker with constraints for searching parameter values;

using the type information contained in reaction models to restrict the search for reaction rules to add to a model;

improving the data structures of BIOCHAM code, in the spirit of its migration from Prolog to SiLCC;

exploring inductive logic programming techniques, through a translation of Biocham models to Prolog and Stochastic Logic Programs code.

Recent advances in cancer chronotherapy techniques support the evidence that there exist some links between the cell and the circadian cycles. Both cycles have been successfully modeled, however, as of today, there are no precise models describing the coupling of the two cycles. One purpose of a coupled model is to better understand how to efficiently target malignant cells depending on the phase of the day. This is at the heart of our participation in the EU STREP project TEMPO.

The BIOCHAM feature for learning parameter values under period constraints was introduced for this study. This allowed us to compute the domain of entrainment of the cell cycle by the circadian cycle. This domain mainly depends on the strength of the WEE1 kinase, regulated by circadian genes, on the activity of MPF. We now intend to incorporate other links, based on evidence from the literature: through the protein c-MYC for instance; and to make the generic cell cycle model more complete in order to see the effect of these other links.

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

Collaboration with TOTAL on a constraint programming approach to the optimization of crude oil blending and the Thesis of Aurélie Strobbe under a CIFRE contract.

INRA project AgroBi (2006-2010) on the modeling of FSH signaling, coordinated by Eric Reiter, INRA Tours;

ARC MOCA (2006-2007) MOdularité, Compositionalité et Abstraction dans les réseaux géniques et protéiques, coordinated by Sylvain Soliman;

ACI IMPbio VICANNE (2004-2007) Modélisation dynamique et simulation des systèmes biologiques;

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

CIFRE thesis and industrial contract with TOTAL (July 2004- July 2007) on the optimization of petroleum processes by constraint programming.

6th PCRD STREP Net-WMS (2006-2010) on constraint optimization in Wharehouse Management Systems, ERCIM coord, F. Fages scientific coordinator, Ecole des Mines de Nantes, SICS, KLS optim, CEA, mindbiz, Widescope, PSA, Fiat;

6th PCRD STREP TEMPO (2006-2010) on temporal genomics for tailored chronotherapeutics, coordinated by Francis Lévi at INSERM Villejuif;

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;

ERCIM Working Group on Constraints, coord. F. Fages, INRIA Rocquencourt.

Have been invited for short visits :

Stephanie Spranger, Ludwig Maximilian University, Munich, Germany,

Bela Novak, Univ. Budapest, Hungary,

Jacques Robin, Universidade Federal de Pernambuco, Brazil,

Khalil Djelloul, University of Ulm, Germany.

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

Several Ph.D. students and members of Contraintes teach in the first cycles of Universities or Engineering schools. Our involvement in Master courses is the following:

24h Course on
*Constraint Programming*, Master Parisien de Recherche en Informatique (MPRI) by Sylvain Soliman (12h) and François Fages (6h).

48h Course on
*Computational Systems Biology*, Master Parisien de Recherche en Informatique (MPRI) by François Fages (15h) and Sriram Krishnamachari (3h).

Pierre Deransart is the General Secretary, past Chairman, of the ``Association Française pour la Programmation par Contraintes'' AFPC.

He is "Brazil Correspondent" in the DREI (INRIA international Direction) and organized several INRIA activities related to INRIA-Brazil scientific cooperation.

François Fages is member of the Editorial Board of RAIRO Operations Research, the Chairman of the ERCIM Working Group on Constraints, vice-Chairman, past Chairman of the ``Association Française pour la Programmation par Contraintes'' AFPC, member of the Scientific Councils of the Epigenomics project of the Genopole of Evry, and of the French-Russian Liapunov Institute.

Sylvain Soliman is the Secretary of the ERCIM Working Group on Constraints.