def nfair_gamma_si(fsm, agents, strat=None): """ Return the set of state/inputs pairs of strat in which agents can avoid a fair path in strat. If strat is None, it is considered true. fsm -- the model agents -- a list of agents names strat -- a BDD representing allowed state/inputs pairs, or None """ if not strat: strat = BDD.true(fsm.bddEnc.DDmanager) if len(fsm.fairness_constraints) == 0: return BDD.false(fsm.bddEnc.DDmanager) else: def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f & fsm.bddEnc.statesMask & strat res = res | fsm.pre_strat_si(fp(lambda Y : (Z | nf) & fsm.pre_strat_si(Y, agents, strat), BDD.true(fsm.bddEnc.DDmanager)), agents, strat) return res return fp(inner, BDD.false(fsm.bddEnc.DDmanager))
def check_cax(self, fsm, explanation, agents, phi): """Check that the explanation is correct.""" # Get the cubes gamma_cube = fsm.inputs_cube_for_agents(agents) ngamma_cube = fsm.bddEnc.inputsCube - gamma_cube # The first state satisfies the spec self.assertTrue(explanation.state <= ~cex(fsm, agents, ~phi)) acts = BDD.false(fsm.bddEnc.DDmanager) states = BDD.false(fsm.bddEnc.DDmanager) for (act, succ) in explanation.successors: # The successor satisfies phi self.assertTrue(succ.state <= phi) # The action is effectively possible self.assertTrue(act <= fsm.get_inputs_between_states( explanation.state, succ.state)) # Accumulate states and actions acts = acts | act states = states | succ.state # The actions are effectively all the possible ones self.assertEqual((fsm.protocol(agents) & explanation.state).forsome(fsm.bddEnc.statesCube). forsome(ngamma_cube) & fsm.bddEnc.statesMask, acts.forsome(ngamma_cube) & fsm.bddEnc.statesMask)
def complete_compatible(mas, agents, moves): """ Return the given moves extended with the set of moves reachable from these ones and compatible with them. mas -- a multi-agent system; agents -- a subset of agents of mas; moves -- a set of non-agents-conflicting moves. """ result = moves new_states = (post_through(mas, agents, BDD.true(mas), result) - result.forsome(mas.bddEnc.inputsCube)) new_moves = compatible_moves(mas, agents, new_states & mas.protocol(agents), moves) while new_moves.isnot_false(): result = result | new_moves new_states = (post_through(mas, agents, BDD.true(mas), result) - result.forsome(mas.bddEnc.inputsCube)) new_moves = compatible_moves(mas, agents, new_states & mas.protocol(agents), moves) return result
def ceu(fsm, agents, phi, psi): """ Return the set of states of fsm satisfying <agents>[phi U psi]. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi """ # phi = phi & fsm.bddEnc.statesInputsMask # psi = psi & fsm.bddEnc.statesInputsMask if len(fsm.fairness_constraints) == 0: return fp(lambda Z: psi | (phi & fsm.pre_strat(Z, agents)), BDD.false(fsm.bddEnc.DDmanager)) else: nfair = nfair_gamma_states(fsm, agents) def inner(Z): res = psi for f in fsm.fairness_constraints: nf = ~f # & fsm.bddEnc.statesMask res = res | fsm.pre_strat( fp( lambda Y: (phi | psi | nfair) & (Z | nf) & (psi | fsm.pre_strat(Y, agents)), BDD.true(fsm.bddEnc.DDmanager), ), agents, ) return (psi | phi | nfair) & res return fp(inner, BDD.false(fsm.bddEnc.DDmanager))
def caw(fsm, agents, phi, psi): """ Return the set of states of fsm satisfying [agents][phi W psi]. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi """ if len(fsm.fairness_constraints) == 0: return fp(lambda Z: psi | (phi & fsm.pre_nstrat(Z, agents)), BDD.true(fsm.bddEnc.DDmanager)) else: def inner(Z): res = phi for f in fsm.fairness_constraints: res = res & fsm.pre_nstrat( fp( lambda Y: (psi & fair_gamma_states(fsm, agents)) | (Z & f) | (phi & fsm.pre_nstrat(Y, agents)), BDD.false(fsm.bddEnc.DDmanager), ), agents, ) return (psi & fair_gamma_states(fsm, agents)) | res return fp(inner, BDD.true(fsm.bddEnc.DDmanager))
def nfair_gamma_states(fsm, agents): """ Return the set of states in which agents cann avoid fair paths. fsm -- the model agents -- a list of agents names """ # NFair_Gamma = not([Gamma] G True) = <Gamma> F False agents = frozenset(agents) if agents not in __nfair_gamma_states: if len(fsm.fairness_constraints) == 0: __nfair_gamma_states[agents] = BDD.false(fsm.bddEnc.DDmanager) else: def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f # & fsm.bddEnc.statesMask res = res | fsm.pre_strat( fp(lambda Y: (Z | nf) & fsm.pre_strat(Y, agents), BDD.true(fsm.bddEnc.DDmanager)), agents ) return res __nfair_gamma_states[agents] = fp(inner, BDD.false(fsm.bddEnc.DDmanager)) return __nfair_gamma_states[agents]
def eg(fsm, phi): """ Return the set of states of fsm satisfying EG phi. fsm -- a MAS representing the system phi -- a BDD representing the set of states of fsm satisfying phi """ # def inner(Z): # res = Z # for f in fsm.fairness_constraints: # res = res & fp(lambda Y : (Z & f) | (phi & fsm.weak_pre(Y)), # BDD.false(fsm.bddEnc.DDmanager)) # return phi & fsm.weak_pre(res) # # r = fp(inner, BDD.true(fsm.bddEnc.DDmanager)) # return r.forsome(fsm.bddEnc.inputsCube) phi = phi.forsome(fsm.bddEnc.inputsCube) & fsm.bddEnc.statesMask if len(fsm.fairness_constraints) == 0: return fp(lambda Z: phi & fsm.pre(Z), BDD.true(fsm.bddEnc.DDmanager)).forsome(fsm.bddEnc.inputsCube) else: def inner(Z): res = phi for f in fsm.fairness_constraints: res = res & fsm.pre(fp(lambda Y: (Z & f) | (phi & fsm.pre(Y)), BDD.false(fsm.bddEnc.DDmanager))) return res return fp(inner, BDD.true(fsm.bddEnc.DDmanager)).forsome(fsm.bddEnc.inputsCube)
def cew_si(fsm, agents, phi, psi, strat=None): """ Return the set of state/inputs pairs of strat satisfying <agents>[phi W psi] under full observability in strat. If strat is None, strat is considered true. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi strat -- a BDD representing allowed state/inputs pairs, or None """ if not strat: strat = BDD.true(fsm.bddEnc.DDmanager) phi = phi & fsm.bddEnc.statesInputsMask & strat psi = psi & fsm.bddEnc.statesInputsMask & strat nfair = nfair_gamma_si(fsm, agents, strat) return fp( lambda Y: (psi | phi | nfair) & (psi | fsm.pre_strat_si(Y, agents, strat)), BDD.true(fsm.bddEnc.DDmanager))
def inner(Z): res = BDD.true(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) res = res & run.pre( fixpoint(lambda Y: (Z & fc) | run.pre(Y), BDD.false(mas))) return res
def nfair_gamma_si(fsm, agents, strat=None): """ Return the set of state/inputs pairs of strat in which agents can avoid a fair path in strat. If strat is None, it is considered true. fsm -- the model agents -- a list of agents names strat -- a BDD representing allowed state/inputs pairs, or None """ if not strat: strat = BDD.true(fsm.bddEnc.DDmanager) if len(fsm.fairness_constraints) == 0: return BDD.false(fsm.bddEnc.DDmanager) else: def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f & fsm.bddEnc.statesMask & strat res = res | fsm.pre_strat_si( fp(lambda Y: (Z | nf) & fsm.pre_strat_si(Y, agents, strat), BDD.true(fsm.bddEnc.DDmanager)), agents, strat) return res return fp(inner, BDD.false(fsm.bddEnc.DDmanager))
def test_get_false(self): (fsm, enc, manager) = self.init_model() false = BDD.false(manager) self.assertIsNotNone(false) self.assertTrue(false.is_false()) self.assertFalse(false.is_true()) self.assertTrue(false.isnot_true()) self.assertFalse(false.isnot_false()) self.assertTrue(false.isnot_true()) false = BDD.false() self.assertIsNotNone(false) self.assertTrue(false.is_false()) self.assertFalse(false.is_true()) self.assertTrue(false.isnot_true()) self.assertFalse(false.isnot_false()) self.assertTrue(false.isnot_true()) false = BDD.false() self.assertIsNotNone(false) self.assertTrue(false.is_false()) self.assertFalse(false.is_true()) self.assertTrue(false.isnot_true()) self.assertFalse(false.isnot_false()) self.assertTrue(false.isnot_true())
def check_cex(self, fsm, explanation, agents, phi): """Check that the explanation is correct.""" # Get the cubes gamma_cube = fsm.inputs_cube_for_agents(agents) ngamma_cube = fsm.bddEnc.inputsCube - gamma_cube # The first state satisfies the spec self.assertTrue(explanation.state <= cex(fsm, agents, phi)) acts = BDD.false(fsm.bddEnc.DDmanager) states = BDD.false(fsm.bddEnc.DDmanager) for (act, succ) in explanation.successors: ag_action = act.forsome(ngamma_cube) # The successor satisfies phi self.assertTrue(succ.state <= phi) # The action is effectively possible self.assertTrue(act <= fsm.get_inputs_between_states( explanation.state, succ.state)) # Accumulate states and actions acts = acts | act states = states | succ.state # The reached states are effectively the reachable states # through the action self.assertTrue(states <= fsm.post(explanation.state, ag_action)) self.assertTrue(states >= fsm.post(explanation.state, ag_action) & fsm.bddEnc.statesMask) # The actions are effectively all the possible actions completing ag_act self.assertTrue(acts <= ag_action) self.assertTrue(acts >= ag_action & fsm.get_inputs_between_states(explanation.state, states) & fsm.bddEnc.inputsMask)
def check_free_choice(self): """ Check whether this MAS satisfies the free-choice property, that is, in every state, the choices of actions for each agent is not constrained by the choices of other agents. Return the set of moves that are not present in the MAS and should, or that are present but should not. """ if len(self.agents) <= 0: return BDD.false(self.bddEnc.DDmanager) true = BDD.true(self.bddEnc.DDmanager) protocols = {agent: self.protocol({agent}) for agent in self.agents} enabled = (self.weak_pre(self.reachable_states) & self.reachable_states & self.bddEnc.statesInputsMask) for s in self.pick_all_states(self.reachable_states): product = self.bddEnc.statesInputsMask for agent in self.agents: product &= protocols[agent] & s if (enabled & s) != product: return product.xor(enabled & s) return BDD.false(self.bddEnc.DDmanager)
def ceu(fsm, agents, phi, psi, strat=None): """ Return the set of states of strat satisfying <agents>[phi U psi] under full observability in strat. If strat is None, strat is considered true. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi strat -- a BDD representing allowed state/inputs pairs, or None """ if len(fsm.fairness_constraints) == 0: return fp(lambda Z : psi | (phi & fsm.pre_strat(Z, agents, strat)), BDD.false(fsm.bddEnc.DDmanager)) else: nfair = nfair_gamma(fsm, agents, strat) def inner(Z): res = psi for f in fsm.fairness_constraints: nf = ~f res = res | fsm.pre_strat(fp(lambda Y : (phi | psi | nfair) & (Z | nf) & (psi | fsm.pre_strat(Y, agents, strat)), BDD.true(fsm.bddEnc.DDmanager)), agents, strat) return (psi | phi | nfair) & res return fp(inner, BDD.false(fsm.bddEnc.DDmanager))
def ceu(fsm, agents, phi, psi): """ Return the set of states of fsm satisfying <agents>[phi U psi]. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi """ #phi = phi & fsm.bddEnc.statesInputsMask #psi = psi & fsm.bddEnc.statesInputsMask if len(fsm.fairness_constraints) == 0: return fp(lambda Z : psi | (phi & fsm.pre_strat(Z, agents)), BDD.false(fsm.bddEnc.DDmanager)) else: nfair = nfair_gamma_states(fsm, agents) def inner(Z): res = psi for f in fsm.fairness_constraints: nf = ~f #& fsm.bddEnc.statesMask res = res | fsm.pre_strat(fp(lambda Y : (phi | psi | nfair) & (Z | nf) & (psi | fsm.pre_strat(Y, agents)), BDD.true(fsm.bddEnc.DDmanager)), agents) return (psi | phi | nfair) & res return fp(inner, BDD.false(fsm.bddEnc.DDmanager))
def nfair_gamma_states(fsm, agents): """ Return the set of states in which agents cann avoid fair paths. fsm -- the model agents -- a list of agents names """ # NFair_Gamma = not([Gamma] G True) = <Gamma> F False agents = frozenset(agents) if agents not in __nfair_gamma_states: if len(fsm.fairness_constraints) == 0: __nfair_gamma_states[agents] = BDD.false(fsm.bddEnc.DDmanager) else: def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f #& fsm.bddEnc.statesMask res = res | fsm.pre_strat(fp(lambda Y : (Z | nf) & fsm.pre_strat(Y, agents), BDD.true(fsm.bddEnc.DDmanager)), agents) return res __nfair_gamma_states[agents] = fp(inner, BDD.false(fsm.bddEnc.DDmanager)) return __nfair_gamma_states[agents]
def eg(fsm, phi): """ Return the set of states of fsm satisfying EG phi. fsm -- a MAS representing the system phi -- a BDD representing the set of states of fsm satisfying phi """ #def inner(Z): # res = Z # for f in fsm.fairness_constraints: # res = res & fp(lambda Y : (Z & f) | (phi & fsm.weak_pre(Y)), # BDD.false(fsm.bddEnc.DDmanager)) # return phi & fsm.weak_pre(res) # #r = fp(inner, BDD.true(fsm.bddEnc.DDmanager)) #return r.forsome(fsm.bddEnc.inputsCube) phi = phi.forsome(fsm.bddEnc.inputsCube) & fsm.bddEnc.statesMask if len(fsm.fairness_constraints) == 0: return fp(lambda Z : phi & fsm.pre(Z), BDD.true(fsm.bddEnc.DDmanager)).forsome(fsm.bddEnc.inputsCube) else: def inner(Z): res = phi for f in fsm.fairness_constraints: res = res & fsm.pre(fp(lambda Y : (Z & f) | (phi & fsm.pre(Y)), BDD.false(fsm.bddEnc.DDmanager))) return res return (fp(inner, BDD.true(fsm.bddEnc.DDmanager)) .forsome(fsm.bddEnc.inputsCube))
def caw(fsm, agents, phi, psi): """ Return the set of states of fsm satisfying [agents][phi W psi]. fsm -- a MAS representing the system agents -- a list of agents names phi -- a BDD representing the set of states of fsm satisfying phi psi -- a BDD representing the set of states of fsm satisfying psi """ if len(fsm.fairness_constraints) == 0: return fp(lambda Z : psi | (phi & fsm.pre_nstrat(Z, agents)), BDD.true(fsm.bddEnc.DDmanager)) else: def inner(Z): res = phi for f in fsm.fairness_constraints: res = res & fsm.pre_nstrat(fp(lambda Y : (psi &fair_gamma_states(fsm, agents)) | (Z & f) | (phi & fsm.pre_nstrat(Y, agents)), BDD.false(fsm.bddEnc.DDmanager)), agents) return (psi &fair_gamma_states(fsm, agents)) | res return fp(inner, BDD.true(fsm.bddEnc.DDmanager))
def nfair_ce_moves(mas, agents, moves): """ mas -- a multi-agent system; agents -- a subset of agents of mas; moves -- a closed set of moves for agents. """ # If there are no fairness constraints, there are no nfair states. if not mas.fairness_constraints: return BDD.false(mas) else: def inner(Z): res = BDD.false(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) nfc = ~fc & mas.bddEnc.statesMask nfc_moves = nfc & mas.protocol(agents) & moves m = stay_ce_moves(mas, agents, Z | nfc_moves, BDD.false(mas), moves) res |= pre_ce_moves(mas, agents, m, moves) return res return fixpoint(inner, BDD.false(mas))
def _nfair(mas, formula, agents): """ Return the set of states in which the given agents cannot avoid a fair path by using the strategy encoded in these states. """ jump = mas.transitions[formula]["jump"] equiv = mas.transitions[formula]["equiv"] follow = mas.transitions[formula]["follow"] if not mas.fairness_constraints: return BDD.false(mas) else: # nfair = # mu Z. \/_fc []_group_follow(nu Y. (Z \/ ~fc) /\ []_group_follow(Y)) def inner(Z): # \/_fc []_group_follow(nu Y. (Z \/ ~fc) /\ []_group_follow(Y)) res = BDD.false(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) nfc = ~fc res = res | ~follow.pre(~fixpoint( lambda Y: (Z | nfc) & ~follow.pre(~Y), BDD.true(mas))) return res res = fixpoint(inner, BDD.false(mas)) return res
def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f # & fsm.bddEnc.statesMask res = res | fsm.pre_strat( fp(lambda Y: (Z | nf) & fsm.pre_strat(Y, agents), BDD.true(fsm.bddEnc.DDmanager)), agents ) return res
def eg(fsm, phi): res = BDD.true(fsm.bddEnc.DDmanager) old = BDD.false(fsm.bddEnc.DDmanager) while res != old: old = res new = ex(fsm, res) res = res & new & phi & fsm.reachable_states return res
def inner(Z): res = BDD.false(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) nfc = ~fc & mas.bddEnc.statesMask states = stay_ce(mas, agents, Z | nfc, BDD.false(mas), moves) res |= pre_ce(mas, agents, states, moves) return res
def inner(Z): res = BDD.false(fsm.bddEnc.DDmanager) for f in fsm.fairness_constraints: nf = ~f & fsm.bddEnc.statesMask & strat res = res | fsm.pre_strat_si( fp(lambda Y: (Z | nf) & fsm.pre_strat_si(Y, agents, strat), BDD.true(fsm.bddEnc.DDmanager)), agents, strat) return res
def test_init(self): fsm = self.init_model() manager = fsm.bddEnc.DDmanager init = fsm.init initState = fsm.pick_one_state(init) self.assertTrue(BDD.false(manager) <= init <= BDD.true(manager)) self.assertTrue(BDD.false(manager) < initState <= init)
def inner(Z): # \/_fc []_group_follow(nu Y. (Z \/ ~fc) /\ []_group_follow(Y)) res = BDD.false(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) nfc = ~fc res = res | ~follow.pre(~fixpoint( lambda Y: (Z | nfc) & ~follow.pre(~Y), BDD.true(mas))) return res
def inner(Z): res = BDD.true(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) res = res & run.pre( fixpoint( lambda Y: (states_2 & _fair(mas)) | (Z & fc) | (states_1 & run.pre(Y)), BDD.false(mas))) return (res & states_1) | (states_2 & _fair(mas))
def eval_strat_FSF(fsm, spec): """ Return the BDD representing the set of states of fsm satisfying spec. spec is a strategic operator <G> pi. Implement a variant of the algorithm that filters, splits and then filters. fsm -- a MAS representing the system; spec -- an AST-based ATLK specification with a top strategic operator. """ if type(spec) is CAX: # [g] X p = ~<g> X ~p newspec = CEX(spec.group, Not(spec.child)) return ~eval_strat_FSF(fsm, newspec) elif type(spec) is CAG: # [g] G p = ~<g> F ~p newspec = CEF(spec.group, Not(spec.child)) return ~eval_strat_FSF(fsm, newspec) elif type(spec) is CAU: # [g][p U q] = ~<g>[ ~q W ~p & ~q ] newspec = CEW(spec.group, Not(spec.right), And(Not(spec.left), Not(spec.right))) return ~eval_strat_FSF(fsm, newspec) elif type(spec) is CAF: # [g] F p = ~<g> G ~p newspec = CEG(spec.group, Not(spec.child)) return ~eval_strat_FSF(fsm, newspec) elif type(spec) is CAW: # [g][p W q] = ~<g>[~q U ~p & ~q] newspec = CEU(spec.group, Not(spec.right), And(Not(spec.left), Not(spec.right))) return ~eval_strat_FSF(fsm, newspec) sat = BDD.false(fsm.bddEnc.DDmanager) agents = {atom.value for atom in spec.group} # First filtering winning = filter_strat(fsm, spec, variant="FSF") if winning.is_false(): # no state/inputs pairs are winning => return false return winning return split_eval(fsm, spec, BDD.false(fsm.bddEnc.DDmanager), winning)
def test_true_false_equalities(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) self.assertTrue(false != true) self.assertFalse(false == true) self.assertTrue(false == false) self.assertTrue(true == true) self.assertTrue((false != true) == (not false == true))
def test_true_false_xor(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertTrue(true ^ false == true) self.assertTrue(true ^ true == false) self.assertTrue(false ^ false == false) self.assertTrue(init ^ true == ~init) self.assertTrue(init ^ false == init)
def test_pre(self): fsm = self.model() trans = fsm.trans true = BDD.true() false = BDD.false() p = eval_simple_expression(fsm, "p") q = eval_simple_expression(fsm, "q") a = eval_simple_expression(fsm, "a") self.assertEqual(trans.pre(p & q), false) self.assertEqual(trans.pre(p & ~q, inputs=a), p & ~q)
def filter_strat(fsm, spec, strat=None, variant="SF"): """ Returns the subset SA of strat (or the whole system if strat is None), state/action pairs of fsm, such that there is a strategy to satisfy spec in fsm. fsm -- a MAS representing the system; spec -- an AST-based ATLK specification with a top strategic operator; the operator is CEX, CEG, CEF, CEU or CEW. strat -- the subset of the system to consider. variant -- the variant of the algorithm to evaluate strategic operators; must be * "SF" for the standard way: splitting in uniform strategies then filtering winning states, * "FS" for the alternating way: filtering winning states, then splitting one conflicting equivalence class, then recurse * "FSF" for the filter-split-filter way: filtering winning states then splitting all remaining actions into uniform strategies, then filtering final winning states. If variant is not in {"SF", "FS", "FSF"}, the standard "SF" way is used. """ sat = BDD.false(fsm.bddEnc.DDmanager) agents = {atom.value for atom in spec.group} # Filtering if type(spec) is CEX: winning = cex_si(fsm, agents, evalATLK(fsm, spec.child, variant=variant), strat) elif type(spec) is CEG: winning = ceg_si(fsm, agents, evalATLK(fsm, spec.child, variant=variant), strat) elif type(spec) is CEU: winning = ceu_si(fsm, agents, evalATLK(fsm, spec.left, variant=variant), evalATLK(fsm, spec.right, variant=variant), strat) elif type(spec) is CEF: # <g> F p = <g>[true U p] winning = ceu_si(fsm, agents, BDD.true(fsm.bddEnc.DDmanager), evalATLK(fsm, spec.child, variant=variant), strat) elif type(spec) is CEW: winning = cew_si(fsm, agents, evalATLK(fsm, spec.left, variant=variant), evalATLK(fsm, spec.right, variant=variant), strat) return winning & fsm.bddEnc.statesInputsMask & fsm.protocol(agents)
def test_true_false_not(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertTrue(~true == -true) self.assertTrue(~false == -false) self.assertTrue(~true == false) self.assertTrue(~false == true) self.assertTrue(false < ~init < true)
def test_pick_states_inputs(self): fsm = self.model() false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) p = evalSexp(fsm, "p") q = evalSexp(fsm, "q") a = evalSexp(fsm, "a") pstates = fsm.pick_all_states_inputs(p & a) self.assertEqual(len(pstates), 2) for pstate in pstates: self.assertTrue(false < pstate < p)
def test_count_states_inputs(self): fsm = self.model() false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) p = evalSexp(fsm, "p") q = evalSexp(fsm, "q") a = evalSexp(fsm, "a") self.assertEqual(fsm.count_states_inputs(a), 4) self.assertEqual(fsm.count_states_inputs(p & ~a), 2) self.assertEqual(fsm.count_states_inputs(true), 8) self.assertEqual(fsm.count_states_inputs(false), 0)
def inner(Z): res = BDD.false(mas) for fc in mas.fairness_constraints: fc = fc.forsome(mas.bddEnc.inputsCube) nfc = ~fc & mas.bddEnc.statesMask nfc_moves = nfc & mas.protocol(agents) & moves m = stay_ce_moves(mas, agents, Z | nfc_moves, BDD.false(mas), moves) res |= pre_ce_moves(mas, agents, m, moves) return res
def test_fairness(self): fsm = BddFsm.from_filename("tests/pynusmv/models/counters-fair.smv") self.assertIsNotNone(fsm) false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) rc1 = evalSexp(fsm, "run = rc1") rc2 = evalSexp(fsm, "run = rc2") fairBdds = fsm.fairness_constraints self.assertEqual(len(fairBdds), 2) for fair in fairBdds: self.assertTrue(fair == rc1 or fair == rc2)
def test_dup(self): (fsm, enc, manager) = self.init_model() false = BDD.false(manager) true = BDD.true(manager) init = fsm.init self.assertEqual(false, false.dup()) self.assertEqual(true, true.dup()) self.assertEqual(init, init.dup()) self.assertNotEqual(true, init.dup()) self.assertNotEqual(init, false.dup())
def test_init_equalities(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertIsNotNone(init) self.assertTrue(init != true) self.assertTrue(init != false) self.assertFalse(init == true) self.assertFalse(init == false)
def test_true_false_and(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertTrue((true & false) == (true * false)) self.assertTrue(true & false == false) self.assertTrue(true & true == true) self.assertTrue(false & false == false) self.assertTrue(init & true == init) self.assertTrue(init & false == false)
def test_true_false_or(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertTrue((true | false) == (true + false)) self.assertTrue(true | false == true) self.assertTrue(true | true == true) self.assertTrue(false | false == false) self.assertTrue(init | true == true) self.assertTrue(init | false == init)
def test_count_inputs(self): fsm = self.model() false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) p = evalSexp(fsm, "p") q = evalSexp(fsm, "q") a = evalSexp(fsm, "a") self.assertEqual(fsm.count_inputs(a), 1) self.assertEqual(fsm.count_inputs(~a), 1) self.assertEqual(fsm.count_inputs(true), 2) self.assertEqual(fsm.count_inputs(false), 0) self.assertEqual(fsm.count_inputs(p & q & a), 0) # WHY ?
def test_true_false_sub(self): (fsm, enc, manager) = self.init_model() true = BDD.true(manager) false = BDD.false(manager) init = fsm.init self.assertTrue(true - false == true) self.assertTrue(true - true == false) self.assertTrue(false - true == false) self.assertTrue(false - false == false) self.assertTrue(init - true == false) self.assertTrue(init - false == init) self.assertTrue(true - init == ~init) self.assertTrue(false - init == false)
def test_pick_one_inputs_error(self): fsm = self.model() false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) p = evalSexp(fsm, "p") q = evalSexp(fsm, "q") a = evalSexp(fsm, "a") with self.assertRaises(NuSMVBddPickingError): i = fsm.pick_one_inputs(false) # This does not raise an error since "p" contains all the inputs # Thus "i" is any inputs i = fsm.pick_one_inputs(p)
def pre(self, states, inputs=None, subsystem=None): """ Return the pre image of states, through inputs (if any) and in subsystem (if any). """ if inputs is None: inputs = BDD.true(self.bddEnc.DDmanager) if subsystem is None: subsystem = BDD.true(self.bddEnc.DDmanager) return ((self.weak_pre(states & inputs) & subsystem).forsome(self.bddEnc.inputsCube) & self.bddEnc.statesMask)
def test_pick_one_state_inputs(self): fsm = self.model() false = BDD.false(fsm.bddEnc.DDmanager) true = BDD.true(fsm.bddEnc.DDmanager) p = evalSexp(fsm, "p") q = evalSexp(fsm, "q") a = evalSexp(fsm, "a") si = fsm.pick_one_state_inputs(a & p) self.assertTrue(false < si <= a & p < true) self.assertTrue(si.isnot_false()) self.assertTrue((si == (a & p & q)) | (si == (a & p & ~q))) si = fsm.pick_one_state_inputs(true) self.assertTrue(false < si < true)
def post(self, states, inputs=None, subsystem=None): """ Return the post image of states, through inputs (if any) and in subsystem (if any). """ if inputs is None: inputs = BDD.true(self.bddEnc.DDmanager) if subsystem is None: subsystem = BDD.true(self.bddEnc.DDmanager) states = states & subsystem return super(MAS, self).post(states, inputs)