Execution Chart

We display below the execution chart for this examination (boot time has been removed).

Trace from the execution

Formatting '/data/fkordon/mcc2023-input.r490-tall-167912709200822.qcow2', fmt=qcow2 size=4294967296 backing_file=/data/fkordon/mcc2023-input.qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16
Waiting for the VM to be ready (probing ssh)
.........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
=====================================================================
Generated by BenchKit 2-5348
Executing tool marciexred
Input is TwoPhaseLocking-PT-nC00050vD, examination is ReachabilityCardinality
Time confinement is 3600 seconds
Memory confinement is 16384 MBytes
Number of cores is 4
Run identifier is r490-tall-167912709200822
=====================================================================

--------------------
preparation of the directory to be used:
/home/mcc/execution
total 484K
-rw-r--r-- 1 mcc users 5.5K Feb 25 17:48 CTLCardinality.txt
-rw-r--r-- 1 mcc users 48K Feb 25 17:48 CTLCardinality.xml
-rw-r--r-- 1 mcc users 6.2K Feb 25 17:46 CTLFireability.txt
-rw-r--r-- 1 mcc users 55K Feb 25 17:46 CTLFireability.xml
-rw-r--r-- 1 mcc users 4.0K Feb 25 17:22 LTLCardinality.txt
-rw-r--r-- 1 mcc users 25K Feb 25 17:22 LTLCardinality.xml
-rw-r--r-- 1 mcc users 2.5K Feb 25 17:23 LTLFireability.txt
-rw-r--r-- 1 mcc users 19K Feb 25 17:23 LTLFireability.xml
-rw-r--r-- 1 mcc users 16K Feb 25 17:49 ReachabilityCardinality.txt
-rw-r--r-- 1 mcc users 170K Feb 25 17:49 ReachabilityCardinality.xml
-rw-r--r-- 1 mcc users 9.1K Feb 25 17:48 ReachabilityFireability.txt
-rw-r--r-- 1 mcc users 77K Feb 25 17:48 ReachabilityFireability.xml
-rw-r--r-- 1 mcc users 1.8K Feb 25 17:23 UpperBounds.txt
-rw-r--r-- 1 mcc users 3.9K Feb 25 17:23 UpperBounds.xml
-rw-r--r-- 1 mcc users 6 Mar 5 18:23 equiv_col
-rw-r--r-- 1 mcc users 10 Mar 5 18:23 instance
-rw-r--r-- 1 mcc users 6 Mar 5 18:23 iscolored
-rw-r--r-- 1 mcc users 4.6K Mar 5 18:23 model.pnml

--------------------
content from stdout:

=== Data for post analysis generated by BenchKit (invocation template)

The expected result is a vector of booleans
BOOL_VECTOR

here is the order used to build the result vector(from text file)
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-00
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-01
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-02
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-03
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-04
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-05
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-06
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-07
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-08
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-09
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-10
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-11
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-12
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-13
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-14
FORMULA_NAME TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-15

=== Now, execution of the tool begins

BK_START 1679339284867

bash -c /home/mcc/BenchKit/BenchKit_head.sh 2> STDERR ; echo ; echo -n "BK_STOP " ; date -u +%s%3N
Invoking MCC driver with
BK_TOOL=marciexred
BK_EXAMINATION=ReachabilityCardinality
BK_BIN_PATH=/home/mcc/BenchKit/bin/
BK_TIME_CONFINEMENT=3600
BK_INPUT=TwoPhaseLocking-PT-nC00050vD
Applying reductions before tool marcie
Invoking reducer
Running Version 202303021504
[2023-03-20 19:08:06] [INFO ] Running its-tools with arguments : [-pnfolder, /home/mcc/execution, -examination, ReachabilityCardinality, -timeout, 360, -rebuildPNML]
[2023-03-20 19:08:06] [INFO ] Parsing pnml file : /home/mcc/execution/model.pnml
[2023-03-20 19:08:06] [INFO ] Load time of PNML (sax parser for PT used): 23 ms
[2023-03-20 19:08:06] [INFO ] Transformed 8 places.
[2023-03-20 19:08:06] [INFO ] Transformed 6 transitions.
[2023-03-20 19:08:06] [INFO ] Parsed PT model containing 8 places and 6 transitions and 18 arcs in 80 ms.
Parsed 16 properties from file /home/mcc/execution/ReachabilityCardinality.xml in 19 ms.
Working with output stream class java.io.PrintStream
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-11 TRUE TECHNIQUES TOPOLOGICAL INITIAL_STATE
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-12 TRUE TECHNIQUES TOPOLOGICAL INITIAL_STATE
Incomplete random walk after 10004 steps, including 33 resets, run finished after 78 ms. (steps per millisecond=128 ) properties (out of 14) seen :9
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-15 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-14 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-13 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-10 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-09 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-08 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-03 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-01 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-00 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 105 ms. (steps per millisecond=95 ) properties (out of 5) seen :0
Incomplete Best-First random walk after 10001 steps, including 36 resets, run finished after 85 ms. (steps per millisecond=117 ) properties (out of 5) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 75 ms. (steps per millisecond=133 ) properties (out of 5) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 113 ms. (steps per millisecond=88 ) properties (out of 5) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 79 ms. (steps per millisecond=126 ) properties (out of 5) seen :0
Running SMT prover for 5 properties.
// Phase 1: matrix 6 rows 8 cols
[2023-03-20 19:08:07] [INFO ] Computed 3 place invariants in 7 ms
[2023-03-20 19:08:07] [INFO ] After 131ms SMT Verify possible using all constraints in real domain returned unsat :0 sat :0 real:5
[2023-03-20 19:08:07] [INFO ] [Nat]Absence check using 3 positive place invariants in 1 ms returned sat
[2023-03-20 19:08:07] [INFO ] After 10ms SMT Verify possible using state equation in natural domain returned unsat :4 sat :1
[2023-03-20 19:08:07] [INFO ] After 16ms SMT Verify possible using trap constraints in natural domain returned unsat :4 sat :1
Attempting to minimize the solution found.
Minimization took 9 ms.
[2023-03-20 19:08:07] [INFO ] After 80ms SMT Verify possible using all constraints in natural domain returned unsat :4 sat :1
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-06 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-05 FALSE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-04 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-02 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
Fused 5 Parikh solutions to 1 different solutions.
Finished Parikh walk after 54 steps, including 0 resets, run visited all 1 properties in 2 ms. (steps per millisecond=27 )
FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-07 FALSE TECHNIQUES TOPOLOGICAL PARIKH_WALK
Parikh walk visited 1 properties in 3 ms.
All properties solved without resorting to model-checking.
Total runtime 1015 ms.
timeout --kill-after=10s --signal=SIGINT 1m for testing only

Marcie built on Linux at 2019-11-18.
A model checker for Generalized Stochastic Petri nets

authors: Alex Tovchigrechko (IDD package and CTL model checking)

Martin Schwarick (Symbolic numerical analysis and CSL model checking)

Christian Rohr (Simulative and approximative numerical model checking)

marcie@informatik.tu-cottbus.de

called as: /home/mcc/BenchKit/bin//../reducer/bin//../../marcie/bin/marcie --net-file=model.pnml --mcc-file=ReachabilityCardinality.xml --memory=6 --mcc-mode

parse successfull
net created successfully

Net: TwoPhaseLocking_PT_nC00050vD
(NrP: 8 NrTr: 6 NrArc: 18)

parse formulas
formulas created successfully
place and transition orderings generation:0m 0.000sec

net check time: 0m 0.000sec

init dd package: 0m 2.748sec


RS generation: 0m 0.132sec


-> reachability set: #nodes 11232 (1.1e+04) #states 380,015 (5)



starting MCC model checker
--------------------------

checking: EF [20<=haveB]
normalized: E [true U 20<=haveB]

abstracting: (20<=haveB)
states: 16,183 (4)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-00 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.044sec

checking: AG [3<=resB]
normalized: ~ [E [true U ~ [3<=resB]]]

abstracting: (3<=resB)
states: 308,890 (5)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-09 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.092sec

checking: EF [24<=haveB]
normalized: E [true U 24<=haveB]

abstracting: (24<=haveB)
states: 1,351 (3)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-13 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: AG [haveA2<=21]
normalized: ~ [E [true U ~ [haveA2<=21]]]

abstracting: (haveA2<=21)
states: 379,148 (5)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-14 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.211sec

checking: AG [~ [Clients<=14]]
normalized: ~ [E [true U Clients<=14]]

abstracting: (Clients<=14)
states: 53,855 (4)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-15 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.018sec

checking: AG [[Clients<=50 & haveA2andB<=7]]
normalized: ~ [E [true U ~ [[Clients<=50 & haveA2andB<=7]]]]

abstracting: (haveA2andB<=7)
states: 312,983 (5)
abstracting: (Clients<=50)
states: 380,015 (5)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-08 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.019sec

checking: AG [haveA<=haveA]
normalized: ~ [E [true U ~ [haveA<=haveA]]]

abstracting: (haveA<=haveA)
states: 380,015 (5)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-12 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: AG [~ [[~ [resA<=resA] & ~ [Clients<=haveAandB]]]]
normalized: ~ [E [true U [~ [Clients<=haveAandB] & ~ [resA<=resA]]]]

abstracting: (resA<=resA)
states: 380,015 (5)
abstracting: (Clients<=haveAandB)
states: 350
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-11 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.040sec

checking: AG [[[resA<=41 | [[[3<=haveA | resA<=6] & Clients<=28] & [~ [haveAandB<=haveA2andB] & ~ [[[~ [[41<=resB | 45<=resA]] & [[haveA2<=Clients | haveA2andB<=19] & [haveA<=27 | haveB<=resB]]] & [haveA2<=resA & [[haveA2<=0 | 42<=haveA] | [7<=Clients & 5<=resA]]]]]]]] | resB<=Clients]]
normalized: ~ [E [true U ~ [[resB<=Clients | [resA<=41 | [[~ [[[haveA2<=resA & [[7<=Clients & 5<=resA] | [haveA2<=0 | 42<=haveA]]] & [[[haveA<=27 | haveB<=resB] & [haveA2<=Clients | haveA2andB<=19]] & ~ [[41<=resB | 45<=resA]]]]] & ~ [haveAandB<=haveA2andB]] & [Clients<=28 & [3<=haveA | resA<=6]]]]]]]]

abstracting: (resA<=6)
states: 242,493 (5)
abstracting: (3<=haveA)
states: 257,140 (5)
abstracting: (Clients<=28)
states: 314,235 (5)
abstracting: (haveAandB<=haveA2andB)
states: 207,388 (5)
abstracting: (45<=resA)
states: 0
abstracting: (41<=resB)
states: 0
abstracting: (haveA2andB<=19)
states: 379,511 (5)
abstracting: (haveA2<=Clients)
states: 360,724 (5)
abstracting: (haveB<=resB)
states: 195,923 (5)
abstracting: (haveA<=27)
states: 380,015 (5)
abstracting: (42<=haveA)
states: 0
abstracting: (haveA2<=0)
states: 44,226 (4)
abstracting: (5<=resA)
states: 191,268 (5)
abstracting: (7<=Clients)
states: 375,312 (5)
abstracting: (haveA2<=resA)
states: 201,474 (5)
abstracting: (resA<=41)
states: 380,015 (5)
abstracting: (resB<=Clients)
states: 380,015 (5)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-04 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.278sec

checking: EF [[Clients<=haveAandB & [[~ [[[[haveA2andB<=48 | [9<=haveA | ~ [haveB<=46]]] & ~ [[~ [haveA2andB<=resA] & [resB<=40 & haveAandB<=22]]]] | [~ [[23<=haveA2andB & [27<=resB | 19<=haveB]]] | ~ [7<=haveA2andB]]]] & ~ [[31<=haveB | [~ [7<=Clients] | [[~ [6<=haveB] & [28<=haveAandB & resB<=haveA2]] | [[Clients<=haveA2 & haveA2<=resB] | ~ [haveB<=resB]]]]]]] | resA<=haveB]]]
normalized: E [true U [Clients<=haveAandB & [resA<=haveB | [~ [[31<=haveB | [[[~ [haveB<=resB] | [Clients<=haveA2 & haveA2<=resB]] | [[28<=haveAandB & resB<=haveA2] & ~ [6<=haveB]]] | ~ [7<=Clients]]]] & ~ [[[~ [7<=haveA2andB] | ~ [[23<=haveA2andB & [27<=resB | 19<=haveB]]]] | [~ [[[resB<=40 & haveAandB<=22] & ~ [haveA2andB<=resA]]] & [haveA2andB<=48 | [9<=haveA | ~ [haveB<=46]]]]]]]]]]

abstracting: (haveB<=46)
states: 380,015 (5)
abstracting: (9<=haveA)
states: 94,962 (4)
abstracting: (haveA2andB<=48)
states: 380,015 (5)
abstracting: (haveA2andB<=resA)
states: 236,872 (5)
abstracting: (haveAandB<=22)
states: 379,982 (5)
abstracting: (resB<=40)
states: 380,015 (5)
abstracting: (19<=haveB)
states: 23,309 (4)
abstracting: (27<=resB)
states: 0
abstracting: (23<=haveA2andB)
states: 33
abstracting: (7<=haveA2andB)
states: 86,317 (4)
abstracting: (7<=Clients)
states: 375,312 (5)
abstracting: (6<=haveB)
states: 239,161 (5)
abstracting: (resB<=haveA2)
states: 142,505 (5)
abstracting: (28<=haveAandB)
states: 0
abstracting: (haveA2<=resB)
states: 261,261 (5)
abstracting: (Clients<=haveA2)
states: 22,931 (4)
abstracting: (haveB<=resB)
states: 195,923 (5)
abstracting: (31<=haveB)
states: 0
abstracting: (resA<=haveB)
states: 261,260 (5)
abstracting: (Clients<=haveAandB)
states: 350
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-01 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.120sec

checking: AG [[~ [resB<=haveA2andB] | [[[~ [[[~ [[haveA2<=8 & haveB<=haveA2]] | haveB<=13] | ~ [[~ [haveA<=20] & ~ [24<=resB]]]]] | [[[haveAandB<=12 | [[haveB<=haveB & resB<=haveB] | ~ [resA<=20]]] & ~ [[~ [42<=Clients] & [4<=Clients | 28<=haveB]]]] & [[[[2<=resA | haveAandB<=37] & ~ [haveB<=39]] | haveAandB<=19] | [[[resB<=24 | 46<=haveA] | [42<=haveAandB | haveB<=haveA2]] | 4<=Clients]]]] & 2<=haveB] & ~ [Clients<=24]]]]
normalized: ~ [E [true U ~ [[[~ [Clients<=24] & [2<=haveB & [[[[4<=Clients | [[42<=haveAandB | haveB<=haveA2] | [resB<=24 | 46<=haveA]]] | [haveAandB<=19 | [~ [haveB<=39] & [2<=resA | haveAandB<=37]]]] & [~ [[[4<=Clients | 28<=haveB] & ~ [42<=Clients]]] & [haveAandB<=12 | [~ [resA<=20] | [haveB<=haveB & resB<=haveB]]]]] | ~ [[~ [[~ [24<=resB] & ~ [haveA<=20]]] | [haveB<=13 | ~ [[haveA2<=8 & haveB<=haveA2]]]]]]]] | ~ [resB<=haveA2andB]]]]]

abstracting: (resB<=haveA2andB)
states: 123,213 (5)
abstracting: (haveB<=haveA2)
states: 142,505 (5)
abstracting: (haveA2<=8)
states: 285,054 (5)
abstracting: (haveB<=13)
states: 298,298 (5)
abstracting: (haveA<=20)
states: 378,307 (5)
abstracting: (24<=resB)
states: 1,352 (3)
abstracting: (resB<=haveB)
states: 195,922 (5)
abstracting: (haveB<=haveB)
states: 380,015 (5)
abstracting: (resA<=20)
states: 378,307 (5)
abstracting: (haveAandB<=12)
states: 365,091 (5)
abstracting: (42<=Clients)
states: 1,287 (3)
abstracting: (28<=haveB)
states: 0
abstracting: (4<=Clients)
states: 379,169 (5)
abstracting: (haveAandB<=37)
states: 380,015 (5)
abstracting: (2<=resA)
states: 294,840 (5)
abstracting: (haveB<=39)
states: 380,015 (5)
abstracting: (haveAandB<=19)
states: 379,511 (5)
abstracting: (46<=haveA)
states: 0
abstracting: (resB<=24)
states: 379,664 (5)
abstracting: (haveB<=haveA2)
states: 142,505 (5)
abstracting: (42<=haveAandB)
states: 0
abstracting: (4<=Clients)
states: 379,169 (5)
abstracting: (2<=haveB)
states: 332,539 (5)
abstracting: (Clients<=24)
states: 237,509 (5)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-03 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.239sec

checking: EF [[~ [[[~ [[[haveAandB<=42 | haveA2<=33] & [[17<=haveA2 | haveA<=16] & [21<=haveA | resA<=resB]]]] | Clients<=haveA2andB] | [[~ [[[34<=haveA & 50<=haveA] | ~ [haveA2<=29]]] | [[[Clients<=resA & 10<=haveB] | [Clients<=haveA2andB | 49<=haveA]] | [haveAandB<=haveA2 | [3<=haveA2andB | resB<=44]]]] | [~ [[resA<=haveAandB & haveA<=13]] | [29<=Clients & [~ [resB<=Clients] | [Clients<=23 | haveB<=29]]]]]]] | 37<=haveA2andB]]
normalized: E [true U [37<=haveA2andB | ~ [[[[[29<=Clients & [[Clients<=23 | haveB<=29] | ~ [resB<=Clients]]] | ~ [[resA<=haveAandB & haveA<=13]]] | [[[haveAandB<=haveA2 | [3<=haveA2andB | resB<=44]] | [[Clients<=haveA2andB | 49<=haveA] | [Clients<=resA & 10<=haveB]]] | ~ [[~ [haveA2<=29] | [34<=haveA & 50<=haveA]]]]] | [Clients<=haveA2andB | ~ [[[[21<=haveA | resA<=resB] & [17<=haveA2 | haveA<=16]] & [haveAandB<=42 | haveA2<=33]]]]]]]]

abstracting: (haveA2<=33)
states: 380,015 (5)
abstracting: (haveAandB<=42)
states: 380,015 (5)
abstracting: (haveA<=16)
states: 368,729 (5)
abstracting: (17<=haveA2)
states: 11,285 (4)
abstracting: (resA<=resB)
states: 261,260 (5)
abstracting: (21<=haveA)
states: 1,708 (3)
abstracting: (Clients<=haveA2andB)
states: 350
abstracting: (50<=haveA)
states: 0
abstracting: (34<=haveA)
states: 0
abstracting: (haveA2<=29)
states: 380,015 (5)
abstracting: (10<=haveB)
states: 152,999 (5)
abstracting: (Clients<=resA)
states: 350
abstracting: (49<=haveA)
states: 0
abstracting: (Clients<=haveA2andB)
states: 350
abstracting: (resB<=44)
states: 380,015 (5)
abstracting: (3<=haveA2andB)
states: 212,290 (5)
abstracting: (haveAandB<=haveA2)
states: 236,872 (5)
abstracting: (haveA<=13)
states: 350,531 (5)
abstracting: (resA<=haveAandB)
states: 171,989 (5)
abstracting: (resB<=Clients)
states: 380,015 (5)
abstracting: (haveB<=29)
states: 380,015 (5)
abstracting: (Clients<=23)
states: 214,109 (5)
abstracting: (29<=Clients)
states: 65,780 (4)
abstracting: (37<=haveA2andB)
states: 0
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-05 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.279sec

checking: AG [[~ [[[[~ [[[haveA2<=17 | [39<=Clients | resA<=0]] & ~ [[Clients<=4 & 6<=haveA]]]] & [[~ [[Clients<=38 | haveB<=29]] & ~ [haveB<=34]] & ~ [27<=resB]]] & ~ [[~ [haveB<=haveAandB] | [haveB<=Clients | 2<=haveA]]]] | 36<=resA]] | ~ [[[haveA2<=haveB | [[[~ [[haveA<=resA | haveA<=45]] & 3<=haveAandB] & [haveAandB<=Clients | ~ [resB<=haveA]]] & ~ [[[[haveA<=46 | resB<=Clients] & [18<=resB & haveA<=Clients]] & [33<=haveB & ~ [haveA2andB<=20]]]]]] & ~ [[[[[~ [resA<=resB] & [30<=haveB | 33<=resA]] | ~ [haveA2<=haveA2andB]] | Clients<=13] & 20<=haveAandB]]]]]]
normalized: ~ [E [true U ~ [[~ [[~ [[20<=haveAandB & [Clients<=13 | [~ [haveA2<=haveA2andB] | [[30<=haveB | 33<=resA] & ~ [resA<=resB]]]]]] & [haveA2<=haveB | [~ [[[33<=haveB & ~ [haveA2andB<=20]] & [[18<=resB & haveA<=Clients] & [haveA<=46 | resB<=Clients]]]] & [[haveAandB<=Clients | ~ [resB<=haveA]] & [3<=haveAandB & ~ [[haveA<=resA | haveA<=45]]]]]]]] | ~ [[36<=resA | [~ [[[haveB<=Clients | 2<=haveA] | ~ [haveB<=haveAandB]]] & [[~ [27<=resB] & [~ [haveB<=34] & ~ [[Clients<=38 | haveB<=29]]]] & ~ [[~ [[Clients<=4 & 6<=haveA]] & [haveA2<=17 | [39<=Clients | resA<=0]]]]]]]]]]]]

abstracting: (resA<=0)
states: 44,225 (4)
abstracting: (39<=Clients)
states: 4,368 (3)
abstracting: (haveA2<=17)
states: 372,360 (5)
abstracting: (6<=haveA)
states: 162,932 (5)
abstracting: (Clients<=4)
states: 1,651 (3)
abstracting: (haveB<=29)
states: 380,015 (5)
abstracting: (Clients<=38)
states: 375,647 (5)
abstracting: (haveB<=34)
states: 380,015 (5)
abstracting: (27<=resB)
states: 0
abstracting: (haveB<=haveAandB)
states: 123,214 (5)
abstracting: (2<=haveA)
states: 294,840 (5)
abstracting: (haveB<=Clients)
states: 328,055 (5)
abstracting: (36<=resA)
states: 0
abstracting: (haveA<=45)
states: 380,015 (5)
abstracting: (haveA<=resA)
states: 201,473 (5)
abstracting: (3<=haveAandB)
states: 212,290 (5)
abstracting: (resB<=haveA)
states: 142,505 (5)
abstracting: (haveAandB<=Clients)
states: 380,015 (5)
abstracting: (resB<=Clients)
states: 380,015 (5)
abstracting: (haveA<=46)
states: 380,015 (5)
abstracting: (haveA<=Clients)
states: 360,723 (5)
abstracting: (18<=resB)
states: 31,956 (4)
abstracting: (haveA2andB<=20)
states: 379,777 (5)
abstracting: (33<=haveB)
states: 0
abstracting: (haveA2<=haveB)
states: 261,260 (5)
abstracting: (resA<=resB)
states: 261,260 (5)
abstracting: (33<=resA)
states: 0
abstracting: (30<=haveB)
states: 0
abstracting: (haveA2<=haveA2andB)
states: 171,990 (5)
abstracting: (Clients<=13)
states: 43,315 (4)
abstracting: (20<=haveAandB)
states: 504
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-02 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.360sec

checking: AG [[[[[haveB<=haveB & [16<=resA | haveA<=haveAandB]] & [[[haveA<=0 | [[haveAandB<=haveB | 11<=resA] & ~ [resA<=haveB]]] & [~ [[[haveA2<=Clients & 16<=haveA2andB] | [14<=haveA & 41<=resA]]] & 34<=haveA]] | [[[50<=haveA2andB & ~ [[haveAandB<=10 | haveAandB<=haveA2]]] | 3<=haveA] & [~ [[haveB<=43 | ~ [12<=haveA2]]] & [[[haveA2andB<=41 | resA<=42] | [haveA2andB<=42 | haveA2<=haveB]] | ~ [11<=haveA]]]]]] & ~ [resB<=resB]] | ~ [[[[[haveA2andB<=resB | [~ [23<=haveA2] | [38<=haveB & ~ [Clients<=37]]]] & ~ [resB<=27]] | [[[[[haveAandB<=6 | haveA<=resB] | ~ [haveA2<=12]] & ~ [haveB<=resB]] & [[[14<=haveA2andB & 48<=Clients] & [47<=Clients | haveA2<=39]] | [10<=resA & [haveA2<=haveA2andB & 16<=haveAandB]]]] & haveB<=34]] | [[[haveA<=12 & [[~ [resB<=resA] | [haveA2<=37 & resB<=43]] & resB<=resB]] & ~ [[Clients<=23 | [haveAandB<=haveA2andB | haveA2andB<=resA]]]] & [[~ [25<=haveAandB] | [haveA2<=Clients | [~ [resB<=haveA] | [resA<=44 & haveA<=39]]]] | [[~ [resB<=32] | 5<=resB] & [haveAandB<=3 & [[haveB<=27 | resB<=haveA2] | ~ [resB<=14]]]]]]]]]]
normalized: ~ [E [true U ~ [[~ [[[[[[haveAandB<=3 & [~ [resB<=14] | [haveB<=27 | resB<=haveA2]]] & [5<=resB | ~ [resB<=32]]] | [[haveA2<=Clients | [[resA<=44 & haveA<=39] | ~ [resB<=haveA]]] | ~ [25<=haveAandB]]] & [~ [[Clients<=23 | [haveAandB<=haveA2andB | haveA2andB<=resA]]] & [haveA<=12 & [resB<=resB & [[haveA2<=37 & resB<=43] | ~ [resB<=resA]]]]]] | [[haveB<=34 & [[[10<=resA & [haveA2<=haveA2andB & 16<=haveAandB]] | [[47<=Clients | haveA2<=39] & [14<=haveA2andB & 48<=Clients]]] & [~ [haveB<=resB] & [~ [haveA2<=12] | [haveAandB<=6 | haveA<=resB]]]]] | [~ [resB<=27] & [haveA2andB<=resB | [[38<=haveB & ~ [Clients<=37]] | ~ [23<=haveA2]]]]]]] | [~ [resB<=resB] & [[[[~ [[haveB<=43 | ~ [12<=haveA2]]] & [~ [11<=haveA] | [[haveA2andB<=42 | haveA2<=haveB] | [haveA2andB<=41 | resA<=42]]]] & [3<=haveA | [50<=haveA2andB & ~ [[haveAandB<=10 | haveAandB<=haveA2]]]]] | [[34<=haveA & ~ [[[14<=haveA & 41<=resA] | [haveA2<=Clients & 16<=haveA2andB]]]] & [haveA<=0 | [~ [resA<=haveB] & [haveAandB<=haveB | 11<=resA]]]]] & [haveB<=haveB & [16<=resA | haveA<=haveAandB]]]]]]]]

abstracting: (haveA<=haveAandB)
states: 171,989 (5)
abstracting: (16<=resA)
states: 16,016 (4)
abstracting: (haveB<=haveB)
states: 380,015 (5)
abstracting: (11<=resA)
states: 62,424 (4)
abstracting: (haveAandB<=haveB)
states: 277,367 (5)
abstracting: (resA<=haveB)
states: 261,260 (5)
abstracting: (haveA<=0)
states: 44,225 (4)
abstracting: (16<=haveA2andB)
states: 4,576 (3)
abstracting: (haveA2<=Clients)
states: 360,724 (5)
abstracting: (41<=resA)
states: 0
abstracting: (14<=haveA)
states: 29,484 (4)
abstracting: (34<=haveA)
states: 0
abstracting: (haveAandB<=haveA2)
states: 236,872 (5)
abstracting: (haveAandB<=10)
states: 351,251 (5)
abstracting: (50<=haveA2andB)
states: 0
abstracting: (3<=haveA)
states: 257,140 (5)
abstracting: (resA<=42)
states: 380,015 (5)
abstracting: (haveA2andB<=41)
states: 380,015 (5)
abstracting: (haveA2<=haveB)
states: 261,260 (5)
abstracting: (haveA2andB<=42)
states: 380,015 (5)
abstracting: (11<=haveA)
states: 62,424 (4)
abstracting: (12<=haveA2)
states: 49,503 (4)
abstracting: (haveB<=43)
states: 380,015 (5)
abstracting: (resB<=resB)
states: 380,015 (5)
abstracting: (23<=haveA2)
states: 377
abstracting: (Clients<=37)
states: 373,827 (5)
abstracting: (38<=haveB)
states: 0
abstracting: (haveA2andB<=resB)
states: 277,367 (5)
abstracting: (resB<=27)
states: 380,015 (5)
abstracting: (haveA<=resB)
states: 261,260 (5)
abstracting: (haveAandB<=6)
states: 293,698 (5)
abstracting: (haveA2<=12)
states: 341,432 (5)
abstracting: (haveB<=resB)
states: 195,923 (5)
abstracting: (48<=Clients)
states: 21
abstracting: (14<=haveA2andB)
states: 10,374 (4)
abstracting: (haveA2<=39)
states: 380,015 (5)
abstracting: (47<=Clients)
states: 56
abstracting: (16<=haveAandB)
states: 4,576 (3)
abstracting: (haveA2<=haveA2andB)
states: 171,990 (5)
abstracting: (10<=resA)
states: 77,520 (4)
abstracting: (haveB<=34)
states: 380,015 (5)
abstracting: (resB<=resA)
states: 142,505 (5)
abstracting: (resB<=43)
states: 380,015 (5)
abstracting: (haveA2<=37)
states: 380,015 (5)
abstracting: (resB<=resB)
states: 380,015 (5)
abstracting: (haveA<=12)
states: 341,431 (5)
abstracting: (haveA2andB<=resA)
states: 236,872 (5)
abstracting: (haveAandB<=haveA2andB)
states: 207,388 (5)
abstracting: (Clients<=23)
states: 214,109 (5)
abstracting: (25<=haveAandB)
states: 1
abstracting: (resB<=haveA)
states: 142,505 (5)
abstracting: (haveA<=39)
states: 380,015 (5)
abstracting: (resA<=44)
states: 380,015 (5)
abstracting: (haveA2<=Clients)
states: 360,724 (5)
abstracting: (resB<=32)
states: 380,015 (5)
abstracting: (5<=resB)
states: 262,108 (5)
abstracting: (resB<=haveA2)
states: 142,505 (5)
abstracting: (haveB<=27)
states: 380,015 (5)
abstracting: (resB<=14)
states: 312,948 (5)
abstracting: (haveAandB<=3)
states: 207,975 (5)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-07 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.292sec

checking: EF [[[[[~ [haveB<=haveA2] | [16<=haveA2andB | [[[~ [12<=haveA2] | [9<=haveAandB | resB<=36]] & resA<=17] | resA<=haveA]]] & [22<=haveA2 | [[[[~ [haveA<=26] | [Clients<=haveB | haveA2andB<=30]] & [[Clients<=resB | 4<=haveAandB] | [haveA2<=27 & haveB<=haveA2]]] & [[[34<=haveA2 & haveA<=50] & [haveB<=haveAandB & haveAandB<=haveB]] & [~ [resA<=16] & [resB<=7 | haveA2<=Clients]]]] & resA<=0]]] | [~ [[[~ [[haveAandB<=haveA2andB | 41<=resA]] & [[resB<=36 | 16<=Clients] | [haveA2andB<=9 & haveAandB<=2]]] | haveA<=12]] | [[[haveA2<=3 & [10<=haveA2andB | ~ [34<=haveA]]] & [~ [[haveB<=haveB | ~ [16<=haveA]]] | [[haveA<=5 & ~ [haveA2<=haveB]] & [haveA2<=haveA | [haveA2<=haveA & resA<=24]]]]] & [~ [[haveB<=22 & ~ [[29<=haveA & haveA<=Clients]]]] | [[[28<=haveA & resA<=haveB] | ~ [Clients<=19]] | [~ [Clients<=26] | [[haveAandB<=haveA | 33<=haveA2] & [18<=resB | haveAandB<=haveB]]]]]]]] & ~ [[[[Clients<=haveB & [[[~ [45<=Clients] & [31<=resB & haveA2andB<=haveB]] | [[Clients<=25 | resB<=43] | haveB<=haveA2andB]] | haveA2andB<=41]] & 31<=haveA2] | [haveAandB<=resA | [[[~ [resA<=34] | 8<=haveA2] & [haveA2andB<=haveB | [~ [5<=haveA] | [resB<=7 & Clients<=21]]]] & [[17<=resB | haveB<=16] | 41<=resB]]]]]]]
normalized: E [true U [~ [[[haveAandB<=resA | [[41<=resB | [17<=resB | haveB<=16]] & [[haveA2andB<=haveB | [[resB<=7 & Clients<=21] | ~ [5<=haveA]]] & [8<=haveA2 | ~ [resA<=34]]]]] | [31<=haveA2 & [Clients<=haveB & [haveA2andB<=41 | [[haveB<=haveA2andB | [Clients<=25 | resB<=43]] | [[31<=resB & haveA2andB<=haveB] & ~ [45<=Clients]]]]]]]] & [[[[[[[[18<=resB | haveAandB<=haveB] & [haveAandB<=haveA | 33<=haveA2]] | ~ [Clients<=26]] | [~ [Clients<=19] | [28<=haveA & resA<=haveB]]] | ~ [[haveB<=22 & ~ [[29<=haveA & haveA<=Clients]]]]] & [[[[haveA2<=haveA | [haveA2<=haveA & resA<=24]] & [haveA<=5 & ~ [haveA2<=haveB]]] | ~ [[haveB<=haveB | ~ [16<=haveA]]]] & [haveA2<=3 & [10<=haveA2andB | ~ [34<=haveA]]]]] | ~ [[haveA<=12 | [[[haveA2andB<=9 & haveAandB<=2] | [resB<=36 | 16<=Clients]] & ~ [[haveAandB<=haveA2andB | 41<=resA]]]]]] | [[22<=haveA2 | [resA<=0 & [[[[resB<=7 | haveA2<=Clients] & ~ [resA<=16]] & [[haveB<=haveAandB & haveAandB<=haveB] & [34<=haveA2 & haveA<=50]]] & [[[haveA2<=27 & haveB<=haveA2] | [Clients<=resB | 4<=haveAandB]] & [[Clients<=haveB | haveA2andB<=30] | ~ [haveA<=26]]]]]] & [[16<=haveA2andB | [resA<=haveA | [resA<=17 & [[9<=haveAandB | resB<=36] | ~ [12<=haveA2]]]]] | ~ [haveB<=haveA2]]]]]]

abstracting: (haveB<=haveA2)
states: 142,505 (5)
abstracting: (12<=haveA2)
states: 49,503 (4)
abstracting: (resB<=36)
states: 380,015 (5)
abstracting: (9<=haveAandB)
states: 51,357 (4)
abstracting: (resA<=17)
states: 372,359 (5)
abstracting: (resA<=haveA)
states: 201,473 (5)
abstracting: (16<=haveA2andB)
states: 4,576 (3)
abstracting: (haveA<=26)
states: 380,015 (5)
abstracting: (haveA2andB<=30)
states: 380,015 (5)
abstracting: (Clients<=haveB)
states: 57,875 (4)
abstracting: (4<=haveAandB)
states: 172,040 (5)
abstracting: (Clients<=resB)
states: 675
abstracting: (haveB<=haveA2)
states: 142,505 (5)
abstracting: (haveA2<=27)
states: 380,015 (5)
abstracting: (haveA<=50)
states: 380,015 (5)
abstracting: (34<=haveA2)
states: 0
abstracting: (haveAandB<=haveB)
states: 277,367 (5)
abstracting: (haveB<=haveAandB)
states: 123,214 (5)
abstracting: (resA<=16)
states: 368,729 (5)
abstracting: (haveA2<=Clients)
states: 360,724 (5)
abstracting: (resB<=7)
states: 185,303 (5)
abstracting: (resA<=0)
states: 44,225 (4)
abstracting: (22<=haveA2)
states: 867
abstracting: (41<=resA)
states: 0
abstracting: (haveAandB<=haveA2andB)
states: 207,388 (5)
abstracting: (16<=Clients)
states: 314,124 (5)
abstracting: (resB<=36)
states: 380,015 (5)
abstracting: (haveAandB<=2)
states: 167,725 (5)
abstracting: (haveA2andB<=9)
states: 341,255 (5)
abstracting: (haveA<=12)
states: 341,431 (5)
abstracting: (34<=haveA)
states: 0
abstracting: (10<=haveA2andB)
states: 38,760 (4)
abstracting: (haveA2<=3)
states: 157,376 (5)
abstracting: (16<=haveA)
states: 16,016 (4)
abstracting: (haveB<=haveB)
states: 380,015 (5)
abstracting: (haveA2<=haveB)
states: 261,260 (5)
abstracting: (haveA<=5)
states: 217,083 (5)
abstracting: (resA<=24)
states: 379,989 (5)
abstracting: (haveA2<=haveA)
states: 201,474 (5)
abstracting: (haveA2<=haveA)
states: 201,474 (5)
abstracting: (haveA<=Clients)
states: 360,723 (5)
abstracting: (29<=haveA)
states: 0
abstracting: (haveB<=22)
states: 376,763 (5)
abstracting: (resA<=haveB)
states: 261,260 (5)
abstracting: (28<=haveA)
states: 0
abstracting: (Clients<=19)
states: 129,282 (5)
abstracting: (Clients<=26)
states: 281,735 (5)
abstracting: (33<=haveA2)
states: 0
abstracting: (haveAandB<=haveA)
states: 236,872 (5)
abstracting: (haveAandB<=haveB)
states: 277,367 (5)
abstracting: (18<=resB)
states: 31,956 (4)
abstracting: (45<=Clients)
states: 252
abstracting: (haveA2andB<=haveB)
states: 277,367 (5)
abstracting: (31<=resB)
states: 0
abstracting: (resB<=43)
states: 380,015 (5)
abstracting: (Clients<=25)
states: 261,260 (5)
abstracting: (haveB<=haveA2andB)
states: 123,214 (5)
abstracting: (haveA2andB<=41)
states: 380,015 (5)
abstracting: (Clients<=haveB)
states: 57,875 (4)
abstracting: (31<=haveA2)
states: 0
abstracting: (resA<=34)
states: 380,015 (5)
abstracting: (8<=haveA2)
states: 114,911 (5)
abstracting: (5<=haveA)
states: 191,268 (5)
abstracting: (Clients<=21)
states: 169,509 (5)
abstracting: (resB<=7)
states: 185,303 (5)
abstracting: (haveA2andB<=haveB)
states: 277,367 (5)
abstracting: (haveB<=16)
states: 337,875 (5)
abstracting: (17<=resB)
states: 42,141 (4)
abstracting: (41<=resB)
states: 0
abstracting: (haveAandB<=resA)
states: 236,872 (5)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-10 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.858sec

checking: AG [[[[~ [[[47<=haveA2 & haveB<=Clients] | [~ [[haveAandB<=43 | 32<=resA]] & ~ [Clients<=20]]]] | ~ [[[~ [[[haveA2<=resB | haveA2andB<=haveAandB] | [resA<=haveB & haveA2<=31]]] & [~ [haveAandB<=14] & ~ [[35<=haveAandB & 40<=haveAandB]]]] | haveA2andB<=resA]]] & [[[[resB<=haveB & [[[haveA2andB<=haveB | 36<=haveB] | Clients<=haveA2andB] | 20<=haveAandB]] | [[[~ [haveA2<=7] & [haveA2<=haveA2andB & resA<=11]] & [haveA2<=39 | ~ [haveA<=haveAandB]]] | [~ [haveB<=47] | [21<=haveA & [27<=haveAandB & 31<=haveA2]]]]] & [~ [[haveA2andB<=haveA2 & resA<=39]] | [haveA2andB<=19 & [[[haveAandB<=haveA | 20<=haveA2andB] | [42<=haveAandB | 18<=Clients]] & [haveB<=17 & haveAandB<=resA]]]]] | 31<=haveA2]] | [~ [[[[[[[19<=haveA2 & 46<=haveB] & [haveA2andB<=Clients & haveA<=43]] | [resA<=haveA2 & ~ [resA<=haveA2]]] & [haveAandB<=29 | haveA<=3]] & [[[~ [haveA2andB<=13] & [haveA2<=12 | haveB<=2]] & Clients<=haveB] & [~ [resA<=41] | ~ [4<=resB]]]] & [[haveAandB<=haveAandB | resA<=4] | ~ [[haveAandB<=haveA2 & ~ [haveA<=resA]]]]]] & [[[[~ [[[16<=haveA2 & resB<=haveAandB] | 25<=resB]] & haveAandB<=haveAandB] | ~ [Clients<=haveA2andB]] | [[9<=resB | [~ [[haveB<=haveA2 & haveA2andB<=haveA]] & 1<=Clients]] & [[[[haveAandB<=haveA | haveAandB<=resB] & ~ [haveA<=haveA2andB]] | haveA2<=32] & [[haveB<=5 & haveA2andB<=haveAandB] & [[29<=haveAandB & haveB<=44] | haveA2andB<=29]]]]] | ~ [32<=Clients]]]]]
normalized: ~ [E [true U ~ [[[[~ [32<=Clients] | [[[[[haveA2andB<=29 | [29<=haveAandB & haveB<=44]] & [haveB<=5 & haveA2andB<=haveAandB]] & [haveA2<=32 | [~ [haveA<=haveA2andB] & [haveAandB<=haveA | haveAandB<=resB]]]] & [9<=resB | [1<=Clients & ~ [[haveB<=haveA2 & haveA2andB<=haveA]]]]] | [~ [Clients<=haveA2andB] | [haveAandB<=haveAandB & ~ [[25<=resB | [16<=haveA2 & resB<=haveAandB]]]]]]] & ~ [[[~ [[haveAandB<=haveA2 & ~ [haveA<=resA]]] | [haveAandB<=haveAandB | resA<=4]] & [[[~ [4<=resB] | ~ [resA<=41]] & [Clients<=haveB & [[haveA2<=12 | haveB<=2] & ~ [haveA2andB<=13]]]] & [[haveAandB<=29 | haveA<=3] & [[resA<=haveA2 & ~ [resA<=haveA2]] | [[haveA2andB<=Clients & haveA<=43] & [19<=haveA2 & 46<=haveB]]]]]]]] | [[31<=haveA2 | [[[haveA2andB<=19 & [[haveB<=17 & haveAandB<=resA] & [[42<=haveAandB | 18<=Clients] | [haveAandB<=haveA | 20<=haveA2andB]]]] | ~ [[haveA2andB<=haveA2 & resA<=39]]] & [[[[21<=haveA & [27<=haveAandB & 31<=haveA2]] | ~ [haveB<=47]] | [[haveA2<=39 | ~ [haveA<=haveAandB]] & [[haveA2<=haveA2andB & resA<=11] & ~ [haveA2<=7]]]] | [resB<=haveB & [20<=haveAandB | [Clients<=haveA2andB | [haveA2andB<=haveB | 36<=haveB]]]]]]] & [~ [[haveA2andB<=resA | [[~ [[35<=haveAandB & 40<=haveAandB]] & ~ [haveAandB<=14]] & ~ [[[resA<=haveB & haveA2<=31] | [haveA2<=resB | haveA2andB<=haveAandB]]]]]] | ~ [[[~ [Clients<=20] & ~ [[haveAandB<=43 | 32<=resA]]] | [47<=haveA2 & haveB<=Clients]]]]]]]]]

abstracting: (haveB<=Clients)
states: 328,055 (5)
abstracting: (47<=haveA2)
states: 0
abstracting: (32<=resA)
states: 0
abstracting: (haveAandB<=43)
states: 380,015 (5)
abstracting: (Clients<=20)
states: 148,763 (5)
abstracting: (haveA2andB<=haveAandB)
states: 207,388 (5)
abstracting: (haveA2<=resB)
states: 261,261 (5)
abstracting: (haveA2<=31)
states: 380,015 (5)
abstracting: (resA<=haveB)
states: 261,260 (5)
abstracting: (haveAandB<=14)
states: 373,008 (5)
abstracting: (40<=haveAandB)
states: 0
abstracting: (35<=haveAandB)
states: 0
abstracting: (haveA2andB<=resA)
states: 236,872 (5)
abstracting: (36<=haveB)
states: 0
abstracting: (haveA2andB<=haveB)
states: 277,367 (5)
abstracting: (Clients<=haveA2andB)
states: 350
abstracting: (20<=haveAandB)
states: 504
abstracting: (resB<=haveB)
states: 195,922 (5)
abstracting: (haveA2<=7)
states: 265,104 (5)
abstracting: (resA<=11)
states: 330,511 (5)
abstracting: (haveA2<=haveA2andB)
states: 171,990 (5)
abstracting: (haveA<=haveAandB)
states: 171,989 (5)
abstracting: (haveA2<=39)
states: 380,015 (5)
abstracting: (haveB<=47)
states: 380,015 (5)
abstracting: (31<=haveA2)
states: 0
abstracting: (27<=haveAandB)
states: 0
abstracting: (21<=haveA)
states: 1,708 (3)
abstracting: (resA<=39)
states: 380,015 (5)
abstracting: (haveA2andB<=haveA2)
states: 236,872 (5)
abstracting: (20<=haveA2andB)
states: 504
abstracting: (haveAandB<=haveA)
states: 236,872 (5)
abstracting: (18<=Clients)
states: 285,453 (5)
abstracting: (42<=haveAandB)
states: 0
abstracting: (haveAandB<=resA)
states: 236,872 (5)
abstracting: (haveB<=17)
states: 348,060 (5)
abstracting: (haveA2andB<=19)
states: 379,511 (5)
abstracting: (31<=haveA2)
states: 0
abstracting: (46<=haveB)
states: 0
abstracting: (19<=haveA2)
states: 4,955 (3)
abstracting: (haveA<=43)
states: 380,015 (5)
abstracting: (haveA2andB<=Clients)
states: 380,015 (5)
abstracting: (resA<=haveA2)
states: 201,473 (5)
abstracting: (resA<=haveA2)
states: 201,473 (5)
abstracting: (haveA<=3)
states: 157,375 (5)
abstracting: (haveAandB<=29)
states: 380,015 (5)
abstracting: (haveA2andB<=13)
states: 369,641 (5)
abstracting: (haveB<=2)
states: 71,126 (4)
abstracting: (haveA2<=12)
states: 341,432 (5)
abstracting: (Clients<=haveB)
states: 57,875 (4)
abstracting: (resA<=41)
states: 380,015 (5)
abstracting: (4<=resB)
states: 285,384 (5)
abstracting: (resA<=4)
states: 188,747 (5)
abstracting: (haveAandB<=haveAandB)
states: 380,015 (5)
abstracting: (haveA<=resA)
states: 201,473 (5)
abstracting: (haveAandB<=haveA2)
states: 236,872 (5)
abstracting: (resB<=haveAandB)
states: 123,213 (5)
abstracting: (16<=haveA2)
states: 16,015 (4)
abstracting: (25<=resB)
states: 351
abstracting: (haveAandB<=haveAandB)
states: 380,015 (5)
abstracting: (Clients<=haveA2andB)
states: 350
abstracting: (haveA2andB<=haveA)
states: 236,872 (5)
abstracting: (haveB<=haveA2)
states: 142,505 (5)
abstracting: (1<=Clients)
states: 379,990 (5)
abstracting: (9<=resB)
states: 173,451 (5)
abstracting: (haveAandB<=resB)
states: 277,367 (5)
abstracting: (haveAandB<=haveA)
states: 236,872 (5)
abstracting: (haveA<=haveA2andB)
states: 171,989 (5)
abstracting: (haveA2<=32)
states: 380,015 (5)
abstracting: (haveA2andB<=haveAandB)
states: 207,388 (5)
abstracting: (haveB<=5)
states: 140,854 (5)
abstracting: (haveB<=44)
states: 380,015 (5)
abstracting: (29<=haveAandB)
states: 0
abstracting: (haveA2andB<=29)
states: 380,015 (5)
abstracting: (32<=Clients)
states: 33,649 (4)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00050vD-ReachabilityCardinality-06 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.414sec

totally nodes used: 421103 (4.2e+05)
number of garbage collections: 0
fire ops cache: hits/miss/sum: 4624840 843990 5468830
used/not used/entry size/cache size: 1100252 66008612 16 1024MB
basic ops cache: hits/miss/sum: 4570983 2949680 7520663
used/not used/entry size/cache size: 3380918 13396298 12 192MB
unary ops cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 16777216 8 128MB
abstract ops cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 16777216 12 192MB
state nr cache: hits/miss/sum: 762612 188264 950876
used/not used/entry size/cache size: 186115 8202493 32 256MB
max state cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 8388608 32 256MB
uniqueHash elements/entry size/size: 67108864 4 256MB
0 66729749
1 358950
2 13671
3 3086
4 1331
5 766
6 344
7 224
8 159
9 115
>= 10 469

Total processing time: 0m 7.866sec


BK_STOP 1679339296170

--------------------
content from stderr:

+ ulimit -s 65536
+ [[ -z '' ]]
+ export LTSMIN_MEM_SIZE=8589934592
+ LTSMIN_MEM_SIZE=8589934592
+ export PYTHONPATH=/home/mcc/BenchKit/itstools/pylibs
+ PYTHONPATH=/home/mcc/BenchKit/itstools/pylibs
+ export LD_LIBRARY_PATH=/home/mcc/BenchKit/itstools/pylibs:
+ LD_LIBRARY_PATH=/home/mcc/BenchKit/itstools/pylibs:
++ sed s/.jar//
++ perl -pe 's/.*\.//g'
++ ls /home/mcc/BenchKit/bin//../reducer/bin//../../itstools//itstools/plugins/fr.lip6.move.gal.application.pnmcc_1.0.0.202303021504.jar
+ VERSION=202303021504
+ echo 'Running Version 202303021504'
+ /home/mcc/BenchKit/bin//../reducer/bin//../../itstools//itstools/its-tools -pnfolder /home/mcc/execution -examination ReachabilityCardinality -timeout 360 -rebuildPNML
check for maximal unmarked siphon
ok
check for constant places
ok
check if there are places and transitions
ok
check if there are transitions without pre-places
ok
check if at least one transition is enabled in m0
ok
check if there are transitions that can never fire
ok


initing FirstDep: 0m 0.000sec


iterations count:673 (112), effective:222 (37)

initing FirstDep: 0m 0.000sec


iterations count:286 (47), effective:100 (16)

iterations count:121 (20), effective:69 (11)

iterations count:342 (57), effective:120 (20)

iterations count:506 (84), effective:152 (25)

iterations count:210 (35), effective:80 (13)

iterations count:285 (47), effective:89 (14)

iterations count:231 (38), effective:100 (16)

iterations count:131 (21), effective:75 (12)

iterations count:559 (93), effective:187 (31)

iterations count:378 (63), effective:151 (25)

Sequence of Actions to be Executed by the VM

This is useful if one wants to reexecute the tool in the VM from the submitted image disk.

set -x
# this is for BenchKit: configuration of major elements for the test
export BK_INPUT="TwoPhaseLocking-PT-nC00050vD"
export BK_EXAMINATION="ReachabilityCardinality"
export BK_TOOL="marciexred"
export BK_RESULT_DIR="/tmp/BK_RESULTS/OUTPUTS"
export BK_TIME_CONFINEMENT="3600"
export BK_MEMORY_CONFINEMENT="16384"
export BK_BIN_PATH="/home/mcc/BenchKit/bin/"

# this is specific to your benchmark or test

export BIN_DIR="$HOME/BenchKit/bin"

# remove the execution directoty if it exists (to avoid increse of .vmdk images)
if [ -d execution ] ; then
rm -rf execution
fi

# this is for BenchKit: explicit launching of the test
echo "====================================================================="
echo " Generated by BenchKit 2-5348"
echo " Executing tool marciexred"
echo " Input is TwoPhaseLocking-PT-nC00050vD, examination is ReachabilityCardinality"
echo " Time confinement is $BK_TIME_CONFINEMENT seconds"
echo " Memory confinement is 16384 MBytes"
echo " Number of cores is 4"
echo " Run identifier is r490-tall-167912709200822"
echo "====================================================================="
echo
echo "--------------------"
echo "preparation of the directory to be used:"

tar xzf /home/mcc/BenchKit/INPUTS/TwoPhaseLocking-PT-nC00050vD.tgz
mv TwoPhaseLocking-PT-nC00050vD execution
cd execution
if [ "ReachabilityCardinality" = "ReachabilityDeadlock" ] || [ "ReachabilityCardinality" = "UpperBounds" ] || [ "ReachabilityCardinality" = "QuasiLiveness" ] || [ "ReachabilityCardinality" = "StableMarking" ] || [ "ReachabilityCardinality" = "Liveness" ] || [ "ReachabilityCardinality" = "OneSafe" ] || [ "ReachabilityCardinality" = "StateSpace" ]; then
rm -f GenericPropertiesVerdict.xml
fi
pwd
ls -lh

echo
echo "--------------------"
echo "content from stdout:"
echo
echo "=== Data for post analysis generated by BenchKit (invocation template)"
echo
if [ "ReachabilityCardinality" = "UpperBounds" ] ; then
echo "The expected result is a vector of positive values"
echo NUM_VECTOR
elif [ "ReachabilityCardinality" != "StateSpace" ] ; then
echo "The expected result is a vector of booleans"
echo BOOL_VECTOR
else
echo "no data necessary for post analysis"
fi
echo
if [ -f "ReachabilityCardinality.txt" ] ; then
echo "here is the order used to build the result vector(from text file)"
for x in $(grep Property ReachabilityCardinality.txt | cut -d ' ' -f 2 | sort -u) ; do
echo "FORMULA_NAME $x"
done
elif [ -f "ReachabilityCardinality.xml" ] ; then # for cunf (txt files deleted;-)
echo echo "here is the order used to build the result vector(from xml file)"
for x in $(grep '' ReachabilityCardinality.xml | cut -d '>' -f 2 | cut -d '<' -f 1 | sort -u) ; do
echo "FORMULA_NAME $x"
done
elif [ "ReachabilityCardinality" = "ReachabilityDeadlock" ] || [ "ReachabilityCardinality" = "QuasiLiveness" ] || [ "ReachabilityCardinality" = "StableMarking" ] || [ "ReachabilityCardinality" = "Liveness" ] || [ "ReachabilityCardinality" = "OneSafe" ] ; then
echo "FORMULA_NAME ReachabilityCardinality"
fi
echo
echo "=== Now, execution of the tool begins"
echo
echo -n "BK_START "
date -u +%s%3N
echo
timeout -s 9 $BK_TIME_CONFINEMENT bash -c "/home/mcc/BenchKit/BenchKit_head.sh 2> STDERR ; echo ; echo -n \"BK_STOP \" ; date -u +%s%3N"
if [ $? -eq 137 ] ; then
echo
echo "BK_TIME_CONFINEMENT_REACHED"
fi
echo
echo "--------------------"
echo "content from stderr:"
echo
cat STDERR ;