mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-10 08:02:01 +00:00
Code Activity

passing with open ai codex on some non-deterministic param eval

Browse source 
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
This commit is contained in:
Lev Nachmanson 2025-10-29 06:25:03 -07:00
parent 2b99949ac4
commit ba83ec929a
29 changed files with 665 additions and 371 deletions
Download patch file Download diff file Expand all files Collapse all files

144
src/ast/rewriter/bv_rewriter.cpp
View file

@ -384,9 +384,10 @@ br_status bv_rewriter::rw_leq_overflow(bool is_signed, expr * a, expr * b, expr_
}
else {
SASSERT(lower.is_pos());
// TODO: non-deterministic parameter evaluation
result = m.mk_and(m_util.mk_ule(mk_numeral(lower, sz), common),
m_util.mk_ule(common, mk_numeral(upper, sz)));
expr_ref lower_bound(m), upper_bound(m);
lower_bound = m_util.mk_ule(mk_numeral(lower, sz), common);
upper_bound = m_util.mk_ule(common, mk_numeral(upper, sz));
result = m.mk_and(lower_bound, upper_bound);
}
return BR_REWRITE2;
}
@ -448,9 +449,10 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
return BR_DONE;
}
if (common > 0) {
// TODO: non-deterministic parameter evaluation
result = m_util.mk_ule(concat(numa - common, a->get_args() + common),
concat(numb - common, b->get_args() + common));
expr_ref tail_a(m), tail_b(m);
tail_a = concat(numa - common, a->get_args() + common);
tail_b = concat(numb - common, b->get_args() + common);
result = m_util.mk_ule(tail_a, tail_b);
return BR_REWRITE2;
}
}
@ -471,10 +473,11 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
return BR_DONE;
}
if (new_numa != numa) {
// TODO: non-deterministic parameter evaluation
result = is_signed ? m_util.mk_sle(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()))
// TODO: non-deterministic parameter evaluation
: m_util.mk_ule(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()));
expr_ref prefix_a(m), prefix_b(m);
prefix_a = concat(new_numa, a->get_args());
prefix_b = concat(new_numb, b->get_args());
result = is_signed ? m_util.mk_sle(prefix_a, prefix_b)
: m_util.mk_ule(prefix_a, prefix_b);
return BR_REWRITE2;
}
}
@ -874,8 +877,10 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
expr* c = nullptr, *t = nullptr, *e = nullptr;
if (m.is_ite(arg, c, t, e) &&
(t->get_ref_count() == 1 || e->get_ref_count() == 1 || !m.is_ite(t) || !m.is_ite(e))) {
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e));
expr_ref then_branch(m), else_branch(m);
then_branch = m_mk_extract(high, low, t);
else_branch = m_mk_extract(high, low, e);
result = m.mk_ite(c, then_branch, else_branch);
return BR_REWRITE2;
}
@ -1088,8 +1093,10 @@ br_status bv_rewriter::mk_bv_ashr(expr * arg1, expr * arg2, expr_ref & result) {
// (bvlshr x k) -> (concat bv0:k (extract [n-1:k] x))
unsigned k = r2.get_unsigned();
// TODO: non-deterministic parameter evaluation
result = m_util.mk_concat(mk_zero(k), m_mk_extract(bv_size - 1, k, arg1));
expr_ref high_part(m), low_part(m);
high_part = mk_zero(k);
low_part = m_mk_extract(bv_size - 1, k, arg1);
result = m_util.mk_concat(high_part, low_part);
return BR_REWRITE2;
}
#if 0
@ -1126,10 +1133,11 @@ br_status bv_rewriter::mk_bv_sdiv_core(expr * arg1, expr * arg2, bool hi_div0, e
}
else {
// The "hardware interpretation" for (bvsdiv x 0) is (ite (bvslt x #x0000) #x0001 #xffff)
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size)),
mk_one(bv_size),
mk_numeral(rational::power_of_two(bv_size) - numeral(1), bv_size));
expr_ref div_zero_cond(m), div_zero_pos(m), div_zero_neg(m);
div_zero_cond = m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size));
div_zero_pos = mk_one(bv_size);
div_zero_neg = mk_numeral(rational::power_of_two(bv_size) - numeral(1), bv_size);
result = m.mk_ite(div_zero_cond, div_zero_pos, div_zero_neg);
return BR_REWRITE2;
}
}
@ -1257,10 +1265,11 @@ br_status bv_rewriter::mk_bv_srem_core(expr * arg1, expr * arg2, bool hi_div0, e
}
bv_size = get_bv_size(arg2);
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
m.mk_app(get_fid(), OP_BSREM0, arg1),
m.mk_app(get_fid(), OP_BSREM_I, arg1, arg2));
expr_ref rem_zero_cond(m), rem_zero_branch(m), rem_nonzero_branch(m);
rem_zero_cond = m.mk_eq(arg2, mk_zero(bv_size));
rem_zero_branch = m.mk_app(get_fid(), OP_BSREM0, arg1);
rem_nonzero_branch = m.mk_app(get_fid(), OP_BSREM_I, arg1, arg2);
result = m.mk_ite(rem_zero_cond, rem_zero_branch, rem_nonzero_branch);
return BR_REWRITE2;
}
@ -1475,10 +1484,11 @@ br_status bv_rewriter::mk_bv_smod_core(expr * arg1, expr * arg2, bool hi_div0, e
}
bv_size = get_bv_size(arg2);
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
m.mk_app(get_fid(), OP_BSMOD0, arg1),
m.mk_app(get_fid(), OP_BSMOD_I, arg1, arg2));
expr_ref mod_zero_cond(m), mod_zero_branch(m), mod_nonzero_branch(m);
mod_zero_cond = m.mk_eq(arg2, mk_zero(bv_size));
mod_zero_branch = m.mk_app(get_fid(), OP_BSMOD0, arg1);
mod_nonzero_branch = m.mk_app(get_fid(), OP_BSMOD_I, arg1, arg2);
result = m.mk_ite(mod_zero_cond, mod_zero_branch, mod_nonzero_branch);
return BR_REWRITE2;
}
@ -1695,8 +1705,10 @@ br_status bv_rewriter::mk_concat(unsigned num_args, expr * const * args, expr_re
ptr_buffer<expr> args1, args2;
for (unsigned i = 0; i < new_args.size(); ++i)
args1.push_back(y), args2.push_back(z);
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(x, m_util.mk_concat(args1), m_util.mk_concat(args2));
expr_ref then_concat(m), else_concat(m);
then_concat = m_util.mk_concat(args1);
else_concat = m_util.mk_concat(args2);
result = m.mk_ite(x, then_concat, else_concat);
return BR_REWRITE2;
}
}
@ -2346,10 +2358,11 @@ br_status bv_rewriter::mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE;
}
// TODO: non-deterministic parameter evaluation
result = m.mk_ite(m.mk_eq(arg1, arg2),
mk_one(1),
mk_zero(1));
expr_ref eq_cond(m), eq_then(m), eq_else(m);
eq_cond = m.mk_eq(arg1, arg2);
eq_then = mk_one(1);
eq_else = mk_zero(1);
result = m.mk_ite(eq_cond, eq_then, eq_else);
return BR_REWRITE2;
}
@ -2626,15 +2639,17 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
return BR_FAILED;
numeral two(2);
ptr_buffer<expr> new_args;
expr_ref_vector eq_args(m);
for (unsigned i = 0; i < sz; i++) {
bool bit0 = (v % two).is_zero();
// TODO: non-deterministic parameter evaluation
new_args.push_back(m.mk_eq(m_mk_extract(i,i, lhs),
mk_numeral(bit0 ? 0 : 1, 1)));
expr_ref lhs_bit(m), rhs_bit(m), eq_arg(m);
lhs_bit = m_mk_extract(i, i, lhs);
rhs_bit = mk_numeral(bit0 ? 0 : 1, 1);
eq_arg = m.mk_eq(lhs_bit, rhs_bit);
eq_args.push_back(eq_arg);
div(v, two, v);
}
result = m.mk_and(new_args);
result = m.mk_and(eq_args);
return BR_REWRITE3;
}
@ -2661,7 +2676,7 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
args2 = &rhs;
}
ptr_buffer<expr> new_eqs;
expr_ref_vector eqs(m);
unsigned low1 = 0;
unsigned low2 = 0;
unsigned i1 = num1;
@ -2673,11 +2688,13 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
unsigned sz2 = get_bv_size(arg2);
SASSERT(low1 < sz1 && low2 < sz2);
unsigned rsz1 = sz1 - low1;
unsigned rsz2 = sz2 - low2;
unsigned rsz2 = sz2 - low2;
if (rsz1 == rsz2) {
// TODO: non-deterministic parameter evaluation
new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2)));
expr_ref lhs_part(m), rhs_part(m), eq_part(m);
lhs_part = m_mk_extract(sz1 - 1, low1, arg1);
rhs_part = m_mk_extract(sz2 - 1, low2, arg2);
eq_part = m.mk_eq(lhs_part, rhs_part);
eqs.push_back(eq_part);
low1 = 0;
low2 = 0;
--i1;
@ -2685,25 +2702,29 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
continue;
}
else if (rsz1 < rsz2) {
// TODO: non-deterministic parameter evaluation
new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(rsz1 + low2 - 1, low2, arg2)));
expr_ref lhs_part(m), rhs_part(m), eq_part(m);
lhs_part = m_mk_extract(sz1 - 1, low1, arg1);
rhs_part = m_mk_extract(rsz1 + low2 - 1, low2, arg2);
eq_part = m.mk_eq(lhs_part, rhs_part);
eqs.push_back(eq_part);
low1 = 0;
low2 += rsz1;
--i1;
}
else {
// TODO: non-deterministic parameter evaluation
new_eqs.push_back(m.mk_eq(m_mk_extract(rsz2 + low1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2)));
expr_ref lhs_part(m), rhs_part(m), eq_part(m);
lhs_part = m_mk_extract(rsz2 + low1 - 1, low1, arg1);
rhs_part = m_mk_extract(sz2 - 1, low2, arg2);
eq_part = m.mk_eq(lhs_part, rhs_part);
eqs.push_back(eq_part);
low1 += rsz2;
low2 = 0;
--i2;
}
}
SASSERT(i1 == 0 && i2 == 0);
SASSERT(new_eqs.size() >= 1);
result = m.mk_and(new_eqs);
SASSERT(eqs.size() >= 1);
result = m.mk_and(eqs);
return BR_REWRITE3;
}
@ -3125,11 +3146,12 @@ br_status bv_rewriter::mk_distinct(unsigned num_args, expr * const * args, expr_
br_status bv_rewriter::mk_bvsmul_overflow(unsigned num, expr * const * args, expr_ref & result) {
SASSERT(num == 2);
// TODO: non-deterministic parameter evaluation
result = m.mk_or(
m.mk_not(m_util.mk_bvsmul_no_ovfl(args[0], args[1])),
m.mk_not(m_util.mk_bvsmul_no_udfl(args[0], args[1]))
);
expr_ref no_ovfl(m), no_udfl(m), not_no_ovfl(m), not_no_udfl(m);
no_ovfl = m_util.mk_bvsmul_no_ovfl(args[0], args[1]);
no_udfl = m_util.mk_bvsmul_no_udfl(args[0], args[1]);
not_no_ovfl = m.mk_not(no_ovfl);
not_no_udfl = m.mk_not(no_udfl);
result = m.mk_or(not_no_ovfl, not_no_udfl);
return BR_REWRITE_FULL;
}
@ -3283,7 +3305,11 @@ br_status bv_rewriter::mk_bvssub_under_overflow(unsigned num, expr * const * arg
auto bvsaddo_stat = mk_bvsadd_over_underflow(2, args2, bvsaddo);
SASSERT(bvsaddo_stat != BR_FAILED); (void)bvsaddo_stat;
auto first_arg_ge_zero = m_util.mk_sle(mk_zero(sz), args[0]);
result = m.mk_ite(m.mk_eq(args[1], minSigned), first_arg_ge_zero, bvsaddo);
expr_ref eq_min_signed(m), ite_then(m), ite_else(m);
eq_min_signed = m.mk_eq(args[1], minSigned);
ite_then = first_arg_ge_zero;
ite_else = bvsaddo;
result = m.mk_ite(eq_min_signed, ite_then, ite_else);
return BR_REWRITE_FULL;
}
@ -3295,8 +3321,10 @@ br_status bv_rewriter::mk_bvsdiv_overflow(unsigned num, expr * const * args, exp
auto sz = get_bv_size(args[1]);
auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz);
auto minusOne = mk_numeral(rational::power_of_two(sz) - 1, sz);
// TODO: non-deterministic parameter evaluation
result = m.mk_and(m.mk_eq(args[0], minSigned), m.mk_eq(args[1], minusOne));
expr_ref eq_min_signed(m), eq_minus_one(m);
eq_min_signed = m.mk_eq(args[0], minSigned);
eq_minus_one = m.mk_eq(args[1], minusOne);
result = m.mk_and(eq_min_signed, eq_minus_one);
return BR_REWRITE_FULL;
}