mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-05 22:06:03 +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++) for (unsigned i = 1; i <= 64; i++)
mk_bv_sort(i); mk_bv_sort(i);
//non-deterministic order change start 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));
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->inc_ref(m_bit0); m->inc_ref(m_bit0);
m->inc_ref(m_bit1); 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; unsigned bv_size = arity;
m_mkbv.reserve(bv_size+1); m_mkbv.reserve(bv_size+1);
if (m_mkbv[bv_size] == 0) { if (m_mkbv[bv_size] == 0) {
//non-deterministic order change start 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));
{
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_manager->inc_ref(m_mkbv[bv_size]); m_manager->inc_ref(m_mkbv[bv_size]);
} }
return 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: case OP_CONCAT:
if (!get_concat_size(arity, domain, r_size)) if (!get_concat_size(arity, domain, r_size))
m_manager->raise_exception("invalid concat application"); 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), return m_manager->mk_func_decl(m_concat_sym, arity, domain, get_bv_sort(r_size),
func_decl_info(m_family_id, k)); func_decl_info(m_family_id, k));
case OP_SIGN_EXT: case OP_SIGN_EXT:
if (!get_extend_size(num_parameters, parameters, arity, domain, r_size)) if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid sign_extend application"); 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), 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)); func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_ZERO_EXT: case OP_ZERO_EXT:
if (!get_extend_size(num_parameters, parameters, arity, domain, r_size)) if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid zero_extend application"); 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), 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)); func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_EXTRACT: case OP_EXTRACT:
if (!get_extract_size(num_parameters, parameters, arity, domain, r_size)) if (!get_extract_size(num_parameters, parameters, arity, domain, r_size))
m_manager->raise_exception("invalid extract application"); 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), 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)); func_decl_info(m_family_id, k, num_parameters, parameters));
case OP_ROTATE_LEFT: 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"); m_manager->raise_exception("repeat expects one nonzero integer parameter");
if (!get_bv_size(domain[0], bv_size)) if (!get_bv_size(domain[0], bv_size))
m_manager->raise_exception("repeat expects an argument with bit-vector sort"); 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()), 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)); func_decl_info(m_family_id, k, num_parameters, parameters));
default: 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; msg << "incorrect number of arguments passed. Expected one character, received " << arity;
else { else {
arith_util a(m); arith_util a(m);
//non-deterministic order change start return m.mk_func_decl(symbol("char.to_int"), arity, domain, a.mk_int(), func_decl_info(m_family_id, k, 0, nullptr));
{
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
} }
m.raise_exception(msg.str()); m.raise_exception(msg.str());
case OP_CHAR_TO_BV: case OP_CHAR_TO_BV:
@ -86,14 +79,7 @@ func_decl* char_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
else { else {
bv_util b(m); bv_util b(m);
unsigned sz = num_bits(); unsigned sz = num_bits();
//non-deterministic order change start return m.mk_func_decl(symbol("char.to_bv"), arity, domain, b.mk_sort(sz), func_decl_info(m_family_id, k, 0, nullptr));
{
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
} }
m.raise_exception(msg.str()); m.raise_exception(msg.str());
case OP_CHAR_FROM_BV: { 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_true(), result1);
rep.apply_substitution(c, m.mk_false(), result2); rep.apply_substitution(c, m.mk_false(), result2);
th_rewriter rw(m); 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); expr_ref result(m.mk_and(m.mk_implies(result2, c), m.mk_implies(c, result1)), m);
rw(result); rw(result);
return 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, format * mk_seq1(ast_manager & m, It const & begin, It const & end, ToDoc proc, char const * header,
char const * lp = "(", char const * rp = ")") { char const * lp = "(", char const * rp = ")") {
if (begin == end) 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)); 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); unsigned indent = static_cast<unsigned>(strlen(lp) + strlen(header) + 1);
It it = begin; It it = begin;
format * first = proc(*it); format * first = proc(*it);
++it; ++it;
//non-deterministic order no change: too complex
return mk_group(m, mk_compose(m, return mk_group(m, mk_compose(m,
mk_string(m, lp), mk_string(m, lp),
mk_string(m, header), mk_string(m, header),
mk_indent(m, indent, mk_indent(m, indent,
//non-deterministic order no change: too complex
mk_compose(m, mk_compose(m,
mk_string(m, " "), mk_string(m, " "),
first, first,
@ -149,7 +146,6 @@ namespace format_ns {
unsigned indent = FORMAT_DEFAULT_INDENT, char const * lp = "(", char const * rp = ")") { unsigned indent = FORMAT_DEFAULT_INDENT, char const * lp = "(", char const * rp = ")") {
SASSERT(i >= 1); SASSERT(i >= 1);
if (begin == end) 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)); return mk_compose(m, mk_string(m, lp), mk_string(m, header), mk_string(m, rp));
unsigned idx = 0; unsigned idx = 0;
It end1 = begin; It end1 = begin;
@ -159,12 +155,9 @@ namespace format_ns {
format * first = proc(*it); format * first = proc(*it);
++it; ++it;
return mk_group(m, return mk_group(m,
//non-deterministic order no change: too complex
mk_compose(m, mk_compose(m,
//non-deterministic order no change: too complex
mk_compose(m, mk_string(m, lp), mk_string(m, header)), 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), 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_compose(m, mk_string(m, " "), first,
mk_seq(m, it, end1, proc)))), mk_seq(m, it, end1, proc)))),
mk_indent(m, indent, mk_seq(m, end1, end, 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, 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 = ")") { char const * lp = "(", char const * rp = ")") {
if (begin == end) if (begin == end)
//non-deterministic order no change: too complex
return mk_compose(m, mk_string(m, lp), mk_string(m, rp)); return mk_compose(m, mk_string(m, lp), mk_string(m, rp));
unsigned indent1 = static_cast<unsigned>(strlen(lp)); unsigned indent1 = static_cast<unsigned>(strlen(lp));
It it = begin; It it = begin;
format * first = proc(*it); format * first = proc(*it);
++it; ++it;
//non-deterministic order no change: too complex
return mk_group(m, mk_compose(m, return mk_group(m, mk_compose(m,
mk_indent(m, indent1, mk_compose(m, mk_string(m, lp), first)), 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_indent(m, indent, mk_compose(m,
mk_seq(m, it, end, proc), mk_seq(m, it, end, proc),
mk_string(m, rp))))); 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); bv_rng = m_bv_util.mk_sort(bv_sz);
func_decl * bv_f = mk_bv_uf(f, f->get_domain(), bv_rng); func_decl * bv_f = mk_bv_uf(f, f->get_domain(), bv_rng);
bv_app = m.mk_app(bv_f, num, args); bv_app = m.mk_app(bv_f, num, args);
//non-deterministic order change start 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),
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz-1, bv_sz-1, bv_app); m_bv_util.mk_extract(sbits-2, 0, 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
new_eq = m.mk_eq(fapp, flt_app); new_eq = m.mk_eq(fapp, flt_app);
m_extra_assertions.push_back(extra_quantify(new_eq)); m_extra_assertions.push_back(extra_quantify(new_eq));
result = flt_app; 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); dbg_decouple("fpa2bv_rem_y_sig_eq_rndd_sig", y_sig_eq_rndd_sig);
expr_ref adj_cnd(m); expr_ref adj_cnd(m);
//non-deterministic order change start 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)),
auto mk_and_1 = m.mk_and(rndd_exp_eq_y_exp, y_sig_le_rndd_sig); m.mk_and(rndd_exp_eq_y_exp_m1, y_sig_eq_rndd_sig, m.mk_not(huge_div_is_even)));
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
dbg_decouple("fpa2bv_rem_adj_cnd", adj_cnd); 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); 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. // Alignment shift with sticky bit computation.
expr_ref shifted_big(m), shifted_f_sig(m); expr_ref shifted_big(m), shifted_f_sig(m);
expr_ref alignment_sticky_raw(m), alignment_sticky(m); expr_ref alignment_sticky_raw(m), alignment_sticky(m);
//non-deterministic order change start shifted_big = m_bv_util.mk_bv_lshr(
{ m_bv_util.mk_concat(f_sig, m_bv_util.mk_numeral(0, sbits)),
auto mk_concat_1 = 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));
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_f_sig = m_bv_util.mk_extract(3*sbits+2, sbits, shifted_big); 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_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()); 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; res_sgn = zero1;
expr_ref real_exp(m); expr_ref real_exp(m);
//non-deterministic order change start 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));
{
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
res_exp = m_bv_util.mk_sign_extend(2, m_bv_util.mk_extract(ebits, 1, real_exp)); res_exp = m_bv_util.mk_sign_extend(2, m_bv_util.mk_extract(ebits, 1, real_exp));
expr_ref e_is_odd(m); 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)); S = m_bv_util.mk_concat(zero1, m_bv_util.mk_extract(sbits+4, 1, S));
expr_ref twoQ_plus_S(m); expr_ref twoQ_plus_S(m);
//non-deterministic order change start twoQ_plus_S = m_bv_util.mk_bv_add(m_bv_util.mk_concat(Q, zero1), m_bv_util.mk_concat(zero1, S));
{
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
T = m_bv_util.mk_bv_sub(m_bv_util.mk_concat(R, zero1), twoQ_plus_S); T = m_bv_util.mk_bv_sub(m_bv_util.mk_concat(R, zero1), twoQ_plus_S);
dbg_decouple("fpa2bv_sqrt_T", T); 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); 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), 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)); m_bv_util.mk_sign_extend(sbits-ebits, a_exp));
//non-deterministic order change start 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));
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
div = m_bv_util.mk_extract(2*sbits-1, sbits, shifted_sig); div = m_bv_util.mk_extract(2*sbits-1, sbits, shifted_sig);
rem = m_bv_util.mk_extract(sbits-1, 0, 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; (void)to_sbits;
SASSERT((unsigned)sz == to_sbits + to_ebits); SASSERT((unsigned)sz == to_sbits + to_ebits);
//non-deterministic order change start 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),
auto mk_extract_1 = m_bv_util.mk_extract(sz - 1, sz - 1, bv); m_bv_util.mk_extract(sz - to_ebits - 2, 0, 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
} }
else if (num == 2 && else if (num == 2 &&
m_util.is_rm(args[0]) && 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. // subtract lz for subnormal numbers.
expr_ref exp_sub_lz(m); expr_ref exp_sub_lz(m);
//non-deterministic order change start 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));
{
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
dbg_decouple("fpa2bv_to_float_exp_sub_lz", exp_sub_lz); dbg_decouple("fpa2bv_to_float_exp_sub_lz", exp_sub_lz);
// check whether exponent is within roundable (to_ebits+2) range. // 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); expr_ref pzero(m), nzero(m);
mk_pzero(result->get_sort(), pzero); mk_pzero(result->get_sort(), pzero);
mk_nzero(result->get_sort(), nzero); 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)))); 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 // 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); 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 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));
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
// big_sig is +- [... bv_sz+2 bits ...][1].[r][ ... sbits-1 ... ] // 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); 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); expr_ref ul(m), in_range(m);
if (!is_signed) { 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))); 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 in_range = m.mk_and(m.mk_or(m.mk_not(x_is_neg),
//non-deterministic order change start m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz+3))),
{ m.mk_not(ovfl),
auto mk_or_1 = m.mk_or(m.mk_not(x_is_neg), m_bv_util.mk_ule(pre_rounded, ul));
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
} }
else { else {
expr_ref ll(m); 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); 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)))); 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); pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded);
//non-deterministic order change start in_range = m.mk_and(m.mk_not(ovfl),
{ m_bv_util.mk_sle(ll, pre_rounded),
auto mk_not_1 = m.mk_not(ovfl); m_bv_util.mk_sle(pre_rounded, ul));
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
dbg_decouple("fpa2bv_to_bv_in_range_ll", ll); dbg_decouple("fpa2bv_to_bv_in_range_ll", ll);
} }
dbg_decouple("fpa2bv_to_bv_in_range_ovfl", ovfl); 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)); SASSERT(m_bv_util.get_bv_size(inc) == 1 && is_well_sorted(m, inc));
dbg_decouple("fpa2bv_rnd_inc", inc); dbg_decouple("fpa2bv_rnd_inc", inc);
//non-deterministic order change start sig = m_bv_util.mk_bv_add(m_bv_util.mk_zero_extend(1, sig),
{ m_bv_util.mk_zero_extend(sbits, inc));
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
SASSERT(is_well_sorted(m, sig)); SASSERT(is_well_sorted(m, sig));
dbg_decouple("fpa2bv_rnd_sig_plus_inc", 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 bv_sz = m_bv_util.get_bv_size(bv);
unsigned sbits = m_util.get_sbits(s); unsigned sbits = m_util.get_sbits(s);
SASSERT(bv_sz == m_util.get_ebits(s) + sbits); SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
//non-deterministic order change start 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),
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, bv); m_bv_util.mk_extract(sbits - 2, 0, 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
SASSERT(m_util.is_float(result)); SASSERT(m_util.is_float(result));
m_const2bv.insert(f, result); m_const2bv.insert(f, result);
m.inc_ref(f); m.inc_ref(f);
@ -4506,35 +4419,19 @@ app_ref fpa2bv_converter_wrapped::unwrap(expr* e, sort* s) {
if (m_util.is_rm(s)) { if (m_util.is_rm(s)) {
SASSERT(bv_sz == 3); SASSERT(bv_sz == 3);
//non-deterministic order change start 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(),
{
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
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(), 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(), 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.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())))); m_util.mk_round_toward_zero()))));
}
//non-deterministic order change end
} }
else { else {
SASSERT(m_util.is_float(s)); SASSERT(m_util.is_float(s));
unsigned sbits = m_util.get_sbits(s); unsigned sbits = m_util.get_sbits(s);
SASSERT(bv_sz == m_util.get_ebits(s) + sbits); SASSERT(bv_sz == m_util.get_ebits(s) + sbits);
//non-deterministic order change start 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),
auto mk_extract_1 = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, e); m_bv_util.mk_extract(sbits - 2, 0, 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
} }
return res; 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 ebits = m_conv.fu().get_ebits(s);
unsigned sbits = m_conv.fu().get_sbits(s); unsigned sbits = m_conv.fu().get_sbits(s);
new_var = m().mk_var(t->get_idx(), m_conv.bu().mk_sort(sbits+ebits)); 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), 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(ebits - 1, 0, new_var),
m_conv.bu().mk_extract(sbits+ebits-2, ebits, 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; return BR_FAILED;
if (m.proofs_enabled()) { if (m.proofs_enabled()) {
//non-deterministic order change start result_pr = m.mk_pull_quant(m.mk_app(f, num, args),
{ to_quantifier(result.get()));
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
} }
return BR_DONE; 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; return BR_FAILED;
expr_ref f2 = remove_factor(f, arg1); expr_ref f2 = remove_factor(f, arg1);
expr* z = m_util.mk_numeral(rational(0), m_util.is_int(arg1)); expr* z = m_util.mk_numeral(rational(0), m_util.is_int(arg1));
//non-deterministic order change start result = m.mk_or(m_util.mk_eq(f, z), m_util.mk_eq(f2, z));
{
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
switch (kind) { switch (kind) {
case EQ: case EQ:
break; 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); rational g = gcd(p, k, a, b);
if (g == 1) { if (g == 1) {
expr_ref nb(m_util.mk_numeral(b, true), m); expr_ref nb(m_util.mk_numeral(b, true), m);
//non-deterministic order change start result = m.mk_eq(m_util.mk_mod(u, y),
{ m_util.mk_mod(m_util.mk_mul(nb, arg2), y));
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
return true; 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) { br_status arith_rewriter::mk_idivides(unsigned k, expr * arg, expr_ref & result) {
//non-deterministic order change start result = m.mk_eq(m_util.mk_mod(arg, m_util.mk_int(k)), m_util.mk_int(0));
{
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
return BR_REWRITE2; return BR_REWRITE2;
} }
@ -1247,14 +1229,7 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
} }
if (arg1 == arg2) { if (arg1 == arg2) {
expr_ref zero(m_util.mk_int(0), m); expr_ref zero(m_util.mk_int(0), m);
//non-deterministic order change start result = m.mk_ite(m.mk_eq(arg1, zero), m_util.mk_idiv(zero, zero), m_util.mk_int(1));
{
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
return BR_REWRITE3; return BR_REWRITE3;
} }
if (is_num2 && v2.is_pos() && m_util.is_add(arg1)) { 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()); 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 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); 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), return expr_ref(m.mk_ite(m.mk_eq(zero, arg),
m_util.mk_idiv(zero, zero), m_util.mk_idiv(zero, zero),
m.mk_ite(m_util.mk_ge(arg, 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; 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)) { 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 result = m_util.mk_mul(m_util.mk_int(v1), m_util.mk_mod(y, m_util.mk_int(v2/v1)));
{
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
return BR_REWRITE1; 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)) { 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(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 // 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)); 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; return neg ? m_util.mk_uminus(result) : result;
} }
if (k_prime == rational(5, 12) || k_prime == rational(7, 12)) { 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(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 // 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)); 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; 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: end:
if (m_expand_tan) { if (m_expand_tan) {
//non-deterministic order change start result = m_util.mk_div(m_util.mk_sin(arg), m_util.mk_cos(arg));
{
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
return BR_REWRITE2; return BR_REWRITE2;
} }
return BR_FAILED; 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 A = rational::power_of_two(sz - n);
auto B = rational::power_of_two(n); auto B = rational::power_of_two(n);
auto hi = mul(r, a.mk_int(A)); 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); auto lo = amod(e, a.mk_idiv(umod(e, 0), a.mk_int(B)), A);
r = add(hi, lo); r = add(hi, lo);
} }
@ -365,13 +364,7 @@ void bv2int_translator::translate_bv(app* e) {
rational N = bv_size(e); rational N = bv_size(e);
expr* x = umod(e, 0), * y = umod(e, 1); expr* x = umod(e, 0), * y = umod(e, 1);
expr* signx = a.mk_ge(x, a.mk_int(N / 2)); expr* signx = a.mk_ge(x, a.mk_int(N / 2));
//non-deterministic order change start r = m.mk_ite(signx, a.mk_int(-1), a.mk_int(0));
{
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
IF_VERBOSE(4, verbose_stream() << "ashr " << mk_bounded_pp(e, m) << " " << bv.get_bv_size(e) << "\n"); IF_VERBOSE(4, verbose_stream() << "ashr " << mk_bounded_pp(e, m) << " " << bv.get_bv_size(e) << "\n");
for (unsigned i = 0; i < sz; ++i) { for (unsigned i = 0; i < sz; ++i) {
expr* d = a.mk_idiv(x, a.mk_int(rational::power_of_two(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; break;
case OP_BCOMP: case OP_BCOMP:
bv_expr = e->get_arg(0); bv_expr = e->get_arg(0);
//non-deterministic order no change: too complex r = m.mk_ite(m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)), a.mk_int(1), a.mk_int(0));
//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
break; break;
case OP_BSMOD_I: case OP_BSMOD_I:
case OP_BSMOD: { case OP_BSMOD: {
@ -464,7 +449,6 @@ void bv2int_translator::translate_bv(app* e) {
r = a.mk_uminus(u); 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(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); 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 = 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(u, 0, a.mk_int(0), r);
r = if_eq(y, 0, x, 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); y = m.mk_ite(signy, a.mk_sub(a.mk_int(N), y), y);
expr* d = a.mk_idiv(x, y); expr* d = a.mk_idiv(x, y);
r = m.mk_ite(m.mk_iff(signx, signy), d, a.mk_uminus(d)); 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); r = if_eq(y, 0, m.mk_ite(signx, a.mk_int(1), a.mk_int(-1)), r);
break; break;
} }
@ -583,27 +566,17 @@ void bv2int_translator::translate_basic(app* e) {
rational N = rational::power_of_two(bv.get_bv_size(bv_expr)); rational N = rational::power_of_two(bv.get_bv_size(bv_expr));
if (a.is_numeral(arg(0)) || a.is_numeral(arg(1)) || if (a.is_numeral(arg(0)) || a.is_numeral(arg(1)) ||
is_bounded(arg(0), N) || is_bounded(arg(1), N)) { 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))); set_translated(e, m.mk_eq(umod(bv_expr, 0), umod(bv_expr, 1)));
} }
else { else {
//non-deterministic order change start m_args[0] = a.mk_sub(arg(0), arg(1));
{
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
set_translated(e, m.mk_eq(umod(bv_expr, 0), a.mk_int(0))); set_translated(e, m.mk_eq(umod(bv_expr, 0), a.mk_int(0)));
} }
} }
else else
//non-deterministic order no change: too complex
set_translated(e, m.mk_eq(arg(0), arg(1))); set_translated(e, m.mk_eq(arg(0), arg(1)));
} }
else if (m.is_ite(e)) 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))); set_translated(e, m.mk_ite(arg(0), arg(1), arg(2)));
else if (m_is_plugin) else if (m_is_plugin)
set_translated(e, e); set_translated(e, e);
@ -688,13 +661,7 @@ expr* bv2int_translator::amod(expr* bv_expr, expr* x, rational const& N) {
rational v; rational v;
expr* r = nullptr, * c = nullptr, * t = nullptr, * e = nullptr; expr* r = nullptr, * c = nullptr, * t = nullptr, * e = nullptr;
if (m.is_ite(x, c, t, e)) if (m.is_ite(x, c, t, e))
//non-deterministic order change start r = m.mk_ite(c, amod(bv_expr, t, N), amod(bv_expr, e, N));
{
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
else if (a.is_idiv(x, t, e) && a.is_numeral(t, v) && 0 <= v && v < N && is_non_negative(bv_expr, e)) 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; r = x;
else if (a.is_mod(x, t, e) && a.is_numeral(t, v) && 0 <= v && v < N) 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); ensure_translated(y);
m_args.reset(); m_args.reset();
m_args.push_back(a.mk_sub(translated(x), translated(y))); 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))); set_translated(e, m.mk_eq(umod(x, 0), a.mk_int(0)));
} }
m_preds.push_back(e); 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 { else {
SASSERT(lower.is_pos()); SASSERT(lower.is_pos());
//non-deterministic order change start result = m.mk_and(m_util.mk_ule(mk_numeral(lower, sz), common),
{ m_util.mk_ule(common, mk_numeral(upper, sz)));
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
} }
return BR_REWRITE2; 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; return BR_DONE;
} }
if (common > 0) { if (common > 0) {
//non-deterministic order change start result = m_util.mk_ule(concat(numa - common, a->get_args() + common),
{ concat(numb - common, b->get_args() + common));
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
return BR_REWRITE2; 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; return BR_DONE;
} }
if (new_numa != numa) { 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())) 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())); : m_util.mk_ule(concat(new_numa, a->get_args()), concat(new_numb, b->get_args()));
return BR_REWRITE2; 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; expr* c = nullptr, *t = nullptr, *e = nullptr;
if (m.is_ite(arg, c, t, e) && 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))) { (t->get_ref_count() == 1 || e->get_ref_count() == 1 || !m.is_ite(t) || !m.is_ite(e))) {
//non-deterministic order change start result = m.mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e));
{
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
return BR_REWRITE2; 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)) // (bvlshr x k) -> (concat bv0:k (extract [n-1:k] x))
unsigned k = r2.get_unsigned(); unsigned k = r2.get_unsigned();
//non-deterministic order change start result = m_util.mk_concat(mk_zero(k), m_mk_extract(bv_size - 1, k, arg1));
{
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
return BR_REWRITE2; return BR_REWRITE2;
} }
#if 0 #if 0
@ -1146,16 +1120,9 @@ br_status bv_rewriter::mk_bv_sdiv_core(expr * arg1, expr * arg2, bool hi_div0, e
} }
else { else {
// The "hardware interpretation" for (bvsdiv x 0) is (ite (bvslt x #x0000) #x0001 #xffff) // The "hardware interpretation" for (bvsdiv x 0) is (ite (bvslt x #x0000) #x0001 #xffff)
//non-deterministic order change start result = m.mk_ite(m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size)),
{ mk_one(bv_size),
auto mk_app_1 = m.mk_app(get_fid(), OP_SLT, arg1, mk_zero(bv_size)); mk_numeral(rational::power_of_two(bv_size) - numeral(1), 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
return BR_REWRITE2; 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); bv_size = get_bv_size(arg2);
//non-deterministic order change start result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
{ m.mk_app(get_fid(), OP_BSREM0, arg1),
auto mk_eq_1 = m.mk_eq(arg2, mk_zero(bv_size)); m.mk_app(get_fid(), OP_BSREM_I, arg1, arg2));
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
return BR_REWRITE2; 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); bv_size = get_bv_size(arg2);
//non-deterministic order change start result = m.mk_ite(m.mk_eq(arg2, mk_zero(bv_size)),
{ m.mk_app(get_fid(), OP_BSMOD0, arg1),
auto mk_eq_1 = m.mk_eq(arg2, mk_zero(bv_size)); m.mk_app(get_fid(), OP_BSMOD_I, arg1, arg2));
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
return BR_REWRITE2; 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; ptr_buffer<expr> args1, args2;
for (unsigned i = 0; i < new_args.size(); ++i) for (unsigned i = 0; i < new_args.size(); ++i)
args1.push_back(y), args2.push_back(z); args1.push_back(y), args2.push_back(z);
//non-deterministic order change start result = m.mk_ite(x, m_util.mk_concat(args1), m_util.mk_concat(args2));
{
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
return BR_REWRITE2; return BR_REWRITE2;
} }
} }
@ -2389,16 +2336,9 @@ br_status bv_rewriter::mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result) {
return BR_DONE; return BR_DONE;
} }
//non-deterministic order change start result = m.mk_ite(m.mk_eq(arg1, arg2),
{ mk_one(1),
auto mk_eq_1 = m.mk_eq(arg1, arg2); mk_zero(1));
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
return BR_REWRITE2; 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; ptr_buffer<expr> new_args;
for (unsigned i = 0; i < sz; i++) { for (unsigned i = 0; i < sz; i++) {
bool bit0 = (v % two).is_zero(); 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), new_args.push_back(m.mk_eq(m_mk_extract(i,i, lhs),
mk_numeral(bit0 ? 0 : 1, 1))); mk_numeral(bit0 ? 0 : 1, 1)));
div(v, two, v); 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 rsz1 = sz1 - low1;
unsigned rsz2 = sz2 - low2; unsigned rsz2 = sz2 - low2;
if (rsz1 == rsz2) { if (rsz1 == rsz2) {
//non-deterministic order no change: too complex
new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1), new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2))); m_mk_extract(sz2 - 1, low2, arg2)));
low1 = 0; low1 = 0;
@ -2734,7 +2672,6 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
continue; continue;
} }
else if (rsz1 < rsz2) { 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), new_eqs.push_back(m.mk_eq(m_mk_extract(sz1 - 1, low1, arg1),
m_mk_extract(rsz1 + low2 - 1, low2, arg2))); m_mk_extract(rsz1 + low2 - 1, low2, arg2)));
low1 = 0; low1 = 0;
@ -2742,7 +2679,6 @@ br_status bv_rewriter::mk_eq_concat(expr * lhs, expr * rhs, expr_ref & result) {
--i1; --i1;
} }
else { else {
//non-deterministic order no change: too complex
new_eqs.push_back(m.mk_eq(m_mk_extract(rsz2 + low1 - 1, low1, arg1), new_eqs.push_back(m.mk_eq(m_mk_extract(rsz2 + low1 - 1, low1, arg1),
m_mk_extract(sz2 - 1, low2, arg2))); m_mk_extract(sz2 - 1, low2, arg2)));
low1 += rsz2; 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) { br_status bv_rewriter::mk_bvsmul_overflow(unsigned num, expr * const * args, expr_ref & result) {
SASSERT(num == 2); SASSERT(num == 2);
//non-deterministic order change start result = m.mk_or(
{ m.mk_not(m_util.mk_bvsmul_no_ovfl(args[0], args[1])),
auto mk_not_1 = 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]))
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
); );
}
//non-deterministic order change end
return BR_REWRITE_FULL; 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 sz = get_bv_size(args[1]);
auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz); auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz);
auto minusOne = 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 result = m.mk_and(m.mk_eq(args[0], minSigned), m.mk_eq(args[1], minusOne));
{
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
return BR_REWRITE_FULL; 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)) { if (is_unate(s)) {
expr_ref one(m_bv.mk_numeral(rational::one(), 1), m); expr_ref one(m_bv.mk_numeral(rational::one(), 1), m);
for (unsigned i = 0; i + 2 < domain_size; ++i) { 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)), 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)))); 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; pos0 = pos;
} }
else { else {
//non-deterministic order no change: too complex
tmp = m().mk_or(m().mk_and(pos, pos0), m().mk_and(neg, neg0)); 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)); neg0 = m().mk_or(m().mk_and(neg, pos0), m().mk_and(pos, neg0));
pos0 = tmp; 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)) { if (m_util.is_ninf(arg1)) {
// -oo < arg2 --> not(arg2 = -oo) and not(arg2 = NaN) // -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)); result = m().mk_and(m().mk_not(m().mk_eq(arg2, arg1)), mk_neq_nan(arg2));
return BR_REWRITE3; 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)) { if (m_util.is_pinf(arg2)) {
// arg1 < +oo --> not(arg1 = +oo) and not(arg1 = NaN) // 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)); result = m().mk_and(m().mk_not(m().mk_eq(arg1, arg2)), mk_neq_nan(arg1));
return BR_REWRITE3; 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* poly_rewriter<Config>::apply_hoist(expr* a, numeral const& g, obj_hashtable<expr> const& shared) {
expr* c = nullptr, *t = nullptr, *e = nullptr; expr* c = nullptr, *t = nullptr, *e = nullptr;
if (M().is_ite(a, c, t, e)) { 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)); return M().mk_ite(c, apply_hoist(t, g, shared), apply_hoist(e, g, shared));
} }
rational k; 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); pull_quantifier(t1, qt, vars, tt1, use_fresh, rewrite_ok);
nt1 = m.mk_not(t1); nt1 = m.mk_not(t1);
pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok); pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
//non-deterministic order change start result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(tt1, tt3));
{
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
} }
else { else {
result = m.mk_ite(t1, tt2, tt3); result = m.mk_ite(t1, tt2, tt3);
@ -269,13 +263,7 @@ private:
nt2 = m.mk_not(t2); nt2 = m.mk_not(t2);
pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok); pull_quantifier(nt1, qt, vars, ntt1, use_fresh, rewrite_ok);
pull_quantifier(nt2, qt, vars, ntt2, use_fresh, rewrite_ok); pull_quantifier(nt2, qt, vars, ntt2, use_fresh, rewrite_ok);
//non-deterministic order change start result = m.mk_and(m.mk_or(ntt1, tt2), m.mk_or(ntt2, tt1));
{
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
} }
else { else {
// the formula contains a quantifier, but it is "inaccessible" // 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; num_no_pats = j;
} }
if (ProofGen) { 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()); 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; m_pr = nullptr;
if (q != new_q) { 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";); 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 (!m_cfg.reduce_quantifier(q, new_body, new_pats.data(), new_no_pats.data(), m_r, m_pr)) {
if (fr.m_new_child) { 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); m_r = m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body);
} }
else { 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; return BR_REWRITE2;
} }
else if (m().is_ite(r, p, r1, r2)) { 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)); result = m().mk_ite(p, re().mk_reverse(r1), re().mk_reverse(r2));
return BR_REWRITE2; 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, re().mk_to_re(e));
suffix = re().mk_concat(suffix, full); 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), fmls.push_back(m().mk_and(re().mk_in_re(x, prefix),
re().mk_in_re(y, suffix))); 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; expr * x;
unsigned val; unsigned val;
if (m_bv_rw.is_eq_bit(lhs, x, 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))); 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; return BR_REWRITE2;
} }
if (m_bv_rw.is_eq_bit(rhs, x, val)) { 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))); 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; 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 sel1(a.mk_select(args1), m);
expr_ref sel2(a.mk_select(args2), 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))); bool r = ctx.add_constraint(m.mk_implies(m.mk_eq(sel1, sel2), m.mk_eq(x, y)));
if (r) if (r)
++m_stats.m_num_axioms; ++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); expr_ref_vector args(m);
for (auto a : acc) for (auto a : acc)
args.push_back(m.mk_app(a, t)); 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)))); 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) if (r == 0 || sx.length() == 0)
// create lemma: len(x) = 0 <=> x = "" // 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("")))); 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()))) if (ctx.rand(2) == 0 && update(e, rational(sx.length())))

4
src/model/model_smt2_pp.cpp
View file

@ -123,7 +123,6 @@ static void pp_uninterp_sorts(std::ostream & out, ast_printer_context & ctx, mod
f_cond = f_conds[0]; f_cond = f_conds[0];
format_ref f_s(fm(m)); format_ref f_s(fm(m));
ctx.pp(s, f_s); ctx.pp(s, f_s);
//non-deterministic order no change: too complex
format * f_args[2] = { mk_compose(m, format * f_args[2] = { mk_compose(m,
mk_string(m, "((x "), mk_string(m, "((x "),
mk_indent(m, 4, mk_compose(m, f_s.get(), mk_string(m, "))")))), mk_indent(m, 4, mk_compose(m, f_s.get(), mk_string(m, "))")))),
@ -253,7 +252,6 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co
ctx.pp(e->get_result(), f_result); ctx.pp(e->get_result(), f_result);
if (i > 0) if (i > 0)
f_entries.push_back(mk_line_break(m)); f_entries.push_back(mk_line_break(m));
//non-deterministic order no change: too complex
f_entries.push_back(mk_group(m, mk_compose(m, f_entries.push_back(mk_group(m, mk_compose(m,
mk_string(m, "(ite "), mk_string(m, "(ite "),
mk_indent(m, 5, f_entry_cond), mk_indent(m, 5, f_entry_cond),
@ -274,9 +272,7 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co
fname = mk_smt2_quoted_symbol(f->get_name()); fname = mk_smt2_quoted_symbol(f->get_name());
else else
fname = f->get_name().str(); fname = f->get_name().str();
//non-deterministic order no change: too complex
def = mk_indent(m, indent, mk_compose(m, def = mk_indent(m, indent, mk_compose(m,
//non-deterministic order no change: too complex
mk_compose(m, mk_compose(m,
mk_string(m, "(define-fun "), mk_string(m, "(define-fun "),
mk_string(m, fname), mk_string(m, fname),

1
src/muz/rel/check_relation.cpp
View file

@ -533,7 +533,6 @@ namespace datalog {
unsigned c1 = m_cols[0]; unsigned c1 = m_cols[0];
for (unsigned i = 1; i < m_cols.size(); ++i) { for (unsigned i = 1; i < m_cols.size(); ++i) {
unsigned c2 = m_cols[i]; unsigned c2 = m_cols[i];
//non-deterministic order no change: too complex
conds.push_back(m.mk_eq(m.mk_var(c1, sig[c1]), m.mk_var(c2, sig[c2]))); conds.push_back(m.mk_eq(m.mk_var(c1, sig[c1]), m.mk_var(c2, sig[c2])));
} }
cond = mk_and(m, conds.size(), conds.data()); cond = mk_and(m, conds.size(), conds.data());

1
src/muz/rel/dl_base.cpp
View file

@ -454,7 +454,6 @@ namespace datalog {
r.get_fact(fact); r.get_fact(fact);
conjs.reset(); conjs.reset();
for (unsigned i = 0; i < fact.size(); ++i) { for (unsigned i = 0; i < fact.size(); ++i) {
//non-deterministic order no change: too complex
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i]))); conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
} }
brw.mk_and(conjs.size(), conjs.data(), fml); brw.mk_and(conjs.size(), conjs.data(), fml);

3
src/muz/rel/dl_bound_relation.cpp
View file

@ -658,19 +658,16 @@ namespace datalog {
relation_signature const& sig = get_signature(); relation_signature const& sig = get_signature();
for (unsigned i = 0; i < sig.size(); ++i) { for (unsigned i = 0; i < sig.size(); ++i) {
if (i != find(i)) { if (i != find(i)) {
//non-deterministic order no change: too complex
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), m.mk_var(find(i), sig[find(i)]))); conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), m.mk_var(find(i), sig[find(i)])));
continue; continue;
} }
uint_set2 const& upper = (*this)[i]; uint_set2 const& upper = (*this)[i];
uint_set::iterator it = upper.lt.begin(), end = upper.lt.end(); uint_set::iterator it = upper.lt.begin(), end = upper.lt.end();
for (; it != end; ++it) { for (; it != end; ++it) {
//non-deterministic order no change: too complex
conjs.push_back(arith.mk_lt(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it]))); conjs.push_back(arith.mk_lt(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it])));
} }
it = upper.le.begin(), end = upper.le.end(); it = upper.le.begin(), end = upper.le.end();
for (; it != end; ++it) { for (; it != end; ++it) {
//non-deterministic order no change: too complex
conjs.push_back(arith.mk_le(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it]))); conjs.push_back(arith.mk_le(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it])));
} }
} }

1
src/muz/rel/dl_finite_product_relation.cpp
View file

@ -2363,7 +2363,6 @@ namespace datalog {
unsigned rel_idx = static_cast<unsigned>(fact[fact_sz-1]); unsigned rel_idx = static_cast<unsigned>(fact[fact_sz-1]);
m_others[rel_idx]->to_formula(tmp); m_others[rel_idx]->to_formula(tmp);
for (unsigned i = 0; i + 1 < fact_sz; ++i) { for (unsigned i = 0; i + 1 < fact_sz; ++i) {
//non-deterministic order no change: too complex
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i]))); conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
} }
sh(tmp, fact_sz-1, tmp); sh(tmp, fact_sz-1, tmp);

1
src/muz/rel/dl_interval_relation.cpp
View file

@ -375,7 +375,6 @@ namespace datalog {
relation_signature const& sig = get_signature(); relation_signature const& sig = get_signature();
for (unsigned i = 0; i < sig.size(); ++i) { for (unsigned i = 0; i < sig.size(); ++i) {
if (i != find(i)) { if (i != find(i)) {
//non-deterministic order no change: too complex
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]),
m.mk_var(find(i), sig[find(i)]))); m.mk_var(find(i), sig[find(i)])));
continue; continue;

8
src/muz/spacer/spacer_convex_closure.cpp
View file

@ -378,13 +378,7 @@ void convex_closure::cc_1dim(const expr_ref &var, expr_ref_vector &out) {
expr *convex_closure::mk_eq_mod(expr *v, rational d, rational r) { expr *convex_closure::mk_eq_mod(expr *v, rational d, rational r) {
expr *res = nullptr; expr *res = nullptr;
if (m_arith.is_int(v)) { if (m_arith.is_int(v)) {
//non-deterministic order change start res = m.mk_eq(m_arith.mk_mod(v, m_arith.mk_int(d)), m_arith.mk_int(r));
{
auto mk_mod_1 = m_arith.mk_mod(v, m_arith.mk_int(d));
auto mk_int_2 = m_arith.mk_int(r);
res = m.mk_eq(mk_mod_1, mk_int_2);
}
//non-deterministic order change end
} else if (m_bv.is_bv(v)) { } else if (m_bv.is_bv(v)) {
res = m.mk_eq(m_bv.mk_bv_urem(v, m_bv.mk_numeral(d, m_bv_sz)), res = m.mk_eq(m_bv.mk_bv_urem(v, m_bv.mk_numeral(d, m_bv_sz)),
m_bv.mk_numeral(r, m_bv_sz)); m_bv.mk_numeral(r, m_bv_sz));

1
src/muz/spacer/spacer_generalizers.cpp
View file

@ -251,7 +251,6 @@ void lemma_array_eq_generalizer::operator() (lemma_ref &lemma)
expr_ref_vector eqs(m); expr_ref_vector eqs(m);
for (unsigned i = 0, sz = vsymbs.size(); i < sz; ++i) { for (unsigned i = 0, sz = vsymbs.size(); i < sz; ++i) {
for (unsigned j = i + 1; j < sz; ++j) { for (unsigned j = i + 1; j < sz; ++j) {
//non-deterministic order no change: too complex
eqs.push_back(m.mk_eq(m.mk_const(vsymbs.get(i)), eqs.push_back(m.mk_eq(m.mk_const(vsymbs.get(i)),
m.mk_const(vsymbs.get(j)))); m.mk_const(vsymbs.get(j))));
} }

17
src/muz/spacer/spacer_qe_project.cpp
View file

@ -559,7 +559,6 @@ class arith_project_util {
tout << "lcm of divs: " << lcm_divs << "\n";); tout << "lcm of divs: " << lcm_divs << "\n";);
} }
//non-deterministic order no change: too complex
expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m); expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
expr_ref x_term_val(m); expr_ref x_term_val(m);
@ -627,14 +626,8 @@ class arith_project_util {
// (lcm_coeffs * var_val) % lcm_divs instead // (lcm_coeffs * var_val) % lcm_divs instead
rational var_val_num; rational var_val_num;
VERIFY(a.is_numeral(var_val, var_val_num)); VERIFY(a.is_numeral(var_val, var_val_num));
//non-deterministic order change start x_term_val = a.mk_numeral(
{ mod(lcm_coeffs * var_val_num, lcm_divs), a.mk_int());
auto mod_1 = mod(lcm_coeffs * var_val_num, lcm_divs);
auto mk_int_2 = a.mk_int();
x_term_val = a.mk_numeral(
mod_1, mk_int_2);
}
//non-deterministic order change end
TRACE(qe, tout << "Substitution for (lcm_coeffs * x): " TRACE(qe, tout << "Substitution for (lcm_coeffs * x): "
<< mk_pp(x_term_val, m) << "\n";); << mk_pp(x_term_val, m) << "\n";);
} }
@ -655,7 +648,6 @@ class arith_project_util {
// syntactic structure // syntactic structure
m_rw(new_lit); m_rw(new_lit);
new_lit = m.mk_eq( new_lit = m.mk_eq(
//non-deterministic order no change: too complex
a.mk_mod(new_lit, a.mk_numeral(m_divs[i], a.mk_int())), a.mk_mod(new_lit, a.mk_numeral(m_divs[i], a.mk_int())),
z); z);
} else if (m_eq[i] || (num_pos == 0 && m_coeffs[i].is_pos()) || } else if (m_eq[i] || (num_pos == 0 && m_coeffs[i].is_pos()) ||
@ -746,7 +738,6 @@ class arith_project_util {
mk_add(m_terms.get(max_t), a.mk_numeral(offset, a.mk_int())); mk_add(m_terms.get(max_t), a.mk_numeral(offset, a.mk_int()));
if (m_strict[max_t]) { if (m_strict[max_t]) {
x_term_val = a.mk_add( x_term_val = a.mk_add(
//non-deterministic order no change: too complex
x_term_val, a.mk_numeral(rational::one(), a.mk_int())); x_term_val, a.mk_numeral(rational::one(), a.mk_int()));
} }
if (m_coeffs[max_t].is_pos()) { if (m_coeffs[max_t].is_pos()) {
@ -985,7 +976,6 @@ class arith_project_util {
return; return;
} }
//non-deterministic order no change: too complex
expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m); expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
bool is_mod_eq = false; bool is_mod_eq = false;
@ -1031,7 +1021,6 @@ class arith_project_util {
lits.push_back(a.mk_le(z, t2)); lits.push_back(a.mk_le(z, t2));
// t2 < abs (num_val) // t2 < abs (num_val)
lits.push_back( lits.push_back(
//non-deterministic order no change: too complex
a.mk_lt(t2, a.mk_numeral(abs(num_val), a.mk_int()))); a.mk_lt(t2, a.mk_numeral(abs(num_val), a.mk_int())));
new_fml = m.mk_and(lits.size(), lits.data()); new_fml = m.mk_and(lits.size(), lits.data());
@ -1084,7 +1073,6 @@ class arith_project_util {
*/ */
void mk_lit_substitutes(expr_ref const &x_term_val, expr_map &map, void mk_lit_substitutes(expr_ref const &x_term_val, expr_map &map,
unsigned idx) { unsigned idx) {
//non-deterministic order no change: too complex
expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m); expr_ref z(a.mk_numeral(rational::zero(), a.mk_int()), m);
expr_ref cxt(m), new_lit(m); expr_ref cxt(m), new_lit(m);
for (unsigned i = 0; i < m_lits.size(); ++i) { for (unsigned i = 0; i < m_lits.size(); ++i) {
@ -1113,7 +1101,6 @@ class arith_project_util {
// top-level operator // top-level operator
m_rw(cxt); m_rw(cxt);
new_lit = m.mk_eq( new_lit = m.mk_eq(
//non-deterministic order no change: too complex
a.mk_mod(cxt, a.mk_numeral(m_divs[i], a.mk_int())), z); a.mk_mod(cxt, a.mk_numeral(m_divs[i], a.mk_int())), z);
} }
} }

10
src/muz/spacer/spacer_util.cpp
View file

@ -359,14 +359,8 @@ void expand_literals(ast_manager &m, expr_ref_vector &conjs) {
rational two(2); rational two(2);
for (unsigned j = 0; j < bv_size; ++j) { for (unsigned j = 0; j < bv_size; ++j) {
parameter p(j); parameter p(j);
//non-deterministic order change start expr *e = m.mk_eq(m.mk_app(bv.get_family_id(), OP_BIT1),
{ bv.mk_extract(j, j, c));
auto mk_app_1 = m.mk_app(bv.get_family_id(), OP_BIT1);
auto mk_extract_2 = bv.mk_extract(j, j, c);
expr *e = m.mk_eq(mk_app_1,
mk_extract_2);
}
//non-deterministic order change end
if ((r % two).is_zero()) { e = m.mk_not(e); } if ((r % two).is_zero()) { e = m.mk_not(e); }
r = div(r, two); r = div(r, two);
if (j == 0) if (j == 0)

1
src/muz/transforms/dl_mk_array_blast.cpp
View file

@ -227,7 +227,6 @@ namespace datalog {
for (unsigned j = 0; j < args1.size(); ++j) { for (unsigned j = 0; j < args1.size(); ++j) {
eqs.push_back(m.mk_eq(args1[j], args2[j])); eqs.push_back(m.mk_eq(args1[j], args2[j]));
} }
//non-deterministic order no change: too complex
conjs.push_back(m.mk_implies(m.mk_and(eqs.size(), eqs.data()), m.mk_eq(v1, v2))); conjs.push_back(m.mk_implies(m.mk_and(eqs.size(), eqs.data()), m.mk_eq(v1, v2)));
} }
} }

1
src/muz/transforms/dl_mk_scale.cpp
View file

@ -55,7 +55,6 @@ namespace datalog {
for (unsigned i = 0; i < old_p->get_arity(); ++i) { for (unsigned i = 0; i < old_p->get_arity(); ++i) {
subst.push_back(m.mk_var(i, old_p->get_domain(i))); subst.push_back(m.mk_var(i, old_p->get_domain(i)));
} }
//non-deterministic order no change: too complex
subst.push_back(a.mk_numeral(rational(1), a.mk_real())); subst.push_back(a.mk_numeral(rational(1), a.mk_real()));
SASSERT(!new_fi->is_partial() && new_fi->num_entries() == 0); SASSERT(!new_fi->is_partial() && new_fi->num_entries() == 0);

1
src/opt/opt_context.cpp
View file

@ -1066,7 +1066,6 @@ namespace opt {
expr_ref_vector soft(m); expr_ref_vector soft(m);
for (unsigned k = 1; k <= min_cardinality; ++k) { for (unsigned k = 1; k <= min_cardinality; ++k) {
auto p_k = m.mk_fresh_const("p", m.mk_bool_sort()); auto p_k = m.mk_fresh_const("p", m.mk_bool_sort());
//non-deterministic order no change: too complex
soft.push_back(m.mk_ite(p_k, a.mk_int(1), a.mk_int(0))); soft.push_back(m.mk_ite(p_k, a.mk_int(1), a.mk_int(0)));
for (auto c : cardinalities) for (auto c : cardinalities)
// p_k => c >= k // p_k => c >= k

8
src/qe/mbp/mbp_arith.cpp
View file

@ -577,13 +577,7 @@ namespace mbp {
case opt::t_le: t = a.mk_le(t, s); break; case opt::t_le: t = a.mk_le(t, s); break;
case opt::t_eq: t = a.mk_eq(t, s); break; case opt::t_eq: t = a.mk_eq(t, s); break;
case opt::t_divides: case opt::t_divides:
//non-deterministic order change start t = a.mk_eq(a.mk_mod(t, a.mk_int(r.m_mod)), a.mk_int(0));
{
auto mk_mod_1 = a.mk_mod(t, a.mk_int(r.m_mod));
auto mk_int_2 = a.mk_int(0);
t = a.mk_eq(mk_mod_1, mk_int_2);
}
//non-deterministic order change end
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();

10
src/qe/mbp/mbp_arrays.cpp
View file

@ -866,14 +866,8 @@ namespace mbp {
SASSERT(xs.size() == ys.size() && !xs.empty()); SASSERT(xs.size() == ys.size() && !xs.empty());
expr_ref result(mk_lt(xs.back(), ys.back()), m); expr_ref result(mk_lt(xs.back(), ys.back()), m);
for (unsigned i = xs.size()-1; i-- > 0; ) { for (unsigned i = xs.size()-1; i-- > 0; ) {
//non-deterministic order change start result = m.mk_or(mk_lt(xs[i], ys[i]),
{ m.mk_and(m.mk_eq(xs[i], ys[i]), result));
auto mk_lt_1 = mk_lt(xs[i], ys[i]);
auto mk_and_2 = m.mk_and(m.mk_eq(xs[i], ys[i]), result);
result = m.mk_or(mk_lt_1,
mk_and_2);
}
//non-deterministic order change end
} }
return result; return result;
} }

8
src/qe/mbp/mbp_solve_plugin.cpp
View file

@ -287,14 +287,8 @@ namespace mbp {
}; };
// `first` is a value, different from 0 // `first` is a value, different from 0
//non-deterministic order change start res = m.mk_and(m.mk_eq(second, a.mk_idiv(lhs, first)),
{
auto mk_eq_1 = m.mk_eq(second, a.mk_idiv(lhs, first));
res = m.mk_and(mk_eq_1,
//non-deterministic order no change: too complex
m.mk_eq(a.mk_int(0), a.mk_mod(lhs, first))); m.mk_eq(a.mk_int(0), a.mk_mod(lhs, first)));
}
//non-deterministic order change end
return true; return true;
} }

76
src/qe/nlarith_util.cpp
View file

@ -389,7 +389,6 @@ namespace nlarith {
}; };
expr* mk_abs(expr* e) { expr* mk_abs(expr* e) {
//non-deterministic order no change: too complex
return m().mk_ite(mk_lt(e), mk_uminus(e), e); return m().mk_ite(mk_lt(e), mk_uminus(e), e);
} }
@ -406,7 +405,6 @@ namespace nlarith {
} }
else { else {
expr* half = A.mk_numeral(rational(1,2), false); expr* half = A.mk_numeral(rational(1,2), false);
//non-deterministic order no change: too complex
result = A.mk_div(mk_add(s.m_a, mk_mul(num(s.m_b), A.mk_power(mk_abs(s.m_c), half))), s.m_d); result = A.mk_div(mk_add(s.m_a, mk_mul(num(s.m_b), A.mk_power(mk_abs(s.m_c), half))), s.m_d);
} }
return result; return result;
@ -441,13 +439,10 @@ namespace nlarith {
expr* result = to_expr(s); expr* result = to_expr(s);
if (is_strict(cmp)) { if (is_strict(cmp)) {
if (p.m_a == z()) { if (p.m_a == z()) {
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
result = mk_add(result, mk_mul(mk_epsilon(), m().mk_ite(mk_lt(p.m_b),num(1),num(-1)))); result = mk_add(result, mk_mul(mk_epsilon(), m().mk_ite(mk_lt(p.m_b),num(1),num(-1))));
} }
else { else {
if (s.m_b > 0) { if (s.m_b > 0) {
//non-deterministic order no change: too complex
result = mk_add(result, mk_mul(num(-1),mk_epsilon())); result = mk_add(result, mk_mul(num(-1),mk_epsilon()));
} }
else { else {
@ -486,7 +481,6 @@ namespace nlarith {
} }
app* sq1(expr * e) { app* sq1(expr * e) {
//non-deterministic order no change: too complex
return mk_add(num(1), sq(e)); return mk_add(num(1), sq(e));
} }
@ -597,13 +591,7 @@ namespace nlarith {
app_ref t1(m()), a2(m()), d(m()); app_ref t1(m()), a2(m()), d(m());
expr_ref cond(m()), t2(m()), branch(m()); expr_ref cond(m()), t2(m()), branch(m());
expr_ref_vector es(m()), subst(m()); expr_ref_vector es(m()), subst(m());
//non-deterministic order change start d = mk_sub(mk_mul(b,b), mk_mul(num(4), a, c));
{
auto mk_mul_1 = mk_mul(b,b);
auto mk_mul_2 = mk_mul(num(4), a, c);
d = mk_sub(mk_mul_1, mk_mul_2);
}
//non-deterministic order change end
a2 = mk_mul(a, num(2)); a2 = mk_mul(a, num(2));
TRACE(nlarith, TRACE(nlarith,
@ -1066,23 +1054,9 @@ namespace nlarith {
r = I.mk_lt(ad); r = I.mk_lt(ad);
} }
else { else {
//non-deterministic order change start aabbc = I.mk_sub(I.mk_mul(a,a), I.mk_mul(b,b,c));
{ r = I.mk_or(I.mk_and(I.mk_lt(ad), I.mk_gt(aabbc)),
auto mk_mul_1 = I.mk_mul(a,a);
auto mk_mul_2 = I.mk_mul(b,b,c);
aabbc = I.mk_sub(mk_mul_1, mk_mul_2);
}
//non-deterministic order change end
//non-deterministic order no change: too complex
//non-deterministic order change start
{
auto mk_and_1 = I.mk_and(I.mk_lt(ad), I.mk_gt(aabbc));
r = I.mk_or(mk_and_1,
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
I.mk_and(I.mk_le(bd), I.mk_or(I.mk_lt(ad), I.mk_lt(aabbc)))); I.mk_and(I.mk_le(bd), I.mk_or(I.mk_lt(ad), I.mk_lt(aabbc))));
}
//non-deterministic order change end
} }
} }
@ -1097,20 +1071,8 @@ namespace nlarith {
r = I.mk_eq(a); r = I.mk_eq(a);
} }
else { else {
//non-deterministic order change start aabbc = I.mk_sub(I.mk_mul(a, a), I.mk_mul(b, b, c));
{ r = I.mk_and(I.mk_le(I.mk_mul(a, b)), I.mk_eq(aabbc));
auto mk_mul_1 = I.mk_mul(a, a);
auto mk_mul_2 = I.mk_mul(b, b, c);
aabbc = I.mk_sub(mk_mul_1, mk_mul_2);
}
//non-deterministic order change end
//non-deterministic order change start
{
auto mk_le_1 = I.mk_le(I.mk_mul(a, b));
auto mk_eq_2 = I.mk_eq(aabbc);
r = I.mk_and(mk_le_1, mk_eq_2);
}
//non-deterministic order change end
} }
} }
@ -1129,22 +1091,9 @@ namespace nlarith {
r = I.mk_le(ad); r = I.mk_le(ad);
} }
else { else {
//non-deterministic order change start aabbc = I.mk_sub(I.mk_mul(a, a), I.mk_mul(b, b, c));
{ r = I.mk_or(I.mk_and(I.mk_le(ad), I.mk_ge(aabbc)),
auto mk_mul_1 = I.mk_mul(a, a);
auto mk_mul_2 = I.mk_mul(b, b, c);
aabbc = I.mk_sub(mk_mul_1, mk_mul_2);
}
//non-deterministic order change end
//non-deterministic order no change: too complex
//non-deterministic order change start
{
auto mk_and_1 = I.mk_and(I.mk_le(ad), I.mk_ge(aabbc));
r = I.mk_or(mk_and_1,
//non-deterministic order no change: too complex
I.mk_and(I.mk_le(bd), I.mk_le(aabbc))); I.mk_and(I.mk_le(bd), I.mk_le(aabbc)));
}
//non-deterministic order change end
} }
} }
}; };
@ -1254,7 +1203,6 @@ namespace nlarith {
return e; return e;
} }
else { else {
//non-deterministic order no change: too complex
return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i))); return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i)));
} }
} }
@ -1285,7 +1233,6 @@ namespace nlarith {
return e; return e;
} }
else { else {
//non-deterministic order no change: too complex
return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i))); return I.mk_or(e, I.mk_and(I.mk_eq(t), mk_lt(p, i)));
} }
} }
@ -1364,15 +1311,8 @@ namespace nlarith {
// = // =
// (d*dr*p[i] + a*ar + b*br*c + (a*br + ar*b)*sqrt(c))/d*dr // (d*dr*p[i] + a*ar + b*br*c + (a*br + ar*b)*sqrt(c))/d*dr
// //
//non-deterministic order no change: too complex
app_ref tmp1(mk_add(mk_mul(d, dr, p[i]), mk_mul(a, ar), mk_mul(b, br, c)), m()); app_ref tmp1(mk_add(mk_mul(d, dr, p[i]), mk_mul(a, ar), mk_mul(b, br, c)), m());
//non-deterministic order change start br = mk_add(mk_mul(a, br), mk_mul(ar, b));
{
auto mk_mul_1 = mk_mul(a, br);
auto mk_mul_2 = mk_mul(ar, b);
br = mk_add(mk_mul_1, mk_mul_2);
}
//non-deterministic order change end
dr = mk_mul(d, dr); dr = mk_mul(d, dr);
ar = tmp1; ar = tmp1;
} }

2
src/qe/nlqsat.cpp
View file

@ -656,7 +656,6 @@ namespace qe {
expr_ref den_is0(m.mk_eq(divs[i].den, arith.mk_real(0)), m); expr_ref den_is0(m.mk_eq(divs[i].den, arith.mk_real(0)), m);
paxioms.push_back(m.mk_or(den_is0, m.mk_eq(divs[i].num, arith.mk_mul(divs[i].den, divs[i].name)))); paxioms.push_back(m.mk_or(den_is0, m.mk_eq(divs[i].num, arith.mk_mul(divs[i].den, divs[i].name))));
for (unsigned j = i + 1; j < divs.size(); ++j) { for (unsigned j = i + 1; j < divs.size(); ++j) {
//non-deterministic order no change: too complex
paxioms.push_back(m.mk_or(m.mk_not(m.mk_eq(divs[i].den, divs[j].den)), paxioms.push_back(m.mk_or(m.mk_not(m.mk_eq(divs[i].den, divs[j].den)),
m.mk_not(m.mk_eq(divs[i].num, divs[j].num)), m.mk_not(m.mk_eq(divs[i].num, divs[j].num)),
m.mk_eq(divs[i].name, divs[j].name))); m.mk_eq(divs[i].name, divs[j].name)));
@ -666,7 +665,6 @@ namespace qe {
expr_ref v0(m.mk_var(0, arith.mk_real()), m); expr_ref v0(m.mk_var(0, arith.mk_real()), m);
expr_ref v1(m.mk_var(1, arith.mk_real()), m); expr_ref v1(m.mk_var(1, arith.mk_real()), m);
for (auto const& p : divs) { for (auto const& p : divs) {
//non-deterministic order no change: too complex
body = m.mk_ite(m.mk_and(m.mk_eq(v0, p.num), m.mk_eq(v1, p.den)), p.name, body); body = m.mk_ite(m.mk_and(m.mk_eq(v0, p.num), m.mk_eq(v1, p.den)), p.name, body);
} }
m_div_mc->add(arith.mk_div0(), body); m_div_mc->add(arith.mk_div0(), body);

8
src/qe/qe_arith_plugin.cpp
View file

@ -468,13 +468,7 @@ namespace qe {
// ax + t = 0 // ax + t = 0
void mk_eq(rational const& a, app* x, expr* t, expr_ref& result) { void mk_eq(rational const& a, app* x, expr* t, expr_ref& result) {
//non-deterministic order change start result = m_arith.mk_eq(mk_add(mk_mul(a, x), t), mk_zero(x));
{
auto mk_add_1 = mk_add(mk_mul(a, x), t);
auto mk_zero_2 = mk_zero(x);
result = m_arith.mk_eq(mk_add_1, mk_zero_2);
}
//non-deterministic order change end
} }
void mk_and(unsigned sz, expr*const* args, expr_ref& result) { void mk_and(unsigned sz, expr*const* args, expr_ref& result) {

11
src/sat/smt/arith_axioms.cpp
View file

@ -262,13 +262,7 @@ namespace arith {
// x mod 2^{i + 1} >= 2^i means the i'th bit is 1. // x mod 2^{i + 1} >= 2^i means the i'th bit is 1.
auto bitof = [&](expr* x, unsigned i) { auto bitof = [&](expr* x, unsigned i) {
expr_ref r(m); expr_ref r(m);
//non-deterministic order change start r = a.mk_ge(a.mk_mod(x, a.mk_int(rational::power_of_two(i+1))), a.mk_int(rational::power_of_two(i)));
{
auto mk_mod_1 = a.mk_mod(x, a.mk_int(rational::power_of_two(i+1)));
auto mk_int_2 = a.mk_int(rational::power_of_two(i));
r = a.mk_ge(mk_mod_1, mk_int_2);
}
//non-deterministic order change end
return mk_literal(r); return mk_literal(r);
}; };
@ -396,11 +390,8 @@ namespace arith {
// y >= sz & x >= 2^{sz-1} => n = -1 // y >= sz & x >= 2^{sz-1} => n = -1
// y = 0 => n = x // y = 0 => n = x
auto signx = mk_literal(a.mk_ge(x, a.mk_int(N/2))); auto signx = mk_literal(a.mk_ge(x, a.mk_int(N/2)));
//non-deterministic order no change: too complex
add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), signx, mk_literal(m.mk_eq(n, a.mk_int(0)))); add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), signx, mk_literal(m.mk_eq(n, a.mk_int(0))));
//non-deterministic order no change: too complex
add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), ~signx, mk_literal(m.mk_eq(n, a.mk_int(N-1)))); add_clause(~mk_literal(a.mk_ge(a.mk_mod(y, a.mk_int(N)), a.mk_int(sz))), ~signx, mk_literal(m.mk_eq(n, a.mk_int(N-1))));
//non-deterministic order no change: too complex
add_clause(~mk_literal(a.mk_eq(a.mk_mod(y, a.mk_int(N)), a.mk_int(0))), mk_literal(m.mk_eq(n, x))); add_clause(~mk_literal(a.mk_eq(a.mk_mod(y, a.mk_int(N)), a.mk_int(0))), mk_literal(m.mk_eq(n, x)));
} }
else else

8
src/sat/smt/q_solver.cpp
View file

@ -341,13 +341,7 @@ namespace q {
} }
if (m.is_not(arg, z) && m.is_iff(z, x, y) && is_literal(x) && is_literal(y)) { if (m.is_not(arg, z) && m.is_iff(z, x, y) && is_literal(x) && is_literal(y)) {
e1 = m.mk_or(x, y); e1 = m.mk_or(x, y);
//non-deterministic order change start e2 = m.mk_or(mk_not(m, x), mk_not(m, y));
{
auto mk_not_1 = mk_not(m, x);
auto mk_not_2 = mk_not(m, y);
e2 = m.mk_or(mk_not_1, mk_not_2);
}
//non-deterministic order change end
return true; return true;
} }
return false; return false;

1
src/sat/tactic/sat2goal.cpp
View file

@ -253,7 +253,6 @@ struct sat2goal::imp {
s.collect_bin_clauses(bin_clauses, m_learned, false); s.collect_bin_clauses(bin_clauses, m_learned, false);
for (sat::solver::bin_clause const& bc : bin_clauses) { for (sat::solver::bin_clause const& bc : bin_clauses) {
checkpoint(); checkpoint();
//non-deterministic order no change: too complex
r.assert_expr(m.mk_or(lit2expr(mc, bc.first), lit2expr(mc, bc.second))); r.assert_expr(m.mk_or(lit2expr(mc, bc.first), lit2expr(mc, bc.second)));
} }
// collect clauses // collect clauses

1
src/smt/seq_regex.cpp
View file

@ -396,7 +396,6 @@ namespace smt {
else if (re().is_empty(r2)) else if (re().is_empty(r2))
r = r1; r = r1;
else else
//non-deterministic order no change: too complex
r = re().mk_union(re().mk_diff(r1, r2), re().mk_diff(r2, r1)); r = re().mk_union(re().mk_diff(r1, r2), re().mk_diff(r2, r1));
rewrite(r); rewrite(r);
return r; return r;

8
src/smt/theory_array_base.cpp
View file

@ -360,13 +360,7 @@ namespace smt {
ctx.mark_as_relevant(sel1_eq_sel2); ctx.mark_as_relevant(sel1_eq_sel2);
if (m.has_trace_stream()) { if (m.has_trace_stream()) {
app_ref body(m); app_ref body(m);
//non-deterministic order change start body = m.mk_implies(m.mk_not(ctx.bool_var2expr(n1_eq_n2.var())), m.mk_not(ctx.bool_var2expr(sel1_eq_sel2.var())));
{
auto mk_not_1 = m.mk_not(ctx.bool_var2expr(n1_eq_n2.var()));
auto mk_not_2 = m.mk_not(ctx.bool_var2expr(sel1_eq_sel2.var()));
body = m.mk_implies(mk_not_1, mk_not_2);
}
//non-deterministic order change end
log_axiom_instantiation(body); log_axiom_instantiation(body);
} }
assert_axiom(n1_eq_n2, ~sel1_eq_sel2); assert_axiom(n1_eq_n2, ~sel1_eq_sel2);

3
src/smt/theory_bv.cpp
View file

@ -241,8 +241,6 @@ namespace smt {
expr_ref eq(m.mk_eq(e1, e2), m); expr_ref eq(m.mk_eq(e1, e2), m);
literal l = ~mk_literal(eq); literal l = ~mk_literal(eq);
std::function<expr*(void)> logfn = [&]() { std::function<expr*(void)> logfn = [&]() {
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
return m.mk_implies(m.mk_eq(mk_bit2bool(e1, idx), m.mk_not(mk_bit2bool(e2, idx))), m.mk_not(eq)); return m.mk_implies(m.mk_eq(mk_bit2bool(e1, idx), m.mk_not(mk_bit2bool(e2, idx))), m.mk_not(eq));
}; };
scoped_trace_stream ts(*this, logfn); scoped_trace_stream ts(*this, logfn);
@ -458,7 +456,6 @@ namespace smt {
e2 = mk_bit2bool(o2, i); e2 = mk_bit2bool(o2, i);
literal eq = mk_eq(e1, e2, true); literal eq = mk_eq(e1, e2, true);
std::function<expr*()> logfn = [&]() { std::function<expr*()> logfn = [&]() {
//non-deterministic order no change: too complex
return m.mk_implies(m.mk_not(ctx.bool_var2expr(eq.var())), m.mk_not(ctx.bool_var2expr(oeq.var()))); return m.mk_implies(m.mk_not(ctx.bool_var2expr(eq.var())), m.mk_not(ctx.bool_var2expr(oeq.var())));
}; };
scoped_trace_stream st(*this, logfn); scoped_trace_stream st(*this, logfn);

1
src/smt/theory_char.cpp
View file

@ -259,7 +259,6 @@ namespace smt {
unsigned p = 0; unsigned p = 0;
arith_util a(m); arith_util a(m);
for (auto b : bits) { for (auto b : bits) {
//non-deterministic order no change: too complex
sum.push_back(m.mk_ite(b, a.mk_int(1 << p), a.mk_int(0))); sum.push_back(m.mk_ite(b, a.mk_int(1 << p), a.mk_int(0)));
p++; p++;
} }

1
src/smt/theory_datatype.cpp
View file

@ -247,7 +247,6 @@ namespace smt {
assert_eq_axiom(arg, acc_own, is_con); assert_eq_axiom(arg, acc_own, is_con);
} }
// update_field is identity if 'n' is not created by a matching constructor. // update_field is identity if 'n' is not created by a matching constructor.
//non-deterministic order no change: too complex
app_ref imp(m.mk_implies(m.mk_not(rec_app), m.mk_eq(n->get_expr(), arg1)), m); app_ref imp(m.mk_implies(m.mk_not(rec_app), m.mk_eq(n->get_expr(), arg1)), m);
assert_eq_axiom(n, arg1, ~is_con); assert_eq_axiom(n, arg1, ~is_con);

1
src/smt/theory_dl.cpp
View file

@ -252,7 +252,6 @@ namespace smt {
get_rep(s, r, v); get_rep(s, r, v);
app_ref lt(m()), le(m()); app_ref lt(m()), le(m());
lt = u().mk_lt(x,y); lt = u().mk_lt(x,y);
//non-deterministic order no change: too complex
le = b().mk_ule(m().mk_app(r,y),m().mk_app(r,x)); le = b().mk_ule(m().mk_app(r,y),m().mk_app(r,x));
if (m().has_trace_stream()) { if (m().has_trace_stream()) {
app_ref body(m()); app_ref body(m());

10
src/smt/theory_lra.cpp
View file

@ -2589,7 +2589,6 @@ public:
if (valy >= sz || valy == 0) if (valy >= sz || valy == 0)
return true; return true;
unsigned k = valy.get_unsigned(); unsigned k = valy.get_unsigned();
//non-deterministic order no change: too complex
sat::literal signx = mk_literal(a.mk_ge(x, a.mk_int(N/2))); sat::literal signx = mk_literal(a.mk_ge(x, a.mk_int(N/2)));
sat::literal eq; sat::literal eq;
expr* xdiv2k; expr* xdiv2k;
@ -3372,13 +3371,7 @@ public:
tout << " ==> " << pp(x) << " = " << pp(y) << "\n"; tout << " ==> " << pp(x) << " = " << pp(y) << "\n";
); );
std::function<expr*(void)> fn = [&]() { //non-deterministic order change start std::function<expr*(void)> fn = [&]() { return m.mk_eq(x->get_expr(), y->get_expr()); };
{
auto get_expr_1 = x->get_expr();
auto get_expr_2 = y->get_expr();
return m.mk_eq(get_expr_1, get_expr_2);
}
//non-deterministic order change end };
scoped_trace_stream _sts(th, fn); scoped_trace_stream _sts(th, fn);
if (params().m_arith_validate) if (params().m_arith_validate)
@ -3878,7 +3871,6 @@ public:
flet<bool> _svalid(s_validating, true); flet<bool> _svalid(s_validating, true);
context nctx(m, ctx().get_fparams(), ctx().get_params()); context nctx(m, ctx().get_fparams(), ctx().get_params());
add_background(nctx); add_background(nctx);
//non-deterministic order no change: too complex
expr_ref neq(m.mk_not(m.mk_eq(x->get_expr(), y->get_expr())), m); expr_ref neq(m.mk_not(m.mk_eq(x->get_expr(), y->get_expr())), m);
nctx.assert_expr(neq); nctx.assert_expr(neq);
cancel_eh<reslimit> eh(m.limit()); cancel_eh<reslimit> eh(m.limit());

45
src/smt/theory_special_relations.cpp
View file

@ -803,13 +803,7 @@ namespace smt {
r.pop(1); r.pop(1);
fi->set_else(arith.mk_numeral(rational(0), true)); fi->set_else(arith.mk_numeral(rational(0), true));
mg.get_model().register_decl(fn, fi); mg.get_model().register_decl(fn, fi);
//non-deterministic order change start result = arith.mk_le(m.mk_app(fn,m.mk_var(0, *ty)), m.mk_app(fn, m.mk_var(1, *ty)));
{
auto mk_app_1 = m.mk_app(fn,m.mk_var(0, *ty));
auto mk_app_2 = m.mk_app(fn, m.mk_var(1, *ty));
result = arith.mk_le(mk_app_1, mk_app_2);
}
//non-deterministic order change end
return result; return result;
} }
@ -829,13 +823,7 @@ namespace smt {
} }
fi->set_else(arith.mk_numeral(rational(0), true)); fi->set_else(arith.mk_numeral(rational(0), true));
mg.get_model().register_decl(fn, fi); mg.get_model().register_decl(fn, fi);
//non-deterministic order change start result = m.mk_eq(m.mk_app(fn, m.mk_var(0, *ty)), m.mk_app(fn, m.mk_var(1, *ty)));
{
auto mk_app_1 = m.mk_app(fn, m.mk_var(0, *ty));
auto mk_app_2 = m.mk_app(fn, m.mk_var(1, *ty));
result = m.mk_eq(mk_app_1, mk_app_2);
}
//non-deterministic order change end
return result; return result;
} }
@ -860,9 +848,7 @@ namespace smt {
hifi->set_else(arith.mk_numeral(rational(0), true)); hifi->set_else(arith.mk_numeral(rational(0), true));
mg.get_model().register_decl(lofn, lofi); mg.get_model().register_decl(lofn, lofi);
mg.get_model().register_decl(hifn, hifi); mg.get_model().register_decl(hifn, hifi);
//non-deterministic order no change: too complex
result = m.mk_and(arith.mk_le(m.mk_app(lofn, m.mk_var(0, *ty)), m.mk_app(lofn, m.mk_var(1, *ty))), result = m.mk_and(arith.mk_le(m.mk_app(lofn, m.mk_var(0, *ty)), m.mk_app(lofn, m.mk_var(1, *ty))),
//non-deterministic order no change: too complex
arith.mk_le(m.mk_app(hifn, m.mk_var(1, *ty)), m.mk_app(hifn, m.mk_var(0, *ty)))); arith.mk_le(m.mk_app(hifn, m.mk_var(1, *ty)), m.mk_app(hifn, m.mk_var(0, *ty))));
return result; return result;
} }
@ -937,17 +923,11 @@ namespace smt {
expr* x = xV, *S = SV; expr* x = xV, *S = SV;
expr_ref mem_body(m); expr_ref mem_body(m);
//non-deterministic order change start mem_body = m.mk_ite(m.mk_app(is_nil, S),
{
auto mk_app_1 = m.mk_app(is_nil, S);
mem_body = m.mk_ite(mk_app_1,
F, F,
//non-deterministic order no change: too complex
m.mk_ite(m.mk_eq(m.mk_app(hd, S), x), m.mk_ite(m.mk_eq(m.mk_app(hd, S), x),
T, T,
m.mk_app(memf, x, m.mk_app(tl, S)))); m.mk_app(memf, x, m.mk_app(tl, S))));
}
//non-deterministic order change end
recfun_replace rep(m); recfun_replace rep(m);
var* vars[2] = { xV, SV }; var* vars[2] = { xV, SV };
p.set_definition(rep, mem, false, 2, vars, mem_body); p.set_definition(rep, mem, false, 2, vars, mem_body);
@ -967,16 +947,9 @@ namespace smt {
var_ref SV(m.mk_var(1, listS), m); var_ref SV(m.mk_var(1, listS), m);
var_ref tupV(m.mk_var(0, tup), m); var_ref tupV(m.mk_var(0, tup), m);
expr* a = aV, *b = bV, *A = AV, *S = SV, *t = tupV; expr* a = aV, *b = bV, *A = AV, *S = SV, *t = tupV;
//non-deterministic order no change: too complex next_body = m.mk_ite(m.mk_and(m.mk_app(memf, a, A), m.mk_not(m.mk_app(memf, b, S))),
//non-deterministic order change start m.mk_app(pair, m.mk_app(cons, b, m.mk_app(fst, t)), m.mk_app(cons, b, m.mk_app(snd, t))),
{
auto mk_and_1 = m.mk_and(m.mk_app(memf, a, A), m.mk_not(m.mk_app(memf, b, S)));
auto mk_app_2 = m.mk_app(pair, m.mk_app(cons, b, m.mk_app(fst, t)), m.mk_app(cons, b, m.mk_app(snd, t)));
next_body = m.mk_ite(mk_and_1,
mk_app_2,
t); t);
}
//non-deterministic order change end
recfun_replace rep(m); recfun_replace rep(m);
var* vars[5] = { aV, bV, AV, SV, tupV }; var* vars[5] = { aV, bV, AV, SV, tupV };
@ -1008,15 +981,9 @@ namespace smt {
expr_ref Ap(m.mk_app(fst, connected_body.get()), m); expr_ref Ap(m.mk_app(fst, connected_body.get()), m);
expr_ref Sp(m.mk_app(snd, connected_body.get()), m); expr_ref Sp(m.mk_app(snd, connected_body.get()), m);
//non-deterministic order change start connected_body = m.mk_ite(m.mk_eq(Ap, nilc), F,
{
auto mk_eq_1 = m.mk_eq(Ap, nilc);
connected_body = m.mk_ite(mk_eq_1, F,
//non-deterministic order no change: too complex
m.mk_ite(m.mk_app(memf, dst, Ap), T, m.mk_ite(m.mk_app(memf, dst, Ap), T,
m.mk_app(connectedf, Ap, dst, Sp))); m.mk_app(connectedf, Ap, dst, Sp)));
}
//non-deterministic order change end
TRACE(special_relations, tout << connected_body << "\n";); TRACE(special_relations, tout << connected_body << "\n";);
recfun_replace rep(m); recfun_replace rep(m);

17
src/tactic/aig/aig.cpp
View file

@ -879,23 +879,10 @@ struct aig_manager::imp {
} }
expr * r; expr * r;
if (m.is_not_eq(t, e)) { if (m.is_not_eq(t, e)) {
//non-deterministic order change start r = ast_mng.mk_iff(get_cached(c), get_cached(t));
{
auto get_cached_1 = get_cached(c);
auto get_cached_2 = get_cached(t);
r = ast_mng.mk_iff(get_cached_1, get_cached_2);
}
//non-deterministic order change end
} }
else { else {
//non-deterministic order change start r = ast_mng.mk_ite(get_cached(c), get_cached(t), get_cached(e));
{
auto get_cached_1 = get_cached(c);
auto get_cached_2 = get_cached(t);
auto get_cached_3 = get_cached(e);
r = ast_mng.mk_ite(get_cached_1, get_cached_2, get_cached_3);
}
//non-deterministic order change end
} }
cache_result(n, r); cache_result(n, r);
TRACE(aig2expr, tout << "caching ITE/IFF "; m.display_ref(tout, n); tout << "\n";); TRACE(aig2expr, tout << "caching ITE/IFF "; m.display_ref(tout, n); tout << "\n";);

9
src/tactic/arith/bv2real_rewriter.cpp
View file

@ -443,11 +443,9 @@ bool bv2real_rewriter::mk_le(expr* s, expr* t, bool is_pos, bool is_neg, expr_re
expr_ref gt_proxy(m().mk_not(le_proxy), m()); expr_ref gt_proxy(m().mk_not(le_proxy), m());
expr_ref s2_is_nonpos(m_bv.mk_sle(s2, m_bv.mk_numeral(rational(0), s2_size)), m()); expr_ref s2_is_nonpos(m_bv.mk_sle(s2, m_bv.mk_numeral(rational(0), s2_size)), m());
//non-deterministic order no change: too complex
expr_ref under(u().mk_bv_add(u().mk_bv_mul(rational(4), s1), u().mk_bv_mul(rational(5), s2)), m()); expr_ref under(u().mk_bv_add(u().mk_bv_mul(rational(4), s1), u().mk_bv_mul(rational(5), s2)), m());
expr_ref z1(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(under)), m()); expr_ref z1(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(under)), m());
expr_ref le_under(m_bv.mk_sle(under, z1), m()); expr_ref le_under(m_bv.mk_sle(under, z1), m());
//non-deterministic order no change: too complex
expr_ref over(u().mk_bv_add(u().mk_bv_mul(rational(2), s1), u().mk_bv_mul(rational(3), s2)), m()); expr_ref over(u().mk_bv_add(u().mk_bv_mul(rational(2), s1), u().mk_bv_mul(rational(3), s2)), m());
expr_ref z2(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(over)), m()); expr_ref z2(m_bv.mk_numeral(rational(0), m_bv.get_bv_size(over)), m());
expr_ref le_over(m_bv.mk_sle(over, z2), m()); expr_ref le_over(m_bv.mk_sle(over, z2), m());
@ -464,10 +462,8 @@ bool bv2real_rewriter::mk_le(expr* s, expr* t, bool is_pos, bool is_neg, expr_re
// predicate may occur in negative polarity. // predicate may occur in negative polarity.
if (is_neg) { if (is_neg) {
// s1 + s2*sqrt(2) > 0 <== s2 > 0 & s1 + s2*(5/4) > 0; 4*s1 + 5*s2 > 0 // s1 + s2*sqrt(2) > 0 <== s2 > 0 & s1 + s2*(5/4) > 0; 4*s1 + 5*s2 > 0
//non-deterministic order no change: too complex
expr* e3 = m().mk_implies(m().mk_and(gt_proxy, m().mk_not(s2_is_nonpos)), m().mk_not(le_under)); expr* e3 = m().mk_implies(m().mk_and(gt_proxy, m().mk_not(s2_is_nonpos)), m().mk_not(le_under));
// s1 + s2*sqrt(2) > 0 <== s2 <= 0 & s1 + s2*(3/2) > 0 <=> 2*s1 + 3*s2 > 0 // s1 + s2*sqrt(2) > 0 <== s2 <= 0 & s1 + s2*(3/2) > 0 <=> 2*s1 + 3*s2 > 0
//non-deterministic order no change: too complex
expr* e4 = m().mk_implies(m().mk_and(gt_proxy, s2_is_nonpos), m().mk_not(le_over)); expr* e4 = m().mk_implies(m().mk_and(gt_proxy, s2_is_nonpos), m().mk_not(le_over));
u().add_side_condition(e3); u().add_side_condition(e3);
u().add_side_condition(e4); u().add_side_condition(e4);
@ -547,9 +543,7 @@ br_status bv2real_rewriter::mk_le(expr * s, expr * t, expr_ref & result) {
expr* ge = m_bv.mk_sle(t22, t12); expr* ge = m_bv.mk_sle(t22, t12);
expr* le = m_bv.mk_sle(t12, t22); expr* le = m_bv.mk_sle(t12, t22);
expr* e1 = m().mk_or(gz1, gz2); expr* e1 = m().mk_or(gz1, gz2);
//non-deterministic order no change: too complex
expr* e2 = m().mk_or(m().mk_not(gz1), m().mk_not(lz2), ge); expr* e2 = m().mk_or(m().mk_not(gz1), m().mk_not(lz2), ge);
//non-deterministic order no change: too complex
expr* e3 = m().mk_or(m().mk_not(gz2), m().mk_not(lz1), le); expr* e3 = m().mk_or(m().mk_not(gz2), m().mk_not(lz1), le);
result = m().mk_and(e1, e2, e3); result = m().mk_and(e1, e2, e3);
TRACE(bv2real_rewriter, tout << "\n";); TRACE(bv2real_rewriter, tout << "\n";);
@ -593,7 +587,6 @@ br_status bv2real_rewriter::mk_eq(expr * s, expr * t, expr_ref & result) {
u().align_divisors(s1, s2, t1, t2, d1, d2); u().align_divisors(s1, s2, t1, t2, d1, d2);
u().align_sizes(s1, t1); u().align_sizes(s1, t1);
u().align_sizes(s2, t2); u().align_sizes(s2, t2);
//non-deterministic order no change: too complex
result = m().mk_and(m().mk_eq(s1, t1), m().mk_eq(s2, t2)); result = m().mk_and(m().mk_eq(s1, t1), m().mk_eq(s2, t2));
return BR_DONE; return BR_DONE;
} }
@ -657,9 +650,7 @@ br_status bv2real_rewriter::mk_mul(expr* s, expr* t, expr_ref& result) {
if (u().is_bv2real(s, s1, s2, d1, r1) && u().is_bv2real(t, t1, t2, d2, r2) && r1 == r2) { if (u().is_bv2real(s, s1, s2, d1, r1) && u().is_bv2real(t, t1, t2, d2, r2) && r1 == r2) {
// s1*t1 + r1*(s2*t2) + (s1*t2 + s2*t2)*r1 // s1*t1 + r1*(s2*t2) + (s1*t2 + s2*t2)*r1
expr_ref u1(m()), u2(m()); expr_ref u1(m()), u2(m());
//non-deterministic order no change: too complex
u1 = u().mk_bv_add(u().mk_bv_mul(s1, t1), u().mk_bv_mul(r1, u().mk_bv_mul(t2, s2))); u1 = u().mk_bv_add(u().mk_bv_mul(s1, t1), u().mk_bv_mul(r1, u().mk_bv_mul(t2, s2)));
//non-deterministic order no change: too complex
u2 = u().mk_bv_add(u().mk_bv_mul(s1, t2), u().mk_bv_mul(s2, t1)); u2 = u().mk_bv_add(u().mk_bv_mul(s1, t2), u().mk_bv_mul(s2, t1));
rational tmp = d1*d2; rational tmp = d1*d2;
if (u().mk_bv2real(u1, u2, tmp, r1, result)) { if (u().mk_bv2real(u1, u2, tmp, r1, result)) {

8
src/tactic/arith/factor_tactic.cpp
View file

@ -63,13 +63,7 @@ class factor_tactic : public tactic {
m_expr2poly.to_expr(fs[i], true, arg); m_expr2poly.to_expr(fs[i], true, arg);
args.push_back(arg); args.push_back(arg);
} }
//non-deterministic order change start result = m.mk_eq(mk_mul(args.size(), args.data()), mk_zero_for(arg));
{
auto size_1 = mk_mul(args.size(), args.data());
auto mk_zero_for_2 = mk_zero_for(arg);
result = m.mk_eq(size_1, mk_zero_for_2);
}
//non-deterministic order change end
} }
// p1^k1 * p2^k2 = 0 --> p1 = 0 or p2 = 0 // p1^k1 * p2^k2 = 0 --> p1 = 0 or p2 = 0

1
src/tactic/arith/lia2card_tactic.cpp
View file

@ -260,7 +260,6 @@ public:
return m_pb.mk_eq(sz, weights, args, w); return m_pb.mk_eq(sz, weights, args, w);
} }
else { else {
//non-deterministic order no change: too complex
return m.mk_and(mk_ge(sz, weights, args, w), mk_le(sz, weights, args, w)); return m.mk_and(mk_ge(sz, weights, args, w), mk_le(sz, weights, args, w));
} }
} }

11
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -623,14 +623,8 @@ private:
if (is_uninterp_const(lhs) && is_uninterp_const(rhs)) { if (is_uninterp_const(lhs) && is_uninterp_const(rhs)) {
add_bounds_dependencies(lhs); add_bounds_dependencies(lhs);
add_bounds_dependencies(rhs); add_bounds_dependencies(rhs);
//non-deterministic order change start r = m.mk_iff(mon_lit2lit(lit(lhs, false)),
{ mon_lit2lit(lit(rhs, !pos)));
auto mon_lit2lit_1 = mon_lit2lit(lit(lhs, false));
auto mon_lit2lit_2 = mon_lit2lit(lit(rhs, !pos));
r = m.mk_iff(mon_lit2lit_1,
mon_lit2lit_2);
}
//non-deterministic order change end
return; return;
} }
k = EQ; k = EQ;
@ -813,7 +807,6 @@ private:
for (unsigned i = 0; i < sz; i += 2) { for (unsigned i = 0; i < sz; i += 2) {
app * x_i = to_app(m_p[i].m_lit.var()); app * x_i = to_app(m_p[i].m_lit.var());
app * y_i = to_app(m_p[i+1].m_lit.var()); app * y_i = to_app(m_p[i+1].m_lit.var());
//non-deterministic order no change: too complex
eqs.push_back(m.mk_eq(int2lit(x_i), int2lit(y_i))); eqs.push_back(m.mk_eq(int2lit(x_i), int2lit(y_i)));
} }
m_b_rw.mk_and(eqs.size(), eqs.data(), r); m_b_rw.mk_and(eqs.size(), eqs.data(), r);

25
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -331,14 +331,12 @@ struct purify_arith_proc {
expr * x = args[0]; expr * x = args[0];
expr * y = args[1]; expr * y = args[1];
// y = 0 \/ y*k = x // y = 0 \/ y*k = x
//non-deterministic order no change: too complex
push_cnstr(OR(EQ(y, mk_real_zero()), push_cnstr(OR(EQ(y, mk_real_zero()),
EQ(u().mk_mul(y, k), x))); EQ(u().mk_mul(y, k), x)));
push_cnstr_pr(result_pr); push_cnstr_pr(result_pr);
rational r; rational r;
if (complete()) { if (complete()) {
// y != 0 \/ k = div-0(x) // y != 0 \/ k = div-0(x)
//non-deterministic order no change: too complex
push_cnstr(OR(NOT(EQ(y, mk_real_zero())), push_cnstr(OR(NOT(EQ(y, mk_real_zero())),
EQ(k, u().mk_div(x, mk_real_zero())))); EQ(k, u().mk_div(x, mk_real_zero()))));
push_cnstr_pr(result_pr); push_cnstr_pr(result_pr);
@ -377,7 +375,6 @@ struct purify_arith_proc {
// y < 0 implies k2 < -y ---> y >= 0 \/ k2 < -y // y < 0 implies k2 < -y ---> y >= 0 \/ k2 < -y
// //
expr * zero = mk_int_zero(); expr * zero = mk_int_zero();
//non-deterministic order no change: too complex
push_cnstr(OR(EQ(y, zero), EQ(x, u().mk_add(u().mk_mul(k1, y), k2)))); push_cnstr(OR(EQ(y, zero), EQ(x, u().mk_add(u().mk_mul(k1, y), k2))));
push_cnstr_pr(result_pr, mod_pr); push_cnstr_pr(result_pr, mod_pr);
@ -392,11 +389,9 @@ struct purify_arith_proc {
rational r; rational r;
if (complete() && (!u().is_numeral(y, r) || r.is_zero())) { if (complete() && (!u().is_numeral(y, r) || r.is_zero())) {
//non-deterministic order no change: too complex
push_cnstr(OR(NOT(EQ(y, zero)), EQ(k1, u().mk_idiv(x, zero)))); push_cnstr(OR(NOT(EQ(y, zero)), EQ(k1, u().mk_idiv(x, zero))));
push_cnstr_pr(result_pr); push_cnstr_pr(result_pr);
//non-deterministic order no change: too complex
push_cnstr(OR(NOT(EQ(y, zero)), EQ(k2, u().mk_mod(x, zero)))); push_cnstr(OR(NOT(EQ(y, zero)), EQ(k2, u().mk_mod(x, zero))));
push_cnstr_pr(mod_pr); push_cnstr_pr(mod_pr);
} }
@ -468,10 +463,8 @@ struct purify_arith_proc {
} }
// (^ x 0) --> k | x != 0 implies k = 1, x = 0 implies k = 0^0 // (^ x 0) --> k | x != 0 implies k = 1, x = 0 implies k = 0^0
//non-deterministic order no change: too complex
push_cnstr(OR(EQ(x, zero), EQ(k, one))); push_cnstr(OR(EQ(x, zero), EQ(k, one)));
push_cnstr_pr(result_pr); push_cnstr_pr(result_pr);
//non-deterministic order no change: too complex
push_cnstr(OR(NOT(EQ(x, zero)), EQ(k, p0))); push_cnstr(OR(NOT(EQ(x, zero)), EQ(k, p0)));
push_cnstr_pr(result_pr); push_cnstr_pr(result_pr);
} }
@ -489,7 +482,6 @@ struct purify_arith_proc {
SASSERT(n.is_even()); SASSERT(n.is_even());
// (^ x (/ 1 n)) --> k | x >= 0 implies (x = k^n and k >= 0), x < 0 implies k = neg-root(x, n) // (^ x (/ 1 n)) --> k | x >= 0 implies (x = k^n and k >= 0), x < 0 implies k = neg-root(x, n)
// when n is even // when n is even
//non-deterministic order no change: too complex
push_cnstr(OR(NOT(u().mk_ge(x, zero)), push_cnstr(OR(NOT(u().mk_ge(x, zero)),
AND(EQ(x, u().mk_power(k, u().mk_numeral(n, false))), AND(EQ(x, u().mk_power(k, u().mk_numeral(n, false))),
u().mk_ge(k, zero)))); u().mk_ge(k, zero))));
@ -608,11 +600,8 @@ struct purify_arith_proc {
expr * pi2 = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi()); expr * pi2 = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi());
expr * mpi2 = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi()); expr * mpi2 = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi());
// -1 <= x <= 1 implies sin(k) = x, -pi/2 <= k <= pi/2 // -1 <= x <= 1 implies sin(k) = x, -pi/2 <= k <= pi/2
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)), push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)),
NOT(u().mk_le(x, one))), NOT(u().mk_le(x, one))),
//non-deterministic order no change: too complex
AND(EQ(x, u().mk_sin(k)), AND(EQ(x, u().mk_sin(k)),
AND(u().mk_ge(k, mpi2), AND(u().mk_ge(k, mpi2),
u().mk_le(k, pi2))))); u().mk_le(k, pi2)))));
@ -653,11 +642,8 @@ struct purify_arith_proc {
expr * pi = u().mk_pi(); expr * pi = u().mk_pi();
expr * zero = u().mk_numeral(rational(0), false); expr * zero = u().mk_numeral(rational(0), false);
// -1 <= x <= 1 implies cos(k) = x, 0 <= k <= pi // -1 <= x <= 1 implies cos(k) = x, 0 <= k <= pi
//non-deterministic order no change: too complex
//non-deterministic order no change: too complex
push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)), push_cnstr(OR(OR(NOT(u().mk_ge(x, mone)),
NOT(u().mk_le(x, one))), NOT(u().mk_le(x, one))),
//non-deterministic order no change: too complex
AND(EQ(x, u().mk_cos(k)), AND(EQ(x, u().mk_cos(k)),
AND(u().mk_ge(k, zero), AND(u().mk_ge(k, zero),
u().mk_le(k, pi))))); u().mk_le(k, pi)))));
@ -692,7 +678,6 @@ struct purify_arith_proc {
// tan(k) = x, -pi/2 < k < pi/2 // tan(k) = x, -pi/2 < k < pi/2
expr * pi2 = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi()); expr * pi2 = u().mk_mul(u().mk_numeral(rational(1,2), false), u().mk_pi());
expr * mpi2 = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi()); expr * mpi2 = u().mk_mul(u().mk_numeral(rational(-1,2), false), u().mk_pi());
//non-deterministic order no change: too complex
push_cnstr(AND(EQ(x, u().mk_tan(k)), push_cnstr(AND(EQ(x, u().mk_tan(k)),
AND(u().mk_gt(k, mpi2), AND(u().mk_gt(k, mpi2),
u().mk_lt(k, pi2)))); u().mk_lt(k, pi2))));
@ -819,9 +804,7 @@ struct purify_arith_proc {
auto const& p1 = divs[i]; auto const& p1 = divs[i];
for (unsigned j = i + 1; j < divs.size(); ++j) { for (unsigned j = i + 1; j < divs.size(); ++j) {
auto const& p2 = divs[j]; auto const& p2 = divs[j];
//non-deterministic order no change: too complex
m_goal.assert_expr(m().mk_implies( m_goal.assert_expr(m().mk_implies(
//non-deterministic order no change: too complex
m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)),
m().mk_eq(p1.d, p2.d))); m().mk_eq(p1.d, p2.d)));
} }
@ -830,9 +813,7 @@ struct purify_arith_proc {
auto const& p1 = mods[i]; auto const& p1 = mods[i];
for (unsigned j = i + 1; j < mods.size(); ++j) { for (unsigned j = i + 1; j < mods.size(); ++j) {
auto const& p2 = mods[j]; auto const& p2 = mods[j];
//non-deterministic order no change: too complex
m_goal.assert_expr(m().mk_implies( m_goal.assert_expr(m().mk_implies(
//non-deterministic order no change: too complex
m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)),
m().mk_eq(p1.d, p2.d))); m().mk_eq(p1.d, p2.d)));
} }
@ -841,9 +822,7 @@ struct purify_arith_proc {
auto const& p1 = idivs[i]; auto const& p1 = idivs[i];
for (unsigned j = i + 1; j < idivs.size(); ++j) { for (unsigned j = i + 1; j < idivs.size(); ++j) {
auto const& p2 = idivs[j]; auto const& p2 = idivs[j];
//non-deterministic order no change: too complex
m_goal.assert_expr(m().mk_implies( m_goal.assert_expr(m().mk_implies(
//non-deterministic order no change: too complex
m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)), m().mk_and(m().mk_eq(p1.x, p2.x), m().mk_eq(p1.y, p2.y)),
m().mk_eq(p1.d, p2.d))); m().mk_eq(p1.d, p2.d)));
} }
@ -864,7 +843,6 @@ struct purify_arith_proc {
expr_ref v0(m().mk_var(0, u().mk_real()), m()); expr_ref v0(m().mk_var(0, u().mk_real()), m());
expr_ref v1(m().mk_var(1, u().mk_real()), m()); expr_ref v1(m().mk_var(1, u().mk_real()), m());
for (auto const& p : divs) { for (auto const& p : divs) {
//non-deterministic order no change: too complex
body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body); body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
} }
fmc->add(u().mk_div0(), body); fmc->add(u().mk_div0(), body);
@ -874,7 +852,6 @@ struct purify_arith_proc {
expr_ref v0(m().mk_var(0, u().mk_int()), m()); expr_ref v0(m().mk_var(0, u().mk_int()), m());
expr_ref v1(m().mk_var(1, u().mk_int()), m()); expr_ref v1(m().mk_var(1, u().mk_int()), m());
for (auto const& p : mods) { for (auto const& p : mods) {
//non-deterministic order no change: too complex
body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body); body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
} }
@ -887,7 +864,6 @@ struct purify_arith_proc {
expr_ref v0(m().mk_var(0, u().mk_int()), m()); expr_ref v0(m().mk_var(0, u().mk_int()), m());
expr_ref v1(m().mk_var(1, u().mk_int()), m()); expr_ref v1(m().mk_var(1, u().mk_int()), m());
for (auto const& p : idivs) { for (auto const& p : idivs) {
//non-deterministic order no change: too complex
body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body); body = m().mk_ite(m().mk_and(m().mk_eq(v0, p.x), m().mk_eq(v1, p.y)), p.d, body);
} }
fmc->add(u().mk_idiv0(), body); fmc->add(u().mk_idiv0(), body);
@ -905,7 +881,6 @@ struct purify_arith_proc {
for (auto const& kv : m_sin_cos) { for (auto const& kv : m_sin_cos) {
emc->add(kv.m_key->get_decl(), emc->add(kv.m_key->get_decl(),
m().mk_ite(u().mk_ge(kv.m_value.first, mk_real_zero()), u().mk_acos(kv.m_value.second), m().mk_ite(u().mk_ge(kv.m_value.first, mk_real_zero()), u().mk_acos(kv.m_value.second),
//non-deterministic order no change: too complex
u().mk_add(u().mk_acos(u().mk_uminus(kv.m_value.second)), u().mk_pi()))); u().mk_add(u().mk_acos(u().mk_uminus(kv.m_value.second)), u().mk_pi())));
} }

1
src/tactic/bv/bv1_blaster_tactic.cpp
View file

@ -156,7 +156,6 @@ class bv1_blaster_tactic : public tactic {
bit_buffer new_ites; bit_buffer new_ites;
unsigned num = t_bits.size(); unsigned num = t_bits.size();
for (unsigned i = 0; i < num; i++) for (unsigned i = 0; i < num; i++)
//non-deterministic order no change: too complex
new_ites.push_back(t_bits[i] == e_bits[i] ? t_bits[i] : m().mk_ite(c, t_bits[i], e_bits[i])); new_ites.push_back(t_bits[i] == e_bits[i] ? t_bits[i] : m().mk_ite(c, t_bits[i], e_bits[i]));
result = butil().mk_concat(new_ites.size(), new_ites.data()); result = butil().mk_concat(new_ites.size(), new_ites.data());
} }

26
src/tactic/bv/bvarray2uf_rewriter.cpp
View file

@ -149,13 +149,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
var_ref x(m_manager.mk_var(0, sorts[0]), m_manager); var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);
expr_ref body(m_manager); expr_ref body(m_manager);
//non-deterministic order change start body = m_manager.mk_eq(m_manager.mk_app(f_t, x.get()), m_manager.mk_app(f_s, x.get()));
{
auto mk_app_1 = m_manager.mk_app(f_t, x.get());
auto mk_app_2 = m_manager.mk_app(f_s, x.get());
body = m_manager.mk_eq(mk_app_1, mk_app_2);
}
//non-deterministic order change end
result = m_manager.mk_forall(1, sorts, names, body); result = m_manager.mk_forall(1, sorts, names, body);
res = BR_DONE; res = BR_DONE;
@ -301,14 +295,8 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
new_args.push_back(m_manager.mk_app(ss[i].get(), x.get())); new_args.push_back(m_manager.mk_app(ss[i].get(), x.get()));
expr_ref body(m_manager); expr_ref body(m_manager);
//non-deterministic order change start body = m_manager.mk_eq(m_manager.mk_app(f_t, x.get()),
{ m_manager.mk_app(map_f, num, new_args.data()));
auto mk_app_1 = m_manager.mk_app(f_t, x.get());
auto mk_app_2 = m_manager.mk_app(map_f, num, new_args.data());
body = m_manager.mk_eq(mk_app_1,
mk_app_2);
}
//non-deterministic order change end
expr_ref frllx(m_manager.mk_forall(1, sorts, names, body), m_manager); expr_ref frllx(m_manager.mk_forall(1, sorts, names, body), m_manager);
extra_assertions.push_back(frllx); extra_assertions.push_back(frllx);
@ -342,15 +330,9 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
var_ref x(m_manager.mk_var(0, sorts[0]), m_manager); var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);
expr_ref body(m_manager); expr_ref body(m_manager);
//non-deterministic order change start body = m_manager.mk_or(m_manager.mk_eq(x, i),
{
auto mk_eq_1 = m_manager.mk_eq(x, i);
body = m_manager.mk_or(mk_eq_1,
//non-deterministic order no change: too complex
m_manager.mk_eq(m_manager.mk_app(f_t, x.get()), m_manager.mk_eq(m_manager.mk_app(f_t, x.get()),
m_manager.mk_app(f_s, x.get()))); m_manager.mk_app(f_s, x.get())));
}
//non-deterministic order change end
expr_ref frllx(m_manager.mk_forall(1, sorts, names, body), m_manager); expr_ref frllx(m_manager.mk_forall(1, sorts, names, body), m_manager);
extra_assertions.push_back(frllx); extra_assertions.push_back(frllx);

8
src/tactic/fd_solver/enum2bv_solver.cpp
View file

@ -178,13 +178,7 @@ public:
expr_ref head(m); expr_ref head(m);
ptr_vector<func_decl> const& enums = *dt.get_datatype_constructors(f->get_range()); ptr_vector<func_decl> const& enums = *dt.get_datatype_constructors(f->get_range());
if (enums.size() > num.get_unsigned()) { if (enums.size() > num.get_unsigned()) {
//non-deterministic order change start head = m.mk_eq(m.mk_const(f), m.mk_const(enums[num.get_unsigned()]));
{
auto mk_const_1 = m.mk_const(f);
auto mk_const_2 = m.mk_const(enums[num.get_unsigned()]);
head = m.mk_eq(mk_const_1, mk_const_2);
}
//non-deterministic order change end
consequences[i] = m.mk_implies(a, head); consequences[i] = m.mk_implies(a, head);
} }
} }

18
src/tactic/fd_solver/smtfd_solver.cpp
View file

@ -314,26 +314,13 @@ namespace smtfd {
} }
family_id fid = a->get_family_id(); family_id fid = a->get_family_id();
if (m.is_eq(a)) { if (m.is_eq(a)) {
//non-deterministic order change start r = m.mk_eq(m_args.get(0), m_args.get(1));
{
auto get_1 = m_args.get(0);
auto get_2 = m_args.get(1);
r = m.mk_eq(get_1, get_2);
}
//non-deterministic order change end
} }
else if (m.is_distinct(a)) { else if (m.is_distinct(a)) {
r = m.mk_distinct(m_args.size(), m_args.data()); r = m.mk_distinct(m_args.size(), m_args.data());
} }
else if (m.is_ite(a)) { else if (m.is_ite(a)) {
//non-deterministic order change start r = m.mk_ite(m_args.get(0), m_args.get(1), m_args.get(2));
{
auto get_1 = m_args.get(0);
auto get_2 = m_args.get(1);
auto get_3 = m_args.get(2);
r = m.mk_ite(get_1, get_2, get_3);
}
//non-deterministic order change end
} }
else if (bvfid == fid || bfid == fid || pbfid == fid) { else if (bvfid == fid || bfid == fid || pbfid == fid) {
r = m.mk_app(a->get_decl(), m_args.size(), m_args.data()); r = m.mk_app(a->get_decl(), m_args.size(), m_args.data());
@ -1170,7 +1157,6 @@ namespace smtfd {
expr_ref a1(m_autil.mk_select(args), m); expr_ref a1(m_autil.mk_select(args), m);
args[0] = b; args[0] = b;
expr_ref b1(m_autil.mk_select(args), m); expr_ref b1(m_autil.mk_select(args), m);
//non-deterministic order no change: too complex
expr_ref ext(m.mk_iff(m.mk_eq(a1, b1), m.mk_eq(a, b)), m); expr_ref ext(m.mk_iff(m.mk_eq(a1, b1), m.mk_eq(a, b)), m);
if (!m.is_true(eval_abs(ext))) { if (!m.is_true(eval_abs(ext))) {
TRACE(smtfd, tout << mk_bounded_pp(a, m, 2) << " " << mk_bounded_pp(b, m, 2) << "\n";); TRACE(smtfd, tout << mk_bounded_pp(a, m, 2) << " " << mk_bounded_pp(b, m, 2) << "\n";);

14
src/util/sorting_network.h
View file

@ -343,7 +343,6 @@ Notes:
return mk_not(out[k]); return mk_not(out[k]);
} }
else { else {
//non-deterministic order no change: too complex
return mk_min(out[k-1], mk_not(out[k])); return mk_min(out[k-1], mk_not(out[k]));
} }
case sorting_network_encoding::unate_at_most: case sorting_network_encoding::unate_at_most:
@ -385,7 +384,6 @@ Notes:
} }
literal eq(unsigned k, unsigned n, unsigned const* ws, literal const* xs) { literal eq(unsigned k, unsigned n, unsigned const* ws, literal const* xs) {
//non-deterministic order no change: too complex
return mk_and(ge(k, n, ws, xs), le(k, n, ws, xs)); return mk_and(ge(k, n, ws, xs), le(k, n, ws, xs));
#if 0 #if 0
m_t = EQ; m_t = EQ;
@ -481,12 +479,7 @@ Notes:
for (unsigned j = last; j-- > 0; ) { for (unsigned j = last; j-- > 0; ) {
// c'[j] <-> (xs[i] & c[j-1]) | c[j] // c'[j] <-> (xs[i] & c[j-1]) | c[j]
literal c0 = j > 0 ? carry[j-1] : ctx.mk_true(); literal c0 = j > 0 ? carry[j-1] : ctx.mk_true();
//non-deterministic order change start carry[j] = mk_or(mk_and(xs[i], c0), carry[j]);
{
auto mk_and_1 = mk_and(xs[i], c0);
carry[j] = mk_or(mk_and_1, carry[j]);
}
//non-deterministic order change end
} }
} }
switch (cmp) { switch (cmp) {
@ -497,7 +490,6 @@ Notes:
case GE_FULL: case GE_FULL:
return carry[k-1]; return carry[k-1];
case EQ: case EQ:
//non-deterministic order no change: too complex
return mk_and(mk_not(carry[k]), carry[k-1]); return mk_and(mk_not(carry[k]), carry[k-1]);
default: default:
UNREACHABLE(); UNREACHABLE();
@ -530,7 +522,6 @@ Notes:
// out[i] = c + x[i] + y[i] // out[i] = c + x[i] + y[i]
// c' = c&x[i] | c&y[i] | x[i]&y[i]; // c' = c&x[i] | c&y[i] | x[i]&y[i];
literal_vector ors; literal_vector ors;
//non-deterministic order no change: too complex
ors.push_back(mk_and(c, mk_not(x[i]), mk_not(y[i]))); ors.push_back(mk_and(c, mk_not(x[i]), mk_not(y[i])));
ors.push_back(mk_and(x[i], mk_not(c), mk_not(y[i]))); ors.push_back(mk_and(x[i], mk_not(c), mk_not(y[i])));
ors.push_back(mk_and(y[i], mk_not(c), mk_not(x[i]))); ors.push_back(mk_and(y[i], mk_not(c), mk_not(x[i])));
@ -587,9 +578,7 @@ Notes:
literal_vector eqs; literal_vector eqs;
SASSERT(kvec.size() == out.size()); SASSERT(kvec.size() == out.size());
for (unsigned i = 0; i < num_bits; ++i) { for (unsigned i = 0; i < num_bits; ++i) {
//non-deterministic order no change: too complex
eqs.push_back(mk_or(mk_not(kvec[i]), out[i])); eqs.push_back(mk_or(mk_not(kvec[i]), out[i]));
//non-deterministic order no change: too complex
eqs.push_back(mk_or(kvec[i], mk_not(out[i]))); eqs.push_back(mk_or(kvec[i], mk_not(out[i])));
} }
eqs.push_back(mk_not(ovfl)); eqs.push_back(mk_not(ovfl));
@ -697,7 +686,6 @@ Notes:
case 1: case 1:
return ands[0]; return ands[0];
case 2: case 2:
//non-deterministic order no change: too complex
return mk_min(ands[0], ands[1]); return mk_min(ands[0], ands[1]);
default: { default: {
return ctx.mk_min(ands.size(), ands.data()); return ctx.mk_min(ands.size(), ands.data());