SOLVER_TERM mk_array_var(SOLVER_CONTEXT ctx, const char * name){ Z3_context z3ctx = (Z3_context) ctx; // Indexes are integers Z3_sort tind = Z3_mk_int_sort(z3ctx); // Values are integers (for the moment) Z3_sort tval = Z3_mk_int_sort(z3ctx); // Declaration of array Z3_sort ty = Z3_mk_array_sort(z3ctx, tind, tval); return (SOLVER_TERM) mk_var(z3ctx, name, ty); }
SOLVER_TERM mk_int(SOLVER_CONTEXT ctx, int v){ if (v > Z3_INT_LIMIT){ fprintf(stderr,"BUG: Z3 overflow of 32int.\n"); exit(1);} Z3_context z3ctx = (Z3_context) ctx; Z3_sort ty = Z3_mk_int_sort(z3ctx); return (SOLVER_TERM) Z3_mk_int(z3ctx, v, ty); //return (SOLVER_TERM) Z3_mk_int64(z3ctx, v, ty); }
static void tst_get_implied_equalities1() { Z3_config cfg = Z3_mk_config(); Z3_context ctx = Z3_mk_context(cfg); Z3_del_config(cfg); 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 c = mk_int_var(ctx,"c"); Z3_ast d = mk_int_var(ctx,"d"); Z3_func_decl f = Z3_mk_func_decl(ctx, Z3_mk_string_symbol(ctx,"f"), 1, &int_ty, int_ty); Z3_ast fa = Z3_mk_app(ctx, f, 1, &a); Z3_ast fb = Z3_mk_app(ctx, f, 1, &b); Z3_ast fc = Z3_mk_app(ctx, f, 1, &c); unsigned const num_terms = 7; unsigned i; Z3_ast terms[7] = { a, b, c, d, fa, fb, fc }; unsigned class_ids[7] = { 0, 0, 0, 0, 0, 0, 0 }; Z3_solver solver = Z3_mk_simple_solver(ctx); Z3_solver_inc_ref(ctx, solver); Z3_solver_assert(ctx, solver, Z3_mk_eq(ctx, a, b)); Z3_solver_assert(ctx, solver, Z3_mk_eq(ctx, b, d)); Z3_solver_assert(ctx, solver, Z3_mk_le(ctx, fa, fc)); Z3_solver_assert(ctx, solver, Z3_mk_le(ctx, fc, d)); 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[5] != class_ids[0]); SASSERT(class_ids[6] != class_ids[0]); SASSERT(class_ids[4] == class_ids[5]); printf("asserting b <= f(a)\n"); Z3_solver_assert(ctx, solver, Z3_mk_le(ctx, b, fa)); 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[5] == class_ids[0]); SASSERT(class_ids[6] == class_ids[0]); Z3_solver_dec_ref(ctx, solver); /* delete logical context */ Z3_del_context(ctx); }
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); }
int test(){ int i; /* Create a Z3 context to contain formulas */ Z3_config cfg = Z3_mk_config(); Z3_context ctx = iz3_mk_context(cfg); int num = 2; Z3_ast *constraints = (Z3_ast *)malloc(num * sizeof(Z3_ast)); #if 1 Z3_sort arr = Z3_mk_array_sort(ctx,Z3_mk_int_sort(ctx),Z3_mk_bool_sort(ctx)); Z3_symbol as = Z3_mk_string_symbol(ctx, "a"); Z3_symbol bs = Z3_mk_string_symbol(ctx, "b"); Z3_symbol xs = Z3_mk_string_symbol(ctx, "x"); Z3_ast a = Z3_mk_const(ctx,as,arr); Z3_ast b = Z3_mk_const(ctx,bs,arr); Z3_ast x = Z3_mk_const(ctx,xs,Z3_mk_int_sort(ctx)); Z3_ast c1 = Z3_mk_eq(ctx,a,Z3_mk_store(ctx,b,x,Z3_mk_true(ctx))); Z3_ast c2 = Z3_mk_not(ctx,Z3_mk_select(ctx,a,x)); #else Z3_symbol xs = Z3_mk_string_symbol(ctx, "x"); Z3_ast x = Z3_mk_const(ctx,xs,Z3_mk_bool_sort(ctx)); Z3_ast c1 = Z3_mk_eq(ctx,x,Z3_mk_true(ctx)); Z3_ast c2 = Z3_mk_eq(ctx,x,Z3_mk_false(ctx)); #endif constraints[0] = c1; constraints[1] = c2; /* print out the result for grins. */ // Z3_string smtout = Z3_benchmark_to_smtlib_string (ctx, "foo", "QFLIA", "sat", "", num, constraints, Z3_mk_true(ctx)); // Z3_string smtout = Z3_ast_to_string(ctx,constraints[0]); // Z3_string smtout = Z3_context_to_string(ctx); // puts(smtout); iz3_print(ctx,num,constraints,"iZ3temp.smt"); /* Make room for interpolants. */ Z3_ast *interpolants = (Z3_ast *)malloc((num-1) * sizeof(Z3_ast)); /* Make room for the model. */ Z3_model model = 0; /* Call the prover */ Z3_lbool result = iz3_interpolate(ctx, num, constraints, interpolants, &model); switch (result) { /* If UNSAT, print the interpolants */ case Z3_L_FALSE: printf("unsat, interpolants:\n"); for(i = 0; i < num-1; i++) printf("%s\n", Z3_ast_to_string(ctx, interpolants[i])); break; case Z3_L_UNDEF: printf("fail\n"); break; case Z3_L_TRUE: printf("sat\n"); printf("model:\n%s\n", Z3_model_to_string(ctx, model)); break; } /* Delete the model if there is one */ if (model) Z3_del_model(ctx, model); /* Delete logical context (note, we call iz3_del_context, not Z3_del_context */ iz3_del_context(ctx); return 1; }
static Z3_ast mk_int_var(Z3_context ctx, char const* name) { return mk_var(ctx, name, Z3_mk_int_sort(ctx)); }
SOLVER_TERM mk_int_var(SOLVER_CONTEXT ctx, const char * name){ Z3_context z3ctx = (Z3_context) ctx; Z3_sort ty = Z3_mk_int_sort(z3ctx); return (SOLVER_TERM) mk_var(z3ctx, name, ty); }
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); }