def trap_predicate(self, number: int) -> mona.Formula: guard = self.guard_as_mona() variables = sorted([cast(mona.Variable, v.as_mona()) for v in self.free_variables], key=str) ports = self.ports.predicates free_pre = mona.Disjunction([p.hit_pre() for p in ports]) free_post = mona.Disjunction([p.hit_post() for p in ports]) safe_post: List[mona.Formula] = [free_post] broadcast_local: List[mona.Formula] = [] if self.broadcasts: broadcasts_one_post = mona.Disjunction([b.one_post() for b in self.broadcasts]) safe_post.append(broadcasts_one_post) broadcasts_vertical = mona.Conjunction( [cast(mona.Formula, mona.Negation(free_pre))] + [b.vertical_hit() for b in self.broadcasts]) broadcast_local.append(broadcasts_vertical) inner = mona.Disjunction([ mona.Disjunction(safe_post), mona.Conjunction([mona.Negation(free_pre), mona.Conjunction(broadcast_local)]) ]) formula = mona.UniversalFirstOrder(variables, mona.Implication(guard, inner)) return mona.PredicateDefinition(f"trap_transition_{number}", self.system.state_variables, [], formula).simplify()
def disjoint_all_post(self) -> mona.Formula: guard = self.guard_as_mona() variables = sorted([cast(mona.Variable, v.as_mona()) for v in self.quantified_variables], key=str) inner = mona.Conjunction([p.miss_post() for p in self.body.predicates]) return mona.UniversalFirstOrder(variables, mona.Implication(guard, inner))
def one_in_post(self) -> mona.Formula: substitution = {v: Variable(self.system, f"substitute_{v.name}") for v in self.quantified_variables} try: renamed_broadcast = self.normalize(substitution) except FormulaError: raise FormulaError("Cannot generate formula for non-normalized" + " Broadcast {self}") pos_variables = sorted([cast(mona.Variable, v.as_mona()) for v in self.quantified_variables], key=str) pos_guard = self.guard_as_mona() neg_variables = sorted([ cast(mona.Variable, v.as_mona()) for v in renamed_broadcast.quantified_variables], key=str) neg_guard = renamed_broadcast.guard_as_mona() inner = mona.UniversalFirstOrder( neg_variables, mona.Implication( mona.Conjunction( [neg_guard, mona.Disjunction([ p.hit_post() for p in renamed_broadcast.body.predicates])]), mona.Equal(cast(mona.Variable, substitution[self.variable].as_mona()), cast(mona.Variable, self.variable.as_mona())))) outer = mona.ExistentialFirstOrder( pos_variables, mona.Conjunction([pos_guard] + [p.hit_post() for p in self.body.predicates] + [inner])) return outer
def unique_intersection_predicate(self) -> mona.Formula: x = mona.Variable("x") y = mona.Variable("y") one_states = [mona.Variable(f"one{s}") for s in self.system.states] two_states = [mona.Variable(f"two{s}") for s in self.system.states] pairs = list(zip(one_states, two_states)) statements: List[mona.Formula] = [] # fix x in intersection of one state: for pair in pairs: pos = [cast(mona.Formula, mona.ElementIn(x, state)) for state in pair] different_pairs = [p for p in pairs if p != pair] neg = [ # negated statement from above cast(mona.Formula, mona.Negation( mona.Conjunction( [mona.ElementIn(x, state) for state in pair]))) # for all other pairs for pair in different_pairs] statements.append(mona.Conjunction(pos + neg)) fix_x = mona.Disjunction(statements) # make sure x is unique: # y is in intersection y_in_intersection = mona.Disjunction([ mona.Conjunction([mona.ElementIn(y, state) for state in pair]) for pair in pairs]) # y is x if y is in intersection unique_x = mona.UniversalFirstOrder( [y], mona.Implication(y_in_intersection, mona.Equal(x, y))) formula = mona.ExistentialFirstOrder([x], mona.Conjunction([fix_x, unique_x])) return mona.PredicateDefinition( "unique_intersection", one_states + two_states, [], formula).simplify()
def marking_predicate(self) -> mona.Formula: m = mona.Variable("m") unique_in_component = mona.UniversalFirstOrder( [m], mona.Conjunction([ mona.Disjunction([ mona.Conjunction( [cast(mona.Formula, mona.ElementIn(m, pos))] + [cast(mona.Formula, mona.ElementNotIn(m, neg)) for neg in c.state_variables if neg != pos]) for pos in c.state_variables]) for c in self.system.components])) flow_invariant = mona.PredicateCall("flow_invariant", self.system.state_variables) trap_invariant = mona.PredicateCall("trap_invariant", self.system.state_variables) return mona.PredicateDefinition( "marking", self.system.state_variables, [], mona.Conjunction([ unique_in_component, flow_invariant, trap_invariant, ])).simplify()
def vertical_hit(self) -> mona.Formula: guard = self.guard_as_mona() variables = sorted([cast(mona.Variable, v.as_mona()) for v in self.quantified_variables], key=str) pre_post_hit = mona.Conjunction([ mona.Implication(p.hit_pre(), p.hit_post()) for p in self.body.predicates]) return mona.UniversalFirstOrder( variables, mona.Implication(guard, pre_post_hit))
def is_dead_predicate(self, number: int) -> mona.Formula: dead_free = mona.Disjunction( [p.miss_pre() for p in self.ports.predicates]) dead_broadcasts = mona.Disjunction( [b.is_dead() for b in self.broadcasts]) guard = self.guard_as_mona() inner = mona.Implication( guard, mona.Disjunction([dead_free, dead_broadcasts])) formula = mona.UniversalFirstOrder([cast(mona.Variable, v.as_mona()) for v in self.free_variables], inner) return mona.PredicateDefinition(f"dead_transition_{number}", self.system.state_variables, [], formula).simplify()
def invariant_predicate(self, number: int) -> mona.Formula: inner = mona.Disjunction([ # disjoint pre and post mona.Conjunction([self.disjoint_all_pre(), self.disjoint_all_post()]), # unique pre and post mona.Conjunction([self.one_in_pre(), self.one_in_post()]), # more than one in pre mona.Conjunction([mona.Negation(self.disjoint_all_pre()), mona.Negation(self.one_in_pre())]), ]) variables = sorted([cast(mona.Variable, v.as_mona()) for v in self.free_variables], key=str) guard = self.guard_as_mona() quantification = mona.UniversalFirstOrder( variables, mona.Implication(guard, inner)) return mona.PredicateDefinition( f"invariant_transition_{number}", self.system.state_variables, [], quantification).simplify()
def uniquely_intersects_initial_predicate(self) -> mona.Formula: x = mona.Variable("x") y = mona.Variable("y") initial_states = [mona.Variable(c.initial_state) for c in self.system.components] statements: List[mona.Formula] = [] for init in initial_states: other_initial_states = [i for i in initial_states if i != init] x_only_in_init = mona.Conjunction( [cast(mona.Formula, mona.ElementIn(x, init))] + [cast(mona.Formula, mona.ElementNotIn(x, i)) for i in other_initial_states]) statements.append(x_only_in_init) x_in_only_one_initial = mona.Disjunction(statements) y_in_initial = mona.Disjunction( [mona.ElementIn(y, i) for i in initial_states]) x_unique = mona.UniversalFirstOrder([y], mona.Implication( y_in_initial, mona.Equal(x, y))) formula = mona.ExistentialFirstOrder( [x], mona.Conjunction([x_in_only_one_initial, x_unique])) return mona.PredicateDefinition( "uniquely_intersects_initial", self.system.state_variables, [], formula).simplify()