def get_split_formula(cls, to_split, split_by, transitions,
quantified_part_getter):
input_vars = transitions.get_input_vectors()[0]
pos_input = VarManager.duplicate_vars(input_vars)
q_part_pos = quantified_part_getter(split_by, transitions)
pos_state_vars = q_part_pos.get_var_vectors()[0]
to_split_pos = to_split.get_descriptive_formula().substitute(
pos_state_vars, 0).substitute_inputs(pos_input, 0)
inner_pos = And(to_split_pos.get_qbf().get_prop(),
q_part_pos.get_qbf().get_prop())
q_list_pos = to_split_pos.get_qbf().get_q_list() + q_part_pos.get_qbf(
).get_q_list()
pos_qbf = QBF(inner_pos, q_list_pos)
pos = FormulaWrapper(pos_qbf, [pos_state_vars], [pos_input])
neg_input = VarManager.duplicate_vars(input_vars)
unnegated_q_part = quantified_part_getter(split_by, transitions)
q_part_neg = unnegated_q_part.negate()
neg_state_vars = q_part_neg.get_var_vectors()[0]
to_split_neg = to_split.get_descriptive_formula().substitute(
neg_state_vars, 0).substitute_inputs(neg_input, 0)
inner_neg = And(to_split_neg.get_qbf().get_prop(),
q_part_neg.get_qbf().get_prop())
q_list_neg = to_split_neg.get_qbf().get_q_list() + q_part_neg.get_qbf(
).get_q_list()
neg_qbf = QBF(inner_neg, q_list_neg)
neg = FormulaWrapper(neg_qbf, [neg_state_vars], [neg_input])
#
# logger.debug("ASSERTING WELL NAMEDNESS")
# assert pos.well_named()
# assert neg.well_named()
return pos, neg, (to_split_pos, pos)
def _get_components_in_quantified(cls, abs_targets, tr):
untagged_in_vec, tag_input_vector = tr.get_input_vectors()
new_state_vars = VarManager.duplicate_vars(tr.get_var_vectors()[0])
new_tag_in_vec = VarManager.duplicate_vars(tag_input_vector)
new_untag_in_vec = VarManager.duplicate_vars(untagged_in_vec)
abs_targets_sub = [
target.get_descriptive_formula().substitute_inputs(
new_tag_in_vec, 0).substitute(new_state_vars,
0).renew_quantifiers()
for target in abs_targets
]
abs_or = Or(*[_t.get_qbf().get_prop() for _t in abs_targets_sub])
new_q_list = [
_v for _t in abs_targets_sub for _v in _t.get_qbf().get_q_list()
]
split_by_formula_tag = FormulaWrapper(QBF(abs_or, new_q_list),
[new_state_vars],
[new_tag_in_vec])
## RENAME QUNATIFIED HERE
transitions_has_sons = tr.substitute(new_state_vars, 1) \
.substitute_inputs(new_untag_in_vec, 0) \
.substitute_inputs(new_tag_in_vec, 1) # R(u,v) [v<-v']
return split_by_formula_tag, transitions_has_sons
def concrete_transition_to_abstract(cls, nodes_from, abstract_witness):
kripke = abstract_witness.get_kripke()
tr = kripke.get_tr_formula()
def sub_src(_tr, src_node):
return _tr.assign_state(src_node.concrete_label)
tr_from_concs = [sub_src(tr, node) for node in nodes_from]
dst_vars = tr_from_concs[0].get_var_vectors()[0]
in_tag = tr.get_input_vectors()[1]
abs_formula = abstract_witness.get_descriptive_formula().substitute(
dst_vars, 0).substitute_inputs(in_tag, 0)
n_flags = len(tr_from_concs)
flags = [Bool('f' + str(i)) for i in xrange(n_flags)]
tr_flagged = [
Or(Not(flags[i]), tr_from_concs[i].get_qbf().get_prop())
for i in xrange(n_flags)
]
all_tr_flagged = simplify(And(*tr_flagged))
f_inner = simplify(
And(all_tr_flagged,
abs_formula.get_qbf().get_prop()))
q_list = abs_formula.get_qbf().get_q_list()
f_qbf = QBF(f_inner, q_list)
f = FormulaWrapper(f_qbf, [dst_vars], tr.get_input_vectors())
i, model = QbfSolverSelector.QbfSolverCtor().incremental_solve_flags(
f, flags, sat)
if i is False:
return False
return nodes_from[i], next(get_states(model, dst_vars, kripke))
def is_EE_closed(cls, to_close, close_with):
kripke = to_close.get_kripke()
transitions = kripke.get_tr_formula()
src_vars, dst_vars = transitions.get_var_vectors()
input_vars, input_tag_vars = transitions.get_input_vectors()
src_wrapper = to_close.get_descriptive_formula().substitute(
src_vars, 0).substitute_inputs(input_vars, 0)
src_qbf_old_q = src_wrapper.get_qbf()
src_qbf = src_qbf_old_q.renew_quantifiers()
dst_formulas = [
closer.get_descriptive_formula().substitute(
dst_vars,
0).substitute_inputs(input_tag_vars,
0).get_qbf().renew_quantifiers().negate()
for closer in close_with
]
dst = QBF(And(*[_d.get_prop() for _d in dst_formulas]),
[_v for _t in dst_formulas for _v in _t.get_q_list()])
tr_qbf = transitions.get_qbf()
inner_prop = simplify(
And(src_qbf.get_prop(), tr_qbf.get_prop(), dst.get_prop()))
q_list = src_qbf.get_q_list() + dst.get_q_list() + tr_qbf.get_q_list()
query = FormulaWrapper(QBF(inner_prop, q_list), [src_vars, dst_vars],
[input_vars])
# logger.debug('Check start')
solver = QbfSolverSelector.QbfSolverCtor()
res, model = solver.solve(query)
# logger.debug('check end.')
if res == unsat:
return True
'''
for s in get_states(model, src_vars, kripke):
f = to_close.get_descriptive_formula().assign_state(s).is_sat()
if not f:
print 'EE-closure is all messed up!'
print 'The src is supposed to be in ' + to_close.get_debug_name()
print 'But is classified to ' + to_close.get_classification_node()._classifier.classify(
s).get_debug_name()
print 'BUG'
get_states(model, src_vars, kripke)
solver = DepQbfSimpleSolver()
res, model = solver.solve(query)
assert False
'''
return EEClosureViolation(next(get_states(model, src_vars, kripke)),
next(get_states(model, dst_vars, kripke)))
def get_bis0_formula(self):
if self.bis0 is not None:
return self.bis0
AP = self.kripke.get_aps()
_, model = self.formula_wrapper.sat_get_model()
state_formula = self.kripke.get_output_formula().get_qbf()
prop = And(state_formula.to_z3(),
*[self.ap_lit_by_model(model, ap) for ap in AP])
bis0 = FormulaWrapper(QBF(prop),
self.formula_wrapper.get_var_vectors(),
[self.kripke.get_input_var_vector()])
self.bis0 = bis0
return bis0
def get_exists_successors_in_formula(cls, abstract_targets, transitions):
kripke = abstract_targets[0].get_kripke()
split_by, tr = cls._get_components_in_quantified(
abstract_targets, transitions)
prev_vars, new_vars = tr.get_var_vectors()
in_vec, quantified_input = tr.get_input_vectors()
inner = And(tr.get_qbf().get_prop(), split_by.get_qbf().get_prop())
q_list = [
(-1, new_vars + in_vec + quantified_input)
] + split_by.get_qbf().get_q_list() + tr.get_qbf().get_q_list()
# exists_formula = cls.apply_qe(simplify(Exists(new_vars + in_vec, inner)), qe_policy)
new_in = VarManager.duplicate_vars(in_vec)
return FormulaWrapper(QBF(inner, q_list), [prev_vars], [new_in])
def get_forall_successors_in_formula(cls, abstract_targets, transitions):
kripke = abstract_targets[0].get_kripke()
split_by, tr = cls._get_components_in_quantified(
abstract_targets, transitions)
prev_vars, new_vars = tr.get_var_vectors()
in_vec, quantified_input = tr.get_input_vectors()
neg_tr = tr.negate()
inner = Or(neg_tr.get_qbf().get_prop(), split_by.get_qbf().get_prop())
# forall_formula = cls.apply_qe(simplify(ForAll(new_vars + in_vec, innektr)), qe_policy)
q_list = [(QDPLL_QTYPE_FORALL, new_vars + in_vec)] + \
[(QDPLL_QTYPE_EXISTS, quantified_input)] + \
split_by.get_qbf().get_q_list() + neg_tr.get_qbf().get_q_list() # quantification over q_in may be false
new_in = VarManager.duplicate_vars(in_vec)
return FormulaWrapper(QBF(inner, q_list), [prev_vars], [new_in])
def is_AE_closed(cls, to_close, close_with):
kripke = to_close.get_kripke()
transitions = kripke.get_tr_formula()
src_vars, dst_vars = transitions.get_var_vectors()
input_vars, input_tag_vars = transitions.get_input_vectors()
src_wrapper = to_close.get_descriptive_formula().substitute(
src_vars, 0).substitute_inputs(input_vars, 0)
src_qbf = src_wrapper.get_qbf().renew_quantifiers()
dst_formulas = [
closer.get_descriptive_formula().substitute(
dst_vars,
0).substitute_inputs(input_tag_vars,
0).get_qbf().renew_quantifiers().negate()
for closer in close_with
]
dst = QBF(And(*[_d.get_prop() for _d in dst_formulas]),
[_v for _t in dst_formulas for _v in _t.get_q_list()])
tr_qbf = transitions.get_qbf()
inner_prop = simplify(
And(src_qbf.get_prop(), Or(Not(tr_qbf.get_prop()),
dst.get_prop())))
q_list = src_qbf.get_q_list() + [
(QDPLL_QTYPE_FORALL, dst_vars)
] + tr_qbf.get_q_list() + dst.get_q_list()
query = FormulaWrapper(QBF(inner_prop, q_list), [src_vars],
[input_vars])
solver = QbfSolverSelector.QbfSolverCtor()
res, model = solver.solve(query)
# logger.debug('check end.')
if res == unsat:
return True
ass = next(get_states(model, src_vars, kripke))
return ass
def from_int_list(int_list, _vars, kripke):
cube = int_list_to_cube(int_list, _vars)
f_wrap = FormulaWrapper(QBF(cube), [_vars],
[kripke.get_input_var_vector()])
return State(f_wrap, kripke)
def get_tr_and_initial(self, kripke):
aag_lines = self._get_aag_lines()
self._prefetch_ap_mapping(aag_lines)
self._init_latch_values = _latch_lines_to_init_values(
aag_lines[1 + self._I:1 + self._I + self._L],
_parse_aag_latch_line)
in_lits, next_state_lits, out_lits, prev_state_lits = self._get_literal_lists(
aag_lines)
formulas = self._get_formulas_hash(aag_lines, in_lits, next_state_lits,
out_lits, prev_state_lits)
in_vars, next_in_vars, next_output_vars, next_state_vars, prev_output_vars, prev_state_vars = self._get_var_lists(
)
ltr_z3_no_sub = simplify(
And(*[
next_state_vars[_l] == formulas[next_state_lits[_l]]
for _l in xrange(self._L)
])) # in_lits,prev_state_lits->nextstate_vars
outputs_z3_no_sub = [
simplify(next_output_vars[_o] == formulas[out_lits[_o]])
for _o in xrange(self._O)
] # in_lits,prev_state_lits->nextoutput_vars
current_in_vars = [Bool(str(_i)) for _i in in_lits]
curr_prev_latch_vars = [Bool(str(_l)) for _l in prev_state_lits]
outputs_z3_next = [
substitute(
outputs_z3_no_sub[_o],
zip(current_in_vars + curr_prev_latch_vars,
next_in_vars + next_state_vars)) for _o in xrange(self._O)
]
outputs_z3_prev = [
substitute(
outputs_z3_no_sub[_o],
zip(
current_in_vars + curr_prev_latch_vars +
[next_output_vars[_o]],
in_vars + prev_state_vars + [prev_output_vars[_o]]))
for _o in xrange(self._O)
]
ltr_no_prev_output_z3 = substitute(
ltr_z3_no_sub,
zip(current_in_vars + curr_prev_latch_vars,
in_vars + prev_state_vars))
ltr_z3 = And(ltr_no_prev_output_z3, *outputs_z3_prev)
output_formulas = [
FormulaWrapper(QBF(outputs_z3_next[_o]),
[next_state_vars, [next_output_vars[_o]]],
[next_in_vars]) for _o in xrange(self._O)
]
prev_var_vector = prev_state_vars + prev_output_vars
next_var_vector = next_state_vars + next_output_vars
var_vectors = [prev_var_vector, next_var_vector]
inner_tr = And(ltr_z3, *outputs_z3_next)
qbf_tr = QBF(inner_tr)
tr = FormulaWrapper(qbf_tr, var_vectors, [in_vars, next_in_vars])
initial_states = get_initial_states(self._init_latch_values,
output_formulas, kripke, tr)
qbf_outputs = QBF(And(*outputs_z3_prev))
output_formula_wrapper = FormulaWrapper(qbf_outputs, [prev_var_vector],
[in_vars])
return tr, initial_states, output_formula_wrapper