Example #1
0
 def test_eu_simple(self):
     fsm = self.simplemodel()
     
     lt = eval_simple_expression(fsm, "at.local")
     lf = eval_simple_expression(fsm, "af.local")
     g = eval_simple_expression(fsm, "global")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     # lt & lf & g |= E[ g U ~lf & ~lt & ~g ]
     eus = eu(fsm, g, ~lf & ~lt & ~g)
     state = fsm.pick_one_state(eus)
     witness = explain_eu(fsm, state, g, ~lf & ~lt & ~g)
     self.assertTrue(witness[0] == state)
     self.assertTrue(witness[0] <= g | ~lf & ~lt & ~g)
     
     for (s, i, sp) in zip(witness[:-2:2], witness[1:-2:2], witness[2:-2:2]):
         self.assertTrue(s <= g)
         self.assertTrue(sp <= g)
         self.assertIsNotNone(i)
         self.assertTrue(i <= fsm.get_inputs_between_states(s, sp))        
     
     self.assertIsNotNone(witness[-2])
     self.assertTrue(witness[-2] <=
                     fsm.get_inputs_between_states(witness[-3], witness[-1]))
     self.assertTrue(witness[-1] <= ~lf)
     self.assertTrue(witness[-1] <= ~lt)
     self.assertTrue(witness[-1] <= ~g)
     self.assertTrue(witness[-1] == ~lf & ~lt & ~g)
Example #2
0
    def test_eu_simple(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        # lt & lf & g |= E[ g U ~lf & ~lt & ~g ]
        eus = eu(fsm, g, ~lf & ~lt & ~g)
        state = fsm.pick_one_state(eus)
        witness = explain_eu(fsm, state, g, ~lf & ~lt & ~g)
        self.assertTrue(witness[0] == state)
        self.assertTrue(witness[0] <= g | ~lf & ~lt & ~g)

        for (s, i, sp) in zip(witness[:-2:2], witness[1:-2:2],
                              witness[2:-2:2]):
            self.assertTrue(s <= g)
            self.assertTrue(sp <= g)
            self.assertIsNotNone(i)
            self.assertTrue(i <= fsm.get_inputs_between_states(s, sp))

        self.assertIsNotNone(witness[-2])
        self.assertTrue(witness[-2] <= fsm.get_inputs_between_states(
            witness[-3], witness[-1]))
        self.assertTrue(witness[-1] <= ~lf)
        self.assertTrue(witness[-1] <= ~lt)
        self.assertTrue(witness[-1] <= ~g)
        self.assertTrue(witness[-1] == ~lf & ~lt & ~g)
Example #3
0
 def test_eu_dincry(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     even = eval_simple_expression(fsm, "countsay = even")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     # init |= E[c1p U odd]
     eus = eu(fsm, c1p, odd)
     self.assertTrue((eus & fsm.init).isnot_false())
     state = fsm.pick_one_state(eus & fsm.init)
     witness = explain_eu(fsm, state, c1p, odd)
     self.assertTrue(witness[0] == state)
     self.assertTrue(witness[0] <= c1p | odd)
     
     for (s, i, sp) in zip(witness[:-2:2], witness[1:-2:2], witness[2:-2:2]):
         self.assertTrue(s <= c1p)
         self.assertTrue(sp <= c1p)
         self.assertIsNotNone(i)
         self.assertTrue(i <= fsm.get_inputs_between_states(s, sp))        
     
     self.assertIsNotNone(witness[-2])
     self.assertTrue(witness[-2] <=
                     fsm.get_inputs_between_states(witness[-3], witness[-1]))
     self.assertTrue(witness[-1] <= odd)
Example #4
0
    def test_eu_dincry(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        even = eval_simple_expression(fsm, "countsay = even")
        unk = eval_simple_expression(fsm, "countsay = unknown")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        # init |= E[c1p U odd]
        eus = eu(fsm, c1p, odd)
        self.assertTrue((eus & fsm.init).isnot_false())
        state = fsm.pick_one_state(eus & fsm.init)
        witness = explain_eu(fsm, state, c1p, odd)
        self.assertTrue(witness[0] == state)
        self.assertTrue(witness[0] <= c1p | odd)

        for (s, i, sp) in zip(witness[:-2:2], witness[1:-2:2],
                              witness[2:-2:2]):
            self.assertTrue(s <= c1p)
            self.assertTrue(sp <= c1p)
            self.assertIsNotNone(i)
            self.assertTrue(i <= fsm.get_inputs_between_states(s, sp))

        self.assertIsNotNone(witness[-2])
        self.assertTrue(witness[-2] <= fsm.get_inputs_between_states(
            witness[-3], witness[-1]))
        self.assertTrue(witness[-1] <= odd)