def encode_run_graph(self, states_to_encode):
state_to_rejecting_scc = build_state_to_rejecting_scc(self.automaton)
for q in self.automaton.nodes:
for m in states_to_encode:
for label in q.transitions:
self._encode_transitions(q, m, label,
state_to_rejecting_scc)
self.solver.comment('encoded spec state ' + smt_name_spec(q, TYPE_A_STATE))
def _build_args_dict(self, smt_m:str, i_o, q:Node) -> dict:
args_dict = dict()
args_dict[ARG_MODEL_STATE] = smt_m
args_dict[ARG_A_STATE] = smt_name_spec(q, TYPE_A_STATE)
if i_o is None:
return args_dict
smt_label_args, _ = _build_signals_values(self.inputs, i_o)
args_dict.update(smt_label_args)
return args_dict
def _parse_value(self, str_v):
if not hasattr(self, 'node_by_smt_value'): # aka static method of the field
self.node_by_smt_value = dict()
self.node_by_smt_value.update((smt_name_spec(s, TYPE_A_STATE), s)
for s in self.automaton.nodes)
if str_v in self.node_by_smt_value:
return self.node_by_smt_value[str_v]
if str_v in ['false', 'true']:
return str_v == 'true'
return smt_unname_m(str_v)
def _get_all_possible_inputs(self, func_desc:FuncDesc):
arg_type_pairs = func_desc.inputs
get_values = lambda t: { 'Bool': ('true', 'false'),
TYPE_MODEL_STATE: [smt_name_m(m) for m in self.last_allowed_states],
TYPE_A_STATE: [smt_name_spec(s, TYPE_A_STATE) for s in self.automaton.nodes]
}[t]
records = product(*[get_values(t) for (_,t) in arg_type_pairs])
args = list(map(lambda a_t: a_t[0], arg_type_pairs))
dicts = []
for record in records:
assert len(args) == len(record)
arg_value_pairs = zip(args, record)
dicts.append(dict(arg_value_pairs))
return dicts
def _encode_automata_functions(self):
self.solver.declare_enum(TYPE_A_STATE,
map(lambda n: smt_name_spec(n, TYPE_A_STATE), self.automaton.nodes))
