def test_get_next_states(self):
state = Node('init')
sig_r, sig_g = Signal('r'), Signal('g')
node_r = Node('r')
node_rg = Node('rg')
node_nr_g = Node('!rg')
_ = False
edge_to_r = {(node_r, _)}
edge_to_rg = {(node_rg, _)}
edge_to_not_r_g = {(node_nr_g, _)}
state.add_transition({sig_r:True}, edge_to_r)
state.add_transition({sig_r:True, sig_g:True}, edge_to_rg)
state.add_transition({sig_r:False, sig_g:True}, edge_to_not_r_g)
next_states = get_next_states(state, Label({sig_r:False, sig_g:False}))
assert len(next_states) == 0
next_states = get_next_states(state, Label({sig_r:False, sig_g:True}))
assert len(next_states) == 1
self._are_equal_sequences({node_nr_g}, next_states)
next_states = get_next_states(state, Label({sig_r:True, sig_g:True}))
assert len(next_states) == 2
self._are_equal_sequences({node_r, node_rg}, next_states)
def test_is_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [(node, True)])
node.add_transition(Label({'r':True}), [(node, True)])
assert is_final_sink(node)
def test_map_setitem(self):
map = LabelsMap()
map[Label({'a': True})] = True
assert map[Label({'a': True})] == True
# map[Label({'a':True})] = False
# assert map[Label({'a':True})] == False
assert Label({'a': True, 'c': True}) in map
assert Label({}) not in map
def test_is_not_absorbing(self):
node = Node('node')
true_label = Label({})
node.add_transition(true_label, [('dst1', True)])
assert not is_final_sink(node)
def _to_expr(l: Label, sig_by_name: dict):
expr = sympy.true
for sig, val in l.items():
sig_by_name[sig.name] = sig
s = sympy.Symbol(str(sig))
expr = (expr & s) if val else (expr & ~s)
return expr
def _mark_states_with_moore_signals(lts: LTS, state_variable, moore_signals):
dot_lines = StrAwareList()
for state in lts.states:
state_label = Label({state_variable: state})
value_by_signal = dict()
for signal in moore_signals:
signal_model = lts.model_by_signal[signal]
value = signal_model[state_label]
value_by_signal[signal] = value
signals_str = _convert_label_to_dot(value_by_signal)
color = ''
if state in lts.init_states:
color = ', fillcolor="green", style=filled'
if signals_str != '':
dot_lines += '"{state}" [label="{out}\\n{state}"{color}]'.format(
color=color, state=state, out=signals_str)
else:
dot_lines += '"{state}" [label="{state}"{color}]'.format(
color=color, state=state)
return dot_lines
def __getitem__(self, key:Label):
if not isinstance(key, Label):
raise TypeError(key)
indices = [v for (l, v) in self._value_by_label
if set(l.items()).issubset(set(key.items()))]
if len(indices) == 0:
raise KeyError(key)
assert len(indices) == 1, 'return value is not unique: %s: %s' % (str(key), str(indices))
return indices[0]
def test_map_getitem(self):
label_map = LabelsMap()
label_map[Label({'a': False, 'b': False})] = True
assert Label({'a': False, 'b': False}) in label_map
assert label_map[Label({'a': False, 'b': False})] == True
assert Label({'a': False, 'b': False, 'c': False}) in label_map
assert label_map[Label({'a': False, 'b': False, 'c': False})] == True
assert Label({'a': True, 'b': False}) not in label_map
assert Label({'a': True}) not in label_map
def smt_out(smt_m: str, i_o: Label, inputs: Iterable[Signal],
descr_by_output: Dict[Signal, FuncDesc]) -> str:
args_dict = build_tau_args_dict(inputs, smt_m, i_o)
conjuncts = []
for sig, val in i_o.items():
out_desc = descr_by_output.get(sig)
if out_desc is None:
continue
condition_on_out = call_func(out_desc, args_dict)
if val is False:
condition_on_out = op_not(condition_on_out)
conjuncts.append(condition_on_out)
return op_and(conjuncts)
def _to_label(cube, sig_by_name: dict) -> Label or None:
if cube == sympy.true:
return LABEL_TRUE
if cube == sympy.false:
return None
label = dict()
if len(cube.atoms()) == 1:
sig_name = tuple(cube.atoms())[0].name
label[sig_by_name[sig_name]] = not isinstance(cube, sympy.Not)
else:
for l in cube.args:
assert len(l.atoms()) == 1, str(l.atoms())
sig_name = tuple(l.atoms())[0].name
label[sig_by_name[sig_name]] = not isinstance(l, sympy.Not)
return Label(label)
def dualize_aht(aht:AHT,
shared_aht:SharedAHT,
dstFormPropMgr:DstFormulaPropMgr)\
-> AHT:
logging.info('dualize_aht: %s' % aht.init_node)
aht_nodes, aht_transitions = get_reachable_from(aht.init_node,
shared_aht.transitions, dstFormPropMgr)
for t in aht_transitions:
shared_aht.transitions.add(Transition(_dualize_node(t.src),
Label(t.state_label),
DualizerVisitor(dstFormPropMgr).dispatch(t.dst_expr)))
new_init_node = _dualize_node(aht.init_node)
dual_aht = AHT(new_init_node, '~' + aht.name)
return dual_aht
def _build_func_model_from_smt(get_value_lines: Iterable[str],
func_desc: FuncDesc,
all_signals: Iterable[Signal]) -> 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
"""
all_signals = set(all_signals)
model = {}
for l in get_value_lines:
# (get-value ((tau t0 true true)))
l = remove_from_str(l, ['get-value', '(', ')'])
tokens = l.split()
func_name = tokens[0]
arg_values_raw = tokens[1:-1]
return_value_raw = tokens[-1]
if func_name != func_desc.name:
continue
smt_args = get_args_dict(func_desc, arg_values_raw)
args_label = Label(
dict((smt_unname_if_signal(var, all_signals), _parse_value(val))
for var, val in smt_args.items()))
if func_desc.output_ty == TYPE_MODEL_STATE:
return_value_raw = smt_unname_m(return_value_raw)
else:
assert func_desc.output_ty == bool_type(), func_desc.output_ty
return_value_raw = (return_value_raw == true())
model[args_label] = return_value_raw
return model
def test_map_getitem2(self):
label_map = LabelsMap()
label_map[Label()] = True
assert Label({'a': False, 'b': False}) in label_map