Z3_ast mk_min(Z3_context ctx, Z3_sort bv, bool is_signed) { unsigned bvsize = Z3_get_bv_sort_size(ctx, bv); if (! is_signed) return Z3_mk_numeral(ctx, "0", bv); unsigned sz = bvsize - 1; rational min_bound = power(rational(2), sz); min_bound.neg(); return Z3_mk_numeral(ctx, min_bound.to_string().c_str(), bv); }
Z3_ast mk_max(Z3_context ctx, Z3_sort bv, bool is_signed) { unsigned bvsize = Z3_get_bv_sort_size(ctx, bv); unsigned sz = is_signed ? bvsize - 1 : bvsize; rational max_bound = power(rational(2), sz); --max_bound; return Z3_mk_numeral(ctx, max_bound.to_string().c_str(), bv); }
static void tst_get_implied_equalities2() { enable_trace("after_search"); enable_trace("get_implied_equalities"); enable_trace("implied_equalities"); Z3_config cfg = Z3_mk_config(); Z3_context ctx = Z3_mk_context(cfg); Z3_del_config(cfg); Z3_solver solver = Z3_mk_simple_solver(ctx); Z3_solver_inc_ref(ctx, solver); Z3_sort int_ty = Z3_mk_int_sort(ctx); Z3_ast a = mk_int_var(ctx,"a"); Z3_ast b = mk_int_var(ctx,"b"); Z3_ast one = Z3_mk_numeral(ctx, "1", int_ty); Z3_ast two = Z3_mk_numeral(ctx, "2", int_ty); Z3_ast x = Z3_mk_const_array(ctx, int_ty, one); Z3_ast y = Z3_mk_store(ctx, x, one, a); Z3_ast z = Z3_mk_store(ctx, y, two , b); Z3_ast u = Z3_mk_store(ctx, x, two , b); Z3_ast v = Z3_mk_store(ctx, u, one , a); unsigned const num_terms = 5; unsigned i; Z3_ast terms[5] = { x, y, z, u, v}; unsigned class_ids[5] = { 0, 0, 0, 0, 0}; Z3_get_implied_equalities(ctx, solver, num_terms, terms, class_ids); for (i = 0; i < num_terms; ++i) { printf("Class %s |-> %d\n", Z3_ast_to_string(ctx, terms[i]), class_ids[i]); } SASSERT(class_ids[1] != class_ids[0]); SASSERT(class_ids[2] != class_ids[0]); SASSERT(class_ids[3] != class_ids[0]); SASSERT(class_ids[4] != class_ids[0]); SASSERT(class_ids[4] == class_ids[2]); SASSERT(class_ids[2] != class_ids[1]); SASSERT(class_ids[3] != class_ids[1]); SASSERT(class_ids[4] != class_ids[1]); SASSERT(class_ids[3] != class_ids[2]); /* delete logical context */ Z3_solver_dec_ref(ctx, solver); Z3_del_context(ctx); }
Z3_sort bv = Z3_mk_bv_sort(ctx, bvsize); Z3_ast min = mk_min(ctx, bv, is_signed); Z3_ast max = mk_max(ctx, bv, is_signed); Z3_ast t1; Z3_ast t2; Z3_ast test_ovfl; Z3_ast test_udfl; t1 = Z3_mk_const(ctx, Z3_mk_string_symbol(ctx,"x"), bv); t2 = Z3_mk_const(ctx, Z3_mk_string_symbol(ctx,"y"), bv); test_ovfl = Z3_mk_bvadd_no_overflow(ctx, t1, t2, is_signed); test_udfl = is_signed ? Z3_mk_bvadd_no_underflow(ctx, t1, t2) : NULL; Z3_push(ctx); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t1, Z3_mk_numeral(ctx, "0", bv))); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t2, Z3_mk_numeral(ctx, "1", bv))); TEST_NO_OVERFLOW; TEST_NO_UNDERFLOW; Z3_pop(ctx, 1); Z3_push(ctx); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t1, Z3_mk_numeral(ctx, "0", bv))); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t2, max)); TEST_NO_OVERFLOW; TEST_NO_UNDERFLOW; Z3_pop(ctx, 1); Z3_push(ctx); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t1, Z3_mk_numeral(ctx, "1", bv))); Z3_assert_cnstr(ctx, Z3_mk_eq(ctx, t2, max));
void test_smt_relation_api() { enable_trace("smt_relation"); enable_trace("smt_relation2"); enable_trace("quant_elim"); Z3_config cfg = Z3_mk_config(); Z3_set_param_value(cfg, "DL_DEFAULT_RELATION", "smt_relation2"); Z3_context ctx = Z3_mk_context(cfg); Z3_fixedpoint dl = Z3_mk_fixedpoint(ctx); Z3_fixedpoint_inc_ref(ctx,dl); Z3_del_config(cfg); Z3_sort int_sort = Z3_mk_int_sort(ctx); Z3_sort bool_sort = Z3_mk_bool_sort(ctx); Z3_func_decl nil_decl, is_nil_decl; Z3_func_decl cons_decl, is_cons_decl, head_decl, tail_decl; Z3_sort list = Z3_mk_list_sort( ctx, Z3_mk_string_symbol(ctx, "list"), int_sort, &nil_decl, &is_nil_decl, &cons_decl, &is_cons_decl, &head_decl, &tail_decl); Z3_sort listint[2] = { list, int_sort }; Z3_symbol p_sym = Z3_mk_string_symbol(ctx, "p"); Z3_symbol q_sym = Z3_mk_string_symbol(ctx, "q"); Z3_func_decl p = Z3_mk_func_decl(ctx, p_sym, 2, listint, bool_sort); Z3_func_decl q = Z3_mk_func_decl(ctx, q_sym, 2, listint, bool_sort); Z3_fixedpoint_register_relation(ctx, dl, p); Z3_fixedpoint_register_relation(ctx, dl, q); Z3_ast zero = Z3_mk_numeral(ctx, "0", int_sort); Z3_ast one = Z3_mk_numeral(ctx, "1", int_sort); Z3_ast two = Z3_mk_numeral(ctx, "2", int_sort); Z3_ast x = Z3_mk_bound(ctx, 0, list); Z3_ast y = Z3_mk_bound(ctx, 1, int_sort); Z3_ast z = Z3_mk_bound(ctx, 2, list); Z3_ast zero_x[2] = { zero, x }; Z3_ast fx = Z3_mk_app(ctx, cons_decl, 2, zero_x); Z3_ast zero_fx[2] = { zero, fx }; Z3_ast ffx = Z3_mk_app(ctx, cons_decl, 2, zero_fx); Z3_ast xy[2] = { x, y }; Z3_ast zy[2] = { z, y }; // Z3_ast ffxy[2] = { ffx, y }; // Z3_ast fxy[2] = { fx, y }; Z3_ast zero_nil[2] = { zero, Z3_mk_app(ctx, nil_decl, 0, 0) }; Z3_ast f0 = Z3_mk_app(ctx, cons_decl, 2, zero_nil); Z3_ast zero_f0[2] = { zero, f0 }; Z3_ast f1 = Z3_mk_app(ctx, cons_decl, 2, zero_f0); Z3_ast zero_f1[2] = { zero, f1 }; Z3_ast f2 = Z3_mk_app(ctx, cons_decl, 2, zero_f1); Z3_ast zero_f2[2] = { zero, f2 }; Z3_ast f3 = Z3_mk_app(ctx, cons_decl, 2, zero_f2); Z3_ast zero_f3[2] = { zero, f3 }; Z3_ast f4 = Z3_mk_app(ctx, cons_decl, 2, zero_f3); Z3_ast zero_f4[2] = { zero, f4 }; Z3_ast f5 = Z3_mk_app(ctx, cons_decl, 2, zero_f4); Z3_ast zero_z[2] = { zero, z }; Z3_ast fz = Z3_mk_app(ctx, cons_decl, 2, zero_z); Z3_ast pxy = Z3_mk_app(ctx, p, 2, xy); Z3_ast pzy = Z3_mk_app(ctx, p, 2, zy); Z3_ast qxy = Z3_mk_app(ctx, q, 2, xy); Z3_ast qzy = Z3_mk_app(ctx, q, 2, zy); Z3_ast even_y = Z3_mk_eq(ctx, zero, Z3_mk_mod(ctx, y, two)); Z3_ast odd_y = Z3_mk_eq(ctx, one, Z3_mk_mod(ctx, y, two)); // p(x, y) :- odd(y), p(z,y), f(z) = x . // dead rule. // q(x, y) :- p(f(f(x)), y). // p(x, y) :- q(f(x), y) // x decreases // p(x, y) :- even y, x = f^5(0) // initial condition. Z3_ast body1[3] = { pzy, Z3_mk_eq(ctx, fz, x), odd_y }; Z3_ast body2[2] = { pzy, Z3_mk_eq(ctx, ffx, z) }; Z3_ast body3[2] = { qzy, Z3_mk_eq(ctx, fx, z) }; Z3_ast body4[2] = { even_y, Z3_mk_eq(ctx, x, f5) }; Z3_fixedpoint_add_rule(ctx, dl, Z3_mk_implies(ctx, Z3_mk_and(ctx, 3, body1), pxy), 0); Z3_fixedpoint_add_rule(ctx, dl, Z3_mk_implies(ctx, Z3_mk_and(ctx, 2, body2), qxy), 0); Z3_fixedpoint_add_rule(ctx, dl, Z3_mk_implies(ctx, Z3_mk_and(ctx, 2, body3), pxy), 0); Z3_fixedpoint_add_rule(ctx, dl, Z3_mk_implies(ctx, Z3_mk_and(ctx, 2, body4), pxy), 0); Z3_lbool r = Z3_fixedpoint_query(ctx, dl, pxy); if (r != Z3_L_UNDEF) { std::cout << Z3_ast_to_string(ctx, Z3_fixedpoint_get_answer(ctx, dl)) << "\n"; } Z3_del_context(ctx); }