def test_coins(self):
fsm = self.coins()
from tools.atlkPO.evalGen import split
agents = {'a1', 'a2'}
strats = split(fsm,
fsm.protocol(agents) & fsm.reachable_states,
agents,
semantics='individual')
self.assertEqual(len(list(strats)), 64)
self.assertFalse(
check(fsm,
parseATLK("<'a1', 'a2'> F 'result = win'")[0],
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'a1', 'a2'> F 'result = win'")[0],
implem="partialSI",
semantics="individual",
variant="FS"))
config.partial.filtering = True
self.assertFalse(
check(fsm,
parseATLK("<'a1', 'a2'> F 'result = win'")[0],
implem="partialSI",
semantics="individual",
variant="SF"))
config.partial.filtering = False
def test_counters_FSF(self):
fsm = self.counters()
from tools.atlkPO.evalGen import split
agents = {"a1", "a2"}
strats = split(fsm, fsm.protocol(agents) & fsm.reachable_states, agents, semantics="individual")
self.assertEqual(len(list(strats)), 16)
self.assertTrue(
check(
fsm, parseATLK("<'a1', 'a2'> F 'v1 & v2'")[0], semantics="individual", implem="symbolic", variant="FSF"
)
)
self.assertFalse(
check(
fsm,
parseATLK("<'a1', 'a2'> G '!v1 & !v2'")[0],
semantics="individual",
implem="symbolic",
variant="FSF",
)
)
self.assertTrue(
check(
fsm,
parseATLK("AG('!v1 & !v2' -> <'a1', 'a2'> G '!v1 | !v2')")[0],
semantics="individual",
implem="symbolic",
variant="FSF",
)
)
def test_counters_FSF(self):
fsm = self.counters()
from tools.atlkPO.evalGen import split
agents = {'a1', 'a2'}
strats = split(fsm,
fsm.protocol(agents) & fsm.reachable_states,
agents,
semantics='individual')
self.assertEqual(len(list(strats)), 16)
config.partial.filtering = True
self.assertTrue(
check(fsm,
parseATLK("<'a1', 'a2'> F 'v1 & v2'")[0],
semantics="individual",
implem="partialSI"))
self.assertFalse(
check(fsm,
parseATLK("<'a1', 'a2'> G '!v1 & !v2'")[0],
semantics="individual",
implem="partialSI"))
self.assertTrue(
check(
fsm,
parseATLK("AG('!v1 & !v2' -> <'a1', 'a2'> G '!v1 | !v2')")[0],
semantics="individual",
implem="partialSI"))
config.partial.filtering = False
def test_fail(self):
kos = ["", "'test", "A<'test'>H 'q'", "O", "A<'a'>E<'e'>G 'true'",
"E<'ac'>[A<'ac'>['a' E<'ac'>['b' W 'c'] W 'd'] "
"U A<'ac'>['e' U 'f']]", "A<'t't'>G 'q'"]
for s in kos:
with self.assertRaises(ParseException):
parseATLK(s)
def test_cardgame(self):
fsm = self.cardgame()
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0]))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0]))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0]))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0]))
self.assertTrue(check(fsm, parseATLK("<'player'> F 'win'")[0]))
def test_fail(self):
kos = [
"", "'test", "A<'test'>H 'q'", "O", "A<'a'>E<'e'>G 'true'",
"E<'ac'>[A<'ac'>['a' E<'ac'>['b' W 'c'] W 'd'] "
"U A<'ac'>['e' U 'f']]", "A<'t't'>G 'q'"
]
for s in kos:
with self.assertRaises(ParseException):
parseATLK(s)
def test_cardgame_post_fair_improved_symbolic(self):
fsm = self.cardgame_post_fair()
self.assertFalse(check(fsm, parseATLK("<'player'> X 'win'")[0], implem="symbolic", variant="FSF"))
self.assertTrue(
check(
fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="symbolic", variant="FSF"
)
)
def test_cardgame_post_fair_not_improved(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(
fsm,
parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0],
implem="symbolic",
semantics="individual",
)
)
self.assertTrue(
check(
fsm,
parseATLK(
"AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))"
)[0],
implem="symbolic",
semantics="individual",
)
)
self.assertTrue(
check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="symbolic", semantics="individual")
)
self.assertFalse(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="symbolic", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="symbolic", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="symbolic", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="symbolic", semantics="individual"))
# Player can win
self.assertTrue(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="symbolic", semantics="individual"))
# Dealer can avoid fairness
self.assertTrue(check(fsm, parseATLK("<'dealer'> F 'FALSE'")[0], implem="symbolic", semantics="individual"))
def test_coins(self):
fsm = self.coins()
from tools.atlkPO.evalGen import split
agents = {'a1', 'a2'}
strats = split(fsm, fsm.protocol(agents) & fsm.reachable_states,
agents, semantics='individual')
self.assertEqual(len(list(strats)), 64)
self.assertFalse(check(fsm, parseATLK("<'a1', 'a2'> F 'result = win'")[0], implem="generatorSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'a1', 'a2'> F 'result = win'")[0], implem="generatorSI", semantics="individual", variant="FSF"))
def test_counters(self):
fsm = self.counters()
from tools.atlkPO.evalGen import split
agents = {'a1', 'a2'}
strats = split(fsm, fsm.protocol(agents) & fsm.reachable_states,
agents, semantics='individual')
self.assertEqual(len(list(strats)), 16)
self.assertTrue(check(fsm, parseATLK("<'a1', 'a2'> F 'v1 & v2'")[0], implem="generatorSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'a1', 'a2'> G '!v1 & !v2'")[0], implem="generatorSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('!v1 & !v2' -> <'a1', 'a2'> G '!v1 | !v2')")[0], implem="generatorSI", semantics="individual"))
def test_cardgame_post_fair_not_improved(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK(
"K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(
fsm,
parseATLK(
"AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))"
)[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0],
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("['dealer'] F 'win'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("['player'] X 'pcard=Ac'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> X 'pcard=Ac'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> G ~'win'")[0],
implem="partialSI",
semantics="individual"))
# Player can win
self.assertTrue(
check(fsm,
parseATLK("<'player'> F 'win'")[0],
implem="partialSI",
semantics="individual"))
# Dealer can avoid fairness
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> F 'FALSE'")[0],
implem="partialSI",
semantics="individual"))
def test_cardgame_post_fair_improved_symbolic(self):
fsm = self.cardgame_post_fair()
self.assertFalse(
check(fsm,
parseATLK("<'player'> X 'win'")[0],
implem="symbolic",
variant="FSF"))
self.assertTrue(
check(fsm,
parseATLK(
"K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic6(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> G ~'win'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic4(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK("['player'] X 'pcard=Ac'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic3(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic12(self):
fsm = self.cardgame_post_fair()
self.assertFalse(
check(fsm,
parseATLK("['dealer'] F 'win'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic11(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic9(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm,
parseATLK("EG ~'win'")[0],
implem="symbolic",
variant="FSF"))
self.assertTrue(
check(fsm,
parseATLK("EF 'win'")[0],
implem="symbolic",
variant="FSF"))
self.assertFalse(
check(fsm,
parseATLK("AF 'win'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic8(self):
fsm = self.cardgame_post_fair()
# Dealer can avoid fairness
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> F 'FALSE'")[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_post_fair_improved_symbolic7(self):
fsm = self.cardgame_post_fair()
# Player can win
self.assertTrue(
check(fsm,
parseATLK("<'player'> F 'win'")[0],
implem="symbolic",
variant="FSF"))
def test_atom(self):
s = "'c <= 3'"
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, Spec))
self.assertTrue(isinstance(ast, Atom))
self.assertEqual(ast.value, "c <= 3")
def test_atom(self):
s = "'c <= 3'"
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, Spec))
self.assertTrue(isinstance(ast, Atom))
self.assertEqual(ast.value, "c <= 3")
def test_tictactoe(self):
fsm = self.tictactoe()
self.assertTrue(
check(
fsm,
parseATLK(
"'run = circle' -> <'circlep'> X 'board[1] = circle'")[0]))
self.assertTrue(
check(
fsm,
parseATLK("'run = circle' -> ['circlep'] X 'run = cross'")[0]))
self.assertTrue(check(fsm, parseATLK("<'circlep'> F 'run = stop'")[0]))
self.assertTrue(
check(fsm,
parseATLK("<'circlep', 'crossp'> G 'winner = empty'")[0]))
self.assertTrue(
check(fsm,
parseATLK("<'circlep'> G 'winner != circle'")[0]))
def test_cardgame_post_fair_improved_symbolic2(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(
fsm,
parseATLK(
"AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))"
)[0],
implem="symbolic",
variant="FSF"))
def test_cardgame_improved(self):
fsm = self.cardgame()
self.assertTrue(
check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], variant="FS", implem="symbolic", semantics="individual")
)
self.assertFalse(
check(fsm, parseATLK("<'dealer'> G ~'win'")[0], variant="FS", implem="symbolic", semantics="individual")
)
self.assertTrue(
check(
fsm,
parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0],
variant="FS",
implem="symbolic",
semantics="individual",
)
)
self.assertFalse(
check(fsm, parseATLK("<'player'> F 'win'")[0], variant="FS", implem="symbolic", semantics="individual")
)
self.assertTrue(
check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], variant="FS", implem="symbolic", semantics="individual")
)
self.assertTrue(
check(fsm, parseATLK("['dealer'] F 'win'")[0], variant="FS", implem="symbolic", semantics="individual")
)
def test_transmission_with_know_not_improved(self):
fsm = self.transmission_with_knowledge()
self.assertFalse(
check(fsm,
parseATLK("<'sender'> F 'received'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> G ~'received'")[0],
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> X 'received'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> X ~'received'")[0],
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> F 'received'")[0],
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'sender'> G ~'received'")[0],
implem="partialSI",
semantics="individual"))
def test_transmission_with_know_improved_symbolic(self):
fsm = self.transmission_with_knowledge()
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> G ~'received'")[0],
implem="symbolic",
variant="FSF"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> F 'received'")[0],
implem="symbolic",
variant="FSF"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> X 'received'")[0],
implem="symbolic",
variant="FSF"))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> X ~'received'")[0],
implem="symbolic",
variant="FSF"))
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> F 'received'")[0],
implem="symbolic",
variant="FSF"))
self.assertTrue(
check(fsm,
parseATLK("<'sender'> G ~'received'")[0],
implem="symbolic",
variant="FSF"))
def test_CEF(self):
s = "<'agent'>F 'test'"
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, CEF))
for ag in ast.group:
self.assertTrue(isinstance(ag, Atom))
self.assertEqual(len(ast.group), 1)
self.assertEqual(ast.group[0].value, 'agent')
self.assertTrue(isinstance(ast.child, Atom))
self.assertEqual(ast.child.value, "test")
def test_CEF(self):
s = "<'agent'>F 'test'"
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, CEF))
for ag in ast.group:
self.assertTrue(isinstance(ag, Atom))
self.assertEqual(len(ast.group), 1)
self.assertEqual(ast.group[0].value, 'agent')
self.assertTrue(isinstance(ast.child, Atom))
self.assertEqual(ast.child.value, "test")
def test_cardgame_post_fair_improved_symbolic2(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(
fsm,
parseATLK(
"AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))"
)[0],
implem="symbolic",
variant="FSF",
)
)
def test_deep_spec(self):
s = ("<'a','b'>[['c'][['e'] F ('p' & 'q') W K<'a'> 'p'] U <'d'>G "
"nC<'g','e'> ('c' -> EF 'k')]")
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, CEU))
self.assertEqual(len(ast.group), 2)
self.assertTrue(isinstance(ast.group[0], Atom))
self.assertEqual(ast.group[0].value, "a")
self.assertTrue(isinstance(ast.group[1], Atom))
self.assertEqual(ast.group[1].value, "b")
self.assertTrue(isinstance(ast.left, CAW))
self.assertEqual(len(ast.left.group), 1)
self.assertTrue(isinstance(ast.left.group[0], Atom))
self.assertEqual(ast.left.group[0].value, "c")
self.assertTrue(isinstance(ast.left.left, CAF))
self.assertEqual(len(ast.left.left.group), 1)
self.assertTrue(isinstance(ast.left.left.group[0], Atom))
self.assertEqual(ast.left.left.group[0].value, "e")
self.assertTrue(isinstance(ast.left.left.child, And))
self.assertTrue(isinstance(ast.left.left.child.left, Atom))
self.assertEqual(ast.left.left.child.left.value, "p")
self.assertTrue(isinstance(ast.left.left.child.right, Atom))
self.assertEqual(ast.left.left.child.right.value, "q")
self.assertTrue(isinstance(ast.left.right, K))
self.assertTrue(isinstance(ast.left.right.agent, Atom))
self.assertEqual(ast.left.right.agent.value, "a")
self.assertTrue(isinstance(ast.left.right.child, Atom))
self.assertEqual(ast.left.right.child.value, "p")
self.assertTrue(isinstance(ast.right, CEG))
self.assertEqual(len(ast.right.group), 1)
self.assertTrue(isinstance(ast.right.group[0], Atom))
self.assertEqual(ast.right.group[0].value, "d")
self.assertTrue(isinstance(ast.right.child, nC))
self.assertEqual(len(ast.right.child.group), 2)
self.assertTrue(isinstance(ast.right.child.group[0], Atom))
self.assertEqual(ast.right.child.group[0].value, "g")
self.assertTrue(isinstance(ast.right.child.group[1], Atom))
self.assertEqual(ast.right.child.group[1].value, "e")
self.assertTrue(isinstance(ast.right.child.child, Implies))
self.assertTrue(isinstance(ast.right.child.child.left, Atom))
self.assertEqual(ast.right.child.child.left.value, "c")
self.assertTrue(isinstance(ast.right.child.child.right, EF))
self.assertTrue(isinstance(ast.right.child.child.right.child, Atom))
self.assertEqual(ast.right.child.child.right.child.value, "k")
def test_deep_spec(self):
s = ("<'a','b'>[['c'][['e'] F ('p' & 'q') W K<'a'> 'p'] U <'d'>G "
"nC<'g','e'> ('c' -> EF 'k')]")
asts = parseATLK(s)
self.assertEqual(len(asts), 1)
ast = asts[0]
self.assertTrue(isinstance(ast, CEU))
self.assertEqual(len(ast.group), 2)
self.assertTrue(isinstance(ast.group[0], Atom))
self.assertEqual(ast.group[0].value, "a")
self.assertTrue(isinstance(ast.group[1], Atom))
self.assertEqual(ast.group[1].value, "b")
self.assertTrue(isinstance(ast.left, CAW))
self.assertEqual(len(ast.left.group), 1)
self.assertTrue(isinstance(ast.left.group[0], Atom))
self.assertEqual(ast.left.group[0].value, "c")
self.assertTrue(isinstance(ast.left.left, CAF))
self.assertEqual(len(ast.left.left.group), 1)
self.assertTrue(isinstance(ast.left.left.group[0], Atom))
self.assertEqual(ast.left.left.group[0].value, "e")
self.assertTrue(isinstance(ast.left.left.child, And))
self.assertTrue(isinstance(ast.left.left.child.left, Atom))
self.assertEqual(ast.left.left.child.left.value, "p")
self.assertTrue(isinstance(ast.left.left.child.right, Atom))
self.assertEqual(ast.left.left.child.right.value, "q")
self.assertTrue(isinstance(ast.left.right, K))
self.assertTrue(isinstance(ast.left.right.agent, Atom))
self.assertEqual(ast.left.right.agent.value, "a")
self.assertTrue(isinstance(ast.left.right.child, Atom))
self.assertEqual(ast.left.right.child.value, "p")
self.assertTrue(isinstance(ast.right, CEG))
self.assertEqual(len(ast.right.group), 1)
self.assertTrue(isinstance(ast.right.group[0], Atom))
self.assertEqual(ast.right.group[0].value, "d")
self.assertTrue(isinstance(ast.right.child, nC))
self.assertEqual(len(ast.right.child.group), 2)
self.assertTrue(isinstance(ast.right.child.group[0], Atom))
self.assertEqual(ast.right.child.group[0].value, "g")
self.assertTrue(isinstance(ast.right.child.group[1], Atom))
self.assertEqual(ast.right.child.group[1].value, "e")
self.assertTrue(isinstance(ast.right.child.child, Implies))
self.assertTrue(isinstance(ast.right.child.child.left, Atom))
self.assertEqual(ast.right.child.child.left.value, "c")
self.assertTrue(isinstance(ast.right.child.child.right, EF))
self.assertTrue(isinstance(ast.right.child.child.right.child, Atom))
self.assertEqual(ast.right.child.child.right.child.value, "k")
def test_transmission_with_know_not_improved_partial(self):
fsm = self.transmission_with_knowledge()
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="partial"))
def test_transmission_with_know_improved_symbolic(self):
fsm = self.transmission_with_knowledge()
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="symbolic", variant="FSF"))
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="symbolic", variant="FSF"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="symbolic", variant="FSF"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="symbolic", variant="FSF"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="symbolic", variant="FSF"))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="symbolic", variant="FSF"))
def test_transmission_with_know_improved(self):
fsm = self.transmission_with_knowledge()
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
def test_transmission_with_know_FSF(self):
fsm = self.transmission_with_knowledge()
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], variant="FSF", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], variant="FSF", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], variant="FSF", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], variant="FSF", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], variant="FSF", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0], variant="FSF", semantics="individual"))
def test_cardgame_improved(self):
fsm = self.cardgame()
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], variant="FS", implem="partial", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'player'> F 'win'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0], variant="FS", implem="partial", semantics="individual"))
def test_cardgame_post_fair_early_filtering(self):
fsm = self.cardgame_post_fair()
config.partial.filtering = True
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("['dealer'] F 'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
# Player can win
self.assertTrue(check(fsm, parseATLK("<'player'> F 'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
# Dealer can avoid fairness
self.assertTrue(check(fsm, parseATLK("<'dealer'> F 'FALSE'")[0], variant="FS", implem="partialSI", semantics="individual"))
config.partial.filtering = False
def test_transmission_with_know_improved_partial_strat_only(self):
fsm = self.transmission_with_knowledge()
config.partial.alternate.type = {"strat"}
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="partial", variant="FS"))
def test_transmission_post_fair_improved(self):
fsm = self.transmission_post_fair()
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], variant="FS", implem="partial", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], variant="FS", implem="partial", semantics="individual"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], variant="FS", implem="partial", semantics="individual"))
def test_transmission_post_fair_improved(self):
fsm = self.transmission_post_fair()
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], variant="FS", implem="partialSI", semantics="individual"))
def test_cardgame_early_filtering(self):
fsm = self.cardgame()
config.partial.filtering = True
self.assertFalse(check(fsm, parseATLK("<'player'> F 'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], variant="FS", implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0], variant="FS", implem="partialSI", semantics="individual"))
config.partial.filtering = False
def test_transmission_early_filtering(self):
fsm = self.transmission()
config.partial.filtering = True
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> G ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> X 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> X ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(
check(fsm,
parseATLK("<'sender'> G ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> F 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> F 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
config.partial.filtering = False
def test_transmission_improved(self):
fsm = self.transmission()
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(
check(
fsm,
parseATLK("<'transmitter'> G ~'received'")[0],
variant="FS",
implem="symbolic",
semantics="individual",
)
)
self.assertFalse(
check(fsm, parseATLK("<'sender'> X 'received'")[0], variant="FS", implem="symbolic", semantics="individual")
)
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(
check(
fsm,
parseATLK("<'transmitter'> X ~'received'")[0],
variant="FS",
implem="symbolic",
semantics="individual",
)
)
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(
check(
fsm, parseATLK("<'sender'> G ~'received'")[0], variant="FS", implem="symbolic", semantics="individual"
)
)
self.assertFalse(
check(
fsm,
parseATLK("<'transmitter'> F 'received'")[0],
variant="FS",
implem="symbolic",
semantics="individual",
)
)
self.assertFalse(
check(fsm, parseATLK("<'sender'> F 'received'")[0], variant="FS", implem="symbolic", semantics="individual")
)
def test_transmission(self):
fsm = self.transmission()
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0]))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> G ~'received'")[0]))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0]))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> X ~'received'")[0]))
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> F 'received'")[0]))
self.assertTrue(check(fsm, parseATLK("<'sender'> G ~'received'")[0]))
def test_transmission_not_improved(self):
fsm = self.transmission()
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], semantics="individual"))
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], semantics="individual"))
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], semantics="individual"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], semantics="individual"))
def test_transmission_with_know_early_filtering(self):
fsm = self.transmission_with_knowledge()
config.partial.filtering = True
self.assertFalse(
check(fsm,
parseATLK("<'sender'> F 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> G ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'sender'> X 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'transmitter'> X ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'transmitter'> F 'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'sender'> G ~'received'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
config.partial.filtering = False
def test_cardgame_early_filtering(self):
fsm = self.cardgame()
config.partial.filtering = True
self.assertFalse(
check(fsm,
parseATLK("<'player'> F 'win'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("<'dealer'> X 'pcard=Ac'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertFalse(
check(fsm,
parseATLK("<'dealer'> G ~'win'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("['player'] X 'pcard=Ac'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
self.assertTrue(
check(fsm,
parseATLK("['dealer'] F 'win'")[0],
variant="FS",
implem="partialSI",
semantics="individual"))
config.partial.filtering = False
def test_transmission_post_fair_not_improved_partial(self):
fsm = self.transmission_post_fair()
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="partial"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("EF 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("EG ~'received'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("AG ~'received'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("AF 'received'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("AF ~'received'")[0], implem="partial"))
def test_cardgame_post_fair_improved_symbolic11(self):
fsm = self.cardgame_post_fair()
self.assertTrue(
check(fsm, parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0], implem="symbolic", variant="FSF")
)
def test_cardgame_improved_partial_univ_only(self):
fsm = self.cardgame()
config.partial.alternate.type = {"univ"}
self.assertFalse(check(fsm, parseATLK("<'player'> X 'win'")[0],
implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EG ~'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EF 'win'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AF 'win'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'player'> G <'player'> F 'win'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AG <'player'> X 'pcard = Ac'")[0], implem="partial", variant="FS"))
def test_transmission_post_fair_improved_partial_strat_only(self):
fsm = self.transmission_post_fair()
config.partial.alternate.type = {"strat"}
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="partial", variant="FS"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EF 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EG ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AG ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AF 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AF ~'received'")[0], implem="partial", variant="FS"))
def test_cardgame_not_improved(self):
fsm = self.cardgame()
self.assertTrue(check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("EG ~'win'")[0], implem="partialSI", semantics="individual"))
self.assertTrue(check(fsm, parseATLK("EF 'win'")[0], implem="partialSI", semantics="individual"))
self.assertFalse(check(fsm, parseATLK("AF 'win'")[0], implem="partialSI", semantics="individual"))
def test_cardgame_post_fair_improved_symbolic12(self):
fsm = self.cardgame_post_fair()
self.assertFalse(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="symbolic", variant="FSF"))
def test_cardgame_post_fair_not_improved_partial(self):
fsm = self.cardgame_post_fair()
self.assertTrue(check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="partial"))
# Player can win
self.assertTrue(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="partial"))
# Dealer can avoid fairness
self.assertTrue(check(fsm, parseATLK("<'dealer'> F 'FALSE'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("EG ~'win'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("EF 'win'")[0], implem="partial"))
self.assertFalse(check(fsm, parseATLK("AF 'win'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'player'> G <'player'> F 'win'")[0], implem="partial"))
self.assertTrue(check(fsm, parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0], implem="partial"))
def test_cardgame_post_fair_improved_partial_strat_only(self):
fsm = self.cardgame_post_fair()
config.partial.alternate.type = {"strat"}
self.assertFalse(check(fsm, parseATLK("<'player'> X 'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="partial", variant="FS"))
# Player can win
self.assertTrue(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="partial", variant="FS"))
# Dealer can avoid fairness
self.assertTrue(check(fsm, parseATLK("<'dealer'> F 'FALSE'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EG ~'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EF 'win'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AF 'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'player'> G <'player'> F 'win'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0], implem="partial", variant="FS"))
def test_tpfni_partial_vs_normal(self):
fsm = self.transmission_post_fair()
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0]))
self.assertTrue(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial"))
def test_cardgame_not_improved_symbolic(self):
fsm = self.cardgame()
self.assertTrue(
check(fsm, parseATLK("K<'player'>'pcard=none' & K<'player'>'dcard=none'")[0], implem="symbolic")
)
self.assertTrue(
check(
fsm,
parseATLK(
"AG('step = 1' -> ~(K<'player'> 'dcard=Ac' | K<'player'> 'dcard=K' | K<'player'> 'dcard=Q'))"
)[0],
implem="symbolic",
)
)
self.assertTrue(check(fsm, parseATLK("<'dealer'> X 'pcard=Ac'")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("<'dealer'> G ~'win'")[0], implem="symbolic"))
self.assertTrue(check(fsm, parseATLK("['player'] X 'pcard=Ac'")[0], implem="symbolic"))
self.assertTrue(check(fsm, parseATLK("['dealer'] F 'win'")[0], implem="symbolic"))
self.assertTrue(check(fsm, parseATLK("AG('step = 1' -> ~<'player'> X 'win')")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("<'player'> F 'win'")[0], implem="symbolic"))
self.assertTrue(check(fsm, parseATLK("EG ~'win'")[0], implem="symbolic"))
self.assertTrue(check(fsm, parseATLK("EF 'win'")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("AF 'win'")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("<'player'> G <'player'> F 'win'")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("<'player'> F <'player'>[~'lose' U 'win']")[0], implem="symbolic"))
self.assertFalse(check(fsm, parseATLK("AG <'player'> X 'pcard = Ac'")[0], implem="symbolic"))
def test_transmission_improved_partial_univ_only(self):
fsm = self.transmission()
config.partial.alternate.type = {"univ"}
self.assertFalse(check(fsm, parseATLK("<'sender'> F 'received'")[0], implem="partial", variant="FS"))
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(check(fsm, parseATLK("<'transmitter'> G ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'sender'> X 'received'")[0], implem="partial", variant="FS"))
# False because transmitter cannot win if received is already true
# and he has no clue about it
self.assertFalse(check(fsm, parseATLK("<'transmitter'> X ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("<'transmitter'> F 'received'")[0], implem="partial", variant="FS"))
# False because the sender does not know if the bit is already
# transmitted (and in this case, no strategy can avoid 'received')
self.assertFalse(check(fsm, parseATLK("<'sender'> G ~'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EF 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("EG ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AG ~'received'")[0], implem="partial", variant="FS"))
self.assertFalse(check(fsm, parseATLK("AF 'received'")[0], implem="partial", variant="FS"))
self.assertTrue(check(fsm, parseATLK("AF ~'received'")[0], implem="partial", variant="FS"))