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; } }
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 extract_clauses_and_dependencies(goal_ref const& g, expr_ref_vector& clauses, ptr_vector<expr>& assumptions, expr2expr_map& bool2dep, ref<filter_model_converter>& fmc) { expr2expr_map dep2bool; ptr_vector<expr> deps; ast_manager& m = g->m(); expr_ref_vector clause(m); unsigned sz = g->size(); for (unsigned i = 0; i < sz; i++) { expr * f = g->form(i); expr_dependency * d = g->dep(i); if (d == 0 || !g->unsat_core_enabled()) { clauses.push_back(f); } else { // create clause (not d1 \/ ... \/ not dn \/ f) when the d's are the assumptions/dependencies of f. clause.reset(); clause.push_back(f); deps.reset(); m.linearize(d, deps); SASSERT(!deps.empty()); // d != 0, then deps must not be empty ptr_vector<expr>::iterator it = deps.begin(); ptr_vector<expr>::iterator end = deps.end(); for (; it != end; ++it) { expr * d = *it; if (is_uninterp_const(d) && m.is_bool(d)) { // no need to create a fresh boolean variable for d if (!bool2dep.contains(d)) { assumptions.push_back(d); bool2dep.insert(d, d); } clause.push_back(m.mk_not(d)); } else { // must normalize assumption expr * b = 0; if (!dep2bool.find(d, b)) { b = m.mk_fresh_const(0, m.mk_bool_sort()); dep2bool.insert(d, b); bool2dep.insert(b, d); assumptions.push_back(b); if (!fmc) { fmc = alloc(filter_model_converter, m); } fmc->insert(to_app(b)->get_decl()); } clause.push_back(m.mk_not(b)); } } SASSERT(clause.size() > 1); expr_ref cls(m); cls = mk_or(m, clause.size(), clause.c_ptr()); clauses.push_back(cls); } } }
void sym_mux::partition_o_idx( expr_ref_vector const& lits, expr_ref_vector& o_lits, expr_ref_vector& other, unsigned idx) const { for (unsigned i = 0; i < lits.size(); ++i) { if (contains(lits[i], idx) && is_homogenous_formula(lits[i], idx)) { o_lits.push_back(lits[i]); } else { other.push_back(lits[i]); } } }
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 set_value_p(app* e, expr* v) { SASSERT(e->get_num_args() == 0); SASSERT(is_uninterp_const(e)); m_const.push_back(std::make_pair(e, v)); m_refs.push_back(e); m_refs.push_back(v); }
void operator()(expr * n, proof* p, expr_ref_vector& result, proof_ref_vector& ps) { expr_ref fml(m); proof_ref pr(m); m_todo.reset(); m_proofs.reset(); m_refs.reset(); m_memoize_disj.reset(); m_memoize_proof.reset(); m_fresh_predicates.reset(); m_todo.push_back(n); m_proofs.push_back(p); m_produce_proofs = p != 0; while (!m_todo.empty() && !m_cancel) { fml = m_todo.back(); pr = m_proofs.back(); m_todo.pop_back(); m_proofs.pop_back(); mk_horn(fml, pr); if (fml) { result.push_back(fml); ps.push_back(pr); } } TRACE("hnf", tout << mk_pp(n, m) << "\n==>\n"; for (unsigned i = 0; i < result.size(); ++i) { tout << mk_pp(result[i].get(), m) << "\n"; });
proof *mk_lemma_core(proof *pf, expr *fact) { ptr_buffer<expr> args; expr_ref lemma(m); if (m.is_or(fact)) { for (unsigned i = 0, sz = to_app(fact)->get_num_args(); i < sz; ++i) { expr *a = to_app(fact)->get_arg(i); if (!is_reduced(a)) { args.push_back(a); } } } else if (!is_reduced(fact)) { args.push_back(fact); } if (args.size() == 0) { return pf; } else if (args.size() == 1) { lemma = args.get(0); } else { lemma = m.mk_or(args.size(), args.c_ptr()); } proof* res = m.mk_lemma(pf, lemma); m_pinned.push_back(res); if (m_hyps.contains(lemma)) { m_units.insert(lemma, res); } return res; }
void mk_const(func_decl * f, expr_ref & result) { SASSERT(f->get_family_id() == null_family_id); SASSERT(f->get_arity() == 0); expr * r; if (m_const2bits.find(f, r)) { result = r; return; } sort * s = f->get_range(); SASSERT(butil().is_bv_sort(s)); unsigned bv_size = butil().get_bv_size(s); if (bv_size == 1) { result = m().mk_const(f); return; } sort * b = butil().mk_sort(1); ptr_buffer<expr> bits; for (unsigned i = 0; i < bv_size; i++) { bits.push_back(m().mk_fresh_const(0, b)); } r = butil().mk_concat(bits.size(), bits.c_ptr()); m_saved.push_back(r); m_const2bits.insert(f, r); result = r; }
bool reduce_args(unsigned sz, expr*const* as, expr_ref_vector& result) { expr_ref tmp(m); for (unsigned i = 0; i < sz; ++i) { if (!reduce_arg(as[i], tmp)) return false; result.push_back(tmp); } return true; }
bool expr_delta::delta_dfs(unsigned& n, unsigned sz, expr* const* exprs, expr_ref_vector& result) { expr_ref r(m_manager); for (unsigned i = 0; i < sz; ++i) { expr* e = exprs[i]; if (delta_dfs(n, e, r)) { result.push_back(r.get()); for (unsigned j = i+1; j < sz; ++j) { result.push_back(exprs[j]); } return true; } else { result.push_back(e); } } return false; }
void aig_exporter::collect_var_substs(substitution& subst, const app *h, const expr_ref_vector& vars, expr_ref_vector& eqs) { for (unsigned i = 0; i < h->get_num_args(); ++i) { expr *arg = h->get_arg(i); expr *latchvar = get_latch_var(i, vars); if (is_var(arg)) { var *v = to_var(arg); expr_offset othervar; if (subst.find(v, 0, othervar)) { eqs.push_back(m.mk_eq(latchvar, othervar.get_expr())); } else { subst.insert(v, 0, expr_offset(latchvar, 0)); } } else { eqs.push_back(m.mk_eq(latchvar, arg)); } } }
expr_ref mk_le_ge(expr_ref_vector& fmls, expr* a, expr* b, expr* bound) { expr_ref x(m), y(m), result(m); unsigned nb = bv.get_bv_size(a); x = bv.mk_zero_extend(1, a); y = bv.mk_zero_extend(1, b); result = bv.mk_bv_add(x, y); x = bv.mk_extract(nb, nb, result); result = bv.mk_extract(nb-1, 0, result); if (is_le != l_false) { fmls.push_back(m.mk_eq(x, bv.mk_numeral(rational::zero(), 1))); fmls.push_back(bv.mk_ule(result, bound)); } else { fmls.push_back(m.mk_eq(x, bv.mk_numeral(rational::one(), 1))); fmls.push_back(bv.mk_ule(bound, result)); } return result; }
pb_fuzzer(ast_manager& m): m(m), rand(0), ctx(m, params), vars(m) { params.m_model = true; params.m_pb_enable_simplex = true; unsigned N = 3; for (unsigned i = 0; i < N; ++i) { std::stringstream strm; strm << "b" << i; vars.push_back(m.mk_const(symbol(strm.str().c_str()), m.mk_bool_sort())); std::cout << "(declare-const " << strm.str() << " Bool)\n"; } }
void closure::add_variables(unsigned num_vars, expr_ref_vector& fmls) { manager& pm = m_pt.get_pdr_manager(); SASSERT(num_vars > 0); while (m_vars.size() < num_vars) { m_vars.resize(m_vars.size()+1); m_sigma.push_back(m.mk_fresh_const("sigma", a.mk_real())); } unsigned sz = m_pt.sig_size(); for (unsigned i = 0; i < sz; ++i) { expr* var; ptr_vector<expr> vars; func_decl* fn0 = m_pt.sig(i); func_decl* fn1 = pm.o2n(fn0, 0); sort* srt = fn0->get_range(); if (a.is_int_real(srt)) { for (unsigned j = 0; j < num_vars; ++j) { if (!m_vars[j].find(fn1, var)) { var = m.mk_fresh_const(fn1->get_name().str().c_str(), srt); m_trail.push_back(var); m_vars[j].insert(fn1, var); } vars.push_back(var); } fmls.push_back(m.mk_eq(m.mk_const(fn1), a.mk_add(num_vars, vars.c_ptr()))); } } if (m_is_closure) { for (unsigned i = 0; i < num_vars; ++i) { fmls.push_back(a.mk_ge(m_sigma[i].get(), a.mk_numeral(rational(0), a.mk_real()))); } } else { // is interior: for (unsigned i = 0; i < num_vars; ++i) { fmls.push_back(a.mk_gt(m_sigma[i].get(), a.mk_numeral(rational(0), a.mk_real()))); } } fmls.push_back(m.mk_eq(a.mk_numeral(rational(1), a.mk_real()), a.mk_add(num_vars, m_sigma.c_ptr()))); }
static void test_cs(app* x, expr_ref_vector& c, vector<expr_ref_vector> const& cs) { if (c.size() == cs.size()) { test_c(x, c); return; } expr_ref_vector const& c1 = cs[c.size()]; for (unsigned i = 0; i < c1.size(); ++i) { c.push_back(c1[i]); test_cs(x, c, cs); c.pop_back(); } }
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 project_plugin::partition_values(model& model, expr_ref_vector const& vals, expr_ref_vector& lits) { ast_manager& m = vals.get_manager(); expr_ref val(m); expr_ref_vector trail(m), reps(m); obj_map<expr, expr*> roots; for (unsigned i = 0; i < vals.size(); ++i) { expr* v = vals[i], *root; VERIFY (model.eval(v, val)); if (roots.find(val, root)) { lits.push_back(m.mk_eq(v, root)); } else { roots.insert(val, v); trail.push_back(val); reps.push_back(v); } } if (reps.size() > 1) { lits.push_back(mk_distinct(reps)); } }
void aig_exporter::assert_pred_id(func_decl *decl, const expr_ref_vector& vars, expr_ref_vector& exprs) { unsigned id = 0; if (decl && !m_decl_id_map.find(decl, id)) { id = m_next_decl_id++; SASSERT(id < (1U << vars.size())); m_decl_id_map.insert(decl, id); } for (unsigned i = 0; i < vars.size(); ++i) { exprs.push_back((id & (1U << i)) ? vars[i] : m.mk_not(vars[i])); } }
void mk_bits(ast_manager & m, char const * prefix, unsigned sz, expr_ref_vector & r) { sort_ref b(m); b = m.mk_bool_sort(); for (unsigned i = 0; i < sz; ++i) { char buffer[128]; #ifdef _WINDOWS sprintf_s(buffer, ARRAYSIZE(buffer), "%s%d.smt", prefix, i); #else sprintf(buffer, "%s%d.smt", prefix, i); #endif r.push_back(m.mk_const(symbol(buffer), b)); } }
void get_bits(expr * t, expr_ref_vector & out_bits) { if (butil().is_mkbv(t)) { out_bits.append(to_app(t)->get_num_args(), to_app(t)->get_args()); } else { unsigned bv_size = butil().get_bv_size(t); for (unsigned i = 0; i < bv_size; i++) { parameter p(i); out_bits.push_back(m().mk_app(butil().get_family_id(), OP_BIT2BOOL, 1, &p, 1, &t)); } SASSERT(bv_size == out_bits.size()); } }
/** * expands equivalence classes to all derivable equalities */ bool equiv_to_expr_full(expr_equiv_class &equiv, expr_ref_vector &out) { ast_manager &m = out.get_manager(); bool dirty = false; for (auto eq_class : equiv) { for (auto a = eq_class.begin(), end = eq_class.end(); a != end; ++a) { expr_equiv_class::iterator b(a); for (++b; b != end; ++b) { out.push_back(m.mk_eq(*a, *b)); dirty = true; } } } return dirty; }
void fixedpoint_context::simplify_rules( unsigned num_rules, expr* const* rules, unsigned num_outputs, func_decl* const* outputs, expr_ref_vector& result) { ast_manager& m = m_context.get_manager(); datalog::context ctx(m, m_context.get_fparams()); datalog::rule_manager& rm = ctx.get_rule_manager(); for (unsigned i = 0; i < num_rules; ++i) { expr* rule = rules[i], *body, *head; while (true) { if (is_quantifier(rule)) { rule = to_quantifier(rule)->get_expr(); } else if (m.is_implies(rule, body, head)) { rule = head; } else { break; } } if (is_app(rule)) { func_decl* r = to_app(rule)->get_decl(); if (!ctx.is_predicate(r)) { ctx.register_predicate(r); if (num_outputs == 0) { ctx.set_output_predicate(r); } } } } for (unsigned i = 0; i < num_outputs; ++i) { ctx.set_output_predicate(outputs[i]); } for (unsigned i = 0; i < num_rules; ++i) { expr* rule = rules[i]; ctx.add_rule(rule, symbol::null); } model_converter_ref mc; // not exposed. proof_converter_ref pc; // not exposed. ctx.apply_default_transformation(mc, pc); datalog::rule_set const& new_rules = ctx.get_rules(); datalog::rule_set::iterator it = new_rules.begin(), end = new_rules.end(); for (; it != end; ++it) { datalog::rule* r = *it; expr_ref fml(m); r->to_formula(fml); result.push_back(fml); } }
void apply_subst(expr_ref_vector& tgt, expr_ref_vector const& sub) { ast_manager& m = tgt.get_manager(); var_subst vs(m, false); expr_ref tmp(m); for (unsigned i = 0; i < tgt.size(); ++i) { if (tgt[i].get()) { vs(tgt[i].get(), sub.size(), sub.c_ptr(), tmp); tgt[i] = tmp; } else { tgt[i] = sub[i]; } } for (unsigned i = tgt.size(); i < sub.size(); ++i) { tgt.push_back(sub[i]); } }
void array_property_expander::operator()(unsigned num_fmls, expr* const* fmls, expr_ref_vector& result) { ast_manager& m = m_manager; unsigned offset = 0; for (unsigned i = 0; i < num_fmls; ++i) { bool change = false; expr_ref e(m); result.push_back(fmls[i]); do { array_property_exp::proc p(m, offset); e = result[i].get(); for_each_expr(p, e); result[i] = p.find(e); change = e != result[i].get(); } while (change); } }
/** * converts equivalence classes to equalities */ void equiv_to_expr(expr_equiv_class &equiv, expr_ref_vector &out) { ast_manager &m = out.get_manager(); for (auto eq_class : equiv) { expr *rep = nullptr; for (expr *elem : eq_class) { if (!m.is_value(elem)) { rep = elem; break; } } SASSERT(rep); for (expr *elem : eq_class) { if (rep != elem) { out.push_back (m.mk_eq (rep, elem)); } } } }
proof *mk_unit_resolution_core(unsigned num_args, proof* const *args) { ptr_buffer<proof> pf_args; pf_args.push_back(args [0]); app *cls_fact = to_app(m.get_fact(args[0])); ptr_buffer<expr> cls; if (m.is_or(cls_fact)) { for (unsigned i = 0, sz = cls_fact->get_num_args(); i < sz; ++i) { cls.push_back(cls_fact->get_arg(i)); } } else { cls.push_back(cls_fact); } // construct new resovent ptr_buffer<expr> new_fact_cls; bool found; // XXX quadratic for (unsigned i = 0, sz = cls.size(); i < sz; ++i) { found = false; for (unsigned j = 1; j < num_args; ++j) { if (m.is_complement(cls.get(i), m.get_fact(args [j]))) { found = true; pf_args.push_back(args [j]); break; } } if (!found) { new_fact_cls.push_back(cls.get(i)); } } SASSERT(new_fact_cls.size() + pf_args.size() - 1 == cls.size()); expr_ref new_fact(m); new_fact = mk_or(m, new_fact_cls.size(), new_fact_cls.c_ptr()); // create new proof step proof *res = m.mk_unit_resolution(pf_args.size(), pf_args.c_ptr(), new_fact); m_pinned.push_back(res); return res; }
virtual void assert_expr(expr * t) { m_assertions.push_back(t); }
void project_plugin::push_back(expr_ref_vector& lits, expr* e) { if (lits.get_manager().is_true(e)) return; lits.push_back(e); }
static void add_random_ineq( expr_ref_vector& fmls, opt::model_based_opt& mbo, random_gen& r, svector<int> const& values, unsigned max_vars, unsigned max_coeff) { ast_manager& m = fmls.get_manager(); arith_util a(m); unsigned num_vars = values.size(); uint_set used_vars; vector<var_t> vars; int value = 0; for (unsigned i = 0; i < max_vars; ++i) { unsigned x = r(num_vars); if (used_vars.contains(x)) { continue; } used_vars.insert(x); int coeff = r(max_coeff + 1); if (coeff == 0) { continue; } unsigned sign = r(2); coeff = sign == 0 ? coeff : -coeff; vars.push_back(var_t(x, rational(coeff))); value += coeff*values[x]; } unsigned abs_value = value < 0 ? - value : value; // value + k <= 0 // k <= - value // range for k is 2*|value| // k <= - value - range opt::ineq_type rel = opt::t_le; int coeff = 0; if (r(4) == 0) { rel = opt::t_eq; coeff = -value; } else { if (abs_value > 0) { coeff = -value - r(2*abs_value); } else { coeff = 0; } if (coeff != -value && r(3) == 0) { rel = opt::t_lt; } } expr_ref fml(m); app_ref t1(m); app_ref t2(a.mk_numeral(rational(0), a.mk_real()), m); mk_term(vars, rational(coeff), t1); switch (rel) { case opt::t_eq: fml = m.mk_eq(t1, t2); break; case opt::t_lt: fml = a.mk_lt(t1, t2); break; case opt::t_le: fml = a.mk_le(t1, t2); break; case opt::t_mod: NOT_IMPLEMENTED_YET(); break; } fmls.push_back(fml); mbo.add_constraint(vars, rational(coeff), rel); }