def test_eg(self):
fsm = self.cardgame()
# Compute EG !win
expr = Nu(Variable("Z"), And(Not(Atom("win")), Diamond(Variable("Z"))))
for state in fsm.pick_all_states(
expr.eval(fsm) & fsm.reachable_states):
expl = expr.explain(fsm, state)
self.assertEqual(expl.initial.state, state)
dot = expl.dot()
self.assertIsNotNone(dot)
# Inspect all nodes
found = set()
pending = {expl.initial}
while len(pending) > 0:
e = pending.pop()
found.add(e)
self.assertEqual(e.fsm, fsm)
self.assertTrue(e.state <= expr.eval(fsm))
self.assertEqual(e.context, {})
self.assertTrue(
len(list(edge for edge in expl.graph.edges
if edge[0] == e)) >= 1 or
len(list(edge
for edge in expl.graph.edges if edge[0] == e)) <=
0 and e.formula == Not(Atom("win")))
pending |= {
edge[2]
for edge in expl.graph.edges if edge[0] == e
} - found
def test_eval_fp(self):
fsm = self.cardgame()
s0 = eval_simple_expression(fsm, "step = 0")
s1 = eval_simple_expression(fsm, "step = 1")
s2 = eval_simple_expression(fsm, "step = 2")
pa = eval_simple_expression(fsm, "pcard = Ac")
pk = eval_simple_expression(fsm, "pcard = K")
pq = eval_simple_expression(fsm, "pcard = Q")
da = eval_simple_expression(fsm, "dcard = Ac")
dk = eval_simple_expression(fsm, "dcard = K")
dq = eval_simple_expression(fsm, "dcard = Q")
dda = eval_simple_expression(fsm, "ddcard = Ac")
ddk = eval_simple_expression(fsm, "ddcard = K")
ddq = eval_simple_expression(fsm, "ddcard = Q")
win = eval_simple_expression(fsm, "win")
lose = eval_simple_expression(fsm, "lose")
true = eval_simple_expression(fsm, "TRUE")
false = eval_simple_expression(fsm, "FALSE")
# mu Z. win | pre(Z)
R = Mu(Variable("Z"), Or(Atom("win"), Diamond(Variable("Z"))))
self.assertTrue(s0 <= R.eval(fsm))
# nu Z. ~win & pre(Z)
NW = Nu(Variable("Z"), And(Not(Atom("win")), Diamond(Variable("Z"))))
self.assertTrue(NW.eval(fsm) <= ~win)
def test_ag_with_alias(self):
fsm = self.cardgame()
@alias("AX {child}")
def AX(child):
return Box(child)
@alias("EX {child}")
def EX(child):
return Diamond(child)
@EX.negation
def exneg(child):
return AX(Not(child))
@AX.negation
def axneg(child):
return EX(Not(child))
@alias("AG {inv}")
def AG(inv):
return Nu(Variable("Z"), And(inv, AX(Variable("Z"))))
@alias("EF {target}")
def EF(target):
return Mu(Variable("Z"), Or(target, EX(Variable("Z"))))
@AG.negation
def agneg(inv):
return EF(Not(inv))
@EF.negation
def efneg(target):
return AG(Not(target))
# Compute AG step <= 1
expr = AG(Atom("step <= 1"))
nsat = ~expr.eval(fsm)
self.assertTrue((fsm.init & nsat).isnot_false())
state = fsm.pick_one_state(nsat & fsm.init)
self.assertTrue(state <= Not(expr).eval(fsm))
expl = Not(expr).explain(fsm, state)
self.assertIsNotNone(expl.dot())
def test_eg_with_alias(self):
fsm = self.cardgame()
@alias("EX {child}")
def EX(child):
return Diamond(child)
@alias("EG {inv}")
def EG(inv):
return POI(Nu(Variable("Z"), And(POI(inv), EX(Variable("Z")))))
# Compute EG !win
expr = EG(Not(Atom("win")))
for state in fsm.pick_all_states(
expr.eval(fsm) & fsm.reachable_states):
expl = expr.explain(fsm, state)
self.assertEqual(expl.initial.state, state)
self.assertIsNotNone(expl.dot())
# Inspect all nodes
found = set()
pending = {expl.initial}
while len(pending) > 0:
e = pending.pop()
found.add(e)
self.assertEqual(e.fsm, fsm)
self.assertTrue(e.state <= expr.eval(fsm))
self.assertEqual(e.context, {})
self.assertTrue(
len(list(edge for edge in expl.graph.edges
if edge[0] == e)) >= 1 or
len(list(edge
for edge in expl.graph.edges if edge[0] == e)) <=
0 and e.formula == POI(Not(Atom("win"))))
pending |= {
edge[2]
for edge in expl.graph.edges if edge[0] == e
} - found
def test_eval_boolean(self):
fsm = self.cardgame()
s0 = eval_simple_expression(fsm, "step = 0")
s1 = eval_simple_expression(fsm, "step = 1")
pa = eval_simple_expression(fsm, "pcard = Ac")
win = eval_simple_expression(fsm, "win")
self.assertEqual(s0 & s1,
And(Atom("step = 0"), Atom("step = 1")).eval(fsm))
self.assertEqual(s0 | s1,
Or(Atom("step = 0"), Atom("step = 1")).eval(fsm))
self.assertEqual(~win, Not(Atom("win")).eval(fsm))
def test_eg_with_alias_and_pod(self):
fsm = self.cardgame()
@alias("EX {child}")
def EX(child):
return POD(Diamond(child))
@alias("EG {inv}")
def EG(inv):
return POI(Nu(Variable("Z"), And(POI(inv), EX(Variable("Z")))))
# Compute EG !win
expr = EG(Not(Atom("win")))
state = fsm.pick_one_state(expr.eval(fsm) & fsm.init)
expl = expr.explain(fsm, state)
self.assertIsNotNone(expl.dot())
def efneg(target):
return AG(Not(target))
def agneg(inv):
return EF(Not(inv))
def axneg(child):
return EX(Not(child))
def exneg(child):
return AX(Not(child))