def __init__(self,
automaton: Automaton,
tau_desc: FuncDesc,
inputs: Iterable[Signal],
descr_by_output: Dict[Signal, FuncDesc],
all_model_states: Iterable[int],
model_init_state: int = 0
): # the automata alphabet is inputs+outputs
self.automaton = automaton
self.inputs = list(inputs) # type: List[Signal]
self.descr_by_output = descr_by_output # type: Dict[Signal,FuncDesc]
self.tau_desc = tau_desc # type: FuncDesc
self.model_states = list(all_model_states)
reach_args_sig = {
ARG_A_STATE: TYPE_A_STATE,
ARG_MODEL_STATE: TYPE_MODEL_STATE
}
rank_args = reach_args_sig
self.reach_func_desc = FuncDesc(FUNC_REACH, reach_args_sig,
bool_type())
self.rank_func_desc = FuncDesc(FUNC_R, rank_args, real_type())
self.model_init_state = model_init_state # type: int
self.last_allowed_states = None # type: List[int]
def __init__(self,
aht: AHT,
aht_transitions: Iterable[Transition],
dstPropMgr: DstFormulaPropMgr,
tau_desc: FuncDesc,
inputs: Iterable[Signal],
descr_by_output: Dict[Signal, FuncDesc],
all_model_states: Iterable[int],
model_init_state: int = 0
): # the automata alphabet is inputs+outputs
self.aht = aht # type: AHT
self.aht_transitions = aht_transitions # type: Iterable[Transition]
self.dstPropMgr = dstPropMgr # type: DstFormulaPropMgr
self.inputs = inputs # type: Iterable[Signal]
self.descr_by_output = descr_by_output # type: Dict[Signal,FuncDesc]
self.tau_desc = tau_desc # type: FuncDesc
self.model_states = list(all_model_states)
reach_args = {
ARG_A_STATE: TYPE_A_STATE,
ARG_MODEL_STATE: TYPE_MODEL_STATE
}
r_args = reach_args
self.reach_func_desc = FuncDesc(FUNC_REACH, reach_args, bool_type())
self.rank_func_desc = FuncDesc(FUNC_R, r_args, real_type())
self.model_init_state = model_init_state # type: int
self.last_allowed_states = None # type: List[int]
def __init__(self,
top_formula: Expr,
atm_by_p: Dict[Prop, Automaton],
UCWs: Iterable[Automaton],
tau_desc: FuncDesc,
inputs: Iterable[Signal],
desc_by_output: Dict[Signal, FuncDesc],
all_model_states: Iterable[int],
model_init_state: int = 0):
self.top_formula = top_formula # type:Expr
self.atm_by_sig = dict(
map(lambda p_atm: (p_atm[0].arg1, p_atm[1]),
atm_by_p.items())) # type: Dict[Signal, Automaton]
self.UCWs = set(UCWs) # type: Set[Automaton]
assert len(set(map(lambda n: n.name,
chain(*lmap(lambda a: a.nodes, chain(atm_by_p.values(),
self.atm_by_sig.values())))))) \
== \
len(set(chain(*lmap(lambda a: a.nodes, chain(atm_by_p.values(),
self.atm_by_sig.values()))))), \
'node names are not unique'
self.inputs = set(inputs) # type: Set[Signal]
self.tau_desc = tau_desc # type: FuncDesc
self.desc_by_outSig = desc_by_output # type: Dict[Signal,FuncDesc]
# we create fake outputs for A/E propositions;
# they are defined via reach in `encode_headers`:
# ( define-fun _prop ((m M)) Bool (__reach q0_prop m) )
self.desc_by_pSig = dict(
map(
lambda sig:
(sig,
FuncDesc(sig.name, {ARG_MODEL_STATE: TYPE_MODEL_STATE}, 'Bool'
)), self.atm_by_sig))
self.desc_by_sig = dict(
chain(self.desc_by_pSig.items(), self.desc_by_outSig.items()))
assert set(map(lambda out_func: out_func.name, self.desc_by_outSig.values()))\
.isdisjoint(set(map(lambda prop_func:prop_func.name, self.desc_by_pSig.values()))),\
"output and prop func names should not collide"
self.model_states = list(all_model_states)
self.model_init_state = model_init_state # type: int
self.last_allowed_states = None # type: List[int]
reach_args = {
ARG_A_STATE: TYPE_A_STATE,
ARG_MODEL_STATE: TYPE_MODEL_STATE
}
r_args = reach_args
self.reach_func_desc = FuncDesc(FUNC_REACH, reach_args, bool_type())
self.rank_func_desc = FuncDesc(FUNC_R, r_args, real_type())
def __init__(self,
automaton: Automaton,
tau_desc: FuncDesc,
inputs: Iterable[Signal],
descr_by_output: Dict[Signal, FuncDesc],
all_model_states: Iterable[int],
max_k: int,
model_init_state: int = 0
): # the automata alphabet is inputs+outputs
self.automaton = automaton
self.inputs = list(inputs) # type: List[Signal]
self.descr_by_output = descr_by_output # type: Dict[Signal,FuncDesc]
self.tau_desc = tau_desc # type: FuncDesc
self.max_model_states = list(all_model_states)
reach_args_sig = {
ARG_A_STATE: TYPE_A_STATE,
ARG_MODEL_STATE: TYPE_MODEL_STATE
}
self.reach_func_desc = FuncDesc(FUNC_REACH, reach_args_sig,
bool_type())
self.model_init_state = model_init_state # type: int
self.last_allowed_states = None # type: List[int]
self.max_k = max_k
self.forbidding_atoms = lmap(lambda k: '__forbid%i' % k,
range(self.max_k)) # type: List[str]
def build_tau_desc(inputs: Iterable[Signal]):
arg_types_dict = dict()
arg_types_dict[ARG_MODEL_STATE] = TYPE_MODEL_STATE
for s in inputs:
arg_types_dict[smt_arg_name_signal(s)] = 'Bool'
tau_desc = FuncDesc(FUNC_MODEL_TRANS, arg_types_dict, TYPE_MODEL_STATE)
return tau_desc
def build_output_desc(output: Signal, is_moore,
inputs: Iterable[Signal]) -> FuncDesc:
arg_types_dict = dict()
arg_types_dict[ARG_MODEL_STATE] = TYPE_MODEL_STATE
if not is_moore:
for s in inputs:
arg_types_dict[smt_arg_name_signal(s)] = 'Bool'
return FuncDesc(output.name, arg_types_dict, 'Bool')
def _build_func_model_from_smt(self, func_smt_lines, func_desc:FuncDesc) -> dict:
"""
Return graph for the transition (or output) function: {label:output}.
For label's keys are used:
- for inputs/outputs: original signals
- for LTS states: ARG_MODEL_STATE
"""
func_model = {}
signals = set(list(self.inputs) + list(self.descr_by_output.keys()))
for l in func_smt_lines:
# (get-value ((tau t0 true true)))
l = l.replace('get-value', '').replace('(', '').replace(')', '')
tokens = l.split()
func_name = tokens[0]
arg_values_raw = lmap(self._parse_value, tokens[1:-1])
return_value_raw = tokens[-1]
if func_name != func_desc.name:
continue
smt_args = func_desc.get_args_dict(arg_values_raw)
args_label = Label(dict((smt_unname_if_signal(var, signals), val)
for var, val in smt_args.items()))
if func_desc.output_ty == TYPE_MODEL_STATE:
return_value = smt_unname_m(return_value_raw)
else:
assert func_desc.output_ty == self.solver.TYPE_BOOL(), func_desc.output_ty
assert return_value_raw.strip() == return_value_raw # TODO: remove after debugging phase
return_value = (return_value_raw == self.solver.get_true())
func_model[args_label] = return_value
return func_model
def call_func(self, func_desc:FuncDesc, vals_by_vars:dict):
return func_desc.call_func(vals_by_vars)
def define_fun(self, func_desc:FuncDesc):
self._query_storage += func_desc.definition()
def declare_fun(self, func_desc:FuncDesc):
self._query_storage += func_desc.declare_fun()
