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 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_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_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 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 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