Towards a correct and efficient implementation of simulation and verification tools for probabilistic ntcc

10/05/2018 ∙ by Mauricio Toro, et al. ∙ 0

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 p under t discrete time- units. 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 ap- plication, 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 real-time capable interpreter.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 time-units”.

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 real-time 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) [ntcc-phd].

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 first-order they over (i.e., a set of first-order 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 [ntcc-phd].

Definition 4.

Let . FD(n) is a CS such that:

- is given by constant symbols and the equality.

- is given by … [ntcc-phd]

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 input-output 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 input-output behavior of [ntcc-phd].

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, non-timed, non-probabilistic 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 *), non-deterministic 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 non-local 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 non-deterministic 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.

Let and be a process in the pntcc fragment given by Def. 8 and the encoding given by Def. 10. Then, for every constraint using a scheduler that chooses the process with minium index which guard holds, it holds that

Proof.

The proof proceeds by induction on the structure of .

  1. = 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

  2. =

    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.

  3. P = when do

    We recall the rule

    SUM if

    There are two cases:

    1. By lemma 1 and SUM, we must have

      Then, we have to prove (1)
      We have (2) by the inductive hypothesis

      From (1) and (2) we deduce

      Since by to Def. 10 and because ???, we have

    2. We must have .Then, we have to prove that .

      Since according to Def. 10 and because , we have

  4. = 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:

    1. Q = tell(h)

      We have Q’ = skip and

      Then, according to Def. 10 and replacing Q, Q’ and c in (3), we have

    2. Q = when do

      Since by Def. 10 and by rule SUM and because we know that asume that , we have

    3. 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

    4. = 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 pre-encoding 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 time-units. 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 non-probabilistic 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 time-unit (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.

Let be a process given by Def. 11, for any constraint , it holds for every FD constraint that

where is the future function applied to Q and the encoding given by Def. 12 applied to

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 time-units.

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 time-units 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 input-output 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 input-output 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.

Proof.

The proof proceeds by induction over the io(P)[1..n] and the simulation sequence. Let and .

Base case:

is a collorary of proposition 4 and Def. 14.

Inductive case:

Let be the inductive hypothesis. We must prove that . This is also a collorary of proposition 4.

2.3 Adding probabilistic choice

In this section we will show how to encode a non-timed 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 random-number 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 stand-alone 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.

Figure 1: Example of the When propagator

We have a propagator

3 Verification

Finally, we will extend the abstract machine to calculate a Discrete-Time Markov Chain (DTMC) and we will show its correctness.

3.0.1 Verification of non-probabilistic 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 time-units 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 self-stabilising 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 self-stabilisation 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(i-1). In a basic step of the protocol, if the current values of xi and x(i-1) 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(i-1).

4.3 Simulation

Figure 2: 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

CL-USER 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)

Figure 3: The minimum probability of reaching a stable configuration within K steps

4.5 zig-zagging 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 second-last action was to go right, and (3) it cannot turn left if its second-last 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 14-17, 2009. Proceedings, volume 5649 of Lecture Notes in Computer Science, pages 509–513. Springer, 2009.
  • [ADCT11] Antoine Allombert, Myriam Desainte-Catherine, 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. On-line 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. Real-time audio analysis tools for Pd and MSP. In Proceedings of the International Computer Music Conference., 1998.
  • [PFATT16] C. Patiño-Forero, M. Agudelo-Toro, and M. Toro. Planning system for deliveries in Medellín. ArXiv e-prints, November 2016.
  • [PT13] Anna Philippou and Mauricio Toro. Process Ordering in a Process Calculus for Spatially-Explicit 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 Spatially-Explicit 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 on-line 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 real-time interaction. In Proc. of ICMC ’09, Montreal, Canada, 2009.
  • [TDC10] Mauricio Toro and Myriam Desainte-Catherine. Concurrent constraint conditional branching interactive scores. In Proc. of SMC ’10, Barcelona, Spain, 2010.
  • [TDCB10] Mauricio Toro, Myriam Desainte-Catherine, 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 Desainte-Catherine, 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 DESAINTE-CATHERINE, 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 Desainte-Catherine, 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 2008-3, 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 16-19, 2010, Edinburgh, Scotland, UK, volume 7 of LIPIcs, pages 300–302. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 2010.
  • [Tor12] Mauricio Toro. Structured Interactive Scores: From a simple structural description of a multimedia scenario to a real-time 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 e-prints, 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. Mean-field semantics for a process calculus for spatially-explicit 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 17-19, 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 real-time 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.