void test2() { ast_manager m; reg_decl_plugins(m); bv_util bv(m); datatype_util dtutil(m); params_ref p; datatype_decl_plugin & dt = *(static_cast<datatype_decl_plugin*>(m.get_plugin(m.get_family_id("datatype")))); sort_ref_vector new_sorts(m); constructor_decl* R = mk_constructor_decl(symbol("R"), symbol("is-R"), 0, nullptr); constructor_decl* G = mk_constructor_decl(symbol("G"), symbol("is-G"), 0, nullptr); constructor_decl* B = mk_constructor_decl(symbol("B"), symbol("is-B"), 0, nullptr); constructor_decl* constrs[3] = { R, G, B }; datatype_decl * enum_sort = mk_datatype_decl(dtutil, symbol("RGB"), 0, nullptr, 3, constrs); VERIFY(dt.mk_datatypes(1, &enum_sort, 0, nullptr, new_sorts)); sort* rgb = new_sorts[0].get(); expr_ref x = mk_const(m, "x", rgb), y = mk_const(m, "y", rgb), z = mk_const(m, "z", rgb); ptr_vector<func_decl> const& enums = *dtutil.get_datatype_constructors(rgb); expr_ref r = expr_ref(m.mk_const(enums[0]), m); expr_ref g = expr_ref(m.mk_const(enums[1]), m); expr_ref b = expr_ref(m.mk_const(enums[2]), m); ref<solver> fd_solver = mk_fd_solver(m, p); fd_solver->assert_expr(m.mk_not(m.mk_eq(x, r))); fd_solver->assert_expr(m.mk_not(m.mk_eq(x, b))); expr_ref_vector asms(m), vars(m), conseq(m); vars.push_back(x); vars.push_back(y); VERIFY(l_true == fd_solver->get_consequences(asms, vars, conseq)); std::cout << conseq << "\n"; conseq.reset(); fd_solver->push(); fd_solver->assert_expr(m.mk_not(m.mk_eq(x, g))); VERIFY(l_false == fd_solver->check_sat(0,nullptr)); fd_solver->pop(1); VERIFY(l_true == fd_solver->get_consequences(asms, vars, conseq)); std::cout << conseq << "\n"; conseq.reset(); model_ref mr; fd_solver->get_model(mr); model_smt2_pp(std::cout << "model:\n", m, *mr.get(), 0); VERIFY(l_true == fd_solver->check_sat(0,nullptr)); fd_solver->get_model(mr); ENSURE(mr.get()); model_smt2_pp(std::cout, m, *mr.get(), 0); }
void tst_horn_subsume_model_converter() { ast_manager m; reg_decl_plugins(m); arith_util a(m); ptr_vector<sort> ints; ints.push_back(a.mk_int()); ints.push_back(a.mk_int()); ints.push_back(a.mk_int()); func_decl_ref p(m), q(m), r(m); p = m.mk_func_decl(symbol("p"), 2, ints.c_ptr(), m.mk_bool_sort()); q = m.mk_func_decl(symbol("q"), 2, ints.c_ptr(), m.mk_bool_sort()); r = m.mk_func_decl(symbol("r"), 2, ints.c_ptr(), m.mk_bool_sort()); ref<horn_subsume_model_converter> mc = alloc(horn_subsume_model_converter,m); model_ref mr = alloc(model, m); mc->insert(p, m.mk_app(q, a.mk_numeral(rational(1), true), a.mk_numeral(rational(2), true))); model_converter_ref mcr = mc.get(); apply(mcr, mr, 0); model_smt2_pp(std::cout, m, *mr.get(), 0); mr = alloc(model, m); mc->insert(p, m.mk_app(q, a.mk_numeral(rational(3), true), a.mk_numeral(rational(5), true))); apply(mcr, mr, 0); model_smt2_pp(std::cout, m, *mr.get(), 0); mr = alloc(model, m); mc->insert(p, m.mk_app(r, m.mk_var(0,a.mk_int()), m.mk_var(1, a.mk_int()))); apply(mcr, mr, 0); model_smt2_pp(std::cout, m, *mr.get(), 0); mr = alloc(model, m); app_ref head1(m); expr_ref body1(m), body2(m); func_decl_ref pred(m); head1 = m.mk_app(p, m.mk_var(0, a.mk_int()), m.mk_var(0, a.mk_int())); body1 = m.mk_app(q, m.mk_var(1, a.mk_int()), m.mk_var(2, a.mk_int())); VERIFY(mc->mk_horn(head1, body1, pred, body2)); mc->insert(pred, body2); apply(mcr, mr, 0); model_smt2_pp(std::cout, m, *mr.get(), 0); mr = alloc(model, m); head1 = m.mk_app(p, m.mk_var(0, a.mk_int()), m.mk_var(0, a.mk_int())); body1 = m.mk_app(q, m.mk_var(1, a.mk_int()), m.mk_var(0, a.mk_int())); VERIFY(mc->mk_horn(head1, body1, pred, body2)); mc->insert(pred, body2); apply(mcr, mr, 0); model_smt2_pp(std::cout, m, *mr.get(), 0); }
static void validate_quant_solution(ast_manager& m, expr* fml, expr* guard, qe::def_vector const& defs) { // verify: // new_fml => fml[t/x] scoped_ptr<expr_replacer> rep = mk_expr_simp_replacer(m); app_ref_vector xs(m); expr_substitution sub(m); for (unsigned i = 0; i < defs.size(); ++i) { xs.push_back(m.mk_const(defs.var(i))); sub.insert(xs.back(), defs.def(i)); } rep->set_substitution(&sub); expr_ref fml1(fml, m); (*rep)(fml1); expr_ref tmp(m); tmp = m.mk_not(m.mk_implies(guard, fml1)); front_end_params fp; smt::kernel solver(m, fp); solver.assert_expr(tmp); lbool res = solver.check(); //SASSERT(res == l_false); if (res != l_false) { std::cout << "Validation failed: " << res << "\n"; std::cout << mk_pp(tmp, m) << "\n"; model_ref model; solver.get_model(model); model_smt2_pp(std::cout, m, *model, 0); fatal_error(0); } }
lbool lackr::operator() () { SASSERT(m_sat); if (!init()) return l_undef; const lbool rv = m_eager ? eager() : lazy(); if (rv == l_true) m_sat->get_model(m_model); CTRACE("lackr", rv == l_true, model_smt2_pp(tout << "abstr_model(\n", m_m, *(m_model.get()), 2); tout << ")\n"; );
void inductive_property::to_model(model_ref& md) const { md = alloc(model, m); vector<relation_info> const& rs = m_relation_info; expr_ref_vector conjs(m); for (unsigned i = 0; i < rs.size(); ++i) { relation_info ri(rs[i]); func_decl * pred = ri.m_pred; expr_ref prop = fixup_clauses(ri.m_body); func_decl_ref_vector const& sig = ri.m_vars; expr_ref q(m); expr_ref_vector sig_vars(m); for (unsigned j = 0; j < sig.size(); ++j) { sig_vars.push_back(m.mk_const(sig[sig.size()-j-1])); } expr_abstract(m, 0, sig_vars.size(), sig_vars.c_ptr(), prop, q); if (sig.empty()) { md->register_decl(pred, q); } else { func_interp* fi = alloc(func_interp, m, sig.size()); fi->set_else(q); md->register_decl(pred, fi); } } TRACE("pdr", model_smt2_pp(tout, m, *md, 0););
std::string inductive_property::to_string() const { std::stringstream stm; model_ref md; expr_ref result(m); to_model(md); model_smt2_pp(stm, m, *md.get(), 0); return stm.str(); }
void tst_model2expr() { ast_manager m; m.register_decl_plugins(); arith_util a(m); ptr_vector<sort> ints; ints.push_back(a.mk_int()); ints.push_back(a.mk_int()); ints.push_back(a.mk_int()); func_decl_ref p(m), q(m), x(m); p = m.mk_func_decl(symbol("p"), 2, ints.c_ptr(), a.mk_int()); q = m.mk_func_decl(symbol("q"), 2, ints.c_ptr(), a.mk_int()); x = m.mk_const_decl(symbol("x"), a.mk_int()); expr_ref n0(m), n1(m), n2(m); n0 = a.mk_numeral(rational(0), true); n1 = a.mk_numeral(rational(1), true); n2 = a.mk_numeral(rational(2), true); model_ref md = alloc(model, m); func_interp* fip = alloc(func_interp, m, 2); func_interp* fiq = alloc(func_interp, m, 2); expr_ref_vector args(m); args.push_back(n1); args.push_back(n2); fip->insert_entry(args.c_ptr(), n1); fiq->insert_entry(args.c_ptr(), n1); args[0] = n0; args[1] = n1; fip->insert_entry(args.c_ptr(), n2); fiq->insert_entry(args.c_ptr(), n2); fip->set_else(n0); md->register_decl(x, a.mk_numeral(rational(0), true)); md->register_decl(p, fip); // full md->register_decl(q, fiq); // partial expr_ref result(m); model2expr(md, result); model_smt2_pp(std::cout, m, *md, 0); std::cout << mk_pp(result, m) << "\n"; }
lbool gia_pareto::operator()() { expr_ref fml(m); lbool is_sat = m_solver->check_sat(0, 0); if (is_sat == l_true) { { solver::scoped_push _s(*m_solver.get()); while (is_sat == l_true) { if (m.canceled()) { return l_undef; } m_solver->get_model(m_model); m_solver->get_labels(m_labels); IF_VERBOSE(1, model_ref mdl(m_model); cb.fix_model(mdl); model_smt2_pp(verbose_stream() << "new model:\n", m, *mdl, 0);); // TBD: we can also use local search to tune solution coordinate-wise. mk_dominates(); is_sat = m_solver->check_sat(0, 0); }
Z3_API char const * Z3_model_to_string(Z3_context c, Z3_model m) { Z3_TRY; LOG_Z3_model_to_string(c, m); RESET_ERROR_CODE(); CHECK_NON_NULL(m, nullptr); std::ostringstream buffer; std::string result; if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB2_COMPLIANT) { model_smt2_pp(buffer, mk_c(c)->m(), *(to_model_ref(m)), 0); // Hack for removing the trailing '\n' result = buffer.str(); if (!result.empty()) result.resize(result.size()-1); } else { model_params p; model_v2_pp(buffer, *(to_model_ref(m)), p.partial()); result = buffer.str(); } return mk_c(c)->mk_external_string(result); Z3_CATCH_RETURN(nullptr); }