Abstract
We extended our simulation tool Ntccrt for probabilistic ntcc (pntcc) models. In addition, we developed a verification tool for pntcc models. Using this tool we can prove properties such as “the system will go to a successful state with probability under discrete timeunits”.
Currently, we are facing a few problems. We can only verify pntcc models using a finite domain constraint system and the encoding of cells ( mathematical entities that can update their value ) is experimental. In addition, in order to reduce the states generated during the verification process we need to implement a procedure to calculate whether two processes are equivalent.
In the future, we want to provide multiple interfaces for the tools (e.g., a web application, a graphical interface and command line interface). We also want to support constraint systems over trees, graph and sets. We want to show the relevance of our tool to model biological and multimedia
interaction systems in our tool, verify some properties about them, and simulate such systems in our realtime capable interpreter.
Process calculi has been applied to the modeling of interactive music systems [Tor18, Tor16b, TDCC16, TRAA16, Tor16a, TRAA15, ADCT11, TDCR14, TAAR09, ORS11, Tor12, Tor09a, Tor10, Tor15, AAO09, TDCC12, Tor09b, TDC10, TDCB10, Tor08] and ecological systems [TPA16, PT13, TPKS14, PTA13]. In addition, research on algorithms [PFATT16, MPT17, RPT17] and software engineering [RML18] also contributes to this field.
1 Introduction
Definition 1.
pntcc internal transitions.
Lemma 1.
Every sequence of internal sequences is terminating (i.e., there are not infinite sequences) [ntccphd].
Definition 2.
Given a configuration , where is an initial store (i.e., input) and is a ntcc process. We define a output as a store such that , where means … means … means…
Definition 3.
A Constraint System (CS) is a pair (,) where is a signature specifying constants, functions and predicate symbols, and is consistent firstorder they over (i.e., a set of firstorder sentences over having at least one model). We say that entails in , written iff the formula is true in all models of . We write instead of when is unimportant [ntccphd].
Definition 4.
Let . FD(n) is a CS such that:
 is given by constant symbols and the equality.
 is given by … [ntccphd]
Definition 5.
A Herbrand CS …
Definition 6.
A CSP is defined as a triple where is a set of variables, is a set of domains and is a set of constraints. A solution for a CSP is an evaluation that satisfies all constraints.
The inputoutput behavior can be interpreted as an interaction between the system and the environment. At the time unit , the environment provides a stimulus and produces as a response. As observers, we can see that on input the process P responds with . We then recard () as a reactive observation of P. Given we shall refer to the set of all its reactive observations as the inputoutput behavior of [ntccphd].
Definition 7.
We recall the following proposition from the pntcc paper.
Proposition 1.
Given a pntcc process , for every reachable from through an observable sequence, in the DTMC given by DTMC( there exists a path from to , for some constraint .
2 Simulation for pntcc
In what follows, we explain how to formalize the construction of an interpreter for pntcc and its implementation.
2.1 Encoding a deterministic, nontimed, nonprobabilistic fragment of pntcc as a CSP
In this section we propose the encoding of a pntcc fragment as a Constraint Satisfaction Problem (CSP). First, we give some useful definitions. Then, we present the enconding of a pntcc process into a constraint. Following, we prove the correctness of the encoding. Finally, we propose the encoding for the execution of a pntcc process and an input (i.e., store) parametrized by a specific scheduler into a CSP.
We prove that all the solutions of the CSP are valuations for the output of a pntcc process for such scheduler. An advantage of representing the execution of a process as a CSP is that we can use any constraint solving tool to simulate the execution of a process.
The following fragment of pntcc does not include temporal operators (i.e., next, !, unless and *), nondeterministic choice (i.e., ) nor probabilistic choice (i.e., ). It is parametrized by a Finite Domain constraint system, which is also parametrized by , which is the size of an integer on a 32 bits computer architecture.
Definition 8.
A fragment of pntcc parametrized by FD[] where
::= when do tell () local
In order to define the CSP, we need to define its variables. For that reason, we provide the function vars(P), which returns all the nonlocal variables used by a pntcc process.
Definition 9.
Let vars(P): “ pntcc process” “set of variable names” be recursively defined.
vars(tell(c))::= , the variables contained in a constraint.
vars() ::= vars(P)vars(Q)
vars( when do ) ::= vars()
vars(local x )::= vars(P)
The encoding [ [.] ]codifies a pntcc process into a constraint. A key issue for this encoding is representing the nondeterministic process when do .
We propose the constraint . The idea is posting the constraints associated to a process for at most one process which guard holds.
We assume a constraint in the constraint system for each constraint used in the “when” processes. These constraints are called reified constraints. The use of constraints as guards of “when” processes will be limited by the reified constraints supplied by the constraint solving tool.
Definition 10.
Let [ [.] ]: “pntcc process” “FD constraint” be defined recursively.
[ [tell()] ]::= , c is a FD constraint
[ [] ]::= [ [P] ][ [Q] ]
[ [ when do ] ]::=
[ [local x ] ]::= [ [P] ]
Using the encoding presented above, we show that for every constraint , given a process , its output is equivalent to the encoding of in conjuction with the constraint . This proposition makes a link between the output of a pntcc process and a constraint.
Proposition 2.
Proof.
The proof proceeds by induction on the structure of .

= tell().
According to the rule TELL (Def. 1) and the fact that skip does not make any internal transition, we must have tell(c),d
Then, we have to prove that
Since accoding to Def. 10, we have

=
We recall the rule
PAR
We suppose and (1)
From (1) and lemma 1, we can deduce
According to the rule PAR, to (1) and to the lemma 1, we must have
(2)
by (2) and the inductive hypothesis, we must have
(3) (4)
from (3) and (4), we have (5)
On the other hand, from (2) and the inductive hypothesis, we can deduce
(6) (7)
From (6) and (7), we deduce (8)
Applying Def. 10, we can deduce from (8) (9)
Finally, replacing (5) in (9) we have
The case where is trivial since according to structural congruence.

P = when do
We recall the rule
SUM if
There are two cases:

= local
We recall the rule
LOC .
According to lemma 1 and LOC, we must have
We have to prove (1) (2)
From (1) and (2) we have (3)
To prove (3), we have to prove all these cases:

Q = tell(h)
We have Q’ = skip and
Then, according to Def. 10 and replacing Q, Q’ and c in (3), we have

Q = when do
Since by Def. 10 and by rule SUM and because we know that asume that , we have

Q =
According to rule PAR, we must have and
Then, we have to prove that
We have the following derivation
by Def. 10
by inductive hypothesis (recalling proof for the case )
by Def. 10

= local
This holds by the inductive hypothesis

∎
Since we can encode the output of a process as a constraint, following, we describe the relation between executing a process and solving a CSP. We will show that a process and a constraint can be rewriten as a CSP, and the solutions of such CSP are all the valuations of the output obtained by executing a process with the scheduler described previously.
Proposition 3.
Let be a process in the pntcc fragment given by Def. 8 and the encoding given in Def. 10 , for every it holds that the solutions to the CSP

Variables =

Domains = for each variable

Constraints =
are
all the valuations for a store obtained by executing with an input described in proposition LABEL:. Formally,
Proof.
According to proposition 2, it holds that the store is equivalent to the constraint [ [P ] ] after executing a process with a store . By Def. 6, we know that a solution for a CSP satisfies all its constraints, thus, all the solutions of a CSP are all the possible valuations that satisfies its constraints. Therefore, all the possible solutions for the CSP, satisifies the store . ∎
The correctness of our tool will be based on solving a CSP correctly. Fortunately, there are multiple techniques and theories about how to solve a CSP composed by FD constraints. In the implementation, we will left the problem of solving a CSP to a constraint solving library called Gecode [SS06]. In order to execute the process instead of the first process, we define a preencoding for the sum process
[ [ when do ] ] ::=
when do [ [] ]
where “set of indexes” “set of indexes” change the other of the indexes.
2.2 Adding time
In this section we explain how we can extend the encoding proposed in Def. 10 for the “time” operators. Then, we propose an abstract machine capable of simulating a finite number of pntcc timeunits. Finally, we will prove that there is a relation between the execution of the abstract machine and the execution of pntcc process.
Definition 11.
A nonprobabilistic fragment of pntcc parametrized by FD[] where
::= when do tell () local next unless next
The following encoding is a function that takes a pntcc process as given by Def. 11 and returns a pair composed by the constraint associated to that process (based on Def. 10) and the process to be executed in the next timeunit (based on the definition of F(P)).
Definition 12.
Let : “pntcc process” “pair” be defined recursively.
[ [tell() ::= , c is a FD constraint
[ [::= , where
[ [ when do ::=
[ [local x ::= , where
[ [next ::=
[ [unless next ::=
[ [! ::= , where
Example 1.
Let = tell(c) next tell (d) !(tell(e)tell(f)).
Then, =
Proposition 4.
Proof.
… Pending ∎
In order to execute , the pntccM machine first need to encode into a suitable machine term. A machine term is a triple composed by a FD constraint, a process and an integer.
Definition 13.
Syntax of pntccM.
V ::= , where
c is a Finite Domain constraint
Q is a process defined in Def. 11
The following function is used to encode a pntcc process into a pntccM term for a simulation of timeunits.
Definition 14.
Encoding a pntcc process into a pntccM term.
where
Once a process has been encoded to a machine term using Def. 14, it can be executed by the machine. A given term can be executed if . The reduction depends on the input from the environment. The new machine term is formed by the output of the process, the future function applied to the process and .
Definition 15.
Reduction in pntccM for an input .
, where and
, when
Next, we define a finite simulation of the pntccM machine.
Definition 16.
Let be the number of timeunits to simulate, a pntcc process defined in Def. 11, and a sequence of inputs (FD constraints). A simulation is a sequence such that and
Example 2.
Let be the process defined in example 1. Then, a simulation
There is a relation between the inputoutput behavior of a pntcc process and a simulation of the pntccM machine.
Proposition 5.
Let be a simulation parametrized by a process given by Def. 11, an integer and a sequence of FD constraints . (i.e., the first elements of the sequence) is equal to
Proving proposition 5 we show that the pntccM gives the same output as a process because an inputoutput sequence generated by a process is equal to a simulation of the machine. Then, every output given by a machine is calculated by a process and viceversa.
2.3 Adding probabilistic choice
In this section we will show how to encode a nontimed fragment of pntcc as a sequence of Propagation Problems (PP). The advantage of this approach is that we can make a implementation of this fragment of pntcc only using a constraint solving tool based on propagators and a randomnumber generation library. We will also show the correctness of the encodings as usual.
Definition 17.
Process up to level j. Let PUL : “pntcc process” “pntcc process” be defined recursively.
PUL(tell(c)) ::= tell(c)
PUL()::= PUL()PUL()
PUL( when do ) ::= when do PUL
PUL(local ) ::= local PUL
PUL( when do , ) ::=
Definition 18.
Probabilistic processes at level j. Let PPAL : “pntcc process” “set of pntcc process” be defined recursively.
PPAL(tell(c)) ::=
PPAL()::= PPAL()PPAL()
PPAL( when do ) ::= PPAL
PPAL(local ) ::= PPAL
PPAL( when do , ) ::=
Property 1.
For any , It exists and , such that and For each ,
Definition 19.
A fragment of pntcc parametrized by FD[] where
::= when do tell () local when do
and holds the property 1
Definition 20.
The Maximum nested depth (mnp) function. Let mnp : pntcc be recursively defined.
mnp(tell()) = 0
mnp() = max( mnp(), mnp())
mnp(local ) = mnp()
mnp( when do ) = max()
mnp( when do , ) = max() + 1
Definition 21.
The Boolean Variables of a Probabilistic Process (ProbGuards) function. Let ProbGuards : “pntcc process” “set of tuples process, index, boolean var” be defined recursively
ProbGuards(skip) = ProbGuards(tell() =
ProbGuards() = ProbGuards()ProbGuards()
ProbGuards( when do ) = ProbGuards()
ProbGuards(local ) = ProbGuards()
ProbGuards( when do , ) =
Definition 22.
getBool(P,i,b) …
Definition 23.
ChooseProb(set)
Definition 24.
The encoding [ [.] ]
[ [skip] ] ::= true
[ [tell()] ] ::= , c is a FD constraint
[ [] ] ::= [ [P] ][ [Q] ]
[ [ when do ] ] ::=
[ [local x ] ] ::= [ [P] ]
[ [ when do , ] ] =
Proposition 6.
Proposition 7.
Copy from the other one…
Let such that . After calculating mutual fixpoints for propagation problems for

Variables = vars(P) ProbGuards(P)

Domains =

Constraints =
Calculate a mutual fixpoint for all the propagators
Add the constraints =
and we think about the last PP as a CSP, the solutions to of the CSP …
2.4 Implementation
Ntccrt [Tor08] is written in C++ and it can generate standalone programs executing a ntcc model. Ntccrt can also use Flext to generate the externals for either Max or Pd [PAZ98], and Gecode [SS06] for constraint solving and concurrency control. Gecode is an efficient constraint solving library, providing efficient propagators (narrowing operators reducing the set of possible values for some variables). The basic principle of Ntccrt is encoding the “when” and “tell” processes as Gecode propagators.
Although Gecode was designed to solve combinatorial problems, Toro found out in [Tor08] that writing the “when” process as a propagator, Gecode can manage all the concurrency needed to represent ntcc. Following, we explain the encoding of the “tell” and the “when”.
To represent the “tell”, we define a super class . For Ntccrt, we provide three subclasses to represent these processes: tell (), tell (), and tell (). Other kind of “tells” can be easily defined by inheriting from the superclass and declaring an method.
We have a When propagator for the “when” and a When class for calling the propagator. A process when do is represented by two propagators: (a reified propagator for the constraint ) and if then else (the When propagator). The When propagator checks the value of . If the value of is true, it calls the Execute method of . Otherwise, it does not take any action. Figure 3 shows how to encode the process when do using our When propagator.
We have a propagator …
3 Verification
Finally, we will extend the abstract machine to calculate a DiscreteTime Markov Chain (DTMC) and we will show its correctness.
3.0.1 Verification of nonprobabilistic pntcc
A key aspect of pntcc is that it can be used for both, simulation and verification. Following, we define another abstract machine that calculates DTMCs instead of a simple sequence of outputs. Using the DTMC we can prove PCTL properties. This machine is an extension of pntccM and it is also based on the encoding given by Def. 12.
In order to execute , the VerificationPntccM machine first need to encode into a suitable machine term. A machine term is a tuple composed by a FD constraint, a process, a DTMC and an integer.
Definition 25.
Syntax of VerificationPntccM.
V ::= , where
A is a Finite Domain constraint
B is a process defined in Def. 11
C is a DTMC (i.e., a tuple )
The following function is used to encode a pntcc process into a VerificationPntccM term to calculate a DTMC representing a timeunits execution.
Definition 26.
Encoding a pntcc process into a VerificationPntccM term.
where
Definition 27.
Reduction in VerificationPntccM.
where , and
, when
Proposition 8.
Given a pntcc process , the DTMC given by the first ? states of the DTMC() is an isomorph of the verification structure Ver(P,n)…
Proof.
The proof proceeds by induction DTMC() ∎
4 Applications
4.1 Herman’s Stabilization protocol
4.2 Description
A selfstabilising protocol for a network of processes is a protocol which, when started from some possibly illegal start configuration, returns to a legal/stable configuration without any outside intervention within some finite number of steps. For further details on selfstabilisation see here.
In each of the protocols we consider, the network is a ring of identical processes. The stable configurations are those where there is exactly one process designated as ”privileged” (has a token). This privilege (token) should be passed around the ring forever in a fair manner.
For each of the protocols, we compute the minimum probability of reaching a stable configuration and the maximum expected time (number of steps) to reach a stable configuration (given that the above probability is 1) over every possible initial configuration of the protocol.
The first protocol we consider is due to Herman [Her90]. The protocol operates synchronously, the ring is oriented, and communication is unidirectional in the ring. In this protocol the number of processes in the ring must be odd.
Each process in the ring has a local boolean variable xi, and there is a token in place i if xi=x(i1). In a basic step of the protocol, if the current values of xi and x(i1) are equal, then it makes a (uniform) random choice as to the next value of xi, and otherwise it sets it equal to the current value of x(i1).
4.3 Simulation
"Ntccrt Simulation" "" "" "Time Unit \# 0" "Number of processes= 7" "" "Variables Value (Only those specified are printed)" "num\_tokens" "3" "x1" "0" "x2" "0" "x3" "0" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 1" "Number of processes= 18" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "1" "x2" "0" "x3" "0" "..........................................." "" "Time Unit # 2" "Number of processes= 22" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "0" "x2" "1" "x3" "1" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 3" "Number of processes= 26" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "1" "x2" "0" "x3" "0" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 4" "Number of processes= 30" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "0" "x2" "1" "x3" "1" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 5" "Number of processes= 34" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "1" "x2" "0" "x3" "0" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 6" "Number of processes= 38" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "0" "x2" "1" "x3" "1" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 7" "Number of processes= 42" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "1" "x2" "0" "x3" "1" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." "" "Time Unit # 8" "Number of processes= 46" "" "Variables Value (Only those specified are printed)" "num_tokens" "1" "x1" "1" "x2" "1" "x3" "0" "changex1" "1" "changex2" "1" "changex3" "1" "..........................................." NIL T
CLUSER 10 ¿
4.4 Model Checking
We first check the correctness of the protocol, namely that:
From any configuration, a stable configuration is reached with probability 1
We then studied the following quantitative properties:
The minimum probability of reaching a stable configuration within K steps (from any configuration)
4.5 zigzagging problem
4.5.1 description
Zigzagging [free99] is task on which a robot can go either foward, left, or right but (1) it cannot go forward if its preceding action was to go forward, (2) it cannot turn right if its secondlast action was to go right, and (3) it cannot turn left if its secondlast action was to go left. (frank thesis  page 105)
Valencia models this problem by using cells and to “look back” and three different distinct constrats and the predicate symbols forward, right, left.
GoF
GoR
GoL
Zigzag
GoZigZag
Valencia verifies that GoZigzag .
4.5.2 simulation
Frank’s style
"Ntccrt Simulation" "" "" "Time Unit # 0" "Number of processes= 3" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "0" "a2" "0" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 1" "Number of processes= 9" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "1" "a2" "0" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 2" "Number of processes= 11" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "3" "a2" "1" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 3" "Number of processes= 13" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "1" "a2" "3" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 4" "Number of processes= 15" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "2" "a2" "1" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 5" "Number of processes= 17" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "2" "a2" "2" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 6" "Number of processes= 19" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "1" "a2" "2" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 7" "Number of processes= 21" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "3" "a2" "1" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 8" "Number of processes= 23" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "3" "a2" "3" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 9" "Number of processes= 25" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "1" "a2" "3" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 10" "Number of processes= 27" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "2" "a2" "1" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 11" "Number of processes= 29" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "2" "a2" "2" "changea1" "1" "changea2" "1" "..........................................." "" "Time Unit # 12" "Number of processes= 31" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "3" "a2" "2" "changea1" "1" "changea2" "1" "..........................................."
My way
"Ntccrt Simulation" "" "SKIP:: cella1 11::" "SKIP:: zigzag 11::" "SKIP:: GoR 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch0 11::" "SKIP:: I will call exch_aux0 11::" "" "Time Unit # 0" "Number of processes= 5" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "0" "a2" "0" "changea1" "1" "changea2" "1" "x" "0" "y" "0" "changex" "1" "changey" "[2147483645..2147483645]" "..........................................." "SKIP:: zigzag 11::" "SKIP:: value changes!!!! 11::" "SKIP:: cella1 11::" "SKIP:: GoF 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch2 11::" "" "Time Unit # 1" "Number of processes= 15" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "2" "a2" "0" "changea1" "1" "changea2" "1" "x" "1" "y" "0" "changex" "[2147483645..2147483645]" "changey" "1" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoL 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch1 11::" "" "Time Unit # 2" "Number of processes= 18" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "1" "a2" "2" "changea1" "1" "changea2" "1" "x" "1" "y" "1" "changex" "1" "changey" "[2147483645..2147483645]" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoF 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch3 11::" "" "Time Unit # 3" "Number of processes= 21" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "3" "a2" "1" "changea1" "1" "changea2" "1" "x" "0" "y" "1" "changex" "[2147483645..2147483645]" "changey" "1" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoR 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch1 11::" "" "Time Unit # 4" "Number of processes= 24" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "1" "a2" "3" "changea1" "1" "changea2" "1" "x" "0" "y" "2" "changex" "1" "changey" "[2147483645..2147483645]" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoR 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch2 11::" "" "Time Unit # 5" "Number of processes= 27" "" "Variables Value (Only those specified are printed)" "direction" "2" "a1" "2" "a2" "1" "changea1" "1" "changea2" "1" "x" "1" "y" "2" "changex" "1" "changey" "[2147483645..2147483645]" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoF 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch2 11::" "" "Time Unit # 6" "Number of processes= 30" "" "Variables Value (Only those specified are printed)" "direction" "1" "a1" "2" "a2" "2" "changea1" "1" "changea2" "1" "x" "2" "y" "2" "changex" "[2147483645..2147483645]" "changey" "1" "..........................................." "SKIP:: zigzag 11::" "SKIP:: cella1 11::" "SKIP:: GoL 11::" "SKIP:: Exchange value ! 11::" "SKIP:: exch1 11::" "" "Time Unit # 7" "Number of processes= 33" "" "Variables Value (Only those specified are printed)" "direction" "3" "a1" "1" "a2" "2" "changea1" "1" "changea2" "1" "x" "2" "y" "3" "changex" "1" "changey" "[2147483645..2147483645]"
4.5.3 Model checking
Frank style
// The robot does not go foward twice ”init” =¿ P¡=0 [F store2 = 1 & store3 = 1]
// The robot does not go right more than twice ”init” =¿ P¡=0 [F store2=2 & store3 = 2 & store4 = 2]
//The robot does not go left more than twice ”init” =¿ P¡=0 [F store2=3 & store3 = 3 & store4 = 3]
// The robot always makes a good move ”init” =¿ P¿=1 [F (store2 !=1 — store3 !=1) & (store2 != 2 — store3 != 2 — store4 != 2) & (store2 != 3 — store3 != 3 — store4 != 3)]
My way
Probability distribution for x,y positions
const x; const y; P ? [F store7 = x & store8 = y]
References
 [AAO09] Jesús Aranda, Gérard Assayag, Carlos Olarte, Jorge A. Pérez, Camilo Rueda, Mauricio Toro, and Frank D. Valencia. An overview of FORCES: an INRIA project on declarative formalisms for emergent systems. In Patricia M. Hill and David Scott Warren, editors, Logic Programming, 25th International Conference, ICLP 2009, Pasadena, CA, USA, July 1417, 2009. Proceedings, volume 5649 of Lecture Notes in Computer Science, pages 509–513. Springer, 2009.
 [ADCT11] Antoine Allombert, Myriam DesainteCatherine, and Mauricio Toro. Modeling temporal constrains for a system of interactive score. In Gérard Assayag and Charlotte Truchet, editors, Constraint Programming in Music, chapter 1, pages 1–23. Wiley, 2011.
 [MPT17] Juan David Arcila Moreno, Santiago Passos, and Mauricio Toro. Online assembling mitochondrial DNA from de novo transcriptome. CoRR, abs/1706.02828, 2017.
 [ORS11] Carlos Olarte, Camilo Rueda, Gerardo Sarria, Mauricio Toro, and Frank Valencia. Concurrent Constraints Models of Music Interaction. In Gérard Assayag and Charlotte Truchet, editors, Constraint Programming in Music, chapter 6, pages 133–153. Wiley, Hoboken, NJ, USA., 2011.
 [PAZ98] M. Puckette, T. Apel, and D. Zicarelli. Realtime audio analysis tools for Pd and MSP. In Proceedings of the International Computer Music Conference., 1998.
 [PFATT16] C. PatiñoForero, M. AgudeloToro, and M. Toro. Planning system for deliveries in Medellín. ArXiv eprints, November 2016.
 [PT13] Anna Philippou and Mauricio Toro. Process Ordering in a Process Calculus for SpatiallyExplicit Ecological Models. In Proceedings of MOKMASD’13, LNCS 8368, pages 345–361. Springer, 2013.
 [PTA13] Anna Philippou, Mauricio Toro, and Margarita Antonaki. Simulation and Verification for a Process Calculus for SpatiallyExplicit Ecological Models. Scientific Annals of Computer Science, 23(1):119–167, 2013.
 [RML18] Mazo Raul, Toro Mauricio, and Cobaleda Luz. Definicion de la arquitectura de referencia de un dominio: de la elucidacion al modelado. In Raul Mazo, editor, Guia para la adopcion industrial de lineas de productos de software, pages 193–210. Editorial Eafit, 2018.
 [RPT17] Juan Manuel Ciro Restrepo, Andrés Felipe Zapata Palacio, and Mauricio Toro. Assembling sequences of DNA using an online algorithm based on debruijn graphs. CoRR, abs/1705.05105, 2017.
 [SS06] Christian Schulte and Peter J. Stuckey. Efficient constraint propagation engines. CoRR, abs/cs/0611009, 2006.
 [TAAR09] Mauricio Toro, Carlos Agón, Gérard Assayag, and Camilo Rueda. Ntccrt: A concurrent constraint framework for realtime interaction. In Proc. of ICMC ’09, Montreal, Canada, 2009.
 [TDC10] Mauricio Toro and Myriam DesainteCatherine. Concurrent constraint conditional branching interactive scores. In Proc. of SMC ’10, Barcelona, Spain, 2010.
 [TDCB10] Mauricio Toro, Myriam DesainteCatherine, and P. Baltazar. A model for interactive scores with temporal constraints and conditional branching. In Proc. of Journées d’Informatique Musical (JIM) ’10, May 2010.
 [TDCC12] Mauricio Toro, Myriam DesainteCatherine, and Julien Castet. An extension of interactive scores for multimedia scenarios with temporal relations for micro and macro controls. In Proc. of Sound and Music Computing (SMC) ’12, Copenhagen, Denmark, July 2012.
 [TDCC16] MAURICIO TORO, MYRIAM DESAINTECATHERINE, and JULIEN CASTET. An extension of interactive scores for multimedia scenarios with temporal relations for micro and macro controls. European Journal of Scientific Research, 137(4):396–409, 2016.
 [TDCR14] Mauricio Toro, Myriam DesainteCatherine, and Camilo Rueda. Formal semantics for interactive music scores: a framework to design, specify properties and execute interactive scenarios. Journal of Mathematics and Music, 8(1):93–112, 2014.
 [Tor08] Mauricio Toro. Exploring the possibilities and limitations of concurrent programming for multimedia interaction and graphical representations to solve musical csp’s. Technical Report 20083, Ircam, Paris.(FRANCE), 2008.
 [Tor09a] Mauricio Toro. Probabilistic Extension to the Factor Oracle Model for Music Improvisation. Master’s thesis, Pontificia Universidad Javeriana Cali, Colombia, 2009.
 [Tor09b] Mauricio Toro. Towards a correct and efficient implementation of simulation and verification tools for probabilistic ntcc. Technical report, Pontificia Universidad Javeriana, May 2009.
 [Tor10] Mauricio Toro. Structured interactive musical scores. In Manuel V. Hermenegildo and Torsten Schaub, editors, Technical Communications of the 26th International Conference on Logic Programming, ICLP 2010, July 1619, 2010, Edinburgh, Scotland, UK, volume 7 of LIPIcs, pages 300–302. Schloss Dagstuhl  LeibnizZentrum fuer Informatik, 2010.
 [Tor12] Mauricio Toro. Structured Interactive Scores: From a simple structural description of a multimedia scenario to a realtime capable implementation with formal semantics . PhD thesis, Univeristé de Bordeaux 1, France, 2012.
 [Tor15] Mauricio Toro. Structured interactive music scores. CoRR, abs/1508.05559, 2015.
 [Tor16a] M. Toro. Probabilistic Extension to the Concurrent Constraint Factor Oracle Model for Music Improvisation. ArXiv eprints, February 2016.
 [Tor16b] Mauricio Toro. Probabilistic Extension to the Concurrent Constraint Factor Oracle Model for Music Improvisation . Inteligencia Artificial, 57(19):37–73, 2016.
 [Tor18] Mauricio Toro. CURRENT TRENDS AND FUTURE RESEARCH DIRECTIONS FOR INTERACTIVE MUSIC. Journal of Theoretical and Applied Information Technology, 69(16):5569–5606, 2018.
 [TPA16] Mauricio Toro, Anna Philippou, Sair Arboleda, María Puerta, and Carlos M. Vélez S. Meanfield semantics for a process calculus for spatiallyexplicit ecological models. In César A. Muñoz and Jorge A. Pérez, editors, Proceedings of the Eleventh International Workshop on Developments in Computational Models, Cali, Colombia, October 28, 2015, volume 204 of Electronic Proceedings in Theoretical Computer Science, pages 79–94. Open Publishing Association, 2016.
 [TPKS14] Mauricio Toro, Anna Philippou, Christina Kassara, and Spyros Sfenthourakis. Synchronous parallel composition in a process calculus for ecological models. In Gabriel Ciobanu and Dominique Méry, editors, Proceedings of the 11th International Colloquium on Theoretical Aspects of Computing  ICTAC 2014, Bucharest, Romania, September 1719, volume 8687 of Lecture Notes in Computer Science, pages 424–441. Springer, 2014.
 [TRAA15] MAURICIO TORO, CAMILO RUEDA, CARLOS AGÓN, and GÉRARD ASSAYAG. Ntccrt: A concurrent constraint framework for soft realtime music interaction. Journal of Theoretical & Applied Information Technology, 82(1), 2015.
 [TRAA16] MAURICIO TORO, CAMILO RUEDA, CARLOS AGÓN, and GÉRARD ASSAYAG. Gelisp: A framework to represent musical constraint satisfaction problems and search strategies. Journal of Theoretical & Applied Information Technology, 86(2), 2016.
Comments
There are no comments yet.