Example #1
0
    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
Example #2
0
    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_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"))