Moved files to 'reactics-bdd'

reactics-bdd/in/scripts/bench_bc.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+
+outdir="results"
+basefname="bc_"
+forms="`seq 1 4`"
+seq_f1="`seq 1 25`"
+seq_f2="`seq 1 25`"
+seq_f3="`seq 9 25`"
+seq_f4="`seq 1 25`"
+
+tool="../main"
+options="-c -z -v -B"
+
+ulimit -t 3600
+ulimit -v 2097152
+
+for form in $forms; do
+    eval sequence='$'seq_f$form
+    for n in $sequence; do
+        echo $form $n
+
+    for part in PT MT; do
+
+		echo "$form $n $part"
+
+        if [ "$part" = "PT" ];then
+            popt="-x"
+            suf="_pt"
+        else
+            popt=""
+            suf=""
+        fi
+
+		stopfile="DONE_${basefname}_f${form}${suf}.done"
+
+		if [ -e "$stopfile" ];then
+			echo "Time limit - SKIPPING"
+			continue
+		fi
+		
+        filename="$outdir/${basefname}${part}_f${form}_n${n}.out"
+
+        echo "$x" > $filename
+
+        ./gen_bc.py $n $form > tmp.rs
+
+        echo "EXEC: $tool $options $popt tmp.rs"
+        $tool $options $popt tmp.rs >&1  >> $filename 
+
+        result="$(tail -1 $filename | grep -E '.*;.*;.*;.*'| sed "s/STAT/$n /")"
+        if [ "$result" = "" ];then
+			echo "time limit"
+			touch $stopfile
+        else
+            echo $result >> results/summary_${basefname}${part}_f${form}
+            echo $result | sed 's/;/ /g' >> $outdir/${basefname}f${form}${suf}.dat
+            echo $result
+        fi
+
+    done
+
+    echo
+    done
+done
+
+rm -f DONE_*.done
+

reactics-bdd/in/scripts/bench_mutex.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+
+outdir="results"
+basefname="mutex_"
+forms="`seq 1 3`"
+seq_f1="`seq 2 40`"
+seq_f2="`seq 2 40`"
+seq_f3="`seq 2 40`"
+
+tool="../main"
+options="-c -z -v -B"
+
+#ulimit -t 10000
+#ulimit -v 2621440
+
+ulimit -t 3600
+ulimit -v 2097152
+
+for form in $forms; do
+    eval sequence='$'seq_f$form
+    for n in $sequence; do
+        echo $form $n
+
+    for part in PT MT; do
+
+		echo "$form $n $part"
+
+        if [ "$part" = "PT" ];then
+            popt="-x"
+            suf="_pt"
+        else
+            popt=""
+            suf=""
+        fi
+
+		stopfile="DONE_${basefname}f${form}${suf}.done"
+
+		if [ -e "$stopfile" ];then
+			echo "Time limit - SKIPPING"
+			continue
+		fi
+
+        filename="$outdir/${basefname}${part}_f${form}_n${n}.out"
+
+        echo "$x" > $filename
+
+        ./gen_mutex.py $n $form > tmp.rs
+
+        echo "EXEC: $tool $options $popt tmp.rs"
+
+        $tool $options $popt tmp.rs >&1  >> $filename 
+
+        result="$(tail -1 $filename | grep -E '.*;.*;.*;.*'| sed "s/STAT/$n /")" 
+        if [ "$result" = "" ];then
+			echo "time limit"
+			touch $stopfile
+        else
+            echo $result >> results/summary_${basefname}${part}_f${form}
+            echo $result | sed 's/;/ /g' >> $outdir/${basefname}f${form}${suf}.dat
+            echo $result
+        fi
+    done
+
+    echo
+    done
+done
+

reactics-bdd/in/scripts/bench_pipe.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+
+outdir="results"
+basefname="pipe_abs_"
+forms="`seq 1 2`"
+seq_f1="`seq 2 40`"
+seq_f2="`seq 2 40`"
+
+tool="../main"
+options="-c -z -v -B"
+
+#ulimit -t 10000
+#ulimit -v 2621440
+
+ulimit -t 3600
+ulimit -v 2097152
+
+for form in $forms; do
+    eval sequence='$'seq_f$form
+    for n in $sequence; do
+        echo $form $n
+
+    for part in PT MT; do
+
+		echo "$form $n $part"
+
+        if [ "$part" = "PT" ];then
+            popt="-x"
+            suf="_pt"
+        else
+            popt=""
+            suf=""
+        fi
+
+		stopfile="DONE_${basefname}v${form}${suf}.done"
+
+		if [ -e "$stopfile" ];then
+			echo "Time limit - SKIPPING"
+			continue
+		fi
+
+        filename="$outdir/${basefname}${part}_v${form}_f0_n${n}.out"
+
+        echo "$x" > $filename
+
+        ./gen_abstract1.py $n $form > tmp.rs
+
+        echo "EXEC: $tool $options $popt tmp.rs"
+
+        $tool $options $popt tmp.rs >&1  >> $filename 
+
+        result="$(tail -1 $filename | grep -E '.*;.*;.*;.*'| sed "s/STAT/$n /")" 
+        if [ "$result" = "" ];then
+            echo "time limit"
+            touch $stopfile
+        else
+            echo $result >> results/summary_${basefname}${part}_v${form}_f0
+            echo $result | sed 's/;/ /g' >> $outdir/${basefname}v${form}_f0${suf}.dat
+            echo $result
+        fi
+    done
+
+    echo
+    done
+done
+
+rm -f DONE_*.done

reactics-bdd/in/scripts/benchmark.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in `seq 0 2`; do
+for x in `seq 2 1 24`;do
+    echo $y $x
+    filename="results/f${y}_n${x}.out"
+    echo "$x" > $filename
+    ./gen_bc.py $x $y > tmp.rs
+    ../main -c -B tmp.rs  >> $filename
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_f${y}.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/benchmark_abs1.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in 1 2; do
+for x in `seq 1 60`;do
+    echo $x
+    filename="results/abs_v${y}_f0_n${x}.out"
+    echo "$x" > $filename
+    ./gen_abstract1.py $x $y > tmp.rs
+    ../main -z -c -p -v -B tmp.rs >&1  >> $filename 
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_v${y}_abs_f0.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/benchmark_abs1_PT.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in 1 2; do
+for x in `seq 1 60`;do
+    echo $x
+    filename="results/abs_v${y}_f0_n${x}_PT.out"
+    echo "$x" > $filename
+    ./gen_abstract1.py $x $y > tmp.rs
+    ../main -z -x -c -p -v -B tmp.rs >&1  >> $filename 
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_v${y}_abs_f0_PT.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/benchmark_bc.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in 2; do
+for x in `seq 1 50`;do
+    echo $x $y
+    filename="results/bc_f${y}_n${x}.out"
+    echo "$x" > $filename
+    ./gen_bc.py $x $y > tmp.rs
+    ../main -z -c -v -B tmp.rs >&1  >> $filename 
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_bc_f${y}.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/benchmark_mutex.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in 3; do
+for x in `seq 2 40`;do
+    echo $x $y
+    filename="results/mutex_f${y}_n${x}.out"
+    echo "$x" > $filename
+    ./gen_mutex.py $x $y > tmp.rs
+    ../main -z -c -p -v -B tmp.rs >&1  >> $filename 
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_mutex_f${y}.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/benchmark_mutex_PT.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+for y in 1 2 3; do
+for x in `seq 2 40`;do
+    echo $x $y
+    filename="results/mutex_f${y}_n${x}_PT.out"
+    echo "$x" > $filename
+    ./gen_mutex.py $x $y > tmp.rs
+    ../main -zcpxvB tmp.rs >&1  >> $filename 
+    result="$(tail -1 $filename | sed "s/STAT/$x /")" 
+    echo $result >> results/summary_mutex_f${y}_PT.out
+    echo $result
+    echo
+done
+done
+
+rm tmp.rs

reactics-bdd/in/scripts/gen_abstract1.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+from sys import argv,exit
+
+if len(argv) < 3:
+    print "Usage:", argv[0], "<number of modules> <variant>"
+    exit(100)
+
+n = int(argv[1])
+v = int(argv[2])
+
+if not ( v > 0 and v < 3 ):
+    print "unsupported variant"
+    exit(100)
+
+print "reactions {"
+s = "\t{ {x},{s} -> {a1} };\n"
+print s
+
+for i in range(1,n+1):
+    s = "\t{ {a" + str(i) + "},{s} -> {y" + str(i) + "} };\n"
+    s += "\t{ {a" + str(i) + "},{s} -> {b" + str(i) + "} };\n"
+    s += "\t{ {b" + str(i) + "},{s} -> {c" + str(i) + "} };\n"
+    s += "\t{ {c" + str(i) + "},{s} -> {d" + str(i) + "} };\n"
+    s += "\t{ {d" + str(i) + ",y" + str(i) + "},{s} -> {a" + str(i+1) + "} };\n"
+    s += "\t{ {y" + str(i) + "},{s} -> {y" + str(i) + "} };\n"
+    print s
+
+s = "\t{ {a" + str(n+1) 
+for i in range(1,n+1):
+    s += ",y" + str(i)
+s += "},{s} -> {r} };\n"
+print s
+print "}"
+
+if v == 1:
+    print "context-entities { s }"
+elif v == 2:
+    s = "context-entities { s"
+    for i in range(1,n+1):
+        if i % 2 == 0:
+            s += ",a" + str(i)
+    s += " }"
+    print s
+
+print "initial-contexts { {x} }"
+print "rsctl-property { E[{}]F(r) }"

reactics-bdd/in/scripts/gen_asm.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+
+from sys import argv,exit
+
+OPTIONS_STR = """
+options { use-context-automaton; make-progressive; }
+"""
+
+PROC_STR = """
+    proc{:d} {{
+        {{{{a}}, {{s}} -> {{y}}}};
+        {{{{y}}, {{s}} -> {{y}}}};
+        {{{{a}}, {{s}} -> {{b}}}};
+        {{{{b}}, {{s}} -> {{c}}}};
+        {{{{c}}, {{s}} -> {{d}}}};
+        {{{{d,y}}, {{s}} -> {{dy}}}};
+    }};
+"""
+
+FINAL_PROC = """
+    procFinal {
+        {{done}, {s} -> {done}};
+    };
+"""
+
+CA_STR = """
+context-automaton {{
+    states {{ init, act }}
+    init-state {{ init }}
+    transitions {{
+{:s}
+    }}
+}}
+"""
+
+PROPERTY_STR = """
+rsctlk-property {{ {:s} : {:s} }}
+"""
+
+
+#################################################################
+
+if len(argv) < 1:
+    print("Usage: {:s} <number of processes>".format(argv[0]))
+    exit(100)
+
+n = int(argv[1])
+
+assert n > 1, "number of proc must be > 1"
+
+out = ""
+
+out += OPTIONS_STR
+out += "reactions {\n"
+for i in range(1, n+1):
+    out += PROC_STR.format(i)
+
+out += FINAL_PROC
+out += "}\n"
+
+transitions = ""
+
+init_trans = 8*" " + "{ proc1={a} }: init -> act;\n"
+transitions += init_trans
+
+for i in range(1, n+1):
+    transitions += "{:s}{{ proc{:d}={{}} }}: act -> act : ~proc{:d}.dy;\n".format(8*" ", i, i, i)
+
+for i in range(2, n+1):
+    transitions += "{:s}{{ proc{:d}={{a}} }}: act -> act : proc{:d}.dy;\n".format(8*" ", i, i-1)
+
+final_cond = "proc1.dy"
+for i in range(2, n+1):
+     final_cond += " AND proc{:d}.dy".format(i)
+
+transitions += "{:s}{{ procFinal={{done}} }}: act -> act : {:s};\n".format(8*" ", final_cond)
+
+out += CA_STR.format(transitions)
+
+# f1
+formula = "EF( procFinal.done )"
+out += PROPERTY_STR.format("f1",formula)
+
+# f2
+formula = "AG( proc{:d}.d IMPLIES K[proc{:d}]( proc{:d}.y ) )".format(n, n, n-1)
+out += PROPERTY_STR.format("f2",formula)
+
+# x1
+formula = "EF( ~procFinal.done )"
+out += PROPERTY_STR.format("x1",formula)
+
+print(out)
+

reactics-bdd/in/scripts/gen_bc.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python2.7
+
+from sys import argv,exit
+
+
+if len(argv) < 3:
+    print "Usage:", argv[0], "<number of bits> <property>"
+    exit(100)
+
+n = int(argv[1])
+property = int(argv[2])
+
+K = 8
+if property == 3:
+    if n < K+1:
+        print "too small n"
+        exit(100)
+
+if not ( property >= 1 and property < 5 ):
+    print "property: 1-4"
+    exit(101)
+
+print "reactions {"
+
+# (1) no dec, no inc
+print "\t# (1) no decrement, no increment"
+for j in range(0,n):
+    print "\t{{p" + str(j) + "},{dec,inc} -> {p" + str(j) + "}};"
+
+# (2) increment
+s = "\n\t# (2) increment operation\n"
+s += "\t{{inc},{dec,p0} -> {p0}};\n"
+for j in range(1,n):
+    s += "\t{{inc,"
+    for k in range(0,j):
+        s += "p" + str(k)
+        if k < j-1:
+            s += ","
+    s += "},{dec,p" + str(j) + "} -> {p" + str(j) + "}};\n"
+
+print s
+
+print "\t# the more significant bits remain (inc)"
+s = ""
+for j in range(0,n):
+    for k in range(j+1,n):
+        s += "\t{{inc,p" + str(k) + "},{dec,p" + str(j) + "} -> {p" + str(k) + "}};\n"
+
+print s
+
+print "\t# (3) decrement operation"
+s = ""
+for j in range(0,n):
+    s += "\t{{dec},{inc,"
+    for k in range(0,j+1):
+        s += "p" + str(k)
+        if k < j:
+            s += ","
+    s += "} -> {p" + str(j) + "}};\n"
+print s
+
+print "\t# the more significant bits remain (dec)"
+s = ""
+for j in range(0,n):
+    for k in range(j+1,n):
+        s += "\t{{dec,p" + str(j) + ",p" + str(k) + "},{inc} -> {p" + str(k) + "}};\n"
+
+s += "}\n"
+print s
+
+print "context-entities { inc,dec }"
+print "initial-contexts { {} }"
+
+if property == 4:
+    print "rsctl-property { AG( p" + str(n-1) + " IMPLIES EF ~p" + str(n-1) + " ) }"
+elif property == 1:
+    s = "rsctl-property { AG(("
+    for i in range(0,n):
+        s += "~p" + str(i)
+        if i < n-1:
+            s += " AND "
+    s += ") IMPLIES E[{inc},{dec}]F("
+    for i in range(0,n):
+        s += "p" + str(i)
+        if i < n-1:
+            s += " AND "
+ 
+    s += ")) }"
+    print s
+elif property == 2:
+    s = "rsctl-property { AG(("
+    for i in range(0,n):
+        s += "p" + str(i)
+        if i < n-1:
+            s += " AND "
+    s += ") IMPLIES A[{inc}]X("
+    for i in range(0,n):
+        s += "~p" + str(i)
+        if i < n-1:
+            s += " AND "
+ 
+    s += ")) }"
+    print s
+
+elif property == 3:
+    s = "rsctl-property { E[{inc}]F("
+    for i in range(0,n-K):
+        s += "p" + str(i)
+        if i < n-1:
+            s += " AND "
+    for i in range(n-K,n):
+        s += "~p" + str(i)
+        if i < n-1:
+            s += " AND "
+    s += ") }"
+    print s
+
+

reactics-bdd/in/scripts/gen_drs_mutex.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+from sys import argv,exit
+
+OPTIONS_STR = """
+options { use-context-automaton; }
+"""
+CONTROLLER_STR = """
+    ct {
+        {{lock},{leave} -> {lock}};
+        {{req},{} -> {lock}};
+    };
+"""
+
+PROC_STR = """
+    proc{:d} {{
+        {{{{out}}, {{}} -> {{approach}}}};
+        {{{{approach}}, {{req}} -> {{req}}}};
+        {{{{req}}, {{lock}} -> {{in}}}};
+        {{{{in}}, {{}} -> {{out,leave}}}};
+        {{{{req}}, {{in}} -> {{req}}}};
+    }};
+"""
+
+CA_STR = """
+context-automaton {{
+    states {{ s0, s1 }}
+    init-state {{ s0 }}
+    transitions {{
+{:s}
+    }}
+}}
+"""
+
+PROPERTY_STR = """
+rsctlk-property {{ {:s} : {:s} }}
+"""
+
+
+#################################################################
+
+if len(argv) < 1:
+    print("Usage: {:s} <number of processes>".format(argv[0]))
+    exit(100)
+
+n = int(argv[1])
+
+assert n > 1, "number of proc must be > 1"
+
+out = ""
+
+out += OPTIONS_STR
+out += "reactions {\n"
+out += CONTROLLER_STR
+for i in range(n):
+    out += PROC_STR.format(i)
+out += "}\n"
+
+transitions = ""
+
+init_trans = 8*" " + "{ ct={} "
+for i in range(n):
+    init_trans += "proc{:d}={{out}} ".format(i)
+
+init_trans += "}: s0 -> s1;\n"
+
+transitions += init_trans
+
+for i in range(n):
+    transitions += "{:s}{{ ct={{}} proc{:d}={{}} }}: s1 -> s1;\n".format(8*" ", i)    
+
+out += CA_STR.format(transitions)
+
+# f1
+formula = "EF( proc0.in )"
+for i in range(1, n):
+    formula += " AND EF( proc{:d}.in )".format(i)
+out += PROPERTY_STR.format("f1",formula)
+
+# f2
+subf = "~proc1.in"
+for i in range(2, n):
+    subf += " AND ~proc{:d}.in".format(i)
+formula = "AG( proc0.in IMPLIES K[proc0]({:s}) )".format(subf)
+
+out += PROPERTY_STR.format("f2",formula)
+
+print(out)
+

reactics-bdd/in/scripts/gen_mutex.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+from sys import argv,exit
+
+
+if len(argv) < 3:
+    print "Usage:", argv[0], "<number of processes> <formula>"
+    exit(100)
+
+n = int(argv[1])
+f = int(argv[2])
+
+if not ( f>0 and f<4 ):
+    print "unsupported formula"
+    exit(100)
+
+print "reactions {"
+for i in range(0,n):
+    s = "\t{{out" + str(i) + ",act" + str(i) + "},{} -> {request" + str(i) + "}};\n"
+    s += "\t{{out" + str(i) + "},{act" + str(i) + "} -> {out" + str(i) + "}};\n"
+    for j in range(0,n):
+        if i != j:
+            s += "\t{{request" + str(i) + ",act" + str(i) + ",act" + str(j) + "},{} -> {request" + str(i) + "}};\n"
+    #s += "\t{{request" + str(i) + "},{"
+    #for j in range(0,n):
+    #    s += "act" + str(j)
+    #    if j < n-1:
+    #        s += ","
+    #s += "} -> {request" + str(i) + "}};\n"
+    s += "\t{{request" + str(i) + "},{act" + str(i) + "} -> {request" + str(i) + "}};\n"
+    s += "\t{{request" + str(i) + ",act" + str(i) + "},{"
+    for j in range(0,n):
+        if i != j:
+            s += "act" + str(j) + ","
+    s += "lock} -> {in" + str(i) + ",lock}};\n"
+    s += "\t{{in" + str(i) + ",act" + str(i) + "},{} -> {out" + str(i) + ",done}};\n"
+    s += "\t{{in" + str(i) + "},{act" + str(i) + "} -> {in" + str(i) + "}};\n"
+    print s
+
+print "\t{{lock},{done} -> {lock}};"
+
+print "}"
+
+s = "context-entities {"
+for i in range(0,n):
+    s += "act" + str(i)
+    if i < n-1:
+        s += ","
+s += "}\n"
+print s
+
+s = "initial-contexts { {"
+for i in range(0,n):
+    s += "out" + str(i)
+    if i < n-1:
+        s += ","
+s += "} }\n"
+print s
+
+#print "rsctl-property { A[{act1}]G(A[{act1}]F(in1)) }"
+if f == 1:
+    print "rsctl-property { A[{act1}]F(in1) }"
+elif f == 2:
+    print "rsctl-property { E[{act1}]F(in1) }"
+elif f == 3:
+    s = "rsctl-property { AG("
+    for i in range(0,n):
+        for j in range(i+1,n):
+            s += "~(in" + str(i) + " AND in" + str(j) + ")"
+            if i < n-2:
+                s += " AND "
+    s += ") }"
+    print s
+else:
+    exit(111)
+

reactics-bdd/in/scripts/gen_tgc_sc.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+from sys import argv,exit
+
+OPTIONS_STR = """
+options { use-context-automaton; make-progressive; };
+"""
+
+PROC_STR = """
+    proc{:d} {{
+        {{{{out}}, {{}} -> {{approach}}}};
+        {{{{approach}}, {{req}} -> {{req}}}};
+        {{{{allowed}}, {{}} -> {{in}}}};
+        {{{{in}}, {{}} -> {{out,leave}}}};
+        {{{{req}}, {{in}} -> {{req}}}};
+    }};
+"""
+
+CA_STR = """
+context-automaton {{
+    states {{ init, green, red }};
+    init-state {{ init }};
+    transitions {{
+{:s}
+    }};
+}};
+"""
+
+PROPERTY_STR = """
+rsctlk-property {{ {:s} : {:s} }};
+"""
+
+
+#################################################################
+
+if len(argv) < 1:
+    print("Usage: {:s} <number of processes>".format(argv[0]))
+    exit(100)
+
+n = int(argv[1])
+
+assert n > 1, "number of proc must be > 1"
+
+out = ""
+
+out += OPTIONS_STR
+out += "reactions {\n"
+for i in range(n):
+    out += PROC_STR.format(i)
+out += "};\n"
+
+transitions = ""
+
+init_trans = 8*" " + "{ "
+for i in range(n):
+    init_trans += "proc{:d}={{out}} ".format(i)
+init_trans += "}: init -> green;\n"
+transitions += init_trans
+
+for i in range(n):
+    transitions += "{:s}{{ proc{:d}={{allowed}} }}: green -> red : proc{:d}.req;\n".format(8*" ", i, i)
+
+no_req_cond = "~proc0.req"
+for i in range(1, n):
+     no_req_cond += " AND ~proc{:d}.req".format(i)
+
+for i in range(n):
+    transitions += "{:s}{{ proc{:d}={{}} }}: green -> green : {:s};\n".format(8*" ", i, no_req_cond)
+
+for i in range(n):
+    transitions += "{:s}{{ proc{:d}={{}} }}: red -> green : proc{:d}.leave;\n".format(8*" ", i, i)
+
+no_leave_cond = "~proc0.leave"
+for i in range(1, n):
+     no_leave_cond += " AND ~proc{:d}.leave".format(i)
+
+for i in range(n):
+    transitions += "{:s}{{ proc{:d}={{}} }}: red -> red : {:s};\n".format(8*" ", i, no_leave_cond)
+
+out += CA_STR.format(transitions)
+
+## f1
+#formula = "EF( proc0.in )"
+#out += PROPERTY_STR.format("f1",formula)
+
+# f1
+formula = "EF( E<proc0.allowed>X( proc0.in ) )"
+for i in range(1, n):
+    formula += " AND EF( E<proc{:d}.allowed>X( proc{:d}.in ) )".format(i, i)
+out += PROPERTY_STR.format("f1",formula)
+
+# f2
+formula = "EF( proc0.approach"
+for i in range(1, n):
+    formula += " AND proc{:d}.approach".format(i)
+formula += " )"
+out += PROPERTY_STR.format("f2",formula)
+
+# f3
+subf = "~proc1.in"
+for i in range(2, n):
+    subf += " AND ~proc{:d}.in".format(i)
+formula = "AG( proc0.in IMPLIES K[proc0]({:s}) )".format(subf)
+out += PROPERTY_STR.format("f3",formula)
+
+# f4
+subf = "~proc1.in"
+for i in range(2, n):
+    subf += " AND ~proc{:d}.in".format(i)
+all_agents = "proc0"
+for i in range(1, n):
+    all_agents += ",proc{:d}".format(i)
+formula = "AG( proc0.in IMPLIES C[{:s}]({:s}) )".format(all_agents,subf)
+out += PROPERTY_STR.format("f4",formula)
+
+print(out)
+

reactics-bdd/in/scripts/get_results.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+test -z "$1" && exit 1
+cd $1
+for f in `ls *.out | sort -n`; do
+    n="$(head -1 $f)"
+    res="$(tail -1 $f)"
+    enct="$(echo $res | cut -f 2 -d';')"
+    vert="$(echo $res | cut -f 3 -d';')"
+    encm="$(echo $res | cut -f 4 -d';')"
+    verm="$(echo $res | cut -f 5 -d';')"
+    tott="$(echo $res | cut -f 6 -d';')"
+    echo "$n $enct $vert $encm $verm $tott"
+done