## Section: Scientific Foundations

### Rule-based Modeling Languages

Logic programming in a broad sense is a declarative programming paradigm based on mathematical logic with the following identifications:

*program = logical formula,*

*execution = proof search,*

In Constraint Satisfaction Problems (CSP), the logical formulae are conjunctions of constraints (i.e. relations on variables expressing partial information) and the satisfiability proofs are computed by constraint solving procedures.

In Constraint Logic Programming (CLP), the logical formulae are Horn clauses with constraints (i.e. one headed rules for the inductive definitions of relations on variables) and the satisfiability proofs combine constraint solving and clause resolution. Gnu-Prolog and its modular extension EMoP that we develop, belong to this family of languages. We use them for solving combinatorial problems and for implementing Biocham.

In Concurrent Constraint Programming (CCP), CLP resolution is extended with a synchronization mechanism based on constraint entailment. The variables play the role of transmissible dynamically created communication channels. An agent may add constraints to the store or read the store to decide whether a constraint guard is entailed by the current store. Sicstus-Prolog and SWI-Prolog belong the this family of languages. We use them for solving combinatorial optimization problems and defining new global constraints.

CCP execution can be identified to deduction in J.Y. Girard's Linear Logic
by interpreting multisets of constraints and agents as tensor product conjunctions
and guards and rules as linear implications (F. Fages, P. Ruet, S. Soliman. *Linear concurrent constraint programming: operational and phase semantics*, in “Information and Control”, 2001, vol. 165(1), pp.14-41.).
The logical completeness of CCP in LL
continues to hold when considering linear logic constraint systems, i.e. constraint systems
where constraints can be consumed by implication. This extension, named
Linear Logic Concurrent Constraint Programming (LLCC), allows
for a non-monotonic evolution of the store of constraints
and can encode multi-headed rules like the Constraint Handling Rules (CHR) language
of T. Frühwirth.

All these rule-based languages, of increasing expressivity, involve some form of *multiset rewriting*.
We have designed and continue developing the following modeling languages:

Rules2CP , a rule-based modeling language for solving constraint optimization problems, developed for non-programmers,

the Biochemical Abstract Machine BIOCHAM , a rule-based modeling language dedicated to Systems Biology, in which biochemical reactions between multisets of reactants and products are expressed with multi-headed rules (somewhat similar to CHR rules) and augmented with

*kinetic expressions*from which one can derive quantitative interpretations by Ordinary Differential Equations (ODE), Continuous-Time Markov Chains (CTMC) or Hybrid Automata.