static void validate_quant_solutions(app* x, expr* fml, expr_ref_vector& guards) { return; // quant_elim option got removed... // verify: // fml <=> guard_1 \/ guard_2 \/ ... ast_manager& m = guards.get_manager(); expr_ref tmp(m), fml2(m); tmp = m.mk_or(guards.size(), guards.c_ptr()); expr* _x = x; std::cout << mk_pp(fml, m) << "\n"; expr_abstract(m, 0, 1, &_x, fml, fml2); std::cout << mk_pp(fml2, m) << "\n"; symbol name(x->get_decl()->get_name()); sort* s = m.get_sort(x); fml2 = m.mk_exists(1, &s, &name, fml2); std::cout << mk_pp(fml2, m) << "\n"; tmp = m.mk_not(m.mk_iff(fml2, tmp)); std::cout << mk_pp(tmp, m) << "\n"; front_end_params fp; smt::kernel solver(m, fp); solver.assert_expr(tmp); lbool res = solver.check(); std::cout << "checked\n"; SASSERT(res == l_false); if (res != l_false) { std::cout << res << "\n"; fatal_error(0); } }
static void test2(char const *ex) { smt_params params; params.m_model = true; ast_manager m; reg_decl_plugins(m); arith_util a(m); expr_ref fml = parse_fml(m, ex); app_ref_vector vars(m); expr_ref_vector lits(m); vars.push_back(m.mk_const(symbol("x"), a.mk_real())); vars.push_back(m.mk_const(symbol("y"), a.mk_real())); vars.push_back(m.mk_const(symbol("z"), a.mk_real())); flatten_and(fml, lits); smt::context ctx(m, params); ctx.push(); ctx.assert_expr(fml); lbool result = ctx.check(); VERIFY(result == l_true); ref<model> md; ctx.get_model(md); ctx.pop(1); std::cout << mk_pp(fml, m) << "\n"; expr_ref pr1(m), pr2(m), fml2(m); expr_ref_vector bound(m); ptr_vector<sort> sorts; svector<symbol> names; for (unsigned i = 0; i < vars.size(); ++i) { bound.push_back(vars[i].get()); names.push_back(vars[i]->get_decl()->get_name()); sorts.push_back(m.get_sort(vars[i].get())); } expr_abstract(m, 0, bound.size(), bound.c_ptr(), fml, fml2); fml2 = m.mk_exists(bound.size(), sorts.c_ptr(), names.c_ptr(), fml2); qe::expr_quant_elim qe(m, params); for (unsigned i = 0; i < vars.size(); ++i) { VERIFY(qe::arith_project(*md, vars[i].get(), lits)); } pr1 = mk_and(lits); qe(m.mk_true(), fml2, pr2); std::cout << mk_pp(pr1, m) << "\n"; std::cout << mk_pp(pr2, m) << "\n"; expr_ref npr2(m); npr2 = m.mk_not(pr2); ctx.push(); ctx.assert_expr(pr1); ctx.assert_expr(npr2); VERIFY(l_false == ctx.check()); ctx.pop(1); }
void tst_model_retrieval() { memory::initialize(0); front_end_params params; params.m_model = true; ast_manager m; m.register_decl_plugins(); family_id array_fid = m.get_family_id(symbol("array")); array_util au(m); array_decl_plugin& ad = *static_cast<array_decl_plugin *>(m.get_plugin(array_fid)); // arr_s and select_fn creation copy-pasted from z3.cpp parameter sparams[2] = { parameter(to_sort(m.mk_bool_sort())), parameter(to_sort(m.mk_bool_sort())) }; sort_ref arr_s(m.mk_sort(array_fid, ARRAY_SORT, 2, sparams), m); sort * domain2[2] = {arr_s, m.mk_bool_sort()}; func_decl_ref select_fn( m.mk_func_decl(array_fid, OP_SELECT, 2, arr_s->get_parameters(), 2, domain2), m); app_ref a1(m.mk_const(symbol("a1"), arr_s), m); app_ref a2(m.mk_const(symbol("a2"), arr_s), m); // (= true (select a1 true)) app_ref fml(m.mk_eq(m.mk_true(), m.mk_app(select_fn.get(), a1, m.mk_true())), m); smt::context ctx(m, params); ctx.assert_expr(fml); lbool check_result = ctx.check(); std::cout<<((check_result==l_true) ? "satisfiable" : (check_result==l_false) ? "unsatisfiable" : "unknown")<<"\n"; ref<model> model; ctx.get_model(model); model_v2_pp(std::cout, *model, false); expr_ref a1_val(model->get_const_interp(a1->get_decl()), m); app_ref fml2(m.mk_eq(a2, a1_val), m); ctx.assert_expr(fml2); std::cout<<"--------------------------\n"; ctx.display(std::cout); std::cout<<"--------------------------\n"; check_result = ctx.check(); ctx.display(std::cout); std::cout<<"--------------------------\n"; std::cout<<((check_result==l_true) ? "satisfiable" : (check_result==l_false) ? "unsatisfiable" : "unknown")<<"\n"; }
void tst_factor_rewriter() { ast_manager m; m.register_decl_plugins(); factor_rewriter_star fw(m); arith_util a(m); expr_ref fml1(m), fml2(m); expr_ref z(m.mk_const(symbol("z"), a.mk_real()), m); expr_ref two(a.mk_numeral(rational(2),false),m); expr_ref zero(a.mk_numeral(rational(0),false),m); fml1 = a.mk_le(zero, a.mk_mul(two, z, z)); fw(fml1, fml2); std::cout << mk_pp(fml1, m) << " -> " << mk_pp(fml2, m) << "\n"; }
void mk_coalesce::merge_rules(rule_ref& tgt, rule const& src) { SASSERT(same_body(*tgt.get(), src)); m_sub1.reset(); m_sub2.reset(); m_idx = 0; app_ref pred(m), head(m); expr_ref fml1(m), fml2(m), fml(m); app_ref_vector tail(m); ptr_vector<sort> sorts1, sorts2; expr_ref_vector conjs1(m), conjs(m); rule_ref res(rm); bool_rewriter bwr(m); svector<bool> is_neg; tgt->get_vars(sorts1); src.get_vars(sorts2); mk_pred(head, src.get_head(), tgt->get_head()); for (unsigned i = 0; i < src.get_uninterpreted_tail_size(); ++i) { mk_pred(pred, src.get_tail(i), tgt->get_tail(i)); tail.push_back(pred); is_neg.push_back(src.is_neg_tail(i)); } extract_conjs(m_sub1, src, fml1); extract_conjs(m_sub2, *tgt.get(), fml2); bwr.mk_or(fml1, fml2, fml); SASSERT(is_app(fml)); tail.push_back(to_app(fml)); is_neg.push_back(false); res = rm.mk(head, tail.size(), tail.c_ptr(), is_neg.c_ptr(), tgt->name()); if (m_ctx.generate_proof_trace()) { src.to_formula(fml1); tgt->to_formula(fml2); res->to_formula(fml); #if 0 sort* ps = m.mk_proof_sort(); sort* domain[3] = { ps, ps, m.mk_bool_sort() }; func_decl* merge = m.mk_func_decl(symbol("merge-clauses"), 3, domain, ps); // TBD: ad-hoc proof rule expr* args[3] = { m.mk_asserted(fml1), m.mk_asserted(fml2), fml }; // ...m_pc->insert(m.mk_app(merge, 3, args)); #else svector<std::pair<unsigned, unsigned> > pos; vector<expr_ref_vector> substs; proof* p = src.get_proof(); p = m.mk_hyper_resolve(1, &p, fml, pos, substs); res->set_proof(m, p); #endif } tgt = res; }
void resolve_rule(replace_proof_converter* pc, rule& r1, rule& r2, unsigned idx, expr_ref_vector const& s1, expr_ref_vector const& s2, rule& res) { if (!pc) return; ast_manager& m = s1.get_manager(); dl_decl_util util(m); expr_ref fml1(m), fml2(m), fml3(m); r1.to_formula(fml1); r2.to_formula(fml2); res.to_formula(fml3); vector<expr_ref_vector> substs; svector<std::pair<unsigned, unsigned> > positions; substs.push_back(s1); substs.push_back(s2); scoped_coarse_proof _sc(m); proof_ref pr(m); proof_ref_vector premises(m); premises.push_back(m.mk_asserted(fml1)); premises.push_back(m.mk_asserted(fml2)); positions.push_back(std::make_pair(idx+1, 0)); TRACE("dl", tout << premises[0]->get_id() << " " << mk_pp(premises[0].get(), m) << "\n"; tout << premises[1]->get_id() << " " << mk_pp(premises[1].get(), m) << "\n";);