Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain) {
Z3_TRY;
LOG_Z3_mk_empty_set(c, domain);
RESET_ERROR_CODE();
Z3_ast r = mk_app_array_core(c, domain, Z3_mk_false(c));
RETURN_Z3(r);
Z3_CATCH_RETURN(0);
}
/**
\brief Create an adder for inputs of size \c num_bits.
The arguments \c in1 and \c in2 are arrays of bits of size \c num_bits.
\remark \c result must be an array of size \c num_bits + 1.
*/
void mk_adder(Z3_context ctx, unsigned num_bits, Z3_ast * in_1, Z3_ast * in_2, Z3_ast * result)
{
Z3_ast cin, cout, out;
unsigned i;
cin = Z3_mk_false(ctx);
for (i = 0; i < num_bits; i++) {
mk_full_adder(ctx, in_1[i], in_2[i], cin, &out, &cout);
result[i] = out;
cin = cout;
}
result[num_bits] = cout;
}
/**
\brief Given an integer val encoded in n bits (boolean variables), assert the constraint that val <= k.
*/
void assert_le_k(Z3_context ctx, Z3_solver s, unsigned n, Z3_ast * val, unsigned k)
{
Z3_ast i1, i2, not_val, out;
unsigned idx;
not_val = Z3_mk_not(ctx, val[0]);
if (get_bit(k, 0))
out = Z3_mk_true(ctx);
else
out = not_val;
for (idx = 1; idx < n; idx++) {
not_val = Z3_mk_not(ctx, val[idx]);
if (get_bit(k, idx)) {
i1 = not_val;
i2 = out;
}
else {
i1 = Z3_mk_false(ctx);
i2 = Z3_mk_false(ctx);
}
out = mk_ternary_or(ctx, i1, i2, mk_binary_and(ctx, not_val, out));
}
// printf("at-most-k:\n%s\n", Z3_ast_to_string(ctx, out));
Z3_solver_assert(ctx, s, out);
}
/**
\brief Given \c num_ins "numbers" of size \c num_bits stored in \c in.
Create floor(num_ins/2) adder circuits. Each circuit is adding two consecutive "numbers".
The numbers are stored one after the next in the array \c in.
That is, the array \c in has size num_bits * num_ins.
Return an array of bits containing \c ceil(num_ins/2) numbers of size \c (num_bits + 1).
If num_ins/2 is not an integer, then the last "number" in the output, is the last "number" in \c in with an appended "zero".
*/
void mk_adder_pairs(Z3_context ctx, unsigned num_bits, unsigned num_ins, Z3_ast * in, unsigned * out_num_ins, Z3_ast * out)
{
unsigned out_num_bits = num_bits + 1;
unsigned i = 0;
Z3_ast * _in = in;
Z3_ast * _out = out;
*out_num_ins = (num_ins % 2 == 0) ? (num_ins / 2) : (num_ins / 2) + 1;
for (i = 0; i < num_ins / 2; i++) {
mk_adder(ctx, num_bits, _in, _in + num_bits, _out);
_in += num_bits;
_in += num_bits;
_out += out_num_bits;
}
if (num_ins % 2 != 0) {
for (i = 0; i < num_bits; i++) {
_out[i] = _in[i];
}
_out[num_bits] = Z3_mk_false(ctx);
}
}
Z3_ast z3_propt::z3_literal(literalt l)
{
Z3_ast literal_l;
std::string literal_s;
if(l==const_literal(false))
return Z3_mk_false(z3_ctx);
else if(l==const_literal(true))
return Z3_mk_true(z3_ctx);
literal_s = "l"+i2string(l.var_no());
#ifdef DEBUG
std::cout << "literal_s: " << literal_s << "\n";
#endif
literal_l = z3_api.mk_bool_var(z3_ctx, literal_s.c_str());
if(l.sign())
{
return Z3_mk_not(z3_ctx, literal_l);
}
return literal_l;
}
Z3_ast Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem) {
return Z3_mk_store(c, set, elem, Z3_mk_false(c));
}
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;
}
SOLVER_TERM mk_false(SOLVER_CONTEXT ctx){
return (SOLVER_TERM) Z3_mk_false((Z3_context) ctx);
}
