mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-21 05:06:39 +00:00
Code Activity

revert the change

Browse source 
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
This commit is contained in:
Lev Nachmanson 2025-10-28 19:00:46 -07:00
parent 51f6dfeb83
commit 54257b6629
62 changed files with 120 additions and 765 deletions
Download patch file Download diff file Expand all files Collapse all files

31
src/ast/bv_decl_plugin.cpp
View file

@ -47,22 +47,8 @@ void bv_decl_plugin::set_manager(ast_manager * m, family_id id) {
for (unsigned i = 1; i <= 64; i++)
mk_bv_sort(i);
//non-deterministic order change start
{
auto symbol_1 = symbol("bit0");
auto get_bv_sort_2 = get_bv_sort(1);
auto func_decl_info_3 = func_decl_info(m_family_id, OP_BIT0);
m_bit0 = m->mk_const_decl(symbol_1, get_bv_sort_2, func_decl_info_3);
}
//non-deterministic order change end
//non-deterministic order change start
{
auto symbol_1 = symbol("bit1");
auto get_bv_sort_2 = get_bv_sort(1);
auto func_decl_info_3 = func_decl_info(m_family_id, OP_BIT1);
m_bit1 = m->mk_const_decl(symbol_1, get_bv_sort_2, func_decl_info_3);
}
//non-deterministic order change end
m_bit0 = m->mk_const_decl(symbol("bit0"), get_bv_sort(1), func_decl_info(m_family_id, OP_BIT0));
m_bit1 = m->mk_const_decl(symbol("bit1"), get_bv_sort(1), func_decl_info(m_family_id, OP_BIT1));
m->inc_ref(m_bit0);
m->inc_ref(m_bit1);
@ -523,13 +509,7 @@ func_decl * bv_decl_plugin::mk_mkbv(unsigned arity, sort * const * domain) {
unsigned bv_size = arity;
m_mkbv.reserve(bv_size+1);
if (m_mkbv[bv_size] == 0) {
//non-deterministic order change start
{
auto get_bv_sort_1 = get_bv_sort(bv_size);
auto func_decl_info_2 = func_decl_info(m_family_id, OP_MKBV);
m_mkbv[bv_size] = m_manager->mk_func_decl(m_mkbv_sym, arity, domain, get_bv_sort_1, func_decl_info_2);
}
//non-deterministic order change end
m_mkbv[bv_size] = m_manager->mk_func_decl(m_mkbv_sym, arity, domain, get_bv_sort(bv_size), func_decl_info(m_family_id, OP_MKBV));
m_manager->inc_ref(m_mkbv[bv_size]);
}
return m_mkbv[bv_size];
@ -598,25 +578,21 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
case OP_CONCAT:
if (!get_concat_size(arity, domain, r_size))
m_manager->raise_exception("invalid concat application");
//non-deterministic order no change: too complex
return m_manager->mk_func_decl(m_concat_sym, arity, domain, get_bv_sort(r_size),
func_decl_info(m_family_id, k));
case OP_SIGN_EXT:
if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid sign_extend application");
//non-deterministic order no change: too complex
return m_manager->mk_func_decl(m_sign_extend_sym, arity, domain, get_bv_sort(r_size),
func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_ZERO_EXT:
if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid zero_extend application");
//non-deterministic order no change: too complex
return m_manager->mk_func_decl(m_zero_extend_sym, arity, domain, get_bv_sort(r_size),
func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_EXTRACT:
if (!get_extract_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid extract application");
//non-deterministic order no change: too complex
return m_manager->mk_func_decl(m_extract_sym, arity, domain, get_bv_sort(r_size),
func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_ROTATE_LEFT:
@ -640,7 +616,6 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
m_manager->raise_exception("repeat expects one nonzero integer parameter");
if (!get_bv_size(domain[0], bv_size))
m_manager->raise_exception("repeat expects an argument with bit-vector sort");
//non-deterministic order no change: too complex
return m_manager->mk_func_decl(m_repeat_sym, arity, domain, get_bv_sort(bv_size * parameters[0].get_int()),
func_decl_info(m_family_id, k, num_parameters, parameters));
default:

18
src/ast/char_decl_plugin.cpp
View file

@ -66,14 +66,7 @@ func_decl* char_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
msg << "incorrect number of arguments passed. Expected one character, received " << arity;
else {
arith_util a(m);
//non-deterministic order change start
{
auto symbol_1 = symbol("char.to_int");
auto mk_int_2 = a.mk_int();
auto func_decl_info_3 = func_decl_info(m_family_id, k, 0, nullptr);
return m.mk_func_decl(symbol_1, arity, domain, mk_int_2, func_decl_info_3);
}
//non-deterministic order change end
return m.mk_func_decl(symbol("char.to_int"), arity, domain, a.mk_int(), func_decl_info(m_family_id, k, 0, nullptr));
}
m.raise_exception(msg.str());
case OP_CHAR_TO_BV:
@ -86,14 +79,7 @@ func_decl* char_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
else {
bv_util b(m);
unsigned sz = num_bits();
//non-deterministic order change start
{
auto symbol_1 = symbol("char.to_bv");
auto mk_sort_2 = b.mk_sort(sz);
auto func_decl_info_3 = func_decl_info(m_family_id, k, 0, nullptr);
return m.mk_func_decl(symbol_1, arity, domain, mk_sort_2, func_decl_info_3);
}
//non-deterministic order change end
return m.mk_func_decl(symbol("char.to_bv"), arity, domain, b.mk_sort(sz), func_decl_info(m_family_id, k, 0, nullptr));
}
m.raise_exception(msg.str());
case OP_CHAR_FROM_BV: {

1
src/ast/converters/generic_model_converter.cpp
View file

@ -262,7 +262,6 @@ expr_ref generic_model_converter::simplify_def(entry const& e) {
rep.apply_substitution(c, m.mk_true(), result1);
rep.apply_substitution(c, m.mk_false(), result2);
th_rewriter rw(m);
//non-deterministic order no change: too complex
expr_ref result(m.mk_and(m.mk_implies(result2, c), m.mk_implies(c, result1)), m);
rw(result);
return result;

10
src/ast/format.h
View file

@ -90,18 +90,15 @@ namespace format_ns {
format * mk_seq1(ast_manager & m, It const & begin, It const & end, ToDoc proc, char const * header,
char const * lp = "(", char const * rp = ")") {
if (begin == end)
//non-deterministic order no change: too complex
return mk_compose(m, mk_string(m, lp), mk_string(m, header), mk_string(m, rp));
unsigned indent = static_cast<unsigned>(strlen(lp) + strlen(header) + 1);
It it = begin;
format * first = proc(*it);
++it;
//non-deterministic order no change: too complex
return mk_group(m, mk_compose(m,
mk_string(m, lp),
mk_string(m, header),
mk_indent(m, indent,
//non-deterministic order no change: too complex
mk_compose(m,
mk_string(m, " "),
first,
@ -149,7 +146,6 @@ namespace format_ns {
unsigned indent = FORMAT_DEFAULT_INDENT, char const * lp = "(", char const * rp = ")") {
SASSERT(i >= 1);
if (begin == end)
//non-deterministic order no change: too complex
return mk_compose(m, mk_string(m, lp), mk_string(m, header), mk_string(m, rp));
unsigned idx = 0;
It end1 = begin;
@ -159,12 +155,9 @@ namespace format_ns {
format * first = proc(*it);
++it;
return mk_group(m,
//non-deterministic order no change: too complex
mk_compose(m,
//non-deterministic order no change: too complex
mk_compose(m, mk_string(m, lp), mk_string(m, header)),
mk_group(m, mk_indent(m, static_cast<unsigned>(strlen(header) + strlen(lp) + 1),
//non-deterministic order no change: too complex
mk_compose(m, mk_string(m, " "), first,
mk_seq(m, it, end1, proc)))),
mk_indent(m, indent, mk_seq(m, end1, end, proc)),
@ -181,16 +174,13 @@ namespace format_ns {
format * mk_seq4(ast_manager & m, It const & begin, It const & end, ToDoc proc, unsigned indent = FORMAT_DEFAULT_INDENT,
char const * lp = "(", char const * rp = ")") {
if (begin == end)
//non-deterministic order no change: too complex
return mk_compose(m, mk_string(m, lp), mk_string(m, rp));
unsigned indent1 = static_cast<unsigned>(strlen(lp));
It it = begin;
format * first = proc(*it);
++it;
//non-deterministic order no change: too complex
return mk_group(m, mk_compose(m,
mk_indent(m, indent1, mk_compose(m, mk_string(m, lp), first)),
//non-deterministic order no change: too complex
mk_indent(m, indent, mk_compose(m,
mk_seq(m, it, end, proc),
mk_string(m, rp)))));

173
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -300,16 +300,9 @@ void fpa2bv_converter::mk_uf(func_decl * f, unsigned num, expr * const * args, e
bv_rng = m_bv_util.mk_sort(bv_sz);
func_decl * bv_f = mk_bv_uf(f, f->get_domain(), bv_rng);
bv_app = m.mk_app(bv_f, num, args);
//non-deterministic order change start
{
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz-1, bv_sz-1, bv_app);
auto mk_extract_2 = m_bv_util.mk_extract(sbits+ebits-2, sbits-1, bv_app);
auto mk_extract_3 = m_bv_util.mk_extract(sbits-2, 0, bv_app);
flt_app = m_util.mk_fp(mk_extract_1,
mk_extract_2,
mk_extract_3);
}
//non-deterministic order change end
flt_app = m_util.mk_fp(m_bv_util.mk_extract(bv_sz-1, bv_sz-1, bv_app),
m_bv_util.mk_extract(sbits+ebits-2, sbits-1, bv_app),
m_bv_util.mk_extract(sbits-2, 0, bv_app));
new_eq = m.mk_eq(fapp, flt_app);
m_extra_assertions.push_back(extra_quantify(new_eq));
result = flt_app;
@ -1252,16 +1245,9 @@ void fpa2bv_converter::mk_rem(sort * s, expr_ref & x, expr_ref & y, expr_ref & r
dbg_decouple("fpa2bv_rem_y_sig_eq_rndd_sig", y_sig_eq_rndd_sig);
expr_ref adj_cnd(m);
//non-deterministic order change start
{
auto mk_and_1 = m.mk_and(rndd_exp_eq_y_exp, y_sig_le_rndd_sig);
auto mk_and_2 = m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_le_rndd_sig, m.mk_not(y_sig_eq_rndd_sig));
auto mk_and_3 = m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_eq_rndd_sig, m.mk_not(huge_div_is_even));
adj_cnd = m.mk_or(mk_and_1,
mk_and_2,
mk_and_3);
}
//non-deterministic order change end
adj_cnd = m.mk_or(m.mk_and(rndd_exp_eq_y_exp, y_sig_le_rndd_sig),
m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_le_rndd_sig, m.mk_not(y_sig_eq_rndd_sig)),
m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_eq_rndd_sig, m.mk_not(huge_div_is_even)));
dbg_decouple("fpa2bv_rem_adj_cnd", adj_cnd);
expr_ref rndd(m), rounded_sub_y(m), rounded_add_y(m), add_cnd(m), adjusted(m);
@ -1660,15 +1646,9 @@ void fpa2bv_converter::mk_fma(func_decl * f, unsigned num, expr * const * args,
// Alignment shift with sticky bit computation.
expr_ref shifted_big(m), shifted_f_sig(m);
expr_ref alignment_sticky_raw(m), alignment_sticky(m);
//non-deterministic order change start
{
auto mk_concat_1 = m_bv_util.mk_concat(f_sig, m_bv_util.mk_numeral(0, sbits));
auto mk_zero_extend_2 = m_bv_util.mk_zero_extend((3*sbits+3)-(ebits+2), exp_delta);
shifted_big = m_bv_util.mk_bv_lshr(
mk_concat_1,
mk_zero_extend_2);
}
//non-deterministic order change end
shifted_big = m_bv_util.mk_bv_lshr(
m_bv_util.mk_concat(f_sig, m_bv_util.mk_numeral(0, sbits)),
m_bv_util.mk_zero_extend((3*sbits+3)-(ebits+2), exp_delta));
shifted_f_sig = m_bv_util.mk_extract(3*sbits+2, sbits, shifted_big);
alignment_sticky_raw = m_bv_util.mk_extract(sbits-1, 0, shifted_big);
alignment_sticky = m.mk_app(m_bv_util.get_fid(), OP_BREDOR, alignment_sticky_raw.get());
@ -1896,13 +1876,7 @@ void fpa2bv_converter::mk_sqrt(func_decl * f, unsigned num, expr * const * args,
res_sgn = zero1;
expr_ref real_exp(m);
//non-deterministic order change start
{
auto mk_sign_extend_1 = m_bv_util.mk_sign_extend(1, a_exp);
auto mk_zero_extend_2 = m_bv_util.mk_zero_extend(1, a_lz);
real_exp = m_bv_util.mk_bv_sub(mk_sign_extend_1, mk_zero_extend_2);
}
//non-deterministic order change end
real_exp = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(1, a_exp), m_bv_util.mk_zero_extend(1, a_lz));
res_exp = m_bv_util.mk_sign_extend(2, m_bv_util.mk_extract(ebits, 1, real_exp));
expr_ref e_is_odd(m);
@ -1933,13 +1907,7 @@ void fpa2bv_converter::mk_sqrt(func_decl * f, unsigned num, expr * const * args,
S = m_bv_util.mk_concat(zero1, m_bv_util.mk_extract(sbits+4, 1, S));
expr_ref twoQ_plus_S(m);
//non-deterministic order change start
{
auto mk_concat_1 = m_bv_util.mk_concat(Q, zero1);
auto mk_concat_2 = m_bv_util.mk_concat(zero1, S);
twoQ_plus_S = m_bv_util.mk_bv_add(mk_concat_1, mk_concat_2);
}
//non-deterministic order change end
twoQ_plus_S = m_bv_util.mk_bv_add(m_bv_util.mk_concat(Q, zero1), m_bv_util.mk_concat(zero1, S));
T = m_bv_util.mk_bv_sub(m_bv_util.mk_concat(R, zero1), twoQ_plus_S);
dbg_decouple("fpa2bv_sqrt_T", T);
@ -2130,14 +2098,8 @@ void fpa2bv_converter::mk_round_to_integral(sort * s, expr_ref & rm, expr_ref &
expr_ref shift(m), shifted_sig(m), div(m), rem(m);
shift = m_bv_util.mk_bv_sub(m_bv_util.mk_numeral(sbits - 1, sbits),
m_bv_util.mk_sign_extend(sbits-ebits, a_exp));
//non-deterministic order change start
{
auto mk_concat_1 = m_bv_util.mk_concat(a_sig, zero_s);
auto mk_concat_2 = m_bv_util.mk_concat(zero_s, shift);
shifted_sig = m_bv_util.mk_bv_lshr(mk_concat_1,
mk_concat_2);
}
//non-deterministic order change end
shifted_sig = m_bv_util.mk_bv_lshr(m_bv_util.mk_concat(a_sig, zero_s),
m_bv_util.mk_concat(zero_s, shift));
div = m_bv_util.mk_extract(2*sbits-1, sbits, shifted_sig);
rem = m_bv_util.mk_extract(sbits-1, 0, shifted_sig);
@ -2489,16 +2451,9 @@ void fpa2bv_converter::mk_to_fp(func_decl * f, unsigned num, expr * const * args
(void)to_sbits;
SASSERT((unsigned)sz == to_sbits + to_ebits);
//non-deterministic order change start
{
auto mk_extract_1 = m_bv_util.mk_extract(sz - 1, sz - 1, bv);
auto mk_extract_2 = m_bv_util.mk_extract(sz - 2, sz - to_ebits - 1, bv);
auto mk_extract_3 = m_bv_util.mk_extract(sz - to_ebits - 2, 0, bv);
result = m_util.mk_fp(mk_extract_1,
mk_extract_2,
mk_extract_3);
}
//non-deterministic order change end
result = m_util.mk_fp(m_bv_util.mk_extract(sz - 1, sz - 1, bv),
m_bv_util.mk_extract(sz - 2, sz - to_ebits - 1, bv),
m_bv_util.mk_extract(sz - to_ebits - 2, 0, bv));
}
else if (num == 2 &&
m_util.is_rm(args[0]) &&
@ -2656,13 +2611,7 @@ void fpa2bv_converter::mk_to_fp_float(sort * to_srt, expr * rm, expr * x, expr_r
// subtract lz for subnormal numbers.
expr_ref exp_sub_lz(m);
//non-deterministic order change start
{
auto mk_sign_extend_1 = m_bv_util.mk_sign_extend(2, exp);
auto mk_sign_extend_2 = m_bv_util.mk_sign_extend(2, lz);
exp_sub_lz = m_bv_util.mk_bv_sub(mk_sign_extend_1, mk_sign_extend_2);
}
//non-deterministic order change end
exp_sub_lz = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(2, exp), m_bv_util.mk_sign_extend(2, lz));
dbg_decouple("fpa2bv_to_float_exp_sub_lz", exp_sub_lz);
// check whether exponent is within roundable (to_ebits+2) range.
@ -2895,8 +2844,6 @@ void fpa2bv_converter::mk_to_fp_real(func_decl * f, sort * s, expr * rm, expr *
expr_ref pzero(m), nzero(m);
mk_pzero(result->get_sort(), pzero);
mk_nzero(result->get_sort(), nzero);
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
m_extra_assertions.push_back(m.mk_implies(m.mk_eq(x, zero), m.mk_or(m.mk_eq(result, pzero), m.mk_eq(result, nzero))));
}
@ -3451,14 +3398,8 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
// x is of the form +- [1].[sig][r][g][s] ... and at least bv_sz + 3 long
expr_ref exp_m_lz(m), e_m_lz_m_bv_sz(m), shift(m), is_neg_shift(m), big_sig(m);
//non-deterministic order change start
{
auto mk_sign_extend_1 = m_bv_util.mk_sign_extend(2, exp);
auto mk_zero_extend_2 = m_bv_util.mk_zero_extend(2, lz);
exp_m_lz = m_bv_util.mk_bv_sub(mk_sign_extend_1,
mk_zero_extend_2);
}
//non-deterministic order change end
exp_m_lz = m_bv_util.mk_bv_sub(m_bv_util.mk_sign_extend(2, exp),
m_bv_util.mk_zero_extend(2, lz));
// big_sig is +- [... bv_sz+2 bits ...][1].[r][ ... sbits-1 ... ]
big_sig = m_bv_util.mk_concat(m_bv_util.mk_zero_extend(bv_sz + 2, sig), bv0);
@ -3524,18 +3465,10 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
expr_ref ul(m), in_range(m);
if (!is_signed) {
ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz)));
//non-deterministic order no change: too complex
//non-deterministic order change start
{
auto mk_or_1 = m.mk_or(m.mk_not(x_is_neg),
m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz+3)));
auto mk_not_2 = m.mk_not(ovfl);
auto mk_ule_3 = m_bv_util.mk_ule(pre_rounded, ul);
in_range = m.mk_and(mk_or_1,
mk_not_2,
mk_ule_3);
}
//non-deterministic order change end
in_range = m.mk_and(m.mk_or(m.mk_not(x_is_neg),
m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz+3))),
m.mk_not(ovfl),
m_bv_util.mk_ule(pre_rounded, ul));
}
else {
expr_ref ll(m);
@ -3549,16 +3482,9 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
ul = m_bv_util.mk_numeral(0, 4);
ovfl = m.mk_or(ovfl, m_bv_util.mk_sle(pre_rounded, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz + 3))));
pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded);
//non-deterministic order change start
{
auto mk_not_1 = m.mk_not(ovfl);
auto mk_sle_2 = m_bv_util.mk_sle(ll, pre_rounded);
auto mk_sle_3 = m_bv_util.mk_sle(pre_rounded, ul);
in_range = m.mk_and(mk_not_1,
mk_sle_2,
mk_sle_3);
}
//non-deterministic order change end
in_range = m.mk_and(m.mk_not(ovfl),
m_bv_util.mk_sle(ll, pre_rounded),
m_bv_util.mk_sle(pre_rounded, ul));
dbg_decouple("fpa2bv_to_bv_in_range_ll", ll);
}
dbg_decouple("fpa2bv_to_bv_in_range_ovfl", ovfl);
@ -4262,14 +4188,8 @@ void fpa2bv_converter::round(sort * s, expr_ref & rm, expr_ref & sgn, expr_ref &
SASSERT(m_bv_util.get_bv_size(inc) == 1 && is_well_sorted(m, inc));
dbg_decouple("fpa2bv_rnd_inc", inc);
//non-deterministic order change start
{
auto mk_zero_extend_1 = m_bv_util.mk_zero_extend(1, sig);
auto mk_zero_extend_2 = m_bv_util.mk_zero_extend(sbits, inc);
sig = m_bv_util.mk_bv_add(mk_zero_extend_1,
mk_zero_extend_2);
}
//non-deterministic order change end
sig = m_bv_util.mk_bv_add(m_bv_util.mk_zero_extend(1, sig),
m_bv_util.mk_zero_extend(sbits, inc));
SASSERT(is_well_sorted(m, sig));
dbg_decouple("fpa2bv_rnd_sig_plus_inc", sig);
@ -4447,16 +4367,9 @@ void fpa2bv_converter_wrapped::mk_const(func_decl* f, expr_ref& result) {
unsigned bv_sz = m_bv_util.get_bv_size(bv);
unsigned sbits = m_util.get_sbits(s);
SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
//non-deterministic order change start
{
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, bv);
auto mk_extract_2 = m_bv_util.mk_extract(bv_sz - 2, sbits - 1, bv);
auto mk_extract_3 = m_bv_util.mk_extract(sbits - 2, 0, bv);
result = m_util.mk_fp(mk_extract_1,
mk_extract_2,
mk_extract_3);
}
//non-deterministic order change end
result = m_util.mk_fp(m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, bv),
m_bv_util.mk_extract(bv_sz - 2, sbits - 1, bv),
m_bv_util.mk_extract(sbits - 2, 0, bv));
SASSERT(m_util.is_float(result));
m_const2bv.insert(f, result);
m.inc_ref(f);
@ -4506,35 +4419,19 @@ app_ref fpa2bv_converter_wrapped::unwrap(expr* e, sort* s) {
if (m_util.is_rm(s)) {
SASSERT(bv_sz == 3);
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TIES_TO_AWAY, 3));
auto mk_round_nearest_ties_to_away_2 = m_util.mk_round_nearest_ties_to_away();
res = m.mk_ite(mk_eq_1, mk_round_nearest_ties_to_away_2,
//non-deterministic order no change: too complex
res = m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TIES_TO_AWAY, 3)), m_util.mk_round_nearest_ties_to_away(),
m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TIES_TO_EVEN, 3)), m_util.mk_round_nearest_ties_to_even(),
//non-deterministic order no change: too complex
m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TO_NEGATIVE, 3)), m_util.mk_round_toward_negative(),
//non-deterministic order no change: too complex
m.mk_ite(m.mk_eq(e, m_bv_util.mk_numeral(BV_RM_TO_POSITIVE, 3)), m_util.mk_round_toward_positive(),
m_util.mk_round_toward_zero()))));
}
//non-deterministic order change end
}
else {
SASSERT(m_util.is_float(s));
unsigned sbits = m_util.get_sbits(s);
SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
//non-deterministic order change start
{
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, e);
auto mk_extract_2 = m_bv_util.mk_extract(bv_sz - 2, sbits - 1, e);
auto mk_extract_3 = m_bv_util.mk_extract(sbits - 2, 0, e);
res = m_util.mk_fp(mk_extract_1,
mk_extract_2,
mk_extract_3);
}
//non-deterministic order change end
res = m_util.mk_fp(m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, e),
m_bv_util.mk_extract(bv_sz - 2, sbits - 1, e),
m_bv_util.mk_extract(sbits - 2, 0, e));
}
return res;

1
src/ast/fpa/fpa2bv_rewriter.cpp
View file

@ -258,7 +258,6 @@ bool fpa2bv_rewriter_cfg::reduce_var(var * t, expr_ref & result, proof_ref & res
unsigned ebits = m_conv.fu().get_ebits(s);
unsigned sbits = m_conv.fu().get_sbits(s);
new_var = m().mk_var(t->get_idx(), m_conv.bu().mk_sort(sbits+ebits));
//non-deterministic order no change: too complex
new_exp = m_conv.fu().mk_fp(m_conv.bu().mk_extract(sbits+ebits-1, sbits+ebits-1, new_var),
m_conv.bu().mk_extract(ebits - 1, 0, new_var),
m_conv.bu().mk_extract(sbits+ebits-2, ebits, new_var));

10
src/ast/normal_forms/pull_quant.cpp
View file

@ -265,14 +265,8 @@ struct pull_quant::imp {
return BR_FAILED;
if (m.proofs_enabled()) {
//non-deterministic order change start
{
auto mk_app_1 = m.mk_app(f, num, args);
auto get_2 = to_quantifier(result.get());
result_pr = m.mk_pull_quant(mk_app_1,
get_2);
}
//non-deterministic order change end
result_pr = m.mk_pull_quant(m.mk_app(f, num, args),
to_quantifier(result.get()));
}
return BR_DONE;
}

54
src/ast/rewriter/arith_rewriter.cpp
View file

@ -622,13 +622,7 @@ br_status arith_rewriter::factor_le_ge_eq(expr * arg1, expr * arg2, op_kind kind
return BR_FAILED;
expr_ref f2 = remove_factor(f, arg1);
expr* z = m_util.mk_numeral(rational(0), m_util.is_int(arg1));
//non-deterministic order change start
{
auto mk_eq_1 = m_util.mk_eq(f, z);
auto mk_eq_2 = m_util.mk_eq(f2, z);
result = m.mk_or(mk_eq_1, mk_eq_2);
}
//non-deterministic order change end
result = m.mk_or(m_util.mk_eq(f, z), m_util.mk_eq(f2, z));
switch (kind) {
case EQ:
break;
@ -874,14 +868,8 @@ bool arith_rewriter::mk_eq_mod(expr* arg1, expr* arg2, expr_ref& result) {
rational g = gcd(p, k, a, b);
if (g == 1) {
expr_ref nb(m_util.mk_numeral(b, true), m);
//non-deterministic order change start
{
auto mk_mod_1 = m_util.mk_mod(u, y);
auto mk_mod_2 = m_util.mk_mod(m_util.mk_mul(nb, arg2), y);
result = m.mk_eq(mk_mod_1,
mk_mod_2);
}
//non-deterministic order change end
result = m.mk_eq(m_util.mk_mod(u, y),
m_util.mk_mod(m_util.mk_mul(nb, arg2), y));
return true;
}
}
@ -1214,13 +1202,7 @@ br_status arith_rewriter::mk_div_core(expr * arg1, expr * arg2, expr_ref & resul
}
br_status arith_rewriter::mk_idivides(unsigned k, expr * arg, expr_ref & result) {
//non-deterministic order change start
{
auto mk_mod_1 = m_util.mk_mod(arg, m_util.mk_int(k));
auto mk_int_2 = m_util.mk_int(0);
result = m.mk_eq(mk_mod_1, mk_int_2);
}
//non-deterministic order change end
result = m.mk_eq(m_util.mk_mod(arg, m_util.mk_int(k)), m_util.mk_int(0));
return BR_REWRITE2;
}
@ -1247,14 +1229,7 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
}
if (arg1 == arg2) {
expr_ref zero(m_util.mk_int(0), m);
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(arg1, zero);
auto mk_idiv_2 = m_util.mk_idiv(zero, zero);
auto mk_int_3 = m_util.mk_int(1);
result = m.mk_ite(mk_eq_1, mk_idiv_2, mk_int_3);
}
//non-deterministic order change end
result = m.mk_ite(m.mk_eq(arg1, zero), m_util.mk_idiv(zero, zero), m_util.mk_int(1));
return BR_REWRITE3;
}
if (is_num2 && v2.is_pos() && m_util.is_add(arg1)) {
@ -1352,7 +1327,6 @@ expr_ref arith_rewriter::remove_divisor(expr* arg, expr* num, expr* den) {
den = args2.empty() ? m_util.mk_int(1) : m_util.mk_mul(args2.size(), args2.data());
expr_ref d(m_util.mk_idiv(num, den), m);
expr_ref nd(m_util.mk_idiv(m_util.mk_uminus(num), m_util.mk_uminus(den)), m);
//non-deterministic order no change: too complex
return expr_ref(m.mk_ite(m.mk_eq(zero, arg),
m_util.mk_idiv(zero, zero),
m.mk_ite(m_util.mk_ge(arg, zero),
@ -1453,13 +1427,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
expr* x = nullptr, * y = nullptr, * z = nullptr;
if (is_num2 && v2.is_pos() && m_util.is_mul(arg1, x, y) && m_util.is_numeral(x, v1, is_int) && v1 > 0 && divides(v1, v2)) {
//non-deterministic order change start
{
auto mk_int_1 = m_util.mk_int(v1);
auto mk_mod_2 = m_util.mk_mod(y, m_util.mk_int(v2/v1));
result = m_util.mk_mul(mk_int_1, mk_mod_2);
}
//non-deterministic order change end
result = m_util.mk_mul(m_util.mk_int(v1), m_util.mk_mod(y, m_util.mk_int(v2/v1)));
return BR_REWRITE1;
}
@ -2115,14 +2083,12 @@ expr * arith_rewriter::mk_sin_value(rational const & k) {
if (k_prime == rational(1, 12) || k_prime == rational(11, 12)) {
// sin(1/12 pi) == sin(11/12 pi) == [sqrt(6) - sqrt(2)]/4
// sin(13/12 pi) == sin(23/12 pi) == -[sqrt(6) - sqrt(2)]/4
//non-deterministic order no change: too complex
expr * result = m_util.mk_div(m_util.mk_sub(mk_sqrt(rational(6)), mk_sqrt(rational(2))), m_util.mk_numeral(rational(4), false));
return neg ? m_util.mk_uminus(result) : result;
}
if (k_prime == rational(5, 12) || k_prime == rational(7, 12)) {
// sin(5/12 pi) == sin(7/12 pi) == [sqrt(6) + sqrt(2)]/4
// sin(17/12 pi) == sin(19/12 pi) == -[sqrt(6) + sqrt(2)]/4
//non-deterministic order no change: too complex
expr * result = m_util.mk_div(m_util.mk_add(mk_sqrt(rational(6)), mk_sqrt(rational(2))), m_util.mk_numeral(rational(4), false));
return neg ? m_util.mk_uminus(result) : result;
}
@ -2301,13 +2267,7 @@ br_status arith_rewriter::mk_tan_core(expr * arg, expr_ref & result) {
end:
if (m_expand_tan) {
//non-deterministic order change start
{
auto mk_sin_1 = m_util.mk_sin(arg);
auto mk_cos_2 = m_util.mk_cos(arg);
result = m_util.mk_div(mk_sin_1, mk_cos_2);
}
//non-deterministic order change end
result = m_util.mk_div(m_util.mk_sin(arg), m_util.mk_cos(arg));
return BR_REWRITE2;
}
return BR_FAILED;

42
src/ast/rewriter/bv2int_translator.cpp
View file

@ -222,7 +222,6 @@ void bv2int_translator::translate_bv(app* e) {
auto A = rational::power_of_two(sz - n);
auto B = rational::power_of_two(n);
auto hi = mul(r, a.mk_int(A));
//non-deterministic order no change: too complex
auto lo = amod(e, a.mk_idiv(umod(e, 0), a.mk_int(B)), A);
r = add(hi, lo);
}
@ -365,13 +364,7 @@ void bv2int_translator::translate_bv(app* e) {
rational N = bv_size(e);
expr* x = umod(e, 0), * y = umod(e, 1);
expr* signx = a.mk_ge(x, a.mk_int(N / 2));
//non-deterministic order change start
{
auto mk_int_1 = a.mk_int(-1);
auto mk_int_2 = a.mk_int(0);
r = m.mk_ite(signx, mk_int_1, mk_int_2);
}
//non-deterministic order change end
r = m.mk_ite(signx, a.mk_int(-1), a.mk_int(0));
IF_VERBOSE(4, verbose_stream() << "ashr " << mk_bounded_pp(e, m) << " " << bv.get_bv_size(e) << "\n");
for (unsigned i = 0; i < sz; ++i) {
expr* d = a.mk_idiv(x, a.mk_int(rational::power_of_two(i)));
@ -438,15 +431,7 @@ void bv2int_translator::translate_bv(app* e) {
break;
case OP_BCOMP:
bv_expr = e->get_arg(0);
//non-deterministic order no change: too complex
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1));
auto mk_int_2 = a.mk_int(1);
auto mk_int_3 = a.mk_int(0);
r = m.mk_ite(mk_eq_1, mk_int_2, mk_int_3);
}
//non-deterministic order change end
r = m.mk_ite(m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)), a.mk_int(1), a.mk_int(0));
break;
case OP_BSMOD_I:
case OP_BSMOD: {
@ -464,7 +449,6 @@ void bv2int_translator::translate_bv(app* e) {
r = a.mk_uminus(u);
r = m.mk_ite(m.mk_and(m.mk_not(signx), signy), add(u, y), r);
r = m.mk_ite(m.mk_and(signx, m.mk_not(signy)), a.mk_sub(y, u), r);
//non-deterministic order no change: too complex
r = m.mk_ite(m.mk_and(m.mk_not(signx), m.mk_not(signy)), u, r);
r = if_eq(u, 0, a.mk_int(0), r);
r = if_eq(y, 0, x, r);
@ -488,7 +472,6 @@ void bv2int_translator::translate_bv(app* e) {
y = m.mk_ite(signy, a.mk_sub(a.mk_int(N), y), y);
expr* d = a.mk_idiv(x, y);
r = m.mk_ite(m.mk_iff(signx, signy), d, a.mk_uminus(d));
//non-deterministic order no change: too complex
r = if_eq(y, 0, m.mk_ite(signx, a.mk_int(1), a.mk_int(-1)), r);
break;
}
@ -583,27 +566,17 @@ void bv2int_translator::translate_basic(app* e) {
rational N = rational::power_of_two(bv.get_bv_size(bv_expr));
if (a.is_numeral(arg(0)) || a.is_numeral(arg(1)) ||
is_bounded(arg(0), N) || is_bounded(arg(1), N)) {
//non-deterministic order no change: too complex
set_translated(e, m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)));
}
else {
//non-deterministic order change start
{
auto arg_1 = arg(0);
auto arg_2 = arg(1);
m_args[0] = a.mk_sub(arg_1, arg_2);
}
//non-deterministic order change end
//non-deterministic order no change: too complex
m_args[0] = a.mk_sub(arg(0), arg(1));
set_translated(e, m.mk_eq(umod(bv_expr, 0), a.mk_int(0)));
}
}
else
//non-deterministic order no change: too complex
set_translated(e, m.mk_eq(arg(0), arg(1)));
}
else if (m.is_ite(e))
//non-deterministic order no change: too complex
set_translated(e, m.mk_ite(arg(0), arg(1), arg(2)));
else if (m_is_plugin)
set_translated(e, e);
@ -688,13 +661,7 @@ expr* bv2int_translator::amod(expr* bv_expr, expr* x, rational const& N) {
rational v;
expr* r = nullptr, * c = nullptr, * t = nullptr, * e = nullptr;
if (m.is_ite(x, c, t, e))
//non-deterministic order change start
{
auto amod_1 = amod(bv_expr, t, N);
auto amod_2 = amod(bv_expr, e, N);
r = m.mk_ite(c, amod_1, amod_2);
}
//non-deterministic order change end
r = m.mk_ite(c, amod(bv_expr, t, N), amod(bv_expr, e, N));
else if (a.is_idiv(x, t, e) && a.is_numeral(t, v) && 0 <= v && v < N && is_non_negative(bv_expr, e))
r = x;
else if (a.is_mod(x, t, e) && a.is_numeral(t, v) && 0 <= v && v < N)
@ -717,7 +684,6 @@ void bv2int_translator::translate_eq(expr* e) {
ensure_translated(y);
m_args.reset();
m_args.push_back(a.mk_sub(translated(x), translated(y)));
//non-deterministic order no change: too complex
set_translated(e, m.mk_eq(umod(x, 0), a.mk_int(0)));
}
m_preds.push_back(e);

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

@ -384,14 +384,8 @@ br_status bv_rewriter::rw_leq_overflow(bool is_signed, expr * a, expr * b, expr_
}
else {
SASSERT(lower.is_pos());
//non-deterministic order change start
{
auto mk_ule_1 = m_util.mk_ule(mk_numeral(lower, sz), common);
auto mk_ule_2 = m_util.mk_ule(common, mk_numeral(upper, sz));
result = m.mk_and(mk_ule_1,
mk_ule_2);
}
//non-deterministic order change end
result = m.mk_and(m_util.mk_ule(mk_numeral(lower, sz), common),
m_util.mk_ule(common, mk_numeral(upper, sz)));
}
return BR_REWRITE2;
}
@ -453,14 +447,8 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
return BR_DONE;
}
if (common > 0) {
//non-deterministic order change start
{
auto get_args_1 = concat(numa - common, a->get_args() + common);
auto get_args_2 = concat(numb - common, b->get_args() + common);
result = m_util.mk_ule(get_args_1,
get_args_2);
}
//non-deterministic order change end
result = m_util.mk_ule(concat(numa - common, a->get_args() + common),
concat(numb - common, b->get_args() + common));
return BR_REWRITE2;
}
}
@ -481,9 +469,7 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
return BR_DONE;
}
if (new_numa != numa) {
//non-deterministic order no change: too complex
result = is_signed ? m_util.mk_sle(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()))
//non-deterministic order no change: too complex
: m_util.mk_ule(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()));
return BR_REWRITE2;
}
@ -884,13 +870,7 @@ 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))) {
//non-deterministic order change start
{
auto m_mk_extract_1 = m_mk_extract(high, low, t);
auto m_mk_extract_2 = m_mk_extract(high, low, e);
result = m.mk_ite(c, m_mk_extract_1, m_mk_extract_2);
}
//non-deterministic order change end
result = m.mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e));
return BR_REWRITE2;
}
@ -1103,13 +1083,7 @@ 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();
//non-deterministic order change start
{
auto mk_zero_1 = mk_zero(k);
auto m_mk_extract_2 = m_mk_extract(bv_size - 1, k, arg1);
result = m_util.mk_concat(mk_zero_1, m_mk_extract_2);
}
//non-deterministic order change end
result = m_util.mk_concat(mk_zero(k), m_mk_extract(bv_size - 1, k, arg1));
return BR_REWRITE2;
}
#if 0
@ -1146,16 +1120,9 @@ 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)
//non-deterministic order change start
{
auto mk_app_1 = m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size));
auto mk_one_2 = mk_one(bv_size);
auto mk_numeral_3 = mk_numeral(rational::power_of_two(bv_size) - numeral(1), bv_size);
result = m.mk_ite(mk_app_1,
mk_one_2,
mk_numeral_3);
}
//non-deterministic order change end
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));
return BR_REWRITE2;
}
}
@ -1283,16 +1250,9 @@ br_status bv_rewriter::mk_bv_srem_core(expr * arg1, expr * arg2, bool hi_div0, e
}
bv_size = get_bv_size(arg2);
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(arg2, mk_zero(bv_size));
auto mk_app_2 = m.mk_app(get_fid(), OP_BSREM0, arg1);
auto mk_app_3 = m.mk_app(get_fid(), OP_BSREM_I, arg1, arg2);
result = m.mk_ite(mk_eq_1,
mk_app_2,
mk_app_3);
}
//non-deterministic order change end
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));
return BR_REWRITE2;
}
@ -1507,16 +1467,9 @@ br_status bv_rewriter::mk_bv_smod_core(expr * arg1, expr * arg2, bool hi_div0, e
}
bv_size = get_bv_size(arg2);
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(arg2, mk_zero(bv_size));
auto mk_app_2 = m.mk_app(get_fid(), OP_BSMOD0, arg1);
auto mk_app_3 = m.mk_app(get_fid(), OP_BSMOD_I, arg1, arg2);
result = m.mk_ite(mk_eq_1,
mk_app_2,
mk_app_3);
}
//non-deterministic order change end
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));
return BR_REWRITE2;
}
@ -1733,13 +1686,7 @@ 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);
//non-deterministic order change start
{
auto mk_concat_1 = m_util.mk_concat(args1);
auto mk_concat_2 = m_util.mk_concat(args2);
result = m.mk_ite(x, mk_concat_1, mk_concat_2);
}
//non-deterministic order change end
result = m.mk_ite(x, m_util.mk_concat(args1), m_util.mk_concat(args2));
return BR_REWRITE2;
}
}
@ -2389,16 +2336,9 @@ br_status bv_rewriter::mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE;
}
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(arg1, arg2);
auto mk_one_2 = mk_one(1);
auto mk_zero_3 = mk_zero(1);
result = m.mk_ite(mk_eq_1,
mk_one_2,
mk_zero_3);
}
//non-deterministic order change end
result = m.mk_ite(m.mk_eq(arg1, arg2),
mk_one(1),
mk_zero(1));
return BR_REWRITE2;
}
@ -2678,7 +2618,6 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
ptr_buffer<expr> new_args;
for (unsigned i = 0; i < sz; i++) {
bool bit0 = (v % two).is_zero();
//non-deterministic order no change: too complex
new_args.push_back(m.mk_eq(m_mk_extract(i,i, lhs),
mk_numeral(bit0 ? 0 : 1, 1)));
div(v, two, v);
@ -2724,7 +2663,6 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
unsigned rsz1 = sz1 - low1;
unsigned rsz2 = sz2 - low2;
if (rsz1 == rsz2) {
//non-deterministic order no change: too complex
new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2)));
low1 = 0;
@ -2734,7 +2672,6 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
continue;
}
else if (rsz1 < rsz2) {
//non-deterministic order no change: too complex
new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(rsz1 + low2 - 1, low2, arg2)));
low1 = 0;
@ -2742,7 +2679,6 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
--i1;
}
else {
//non-deterministic order no change: too complex
new_eqs.push_back(m.mk_eq(m_mk_extract(rsz2 + low1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2)));
low1 += rsz2;
@ -3174,16 +3110,10 @@ 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);
//non-deterministic order change start
{
auto mk_not_1 = m.mk_not(m_util.mk_bvsmul_no_ovfl(args[0], args[1]));
auto mk_not_2 = m.mk_not(m_util.mk_bvsmul_no_udfl(args[0], args[1]));
result = m.mk_or(
mk_not_1,
mk_not_2
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]))
);
}
//non-deterministic order change end
return BR_REWRITE_FULL;
}
@ -3349,13 +3279,7 @@ 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);
//non-deterministic order change start
{
auto mk_eq_1 = m.mk_eq(args[0], minSigned);
auto mk_eq_2 = m.mk_eq(args[1], minusOne);
result = m.mk_and(mk_eq_1, mk_eq_2);
}
//non-deterministic order change end
result = m.mk_and(m.mk_eq(args[0], minSigned), m.mk_eq(args[1], minusOne));
return BR_REWRITE_FULL;
}

1
src/ast/rewriter/enum2bv_rewriter.cpp
View file

@ -74,7 +74,6 @@ struct enum2bv_rewriter::imp {
if (is_unate(s)) {
expr_ref one(m_bv.mk_numeral(rational::one(), 1), m);
for (unsigned i = 0; i + 2 < domain_size; ++i) {
//non-deterministic order no change: too complex
bounds.push_back(m.mk_implies(m.mk_eq(one, m_bv.mk_extract(i + 1, i + 1, x)),
m.mk_eq(one, m_bv.mk_extract(i, i, x))));
}

2
src/ast/rewriter/factor_rewriter.cpp
View file

@ -141,9 +141,7 @@ void factor_rewriter::mk_is_negative(expr_ref& result, expr_ref_vector& eqs) {
pos0 = pos;
}
else {
//non-deterministic order no change: too complex
tmp = m().mk_or(m().mk_and(pos, pos0), m().mk_and(neg, neg0));
//non-deterministic order no change: too complex
neg0 = m().mk_or(m().mk_and(neg, pos0), m().mk_and(pos, neg0));
pos0 = tmp;
}

2
src/ast/rewriter/fpa_rewriter.cpp
View file

@ -494,7 +494,6 @@ br_status fpa_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
}
if (m_util.is_ninf(arg1)) {
// -oo < arg2 --> not(arg2 = -oo) and not(arg2 = NaN)
//non-deterministic order no change: too complex
result = m().mk_and(m().mk_not(m().mk_eq(arg2, arg1)), mk_neq_nan(arg2));
return BR_REWRITE3;
}
@ -510,7 +509,6 @@ br_status fpa_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
}
if (m_util.is_pinf(arg2)) {
// arg1 < +oo --> not(arg1 = +oo) and not(arg1 = NaN)
//non-deterministic order no change: too complex
result = m().mk_and(m().mk_not(m().mk_eq(arg1, arg2)), mk_neq_nan(arg1));
return BR_REWRITE3;
}

1
src/ast/rewriter/poly_rewriter_def.h
View file

@ -1065,7 +1065,6 @@ template<typename Config>
expr* poly_rewriter<Config>::apply_hoist(expr* a, numeral const& g, obj_hashtable<expr> const& shared) {
expr* c = nullptr, *t = nullptr, *e = nullptr;
if (M().is_ite(a, c, t, e)) {
//non-deterministic order no change: too complex
return M().mk_ite(c, apply_hoist(t, g, shared), apply_hoist(e, g, shared));
}
rational k;

16
src/ast/rewriter/quant_hoist.cpp
View file

@ -249,13 +249,7 @@ private:
pull_quantifier(t1, qt, vars, tt1, use_fresh, rewrite_ok);
nt1 = m.mk_not(t1);
pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
//non-deterministic order change start
{
auto mk_or_1 = m.mk_or(ntt1, tt2);
auto mk_or_2 = m.mk_or(tt1, tt3);
result = m.mk_and(mk_or_1, mk_or_2);
}
//non-deterministic order change end
result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(tt1, tt3));
}
else {
result = m.mk_ite(t1, tt2, tt3);
@ -269,13 +263,7 @@ private:
nt2 = m.mk_not(t2);
pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
pull_quantifier(nt2, qt, vars, ntt2, use_fresh, rewrite_ok);
//non-deterministic order change start
{
auto mk_or_1 = m.mk_or(ntt1, tt2);
auto mk_or_2 = m.mk_or(ntt2, tt1);
result = m.mk_and(mk_or_1, mk_or_2);
}
//non-deterministic order change end
result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(ntt2, tt1));
}
else {
// the formula contains a quantifier, but it is "inaccessible"

2
src/ast/rewriter/rewriter_def.h
View file

@ -574,7 +574,6 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
num_no_pats = j;
}
if (ProofGen) {
//non-deterministic order no change: too complex
quantifier_ref new_q(m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body), m());
m_pr = nullptr;
if (q != new_q) {
@ -600,7 +599,6 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
TRACE(reduce_quantifier_bug, tout << mk_ismt2_pp(q, m()) << " " << mk_ismt2_pp(new_body, m()) << "\n";);
if (!m_cfg.reduce_quantifier(q, new_body, new_pats.data(), new_no_pats.data(), m_r, m_pr)) {
if (fr.m_new_child) {
//non-deterministic order no change: too complex
m_r = m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body);
}
else {

2
src/ast/rewriter/seq_rewriter.cpp
View file

@ -2764,7 +2764,6 @@ br_status seq_rewriter::mk_re_reverse(expr* r, expr_ref& result) {
return BR_REWRITE2;
}
else if (m().is_ite(r, p, r1, r2)) {
//non-deterministic order no change: too complex
result = m().mk_ite(p, re().mk_reverse(r1), re().mk_reverse(r2));
return BR_REWRITE2;
}
@ -4283,7 +4282,6 @@ bool seq_rewriter::rewrite_contains_pattern(expr* a, expr* b, expr_ref& result)
suffix = re().mk_concat(suffix, re().mk_to_re(e));
suffix = re().mk_concat(suffix, full);
}
//non-deterministic order no change: too complex
fmls.push_back(m().mk_and(re().mk_in_re(x, prefix),
re().mk_in_re(y, suffix)));
}

2
src/ast/rewriter/th_rewriter.cpp
View file

@ -143,12 +143,10 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
expr * x;
unsigned val;
if (m_bv_rw.is_eq_bit(lhs, x, val)) {
//non-deterministic order no change: too complex
result = m().mk_eq(x, m().mk_ite(rhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
return BR_REWRITE2;
}
if (m_bv_rw.is_eq_bit(rhs, x, val)) {
//non-deterministic order no change: too complex
result = m().mk_eq(x, m().mk_ite(lhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
return BR_REWRITE2;
}

1
src/ast/sls/sls_array_plugin.cpp
View file

@ -414,7 +414,6 @@ namespace sls {
}
expr_ref sel1(a.mk_select(args1), m);
expr_ref sel2(a.mk_select(args2), m);
//non-deterministic order no change: too complex
bool r = ctx.add_constraint(m.mk_implies(m.mk_eq(sel1, sel2), m.mk_eq(x, y)));
if (r)
++m_stats.m_num_axioms;

1
src/ast/sls/sls_datatype_plugin.cpp
View file

@ -254,7 +254,6 @@ namespace sls {
expr_ref_vector args(m);
for (auto a : acc)
args.push_back(m.mk_app(a, t));
//non-deterministic order no change: too complex
m_axioms.push_back(m.mk_iff(m.mk_app(r, t), m.mk_eq(t, m.mk_app(c, args))));
}
}

1
src/ast/sls/sls_seq_plugin.cpp
View file

@ -161,7 +161,6 @@ namespace sls {
if (r == 0 || sx.length() == 0)
// create lemma: len(x) = 0 <=> x = ""
//non-deterministic order no change: too complex
ctx.add_constraint(m.mk_eq(m.mk_eq(e, a.mk_int(0)), m.mk_eq(x, seq.str.mk_string(""))));
if (ctx.rand(2) == 0 && update(e, rational(sx.length())))