A Stochastic Concurrent Constraint Based Framework to Model and Verify Biological Systems

Concurrent process calculi are powerful formalisms for modelling concurrent systems. The mathematical style underlying process calculi allow to both model and verify properties of a system, thus providing a concrete design methodology for complex systems. ntcc , a constraints-based calculus for modeling temporal non-deterministic and asynchronous behaviour of processes has been proposed recently. Process interactions in ntcc can be determined by partial information (i.e. constraints) accumulated in a global store. ntcc has also an associated temporal logic with a proof system that can be conveniently used to formally verify temporal properties of processes. We are interested in using ntcc to model the activity of genes in biological systems. In order to account for issues such as the basal rate of reactions or binding affinities of molecular components, we believe that stochastic features must be added to the calculus. In this paper we propose an extension of ntcc with various stochastic constructs. We describe the syntax and semantics of this extension together with the new temporal logic and proof system associated with it. We show the relevance of the added features by modelling a non trivial biological system: the gene expression mechanisms of the λ virus. We argue that this model is both more elaborate and compact than the stochastic π calculus model proposed recently for the same system.


Introduction
We are interested in using soft computing techniques for modelling complex systems such as those arising frequently in biology. From a broad perspective we view soft computing as those techniques pertaining to systems that can best be described as a collection of processes dealing with partial information. What "partial" means depends on the particular application. It can refer to being able to use partial knowledge of a state of affairs and to perform different kinds of guessing (bounded or unbounded non determinism, probabilistic choices, approximate answers). In this view, concurrency also belongs to this realm since it deals with partial information on the ordering of events. So does constraint programming which is based on the very idea of computing with predicates expressing different degrees of knowledge about variable values. Concurrent constraint (CC) process calculi [15] provides formal grounds to the integration of concurrency and constraints so that non trivial properties of concurrent systems can be expressed and proved. They are thus natural simulators to gain experience on different soft computing techniques.
We view biological phenomena at the molecular level as constructed from very complex interactions among a great number of concurrent processes acting at different biological scales.
Concurrent processes occurring in molecular biology exhibit a rich variety of synchronisation schemes, calling into play different degrees of precision (i.e. partial information) about temporal or chemical relations involving them. The complexity of biological phenomena poses a great challenge to any computational formalism. We think that a suitable CC process calculus should provide a convenient framework to get insights into the right models to cope with this challenge.
We thus borrow concepts and techniques from concurrent processes modelling to define suitable computational calculi and analyse their behaviour in real biological settings. What we gain from this low level approach is twofold. On the one hand, we are able to ground the development of simulation tools on a very precise formal foundation and by this means proposing coherent models of higher level biological structures and operations. On the other hand, our model can give us clues for constructing formal proofs of interesting properties of a given biological process.
Works modelling biological systems by means of process calculi have been proposed recently. Most of these works have been conducted using (extensions of) the π calculus ( [12], [4] ) and the Ambient calculus ( [1] , [8]). Calculi devised for specific biological systems have also been proposed. For instance, calculi for modeling membranes ( [7]), protein interaction ( [16]) and reversibility in bio-molecular processes ( [5]). We propose using a temporal non deterministic concurrent concurrent calculus (ntcc , see [11]) as a formal base to model timed gene activity processes in such a way that their biological properties can be formally proved. The novelty of our work is to be able to prove properties in those systems. Additionally, the notion of constraints allows us to model in a simpler way the behaviour of the genes (see section 4).
The ntcc calculus inherits ideas from the tcc model [14], a formalism for reactive concurrent constraint programming. In tcc time is conceptually divided into discrete intervals (or time-units). In a particular time interval, a deterministic ccp process receives a stimulus (i.e. a constraint) from the environment, it executes with this stimulus as the initial store, and when it reaches its resting point, it responds to the environment with the resulting store. Also the resting point determines a residual process, which is then executed in the next time interval.
The ntcc calculus is obtained from tcc by adding guarded-choice for modelling non-determinism and an unbounded but finite delay operator for asynchrony. Computation in ntcc progresses as in tcc, except for the non-determinism and asynchrony induced by the new constructs. The calculus allows for the specification of temporal properties, and for modelling and expressing constraints upon the environment both of which are useful in proving properties of timed systems.
However, ntcc does not provide stochastic constructs. These are fundamental to faithfully model aspects such as the effect of reactions on concentration of particular components, affinities or distances. We thus propose orthogonal extensions of ntcc to account for the stochastic behaviour of processes.
In this paper we are interested in showing how non trivial biological processes calling into action different forms of partial information can be modelled in ntcc extended with suitable stochastic constructs. We also investigate ways in which properties of a biological process can be formally proved. We are able to do this thanks to the logical nature of ntcc , which comes to the surface when we consider its relation with linear temporal logic: All the operators of ntcc correspond to temporal logic constructs. Since we extend ntcc , new linear temporal logic and proof system must also be provided. We propose both and use them to prove some properties of a gene regulation system called the lambda switch (see [3]). Our model using the stochastic extension is both simpler and more complete than the one recently proposed in [6].
The main contributions of this paper are: 1) to define an orthogonal extension adding stochastic constructs to ntcc , 2) to couple the extended calculus with a suitable temporal logic and proof system, 3) to show how the expressiveness of the extended ntcc model allows faithful and simple descriptions of complex systems of interacting biological processes, such as the lambda switch and 4) showing that by modelling a gene activities system in the extended stochastic ntcc one inherits a well defined logical inference system (also proposed here) that can be used to prove interesting temporal properties (or lack thereof) of the system.

NTCC Calculus
In concurrent constraint calculi such as ntcc , process interactions can be determined by partial information (i.e. constraints) accumulated in a global store. The particular type of constraints is not fixed but specified in a constraint system that is considered a parameter of the calculus.

Constraint System
A constraint represents a piece of partial information over a set of variables. For example, in constraint x > 3, the value of x is unknown but we can assert that it is greater than 3.
A constraint system provides a signature from which constraints can be constructed. It also provides an entailment relation (|=) over constraints where c 1 |= c 2 holds iff the information of c 2 can be inferred from c 1 . Formally, a constraint system is a tuple , ∆ where is a signature (i.e a set of constants, functions and predicate symbols) and ∆ is a consistent first-order theory over (i.e a set of sentences over having at least one model). Constraints can be viewed as first-order formulae over and c |= d holds if the implication c ⇒ d is valid in ∆ [11]. For practical reasons the entailment relation must be decidable. A constraint store is a a set of variables and a conjunction of formulae (i.e constrains) between them. It is used to share information between process and for synchronisation purposes. The store is monotonically refined by adding information using tell operations of the calculus. For example, tell(x < 2) adds constraint x < 2 to the store. Additionally, we can test if a constraint c can be entailed from the store by means of ask operations. For example, ask(x < 5) tests whether store |= x < 5. The ask operation blocks when neither store |= x < 5 nor store |= ¬(x < 5) holds.

ntcc Overview
ntcc [11] is a process calculus that extends tcc [14]. In both of them, processes share a common store of partial information [15]. Both ntcc and tcc have an explicit notion of (discrete) time. ntcc time is conceptually divided into discrete intervals (or time-units). In a particular time interval, a deterministic ccp process receives a stimulus (i.e. a constraint) from the environment, it executes with this stimulus as the initial store, and when it reaches its resting point, it responds to the environment with the resulting store. Also the resting point determines a residual process, which is then executed in the next time interval.
ntcc has been successfully used to model many real life system such as reactive system, robot behaviour [10] and music composition [11]. Unlike tcc, ntcc includes constructs for modeling nondeterminism and asynchrony. A very important benefit of being able to specify nondeterministic and asynchronous behaviour arises when modelling the interaction among several components running in parallel, in which one component is part of the environment of the others. This is frequent in biological settings. These systems often need non-determinism and asynchrony to be modelled faithfully.

Process Syntax
In this section we describe briefly the syntax of ntcc processes. See [11] for further details. ntcc provides the following constructors: • tell : adds new information to the constraints store. For example, the process P 1 def ≡ tell (c > 5) adds constraint c > 5 to the store.
• i∈1..n when c i do P i chooses non-deterministically a process P i whose guard c i is entailed by the store. For example, process P 2 def ≡ when (c < 3) do tell (d = 5)+when (e > 5) do tell (d < 3) adds the information d = 5 when constraint c < 3 is entailed from the current store. On the other hand, if e > 5 is entailed, d < 3 is asserted. When both guards are entailed a non-deterministic choice is performed.
• Given two ntcc processes P and Q, process P ||Q represents the parallel composition between P and Q.
• local x in P behaves like P but the information of the variable x is local to P , i.e. P cannot see information about a global variable x and processes which are not part of P cannot see the information generated by P about x.
• next P executes process P in the next time unit (unit-delay) • unless c next P executes P iff c cannot be entailed by the constraint store in the current time unit • !P executes P in all time units from the current one. It can be viewed as P ||next P ||next next P ||...
• P represents unbounded but finite delays, i.e P eventually will be executed. This process can be viewed as P + next P + next next P...next n P where n is a finite natural number.
The operators above lack of the ability to express stochastic behaviour that is quite common in biological systems. In section 3, we propose two new operations in the calculus allowing us to express stochastic interaction between processes.

Rules of internal reduction
In this section we show the operational semantics of ntcc by giving reduction rules for each process. These rules will help us to understand how ntcc processes interact with each other until they reach a resting point. Recall that when this state is reached, another time units is created with an empty constraint store and the residual process. For a complete description of ntcc semantics refer to [11]. Reduction rules are based on configurations. A configuration P, d is composed of a ntcc process P and a store d.
For tell processes we have: where skip is the empty process. This reaction says that a tell process adds information (a constraint) to the constraint store d.
In when c do P processes the rule is as follows: It means that a particular process P j is non-deterministically chosen for execution among all those whose guard (c i ) can be entailed from the current store d.
For parallel composition we have: It says that if P evolves to P , then the same transition will occur if we execute P in parallel with some process Q. Parallel composition is commutative. For unless c next P processes: The rule says that nothing is done when c is entailed by the store. Finally, the rule for star processes is: It means that process P will be run in the (undetermined) future.
The above rules define so-called internal transitions. In addition to these, ntcc defines an observable transition which is the one that goes from one time unit to the next. At the end of a time unit the resulting store can be observed by the environment. Then, processes contained in next constructs are scheduled for the next time unit. This includes those defined by unless processes whose guard cannot be entailed from the current store (see [11] for details).

Linear Temporal Logic in ntcc
ntcc can be used to verify properties over timed systems. It provides for this a linear temporal logic in which temporal properties over infinite sequences of constraints can be stated [11]. The syntax of this logic is as follows: · ∃ x represent the lineartemporal logic implication, negation and existential quantification, respectively [9]. These symbols should not be confused with their counterpart in the constraint system (i.e ⇒ , ¬ and ∃). Symbols • , and ♦ denote the temporal operators next, always and eventually.
The interpretation structures of formulae in this logic are infinite sequences of states [9]. In ntcc , states are replaced by constraints. Given the set C of constraints in the constraint system, let α ∈ C ∞ be an infinite sequence of constraint and α(i) the i − th element of α. We say that α ∈ C ∞ is a model of (or that it satisfies) In the last expression, d and α are x−variants of c and α , respectively, if they are the same except for the information about x.
In [11] a proof system is built on the top of this logic. Given a process P and a formula A, a proof of P |= A can be obtained by following a set of inference rules. Nevertheless, we are interested in proving properties with probabilistic statements such as "The concentration of component c will eventually become 0 with probability ρ".
In section 3.3 we provide an inference system to deal with such as properties.

Lambda Switch
In this section we give a brief description of a biological system called the λ switch that we model in section 4 using our proposed extension of ntcc . For additional details see [6] or [3]. Bacteriophage λ is a virus that infects the Escherichia coli bacterium. As we will see, this biological system exhibits cooperativity relationships and non-deterministic behavior. When the virus injects its genome into the bacteria, there are two states that the bacteria can reach: (1)lytic growth in which the virus produces new viruses and (2) lysogeny in which the viral genome is passed to new generations in a passive way. The switching between states is determined by processes in a region of the virus genome called the λ switch (see figure 1). In this switch there are two promoter regions called P RM and P R where production of rep and cro proteins, respectively, takes place. The lytic growth state is characterised by a high concentration of cro proteins whereas lysogeny is characterised by a high concentration of rep. Promoters are overlapped by three regions (binding sites) called OR1, OR2 and OR3. Region OR1 exhibits a high affinity for rep and a low affinity for cro. On the other hand, OR3 exhibits a high affinity for cro and a low affinity for rep.
In lysogeny, rep proteins usually bind OR1 and OR2. When OR1 is bound by rep, OR2 affinity for rep increases. This is a cooperation relation between bindings at different sites. On the other hand, OR3 and the promoter P RM are usually vacant but eventually bound by the polymerase RN AP . When this occurs, the transcription of the gene cI starts and new instances of rep proteins are produced. When OR1 is not vacant, binding of RN AP to P R is inhibited, stopping in this way the production of cro. Another cooperation relationship is present in the lambda switch: since P RM is a weak promoter, when OR2 is bound by rep, rep cooperates with RN AP and more frequent transcriptions of gene cI happen. It implies that more rep proteins are produced thus increasing the chance of maintaining the lysogeny state. Lysogeny state is maintained until an environmental signal turns the switch to the lytic growth. This process is called Induction and it occurs with very low probability. In this state the concentration of rep decreases dramatically and then RN AP has the chance to bind to OR1, that is now vacant most of the time. P R, a stronger promoter than P RM , starts the transcription of gene cro and thus new instances of cro are produced. Because OR3 has a high affinity for cro, it is bound by this protein avoiding RN AP bindings to P RM , inhibiting in this way production of rep proteins. This biological system has been successfully modelled in [6] by using the π calculus [13] with stochastic behaviour [12]. However, we believe that notions such as cooperation and the effect of distance (i.e reactions may occur depending on the distance between molecules) can be expressed in a more straightforward manner by using the notion of constraint. We also introduce some additional details that were left aside in the model in [6].

Introducing Stochastic Behaviour in ntcc
In this section we introduce two new operators in ntcc for modelling stochastic behaviour. We also propose an extension of the ntcc lineartemporal logic that can be used to prove properties involving probabilistic statements.

ρ P
Informally, this construct allows executing processes (i.e P ) according to a given probability ρ ∈ [0, 1]. For example, if we observe 100 timeunits generated from the process: ! ρ P , we will observe 100 × ρ times the execution of P .
The inclusion of this construct in the calculus can be orthogonally done by adding a probabilistic function Φ : R ∈ [0, 1] → Bool into the constraint systems. Φ is computed by generating pseudo-random numbers following a binomial distribution with probability ρ and 1 as number of events. If Φ(ρ) = 1 we say that the process will be executed, otherwise it will not. ρ P can be expressed in terms of the rest of the standard constructs of ntcc as follows: Notice that P will be activated only if Φ(ρ) = 1 as is described by rule RHOP : RHOP ρP, d → P, d if Φ(ρ) = 1 This construct will be useful to model events such as rates of gene transcription. For example, in the lambda switch, when RN AP binds P RM , one will observe the production of a new rep protein. Nevertheless, this transcription depends on the cooperativity relationship between RN AP and OR2. In this way, we will observe the increase of rep with some probability ρ 1 when there is no reps proteins binding OR2 and with some other probability ρ 2 otherwise, having ρ 2 > ρ 1 (see section 4.3 for further details).

( ρ )P Processes
Star processes are used to express eventually in ntcc . However, we should be able to differentiate between two processes that eventually occur with different probabilities. For example, the induction process in the lambda switch occurs eventually but with a very low probability, while bindings between rep and region OR3 are quite frequent in lysogeny. We propose the constructor ( ρ )P in which P eventually occurs with probability ρ. Operationally: It is easy to verify that this process can be viewed as a ρ P process: ( ρ )P def ≡ local x in tell (x = Φ(ρ))||when x = 1 do P and that commutativity holds, i.e., ( ρ )P ≡ (ρP )

Stochastic parameters in the linear-temporal logic
To prove properties such as "The concentration of rep will eventually become 0 with probability ρ" we change the structure of formulae by adding probabilities, i.e formulae will be tuples A , ρ where A is a formula in the ntcc lineal-temporal logic. The syntax is: Probability ρ should not be confused with some notion of degree of validity of the formula. This probability refers to the occurrence of events (time). For example, the formula c < 3, 0.5 expresses that with a probability of 0.5 constraint c < 3 will be asserted. The semantics of our new logic is as follows: where α(i) |= c , ρ is defined as: c 1 , ρ 1 |= c 2 , ρ 2 iff c 1 entails c 2 in the constraint system and ρ 2 ≤ ρ 1 .
Since formulae such as A • ⇒ B are not in the expected form A, ρ , we can express equivalences between linear-temporal implication and negation operators in our new logic and their counterpart in ntcc logic by using properties of probability theory:

Inference System
We extend the inference system proposed in [11] with inferences rules taking into account the new form of formulae and the probabilistic operators ρ P and ( ρ )P . The rules permit build a proof if some process P satisfies some formula A, ρ in the logic, i.e, if P A, ρ LT ELL : tell c c , 1.0 LP AR : i.e. the parallel execution of two process satisfies the conjunction of the formulae of each process.
LLOC : LN EXT : LCON S : LST AR : LSU M : The previous equation represents the inference rule for ρP processes. Since the probability ρ and the probability ρ 2 are independent, the probability of both occurrences is ρ × ρ 2 . Finally, the rule for the ( ρ )P process is: 4 Modeling the λ-Switch with the stochastic ntcc extension Recall that our objective is to use concurrent calculi to faithfully model biological systems. We test the appropriateness for this task by constructing a (somewhat) detailed model of the lambda-switch using the extended calculus defined above. We use process definition constructs of the form PROCESS(x) def ≡ P that do not formally belong to the calculus. These, however, can be easily defined in terms of the standard calculus constructs (see [11]).

REP and CRO Protein Control
In our model production of rep proteins is controlled by 3 extended calculus processes: (1) Induction, that reduces the concentration of rep thus switching the system to a lytic growth state, (2) a process supervising that the concentration of rep does not exceed a given threshold and (3) a process that increases the concentration of rep as a result of the expression of gene cI.
The induction process (see section 2.3), activated by environment signals that are at present little understood, causes a strong reduction of rep proteins and therefore switching to a lytic growth state. The occurrence probability for this process is very low. By using ( ρ )P processes we can model this fact as: Eventually, under the probability ρ ind , this process reduces the concentration of rep to 0 (see reset rep c in equation 19).
The following process avoids a negative feedback by controlling the concentration of rep proteins. This represents the situation in which there are so many rep proteins floating around that even OR3 will get bound to rep thus inhibiting gene cI expression. The process inhibits the production of rep when concentration reaches rep threshold .

Gene transcription
As mentioned before, P RM is a weaker promoter than P R . This means that production of rep takes more time than production of cro once RN AP binds to P RM (resp. P R ). Sometimes no rep protein is produced at all when the binding occurs, i.e RN AP falls off without transcribing gene cI.
We model the gene transcription at the P R promoter as follows: CROtrans def ≡ when pr bound do ρ crotrans (tell inc croc) (14) where predicate pr bound is true iff RN AP is binding P R . Constraint inc cro c causes a new (higher) value for concentration of cro proteins to be asserted in the next time unit ( see equation 19). Modeling gene transcription at P RM is more difficult because the probability of transcription may vary according to the presence or absence of rep at OR2 . When OR2 is bound by rep , the probability of gene cI transcription at P RM is higher and in consequence higher is also the probability of producing more reps. Equation 15 models gene transcription at P RM : CItrans(ρ high , ρ low ) def ≡ when ¬inhibitrep ∧ prm bound do local p in (when or2 bound rep do tell p = ρ high + when or2 bound cro ∨ or2 vacant do p = ρ low ) || p(tell inc repc) (15) where cooperativity is modelled by means a when c do P process that chooses between ρ high and ρ low in order to execute tell inc(rep c ) with the right probability. Notice that synchronisation is guaranteed by the use of constraints: process p (tell inc rep c ) blocks until the value of p is known.

Operator Regions
In what follows we model the behaviour of OR1, OR2 and OR3 binding sites. Since each operator has different affinities for rep and cro , ρ P type processes are needed. Additionally, we have to take in account cooperativity relationship between OR1 and OR2: OR2 increases its affinity for rep when OR1 is bound by rep . The following equations model the operator regions in the lambda switch: when repc > 0 do ρ or1rep (next tell (or1 rep bound ∧ dec repc)) + when croc > 0 do ρ or1cro (next tell (or1 cro bound ∧ dec croc)) + when or1 rep bound do 1.0−ρ or1rep (next tell (or1 unbound ∧ inc repc)) + when or1 cro bound do 1.0−ρ or1cro (next tell (or1 unbound ∧ inc croc)) (16) OR2 def ≡ local or2rep in when or2 unbound do when repc > 0 do ρ or2rep (next tell (or2 rep bound ∧ dec repc)) + when croc > 0 do ρ or2cro (next tell (or2 cro bound ∧ dec croc)) + when ¬or1 bound rep do tell (ρor2rep = ρor2rep low) + when or2 rep bound do 1.0−ρ or2rep (next tell (or2 unbound ∧ inc repc)) + when or2 cro bound do 1.0−ρ or2cro (next tell (or2 unbound ∧ inc croc)) (when or1 bound rep do tell (ρor2rep = ρor2rep high) (17) OR3 def ≡ when or3 unbound do when repc > 0 do ρ or3rep (next tell (or3 rep bound ∧ dec(repc)) + when croc > 0 do ρ or3cro (next tell (or3 cro bound ∧ dec(croc)) + when or1 rep bound do 1.0−ρ or3rep (next tell (or3 unbound ∧ inc(repc)) + when or1 cro bound do 1.0−ρ or3cro (next tell (or3 unbound ∧ inc(croc)) (18) where ρor1rep, ρor1cro, ρor2rep high, ρor2rep low, ρor3rep and ρor3cro are the probabilities (affinities) of each binding site w.r.t rep and cro. Constraints dec rep c and dec cro c will cause decrementing of the concentration of rep (resp. cro ) in the environment (see equation 19). In the above processes, when the operator is unbound (i.e vacant) and reps or cros are available in the environment, eventually the protein (i.e rep or cro) binds the operator and consequently also decreases the protein concentration in the environment. Finally, equation 19 controls the concentration of rep and cro for the next time unit according to signal controls (constraints) posted by pre-vious processes (e.g. inc rep c ): CONCCTR def ≡ (when reset repc do next tell repc = 0+ when inc repc ∧ ¬reset repc do next tell (repc = rep c + 1)+ when dec repc ∧ ¬reset repc do next tell (repc = rep c − 1))|| (when inc croc do next tell (croc = cro c + 1)+ when dec croc do next tell (croc = cro c − 1)) In previous equation, variables with prime symbol (e.g. cro c ) are used to denote the state of the variables in the previous time-unit. This is not part of the ntcc calculus syntax but it can be modeled by means of a process making "persistent"the state of the variables between two time-units . This process can be defined as follows [2]: where v i represents the value of the variable in the first time-unit and m i is the value of the variable m i in the previous time-unit.

RNAP binding
Equations 14 and 15 depend on bindings between RN AP and promoters P R and P RM , respectively. The behaviour of RN AP has two components: (1) when RN AP is binding P R (resp P RM ), there is a probability of 1.0−ρrnap pr (resp. 1.0−ρrnap prm) of falling off thus interrupting gene transcription. And (2) when promoters are unbound, RN AP may bind to P R (resp P RM ) if OR1 (resp. OR3) is vacant, with probability rnap pr (resp. rnap prm). Equation 21 models this fact: RNAPCTR def ≡ when rnap unbound do ( when or1 unbound do rnap pr (next tell (or1 rnap bound ∧ pr bound)) + when or3 unbound do rnap prm(next tell (or3 rnap bound ∧ prm bound)) +when rnap bound do ( + when or1 rnap bound do 1.0−rnap pr (next tell or1 unbound) + when or3 rnap bound do 1.0−rnap prm (next tell or3 unbound)) (21) Using parallel composition among equations 12 to 21 we can de-scribe the overall lambda-switch system as follows:

Simulating Biological Systems
The sections above showed how we can model a biological system by means of constructs in the ntcc calculus. This models come from a functional description of the system and they are easily mapped to process definition describing the expected behavior. In this way, models must be viewed as runnable specification since we can obtain the values of the variables in each time-unit representing in our case of study, changes in the concentration of proteins during the time.
To accomplish this task, we developed a simulator for our calculus. This was built in the top of the Oz system (www.mozart-oz.org), a multi-paradigm programming language including constraint-based libraries and support for concurrent programming. This simulator takes as input process definition such as those presented in above equation and returns the stores in each time-unit. The store contains the value of each variable obtaining in this way quantitative measures of the system. As example , we show the definition of INDUCTION process in figure  2. Constructs in the calculus are defined by means of Oz records. For example rep() represents replication (!) operator, rho(P ) stands for ρ P and IndRho is the probability of induction process. For readers non familiarised with Oz syntax, proc{$Root}...end is the standard mechanism to define procedures that can be injected as new constraints in the constraint store. This mechanism is used by tell processes. In this way, all the processes can be defined into the simulator. Next, a procedure takes as input all processes definition and generates a given number of time-units respecting the operational semantic of the calculus.
Stores in each time-unit can be used to plot for example concentration of rep and cro proteins as showed in figure 3. Notice that rep Induction = rep(rho(tell(proc{$ Root} Root.reset_rep =:1 end) IndRho)) concentration growths at the beginning while cro concentration remains around zero. After induction, the system behaves in a opposite way.
Tools such this will allow biologist to observe the behaviour of the system and study how the system evolves if one change some parameters such as affinities between components (i.e probabilities).

Proving temporal properties of the λ switch system
Simulators can be useful to observe the system in an finite interval of time, but they are not enough to predict behaviour in the future. An advantage of using process calculi such as ntcc with a well defined semantic operation and an underlying logic, is that we can reason about the system by means of an inference systems. Proofs will allow us to check our model and establish if we can expect some behaviour in the system or not. In this section we show proofs for two properties in the lambda switch system: • Eventually, with probability ρ (a very low probability in this case) the concentration of rep proteins drops to zero .
• If OR1 and OR2 are bound by reps and OR3 is bound by RN AP , a new instance of rep will eventually be produced (i.e. the protein concentration will be incremented) with probability ρ ci high . Re-call that when OR2 is bound by rep, the rate of transcription of gene cI is incremented because of the cooperativity relationship between OR2 and P RM .
The first one shows how induction process will be observed in the future. Since induction process has a very low probability, it is quiet difficult to observe this phenomenon in a simulation. It may be necessary run the simulation too many times or generate too many timeunits. In fact, figure 3 was generated increasing the probability of the induction phenomenon. The second one shows how it is possible to perform model checking over our models and proof, in this case, if some property of the system (cooperativity) can be deduced from the model.
In order to proof the first property, we star with the definition of the overall system: LP AR : (23) Notice that we use the temporal always operator because processes are replicated (i.e. use the "!" prefix) in the definition of λ − P ROC.
By using LCON S in equation 23 we get: The IN DU CT ION process satisfies the formula A , ρ . Now, we are going to find out the structure of A: P ST AR : Finally, by using P P RO we can verify that CIT RAN S satisfies the following formula: Equation 29 says that new reps will appear with a probability ρ high verifying the cooperative behavior between OR2 and P R .

Concluding remarks and Future Work
We have given orthogonal extensions of ntcc for modelling stochastic behaviour of processes. In particular, we proposed two new operators: ρ P and ( ρ )P . The first one expresses that P is executed in the current time unit with probability ρ and the second one that P is eventually executed with probability ρ. We showed that both can be expressed in terms of existing ntcc constructs by including in the signature of the underlying constraint system of ntcc a probabilistic function Φ(ρ) : [0, 1] → bool following a binomial distribution. Additionally, an inference system to prove probabilistic properties in the calculus was provided. This inference system is built on an ntcc linear-temporal logic extension by adding probabilities to each formula. For each process construction including our new processes ( ρ )P and ρ P , we defined an inference rule to proof if a process P satisfies an specification (i.e a formula in the logic).
Using this new stochastic non-deterministic calculus we were able to provide a model of a biological system called the lambda switch that is both simpler and more complete than models previously proposed based on the stochastic π-calculus. This approach has several advantages: 1)The notion of constraints allows to define relation between components in a declarative way leading to a straightforward representation of the functional description of the system. 2) Notion of partial information in the constraint store allows to represent the system even though we do not have a complete knowledge of all the components and relations involved. 3) Thanks to the parallel composition operator, the system is described in terms of well defined processes running concurrently. 4) Models in this calculus can be simulated following the operational semantic of the calculus. Finally, 5) We can build a proof with the inference system provided to know if some behaviour can be observed in the system without simulating the system infinitely.
As future work, we expect to use our proof system to verify properties of relevance to biologists. Adapting or implementing a new automatic theorem-prover will help us in this task. We also plan to construct reasonably complete models of some other biological systems.