## Project-Team : modbio

## Section: Scientific Foundations

## Constraint programming

Constraint programming [50] is a declarative programming language paradigm
that appeared in the late 80's, and which has become more and more popular since then.
A *constraint* is a logical formula that
defines a relation to be satisfied by the values of the
variables the formula contains. For instance, the formula x + y1 expresses
that the sum of the values of the variables x and y must be less than
or equal to 1.

In *constraint programming*, the user programs with constraints,
i.e., he or she describes a problem by a set of constraints,
which are connected by *combinators* such as conjunction,
disjunction, or temporal operators (`always`).
Each constraint gives some *partial* information about the state of
the system to be studied. Constraint programming systems allow one to
deduce new constraints from the given ones and to compute
*solutions*, i.e., values for the variables that satisfy all
constraints simultaneously.

One of the main goals of constraint programming is to develop programming languages that allow one to express constraint problems in a natural way, and to solve them efficiently.

### Finite domain constraint programming

In our work, we are first interested in constraint problems over
finite domains. In this case, the domain of each variable (the set of values it may
take) is a finite set of integer numbers. Theory tells us that
most constraint problems over finite domains are NP-hard, which
means that there is little hope to solve them by algorithms polynomial
in the size of the input. In practice, these problems are handled
by tree search methods which try successively different
valuations of the variables until a solution is found. Because of the
exponential number of possible combinations, it is crucial to reduce
the search space as much as possible, i.e., to eliminate *a priori*
as many valuations as possible.

There exist two generic methods to solve such problems. The first one is
classical *integer linear programming* (see also Sect.
3.3),
which has been studied in mathematical programming and operations research for
more than 40 years. Here, constraints are linear equations and inequalities
over the integer numbers. In order to reduce the search space, one typically uses
the linear relaxation of the constraint set. Equations and
inequalities are first solved over the real numbers, which is much easier;
then the information obtained is used to prune the search tree.

The second method is *finite domain constraint programming* which
arose in the last 15 years by combining ideas from declarative
programming languages and constraint satisfaction techniques in
artificial intelligence. In contrast to integer linear optimization one
uses, in addition to simple arithmetic constraints, more complex
constraints, which are called *symbolic constraints*. For
instance, the symbolic constraint
alldifferent(x_{1}, ..., x_{n}) expresses that the values of
the variables x_{1}, ..., x_{n} must be pairwise distinct. Such a
constraint is difficult to express in a compact way using only linear
equations and inequalities. Symbolic constraints are handled
individually by specific filtering algorithms that reduce the domain
of the variables. This information is propagated to other constraints
which may further reduce the domains.

A state-of-the-art survey of finite domain constraint programming, with special emphasis on its relation to integer linear programming can be found in [12], see also Sect. 6.9.

### Concurrent constraint programming

In *concurrent* constraint programming (cc) [44], different
computation processes may run concurrently. Interaction is
possible via the *constraint store*. The store contains all the
constraints currently known about the system. A process may
*tell* the store a new constraint, or *ask* the store
whether some constraint is entailed by the information currently
available, in which case further action is taken.

*Hybrid* concurrent constraint programming
(`Hybrid cc`) [38] is an extension
of concurrent constraint programming which allows one to model and to
simulate the temporal evolution of *hybrid systems*, i.e.,
systems that exhibit both discrete and continuous state
changes. Constraints in `Hybrid cc` may be
both algebraic and differential equations. State changes can be
specified using the combinators of concurrent constraint programming
and default logic.
`Hybrid cc` is well-suited to model dynamic biological systems, as shown
in [4].