void tst_substitution() { memory::initialize(0); smt_params params; params.m_model = true; enable_trace("subst_bug"); ast_manager m; reg_decl_plugins(m); var_ref v1(m.mk_var(0, m.mk_bool_sort()), m); var_ref v2(m.mk_var(1, m.mk_bool_sort()), m); var_ref v3(m.mk_var(2, m.mk_bool_sort()), m); var_ref v4(m.mk_var(3, m.mk_bool_sort()), m); substitution subst(m); subst.reserve(1,4); unifier unif(m); bool ok1 = unif(v1.get(), v2.get(), subst, false); bool ok2 = unif(v2.get(), v1.get(), subst, false); expr_ref res(m); TRACE("substitution", subst.display(tout););
void tst_expr_arith(unsigned num_files) { ast_manager m; reg_decl_plugins(m); expr_rand er(m); er.seed(rand_seed); er.initialize_arith(20); family_id fid = m.mk_family_id("arith"); sort* int_ty = m.mk_sort(fid, INT_SORT, 0, 0); sort* real_ty = m.mk_sort(fid, REAL_SORT, 0, 0); er.initialize_array(3, int_ty, int_ty); er.initialize_array(3, int_ty, real_ty); er.initialize_basic(20); for (unsigned i = 0; i < num_files; ++i) { expr_ref e(m); er.get_next(m.mk_bool_sort(), e); ast_smt_pp pp(m); pp.set_logic(symbol("QF_AUFLIA")); std::ostringstream buffer; buffer << "random_arith_" << i << ".smt"; std::cout << buffer.str() << "\n"; std::ofstream file(buffer.str().c_str()); pp.display(file, e.get()); file.close(); } }
void tst1() { ast_manager m; reg_decl_plugins(m); sort_ref s( m.mk_uninterpreted_sort(symbol("S")), m); func_decl_ref g( m.mk_func_decl(symbol("g"), s, s), m); func_decl_ref h( m.mk_func_decl(symbol("h"), s, s), m); sort * domain[2] = {s, s}; func_decl_ref f( m.mk_func_decl(symbol("f"), 2, domain, s), m); app_ref a( m.mk_const(symbol("a"), s), m); app_ref b( m.mk_const(symbol("b"), s), m); expr_ref x( m.mk_var(0, s), m); expr_ref y( m.mk_var(1, s), m); app_ref gx( m.mk_app(g, x), m); app_ref fgx_x( m.mk_app(f, gx.get(), x.get()), m); app_ref ha( m.mk_app(h, a.get()), m); app_ref gha( m.mk_app(g, ha.get()), m); app_ref fgha_ha( m.mk_app(f, gha.get(), ha.get()), m); tst_match(m, fgx_x, fgha_ha); app_ref fgha_gha( m.mk_app(f, gha.get(), gha.get()), m); tst_match(m, fgx_x, fgha_gha); app_ref fxy( m.mk_app(f, x.get(), y.get()), m); app_ref fyx( m.mk_app(f, y.get(), x.get()), m); tst_match(m, fxy, fyx); app_ref fygx( m.mk_app(f, y.get(), gx.get()), m); tst_match(m, fxy, fygx); tst_match(m, fygx, fxy); }
void tst_theory_pb() { fuzz_pb(); ast_manager m; smt_params params; params.m_model = true; reg_decl_plugins(m); expr_ref tmp(m); enable_trace("pb"); for (unsigned N = 4; N < 11; ++N) { for (unsigned i = 0; i < (1u << N); ++i) { smt::literal_vector lits(N, smt::false_literal); unsigned k = populate_literals(i, lits); std::cout << "k:" << k << " " << N << "\n"; std::cout.flush(); TRACE("pb", tout << "k " << k << ": "; for (unsigned j = 0; j < lits.size(); ++j) { tout << lits[j] << " "; } tout << "\n";); { smt::context ctx(m, params); ctx.push(); smt::literal l = smt::theory_pb::assert_ge(ctx, k+1, lits.size(), lits.c_ptr()); if (l != smt::false_literal) { ctx.assign(l, 0, false); TRACE("pb", tout << "assign: " << l << "\n"; ctx.display(tout);); VERIFY(l_false == ctx.check()); } ctx.pop(1); }
static void fuzz_pb() { ast_manager m; reg_decl_plugins(m); pb_fuzzer fuzzer(m); fuzzer.fuzz(); }
void tst_check_assumptions() { memory::initialize(0); front_end_params params; ast_manager mgr; reg_decl_plugins(mgr); sort_ref b(mgr.mk_bool_sort(), mgr); func_decl_ref pPred(mgr.mk_func_decl(symbol("p"), 0, static_cast<sort * const *>(0), b), mgr); func_decl_ref qPred(mgr.mk_func_decl(symbol("q"), 0, static_cast<sort * const *>(0), b), mgr); func_decl_ref rPred(mgr.mk_func_decl(symbol("r"), 0, static_cast<sort * const *>(0), b), mgr); app_ref p(mgr.mk_app(pPred,0,static_cast<expr * const *>(0)), mgr); app_ref q(mgr.mk_app(qPred,0,static_cast<expr * const *>(0)), mgr); app_ref r(mgr.mk_app(rPred,0,static_cast<expr * const *>(0)), mgr); app_ref pOqOr(mgr.mk_or(p,q,r), mgr); app_ref np(mgr.mk_not(p), mgr); app_ref nq(mgr.mk_not(q), mgr); app_ref nr(mgr.mk_not(r), mgr); smt::context ctx(mgr, params); ctx.assert_expr(pOqOr); expr * npE = np.get(); lbool res1 = ctx.check(1, &npE); SASSERT(res1==l_true); ctx.assert_expr(npE); expr * assumpt[] = { nq.get(), nr.get() }; //here it should crash ctx.check(2, assumpt); }
static void test_ineqs() { ast_manager m; reg_decl_plugins(m); arith_util a(m); sort* s_int = a.mk_int(); sort* s_real = a.mk_real(); test_ineqs(m, s_int, true); test_ineqs(m, s_real, false); }
static void check_random_ineqs() { random_gen r(1); ast_manager m; reg_decl_plugins(m); for (unsigned i = 0; i < 100; ++i) { check_random_ineqs(r, m, 4, 5, 5, 3, 6); } }
static void testI(char const *ex) { ast_manager m; reg_decl_plugins(m); arith_util a(m); expr_ref fml = parse_fml(m, ex); symbol x_name("i"); sort_ref x_sort(a.mk_int(), m); app_ref var(m.mk_const(x_name, x_sort), m); test(var, fml); }
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 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 test_sorting3() { ast_manager m; reg_decl_plugins(m); expr_ref_vector in(m), out(m); for (unsigned i = 0; i < 7; ++i) { in.push_back(m.mk_fresh_const("a",m.mk_bool_sort())); } for (unsigned i = 0; i < in.size(); ++i) { std::cout << mk_pp(in[i].get(), m) << "\n"; } ast_ext aext(m); sorting_network<ast_ext> sn(aext); sn(in, out); std::cout << "size: " << out.size() << "\n"; for (unsigned i = 0; i < out.size(); ++i) { std::cout << mk_pp(out[i].get(), m) << "\n"; } }
static void test_sorting_eq(unsigned n, unsigned k) { SASSERT(k < n); ast_manager m; reg_decl_plugins(m); ast_ext2 ext(m); expr_ref_vector in(m), out(m); for (unsigned i = 0; i < n; ++i) { in.push_back(m.mk_fresh_const("a",m.mk_bool_sort())); } smt_params fp; smt::kernel solver(m, fp); psort_nw<ast_ext2> sn(ext); expr_ref result(m); // equality: std::cout << "eq " << k << "\n"; solver.push(); result = sn.eq(true, k, in.size(), in.c_ptr()); solver.assert_expr(result); for (unsigned i = 0; i < ext.m_clauses.size(); ++i) { solver.assert_expr(ext.m_clauses[i].get()); } lbool res = solver.check(); SASSERT(res == l_true); solver.push(); for (unsigned i = 0; i < k; ++i) { solver.assert_expr(in[i].get()); } res = solver.check(); SASSERT(res == l_true); solver.assert_expr(in[k].get()); res = solver.check(); if (res == l_true) { TRACE("pb", unsigned sz = solver.size(); for (unsigned i = 0; i < sz; ++i) { tout << mk_pp(solver.get_formulas()[i], m) << "\n"; });
void tst_expr_substitution() { memory::initialize(0); ast_manager m; reg_decl_plugins(m); bv_util bv(m); expr_ref a(m), b(m), c(m), d(m); expr_ref x(m); expr_ref new_a(m); proof_ref pr(m); x = m.mk_const(symbol("x"), bv.mk_sort(8)); a = mk_bv_and(bv, mk_bv_xor(bv, x,bv.mk_numeral(8,8)), mk_bv_xor(bv,x,x)); b = x; c = bv.mk_bv_sub(x, bv.mk_numeral(4, 8)); expr_substitution subst(m); th_rewriter rw(m); std::cout << mk_pp(c, m) << "\n"; // normalizing c does not help. rw(c, d, pr); std::cout << mk_pp(d, m) << "\n"; // This portion diverges. It attempts to replace x by (bvadd #xfc x), which contains x. // subst.insert(b, d); // std::cout << mk_pp(a, m) << "\n"; // rw.set_substitution(&subst); // enable_trace("th_rewriter_step"); // rw(a, new_a, pr); // std::cout << mk_pp(new_a, m) << "\n"; }
static void test_formula(lbool expected_outcome, char const* fml) { ast_manager m; reg_decl_plugins(m); scoped_ptr<smtlib::parser> parser = smtlib::parser::create(m); parser->initialize_smtlib(); std::ostringstream buffer; buffer << "(benchmark presburger :status unknown :logic AUFLIA :extrapreds ((p1) (p2) (p3)) " << ":extrafuns ((a Int) (b Int))\n" << ":extrapreds ((p) (q) (r))\n" << ":datatypes ((list (nil) (cons (hd Int) (tl list))))\n" << ":datatypes ((cell (cnil) (ccons (car cell) (cdr cell))))\n" << ":extrasorts (U)\n" << ":extrafuns ((f U U))\n" << ":formula " << fml << ")"; parser->parse_string(buffer.str().c_str()); smtlib::benchmark* b = parser->get_benchmark(); smtlib::theory::expr_iterator it = b->begin_formulas(); smtlib::theory::expr_iterator end = b->end_formulas(); for (; it != end; ++it) { test_qe(m, expected_outcome, *it, 0); } }
void tst_arith_rewriter() { ast_manager m; reg_decl_plugins(m); arith_rewriter ar(m); arith_util au(m); expr_ref t1(m), t2(m), result(m); t1 = au.mk_numeral(rational(0),false); t2 = au.mk_numeral(rational(-3),false); expr* args[2] = { t1, t2 }; ar.mk_mul(2, args, result); std::cout << mk_pp(result, m) << "\n"; th_rewriter rw(m); expr_ref fml = parse_fml(m, example1); rw(fml); std::cout << mk_pp(fml, m) << "\n"; fml = parse_fml(m, example2); rw(fml); std::cout << mk_pp(fml, m) << "\n"; }
static unsigned parse_opt(std::istream& in, bool is_wcnf) { ast_manager m; reg_decl_plugins(m); opt::context opt(m); g_opt = &opt; params_ref p = gparams::get_module("opt"); opt.updt_params(p); if (is_wcnf) { parse_wcnf(opt, in, g_handles); } else { parse_opb(opt, in, g_handles); } try { lbool r = opt.optimize(); switch (r) { case l_true: std::cout << "sat\n"; break; case l_false: std::cout << "unsat\n"; break; case l_undef: std::cout << "unknown\n"; break; } DEBUG_CODE( if (false && r == l_true) { model_ref mdl; opt.get_model(mdl); expr_ref_vector hard(m); opt.get_hard_constraints(hard); for (unsigned i = 0; i < hard.size(); ++i) { std::cout << "validate: " << i << "\n"; expr_ref tmp(m); VERIFY(mdl->eval(hard[i].get(), tmp)); if (!m.is_true(tmp)) { std::cout << tmp << "\n"; } } }); }
static void test1() { ast_manager m; reg_decl_plugins(m); bv_util bv(m); params_ref p; ref<solver> solver = mk_inc_sat_solver(m, p); expr_ref a = mk_bool(m, "a"), b = mk_bool(m, "b"), c = mk_bool(m, "c"); expr_ref ba = mk_bv(m, "ba", 3), bb = mk_bv(m, "bb", 3), bc = mk_bv(m, "bc", 3); solver->assert_expr(m.mk_implies(a, b)); solver->assert_expr(m.mk_implies(b, c)); expr_ref_vector asms(m), vars(m), conseq(m); asms.push_back(a); vars.push_back(b); vars.push_back(c); vars.push_back(bb); vars.push_back(bc); solver->assert_expr(m.mk_eq(ba, bc)); solver->assert_expr(m.mk_eq(bv.mk_numeral(2, 3), ba)); solver->get_consequences(asms, vars, conseq); std::cout << conseq << "\n"; }
static void test(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())); flatten_and(fml, lits); smt::context ctx(m, params); ctx.assert_expr(fml); lbool result = ctx.check(); SASSERT(result == l_true); ref<model> md; ctx.get_model(md); expr_ref pr = qe::arith_project(*md, vars, lits); std::cout << mk_pp(fml, m) << "\n"; std::cout << mk_pp(pr, m) << "\n"; }
void test_smt_relation_unit() { ast_manager m; reg_decl_plugins(m); arith_util a(m); sort* int_sort = a.mk_int(); sort* real_sort = a.mk_real(); front_end_params params; context ctx(m, params); relation_manager & rm = ctx.get_rmanager(); relation_signature sig1; sig1.push_back(int_sort); sig1.push_back(int_sort); sig1.push_back(real_sort); smt_relation_plugin plugin(rm); scoped_rel<relation_base> r1 = plugin.mk_empty(sig1); // add_fact relation_fact fact1(m); fact1.push_back(a.mk_numeral(rational(1), true)); fact1.push_back(a.mk_numeral(rational(2), true)); fact1.push_back(a.mk_numeral(rational(3), false)); relation_fact fact2(m); fact2.push_back(a.mk_numeral(rational(2), true)); fact2.push_back(a.mk_numeral(rational(2), true)); fact2.push_back(a.mk_numeral(rational(3), false)); r1->add_fact(fact1); r1->display(std::cout << "r1: "); // contains_fact SASSERT(r1->contains_fact(fact1)); SASSERT(!r1->contains_fact(fact2)); // empty scoped_rel<relation_base> r2 = plugin.mk_empty(sig1); SASSERT(!r1->empty()); SASSERT(r2->empty()); // clone scoped_rel<relation_base> r3 = r1->clone(); // complement? r2->add_fact(fact2); scoped_rel<relation_base> r4 = dynamic_cast<smt_relation&>(*r2).complement(0); r4->display(std::cout << "complement r4: " ); // join unsigned col_cnt = 2; unsigned cols1[2] = {1, 2}; unsigned cols2[2] = {0, 2}; scoped_ptr<relation_join_fn> joinfn = plugin.mk_join_fn(*r1, *r4, col_cnt, cols1, cols2); scoped_rel<relation_base> r5 = (*joinfn)(*r1, *r4); r5->display(std::cout<< "join r5: "); relation_fact fact3(m); fact3.push_back(a.mk_numeral(rational(1), true)); fact3.push_back(a.mk_numeral(rational(2), true)); fact3.push_back(a.mk_numeral(rational(3), false)); fact3.push_back(a.mk_numeral(rational(2), true)); fact3.push_back(a.mk_numeral(rational(2), true)); fact3.push_back(a.mk_numeral(rational(3), false)); SASSERT(!r5->contains_fact(fact3)); fact3[5] = a.mk_numeral(rational(4), false); SASSERT(!r5->contains_fact(fact3)); fact3[5] = a.mk_numeral(rational(3), false); fact3[4] = a.mk_numeral(rational(3), true); SASSERT(r5->contains_fact(fact3)); // project unsigned removed_cols[2] = { 1, 4 }; scoped_ptr<relation_transformer_fn> projfn = plugin.mk_project_fn(*r5, col_cnt, removed_cols); scoped_rel<relation_base> r6 = (*projfn)(*r5); r6->display(std::cout<< "project r6: "); // rename unsigned cycle[3] = { 0, 2, 4 }; unsigned cycle_len = 3; scoped_rel<relation_transformer_fn> renamefn = plugin.mk_rename_fn(*r5, cycle_len, cycle); scoped_rel<relation_base> r7 = (*renamefn)(*r5); r7->display(std::cout << "rename r7: "); // union // widen relation_base* delta = 0; scoped_ptr<relation_union_fn> widenfn = plugin.mk_widen_fn(*r1, *r2, delta); scoped_ptr<relation_union_fn> unionfn = plugin.mk_union_fn(*r1, *r2, delta); scoped_rel<relation_base> r8 = r1->clone(); (*unionfn)(*r8,*r2,0); r8->display(std::cout << "union r8: "); // filter_identical unsigned identical_cols[2] = { 1, 3 }; scoped_ptr<relation_mutator_fn> filti = plugin.mk_filter_identical_fn(*r5, col_cnt, identical_cols); scoped_rel<relation_base> r9 = r1->clone(); (*filti)(*r9); r9->display(std::cout << "filter identical r9: "); // filter_equal app_ref value(m); value = m.mk_const(symbol("x"), int_sort); scoped_rel<relation_mutator_fn> eqn = plugin.mk_filter_equal_fn(*r5, value.get(), 3); scoped_rel<relation_base> r10 = r1->clone(); (*eqn)(*r10); r10->display(std::cout << "filter equal r10: "); // filter_interpreted app_ref cond(m); cond = a.mk_lt(m.mk_var(3, int_sort), m.mk_var(4, int_sort)); scoped_rel<relation_mutator_fn> filtint = plugin.mk_filter_interpreted_fn(*r5, cond); scoped_rel<relation_base> r11 = r5->clone(); (*filtint)(*r11); r11->display(std::cout << "filter interpreted r11: "); }
static void test_quant_solve1() { ast_manager m; arith_util ar(m); reg_decl_plugins(m); sort* i = ar.mk_int(); app_ref xr(m.mk_const(symbol("x"),i), m); app_ref yr(m.mk_const(symbol("y"),i), m); app* x = xr.get(); app* y = yr.get(); app* xy[2] = { x, y }; test_quant_solver(m, x, "(and (<= x y) (= (mod x 2) 0))"); test_quant_solver(m, x, "(and (<= (* 2 x) y) (= (mod x 2) 0))"); test_quant_solver(m, x, "(and (>= x y) (= (mod x 2) 0))"); test_quant_solver(m, x, "(and (>= (* 2 x) y) (= (mod x 2) 0))"); test_quant_solver(m, x, "(and (<= (* 2 x) y) (>= x z) (= (mod x 2) 0))"); test_quant_solver(m, x, "(and (<= (* 2 x) y) (>= (* 3 x) z) (= (mod x 2) 0))"); test_quant_solver(m, x, "(>= (* 2 x) a)"); test_quant_solver(m, x, "(<= (* 2 x) a)"); test_quant_solver(m, x, "(< (* 2 x) a)"); test_quant_solver(m, x, "(= (* 2 x) a)"); test_quant_solver(m, x, "(< (* 2 x) a)"); test_quant_solver(m, x, "(> (* 2 x) a)"); test_quant_solver(m, x, "(and (<= a x) (<= (* 2 x) b))"); test_quant_solver(m, x, "(and (<= a x) (<= x b))"); test_quant_solver(m, x, "(and (<= (* 2 a) x) (<= x b))"); test_quant_solver(m, x, "(and (<= (* 2 a) x) (<= (* 2 x) b))"); test_quant_solver(m, x, "(and (<= a x) (<= (* 3 x) b))"); test_quant_solver(m, x, "(and (<= (* 3 a) x) (<= x b))"); test_quant_solver(m, x, "(and (<= (* 3 a) x) (<= (* 3 x) b))"); test_quant_solver(m, x, "(and (< a (* 3 x)) (< (* 3 x) b))"); test_quant_solver(m, x, "(< (* 3 x) a)"); test_quant_solver(m, x, "(= (* 3 x) a)"); test_quant_solver(m, x, "(< (* 3 x) a)"); test_quant_solver(m, x, "(> (* 3 x) a)"); test_quant_solver(m, x, "(<= (* 3 x) a)"); test_quant_solver(m, x, "(>= (* 3 x) a)"); test_quant_solver(m, x, "(<= (* 2 x) a)"); test_quant_solver(m, x, "(or (= (* 2 x) y) (= (+ (* 2 x) 1) y))"); test_quant_solver(m, x, "(= x a)"); test_quant_solver(m, x, "(< x a)"); test_quant_solver(m, x, "(> x a)"); test_quant_solver(m, x, "(and (> x a) (< x b))"); test_quant_solver(m, x, "(and (> x a) (< x b))"); test_quant_solver(m, x, "(<= x a)"); test_quant_solver(m, x, "(>= x a)"); test_quant_solver(m, x, "(and (<= (* 2 x) y) (= (mod x 2) 0))"); test_quant_solver(m, x, "(= (* 2 x) y)"); test_quant_solver(m, x, "(or (< x 0) (> x 1))"); test_quant_solver(m, x, "(or (< x y) (> x y))"); test_quant_solver(m, x, "(= x y)"); test_quant_solver(m, x, "(<= x y)"); test_quant_solver(m, x, "(>= x y)"); test_quant_solver(m, x, "(and (<= (+ x y) 0) (<= (+ x z) 0))"); test_quant_solver(m, x, "(and (<= (+ x y) 0) (<= (+ (* 2 x) z) 0))"); test_quant_solver(m, x, "(and (<= (+ (* 3 x) y) 0) (<= (+ (* 2 x) z) 0))"); test_quant_solver(m, x, "(and (>= x y) (>= x z))"); test_quant_solver(m, x, "(< x y)"); test_quant_solver(m, x, "(> x y)"); test_quant_solver(m, 2, xy, "(and (<= (- (* 2 y) b) (+ (* 3 x) a)) (<= (- (* 2 x) a) (+ (* 4 y) b)))"); test_quant_solver(m, "(exists ((c Cell)) (= c null))"); test_quant_solver(m, "(exists ((c Cell)) (= c (cell null c1)))"); test_quant_solver(m, "(exists ((c Cell)) (not (= c null)))", false); test_quant_solver(m, "(exists ((c Cell)) (= (cell c c) c1))", false); test_quant_solver(m, "(exists ((c Cell)) (= (cell c (cdr c1)) c1))", false); test_quant_solver(m, "(exists ((t Tuple)) (= (tuple a P r1) t))"); test_quant_solver(m, "(exists ((t Tuple)) (= a (first t)))"); test_quant_solver(m, "(exists ((t Tuple)) (= P (second t)))"); test_quant_solver(m, "(exists ((t Tuple)) (= r2 (third t)))"); test_quant_solver(m, "(exists ((t Tuple)) (not (= a (first t))))"); test_quant_solver(m, "(exists ((t Tuple)) (not (= P (second t))))"); test_quant_solver(m, "(exists ((t Tuple)) (not (= r2 (third t))))"); }
static void test_project() { ast_manager m; reg_decl_plugins(m); qe::arith_project_plugin plugin(m); arith_util a(m); app_ref_vector vars(m); expr_ref_vector lits(m), ds(m); model mdl(m); app_ref x(m), y(m), z(m), u(m); x = m.mk_const(symbol("x"), a.mk_int()); y = m.mk_const(symbol("y"), a.mk_int()); z = m.mk_const(symbol("z"), a.mk_int()); u = m.mk_const(symbol("u"), a.mk_int()); func_decl_ref f(m); sort* int_sort = a.mk_int(); f = m.mk_func_decl(symbol("f"), 1, &int_sort, int_sort); // test non-projection mdl.register_decl(x->get_decl(), a.mk_int(0)); mdl.register_decl(y->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(2)); mdl.register_decl(u->get_decl(), a.mk_int(3)); func_interp* fi = alloc(func_interp, m, 1); expr_ref_vector nums(m); nums.push_back(a.mk_int(0)); nums.push_back(a.mk_int(1)); nums.push_back(a.mk_int(2)); fi->insert_new_entry(nums.c_ptr(), a.mk_int(1)); fi->insert_new_entry(nums.c_ptr()+1, a.mk_int(2)); fi->insert_new_entry(nums.c_ptr()+2, a.mk_int(3)); fi->set_else(a.mk_int(10)); mdl.register_decl(f, fi); vars.reset(); lits.reset(); vars.push_back(x); lits.push_back(x <= app_ref(m.mk_app(f, (expr*)x), m)); lits.push_back(x < y); plugin(mdl, vars, lits); std::cout << lits << "\n"; // test not-equals vars.reset(); lits.reset(); vars.push_back(x); lits.push_back(m.mk_not(m.mk_eq(x, y))); plugin(mdl, vars, lits); std::cout << lits << "\n"; // test negation of distinct using bound variables mdl.register_decl(x->get_decl(), a.mk_int(0)); mdl.register_decl(y->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(0)); mdl.register_decl(u->get_decl(), a.mk_int(6)); vars.reset(); lits.reset(); ds.reset(); vars.push_back(x); vars.push_back(y); ds.push_back(x); ds.push_back(y); ds.push_back(z + 2); ds.push_back(u); ds.push_back(z); lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.c_ptr()))); plugin(mdl, vars, lits); std::cout << lits << "\n"; // test negation of distinct, not using bound variables mdl.register_decl(x->get_decl(), a.mk_int(0)); mdl.register_decl(y->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(0)); mdl.register_decl(u->get_decl(), a.mk_int(6)); vars.reset(); lits.reset(); ds.reset(); vars.push_back(x); vars.push_back(y); ds.push_back(x); ds.push_back(y); ds.push_back(z + 2); ds.push_back(u); ds.push_back(z + 10); ds.push_back(u + 4); lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.c_ptr()))); plugin(mdl, vars, lits); std::cout << lits << "\n"; // test distinct mdl.register_decl(x->get_decl(), a.mk_int(0)); mdl.register_decl(y->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(0)); mdl.register_decl(u->get_decl(), a.mk_int(6)); vars.reset(); lits.reset(); ds.reset(); vars.push_back(x); vars.push_back(y); ds.push_back(x); ds.push_back(y); ds.push_back(z + 2); ds.push_back(u); lits.push_back(m.mk_distinct(ds.size(), ds.c_ptr())); plugin(mdl, vars, lits); std::cout << lits << "\n"; // equality over modulus mdl.register_decl(y->get_decl(), a.mk_int(4)); mdl.register_decl(z->get_decl(), a.mk_int(8)); lits.reset(); vars.reset(); vars.push_back(y); lits.push_back(m.mk_eq(a.mk_mod(y, a.mk_int(3)), a.mk_int(1))); lits.push_back(m.mk_eq(2*y, z)); plugin(mdl, vars, lits); std::cout << lits << "\n"; // inequality test mdl.register_decl(x->get_decl(), a.mk_int(0)); mdl.register_decl(y->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(0)); mdl.register_decl(u->get_decl(), a.mk_int(6)); vars.reset(); lits.reset(); vars.push_back(x); vars.push_back(y); lits.push_back(z <= (x + (2*y))); lits.push_back(2*x < u + 3); lits.push_back(2*y <= u); plugin(mdl, vars, lits); std::cout << lits << "\n"; // non-unit equalities mdl.register_decl(x->get_decl(), a.mk_int(1)); mdl.register_decl(z->get_decl(), a.mk_int(2)); mdl.register_decl(u->get_decl(), a.mk_int(3)); mdl.register_decl(y->get_decl(), a.mk_int(4)); lits.reset(); vars.reset(); vars.push_back(x); lits.push_back(m.mk_eq(2*x, z)); lits.push_back(m.mk_eq(3*x, u)); plugin(mdl, vars, lits); std::cout << lits << "\n"; }
context::add_plugins::add_plugins(ast_manager & m) { reg_decl_plugins(m); }