mbi_result prop_mbi_plugin::operator()(expr_ref_vector& lits, model_ref& mdl) { lbool r = m_solver->check_sat(lits); switch (r) { case l_false: lits.reset(); m_solver->get_unsat_core(lits); return mbi_unsat; case l_true: m_solver->get_model(mdl); lits.reset(); for (unsigned i = 0, sz = mdl->get_num_constants(); i < sz; ++i) { func_decl* c = mdl->get_constant(i); if (m_shared.contains(c)) { if (m.is_true(mdl->get_const_interp(c))) { lits.push_back(m.mk_const(c)); } else if (m.is_false(mdl->get_const_interp(c))) { lits.push_back(m.mk_not(m.mk_const(c))); } } } return mbi_sat; default: return mbi_undef; } }
void reset() { m_cache.reset(); m_units.reset(); m_hyps.reset(); m_hypmark.reset(); m_pinned.reset(); }
void itp_solver::elim_proxies (expr_ref_vector &v) { expr_ref f = mk_and (v); scoped_ptr<expr_replacer> rep = mk_expr_simp_replacer (m); rep->set_substitution (&m_elim_proxies_sub); (*rep) (f); v.reset (); flatten_and (f, v); }
bool euf_arith_mbi_plugin::get_literals(model_ref& mdl, expr_ref_vector& lits) { lits.reset(); for (expr* e : m_atoms) { if (mdl->is_true(e)) { lits.push_back(e); } else if (mdl->is_false(e)) { lits.push_back(m.mk_not(e)); } } TRACE("qe", tout << "atoms from model: " << lits << "\n";);
void sym_mux::conv_formula_vector(const expr_ref_vector & vect, unsigned src_idx, unsigned tgt_idx, expr_ref_vector & res) const { res.reset(); expr * const * begin = vect.c_ptr(); expr * const * end = begin + vect.size(); for (expr * const * it = begin; it != end; it++) { expr_ref converted(m); conv_formula(*it, src_idx, tgt_idx, converted); res.push_back(converted); } }
void flush_assertions() const { proof_ref proof(m); expr_ref fml(m); expr_ref_vector fmls(m); for (unsigned i = 0; i < m_assertions.size(); ++i) { m_rewriter(m_assertions[i].get(), fml, proof); m_solver->assert_expr(fml); } m_rewriter.flush_side_constraints(fmls); m_solver->assert_expr(fmls); m_assertions.reset(); }
void flatten_or(expr_ref_vector& result) { ast_manager& m = result.get_manager(); expr* e1, *e2, *e3; for (unsigned i = 0; i < result.size(); ++i) { if (m.is_or(result[i].get())) { app* a = to_app(result[i].get()); unsigned num_args = a->get_num_args(); for (unsigned j = 0; j < num_args; ++j) { result.push_back(a->get_arg(j)); } result[i] = result.back(); result.pop_back(); --i; } else if (m.is_not(result[i].get(), e1) && m.is_not(e1, e2)) { result[i] = e2; --i; } else if (m.is_not(result[i].get(), e1) && m.is_and(e1)) { app* a = to_app(e1); unsigned num_args = a->get_num_args(); for (unsigned j = 0; j < num_args; ++j) { result.push_back(m.mk_not(a->get_arg(j))); } result[i] = result.back(); result.pop_back(); --i; } else if (m.is_implies(result[i].get(),e2,e3)) { result.push_back(e3); result[i] = m.mk_not(e2); --i; } else if (m.is_false(result[i].get()) || (m.is_not(result[i].get(), e1) && m.is_true(e1))) { result[i] = result.back(); result.pop_back(); --i; } else if (m.is_true(result[i].get()) || (m.is_not(result[i].get(), e1) && m.is_false(e1))) { result.reset(); result.push_back(m.mk_true()); return; } } }
void flush_assertions() const { if (m_assertions.empty()) return; m_rewriter.updt_params(get_params()); proof_ref proof(m); expr_ref fml1(m), fml(m); expr_ref_vector fmls(m); for (expr* a : m_assertions) { m_th_rewriter(a, fml1, proof); m_rewriter(false, fml1, fml, proof); m_solver->assert_expr(fml); } m_rewriter.flush_side_constraints(fmls); m_solver->assert_expr(fmls); m_assertions.reset(); }
void simple_check_sat_result::get_unsat_core(expr_ref_vector & r) { if (m_status == l_false) { r.reset(); r.append(m_core.size(), m_core.c_ptr()); } }
virtual void pop_core(unsigned n) { m_assertions.reset(); m_solver->pop(n); m_rewriter.pop(n); }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { if (m.is_not(f) && (m.is_and(args[0]) || m.is_or(args[0]))) { SASSERT(num == 1); expr_ref tmp(m); app* a = to_app(args[0]); m_app_args.reset(); for (expr* arg : *a) { m_brwr.mk_not(arg, tmp); m_app_args.push_back(tmp); } if (m.is_and(args[0])) { result = mk_or(m_app_args); } else { result = mk_and(m_app_args); } return BR_REWRITE2; } if (!m.is_and(f) && !m.is_or(f)) { return BR_FAILED; } if (num == 0) { if (m.is_and(f)) { result = m.mk_true(); } else { result = m.mk_false(); } return BR_DONE; } if (num == 1) { result = args[0]; return BR_DONE; } m_app_args.reset(); m_app_args.append(num, args); std::sort(m_app_args.c_ptr(), m_app_args.c_ptr()+m_app_args.size(), m_expr_cmp); remove_duplicates(m_app_args); bool have_rewritten_args = false; have_rewritten_args = detect_equivalences(m_app_args, m.is_or(f)); if (m_app_args.size()==1) { result = m_app_args[0].get(); } else { if (m.is_and(f)) { result = m.mk_and(m_app_args.size(), m_app_args.c_ptr()); } else { SASSERT(m.is_or(f)); result = m.mk_or(m_app_args.size(), m_app_args.c_ptr()); } } if (have_rewritten_args) { return BR_REWRITE1; } return BR_DONE; }
void pop_core(unsigned n) override { m_assertions.reset(); m_solver->pop(n); m_rewriter.pop(n); }
void flush_side_constraints(expr_ref_vector& side_constraints) { side_constraints.append(m_bounds); m_bounds.reset(); }
virtual void operator()( goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) { SASSERT(g->is_well_sorted()); mc = 0; pc = 0; core = 0; m_trail.reset(); m_fd.reset(); m_max.reset(); m_nonfd.reset(); m_bounds.reset(); ref<bvmc> mc1 = alloc(bvmc); tactic_report report("eq2bv", *g); m_bounds(*g); for (unsigned i = 0; i < g->size(); i++) { collect_fd(g->form(i)); } cleanup_fd(mc1); if (m_max.empty()) { result.push_back(g.get()); return; } for (unsigned i = 0; i < g->size(); i++) { expr_ref new_curr(m); proof_ref new_pr(m); if (is_bound(g->form(i))) { g->update(i, m.mk_true(), 0, 0); continue; } m_rw(g->form(i), new_curr, new_pr); if (m.proofs_enabled() && !new_pr) { new_pr = m.mk_rewrite(g->form(i), new_curr); new_pr = m.mk_modus_ponens(g->pr(i), new_pr); } g->update(i, new_curr, new_pr, g->dep(i)); } obj_map<expr, unsigned>::iterator it = m_max.begin(), end = m_max.end(); for (; it != end; ++it) { expr* c = it->m_key; bool strict; rational r; if (m_bounds.has_lower(c, r, strict)) { SASSERT(!strict); expr* d = m_fd.find(c); g->assert_expr(bv.mk_ule(bv.mk_numeral(r, m.get_sort(d)), d), m_bounds.lower_dep(c)); } if (m_bounds.has_upper(c, r, strict)) { SASSERT(!strict); expr* d = m_fd.find(c); g->assert_expr(bv.mk_ule(d, bv.mk_numeral(r, m.get_sort(d))), m_bounds.upper_dep(c)); } } g->inc_depth(); mc = mc1.get(); result.push_back(g.get()); TRACE("pb", g->display(tout););