mirror of
https://github.com/Z3Prover/z3
synced 2025-09-14 13:41:27 +00:00
Merge remote-tracking branch 'origin/master' into poly
This commit is contained in:
Jakob Rath
commit
183e911a79
260 changed files with 4131 additions and 3248 deletions
|
|
@ -1235,7 +1235,7 @@ static rational symmod(rational const& a, rational const& b) {
|
|||
if (2*r > b) r -= b;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & result) {
|
||||
set_curr_sort(arg1->get_sort());
|
||||
numeral v1, v2;
|
||||
|
|
@ -1297,9 +1297,9 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
|
|||
}
|
||||
|
||||
expr* x, *y;
|
||||
if (is_num2 && v2.is_pos() && m_util.is_mul(arg1, x, y) && m_util.is_numeral(x, v1, is_int) && divides(v1, v2)) {
|
||||
result = m_util.mk_mul(x, m_util.mk_mod(y, m_util.mk_int(v2/v1)));
|
||||
return BR_REWRITE2;
|
||||
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)) {
|
||||
result = m_util.mk_mul(m_util.mk_int(v1), m_util.mk_mod(y, m_util.mk_int(v2/v1)));
|
||||
return BR_REWRITE1;
|
||||
}
|
||||
|
||||
if (is_num2 && v2 == 2 && m_util.is_mul(arg1, x, y)) {
|
||||
|
|
@ -1310,6 +1310,27 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
|
|||
return BR_FAILED;
|
||||
}
|
||||
|
||||
bool arith_rewriter::get_range(expr* e, rational& lo, rational& hi) {
|
||||
expr* x, *y;
|
||||
rational r;
|
||||
if (m_util.is_idiv(e, x, y) && m_util.is_numeral(y, r) && get_range(x, lo, hi) && 0 <= lo && r > 0) {
|
||||
lo = div(lo, r);
|
||||
hi = div(hi, r);
|
||||
return true;
|
||||
}
|
||||
if (m_util.is_mod(e, x, y) && m_util.is_numeral(y, r) && r > 0) {
|
||||
lo = 0;
|
||||
hi = r - 1;
|
||||
return true;
|
||||
}
|
||||
if (m_util.is_numeral(e, r)) {
|
||||
lo = hi = r;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
br_status arith_rewriter::mk_rem_core(expr * arg1, expr * arg2, expr_ref & result) {
|
||||
set_curr_sort(arg1->get_sort());
|
||||
numeral v1, v2;
|
||||
|
|
@ -1454,7 +1475,7 @@ br_status arith_rewriter::mk_lshr_core(unsigned sz, expr* arg1, expr* arg2, expr
|
|||
}
|
||||
if (is_num_x && is_num_y) {
|
||||
if (y >= sz)
|
||||
result = m_util.mk_int(N-1);
|
||||
result = m_util.mk_int(0);
|
||||
else {
|
||||
rational d = div(x, rational::power_of_two(y.get_unsigned()));
|
||||
result = m_util.mk_int(d);
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ class arith_rewriter : public poly_rewriter<arith_rewriter_core> {
|
|||
bool m_eq2ineq;
|
||||
unsigned m_max_degree;
|
||||
|
||||
bool get_range(expr* e, rational& lo, rational& hi);
|
||||
void get_coeffs_gcd(expr * t, numeral & g, bool & first, unsigned & num_consts);
|
||||
enum const_treatment { CT_FLOOR, CT_CEIL, CT_FALSE };
|
||||
bool div_polynomial(expr * t, numeral const & g, const_treatment ct, expr_ref & result);
|
||||
|
|
|
|||
|
|
@ -206,7 +206,9 @@ br_status array_rewriter::mk_store_core(unsigned num_args, expr * const * args,
|
|||
bool array_rewriter::squash_store(unsigned n, expr* const* args, expr_ref& result) {
|
||||
ptr_buffer<expr> parents, sargs;
|
||||
expr* a = args[0];
|
||||
while (m_util.is_store(a)) {
|
||||
unsigned rounds = 0;
|
||||
while (m_util.is_store(a) && rounds < 10) {
|
||||
++rounds;
|
||||
lbool r = compare_args(n - 2, args + 1, to_app(a)->get_args() + 1);
|
||||
switch (r) {
|
||||
case l_undef:
|
||||
|
|
|
|||
|
|
@ -615,6 +615,8 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
|
|||
if (m_blast_quant) {
|
||||
if (m_bindings.empty())
|
||||
return false;
|
||||
if (!butil().is_bv(t))
|
||||
return false;
|
||||
unsigned shift = m_shifts.back();
|
||||
if (t->get_idx() >= m_bindings.size()) {
|
||||
if (shift == 0)
|
||||
|
|
|
|||
|
|
@ -545,16 +545,9 @@ bool bool_rewriter::local_ctx_simp(unsigned num_args, expr * const * args, expr_
|
|||
bool simp = false;
|
||||
bool modified = false;
|
||||
bool forward = true;
|
||||
unsigned rounds = 0;
|
||||
expr* narg;
|
||||
|
||||
while (true) {
|
||||
rounds++;
|
||||
#if 0
|
||||
if (rounds > 10)
|
||||
verbose_stream() << "rounds: " << rounds << "\n";
|
||||
#endif
|
||||
|
||||
|
||||
#define PROCESS_ARG() \
|
||||
{ \
|
||||
|
|
@ -699,6 +692,22 @@ app* bool_rewriter::mk_eq(expr* lhs, expr* rhs) {
|
|||
return m().mk_eq(lhs, rhs);
|
||||
}
|
||||
|
||||
bool bool_rewriter::try_ite_eq(expr* lhs, expr* rhs, expr_ref& r) {
|
||||
expr* c, *t, *e;
|
||||
if (!m().is_ite(lhs, c, t, e))
|
||||
return false;
|
||||
if (m().are_equal(t, rhs) && m().are_distinct(e, rhs)) {
|
||||
r = c;
|
||||
return true;
|
||||
}
|
||||
if (m().are_equal(e, rhs) && m().are_distinct(t, rhs)) {
|
||||
r = m().mk_not(c);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
br_status bool_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
||||
if (m().are_equal(lhs, rhs)) {
|
||||
result = m().mk_true();
|
||||
|
|
@ -713,6 +722,12 @@ br_status bool_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
|||
br_status r = BR_FAILED;
|
||||
|
||||
|
||||
if (try_ite_eq(lhs, rhs, result))
|
||||
return BR_REWRITE1;
|
||||
|
||||
if (try_ite_eq(rhs, lhs, result))
|
||||
return BR_REWRITE1;
|
||||
|
||||
if (m_ite_extra_rules) {
|
||||
if (m().is_ite(lhs) && m().is_value(rhs)) {
|
||||
r = try_ite_value(to_app(lhs), to_app(rhs), result);
|
||||
|
|
|
|||
|
|
@ -71,6 +71,8 @@ class bool_rewriter {
|
|||
|
||||
void mk_and_as_or(unsigned num_args, expr * const * args, expr_ref & result);
|
||||
|
||||
bool try_ite_eq(expr* lhs, expr* rhs, expr_ref& r);
|
||||
|
||||
expr * mk_or_app(unsigned num_args, expr * const * args);
|
||||
bool simp_nested_not_or(unsigned num_args, expr * const * args, expr_fast_mark1 & neg_lits, expr_fast_mark2 & pos_lits, expr_ref & result);
|
||||
expr * simp_arg(expr * arg, expr_fast_mark1 & neg_lits, expr_fast_mark2 & pos_lits, bool & modified);
|
||||
|
|
|
|||
|
|
@ -20,8 +20,9 @@ Notes:
|
|||
#include "ast/rewriter/bv_rewriter.h"
|
||||
#include "ast/rewriter/poly_rewriter_def.h"
|
||||
#include "ast/rewriter/bool_rewriter.h"
|
||||
#include "ast/ast_smt2_pp.h"
|
||||
#include "ast/ast_lt.h"
|
||||
#include "ast/ast_pp.h"
|
||||
|
||||
|
||||
|
||||
void bv_rewriter::updt_local_params(params_ref const & _p) {
|
||||
|
|
@ -54,45 +55,58 @@ void bv_rewriter::get_param_descrs(param_descrs & r) {
|
|||
br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
|
||||
SASSERT(f->get_family_id() == get_fid());
|
||||
|
||||
br_status st = BR_FAILED;
|
||||
switch(f->get_decl_kind()) {
|
||||
case OP_BIT0: SASSERT(num_args == 0); result = mk_zero(1); return BR_DONE;
|
||||
case OP_BIT1: SASSERT(num_args == 0); result = mk_one(1); return BR_DONE;
|
||||
case OP_ULEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ule(args[0], args[1], result);
|
||||
st = mk_ule(args[0], args[1], result);
|
||||
break;
|
||||
case OP_UGEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_uge(args[0], args[1], result);
|
||||
st = mk_uge(args[0], args[1], result);
|
||||
break;
|
||||
case OP_ULT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ult(args[0], args[1], result);
|
||||
st = mk_ult(args[0], args[1], result);
|
||||
break;
|
||||
case OP_UGT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ult(args[1], args[0], result);
|
||||
st = mk_ult(args[1], args[0], result);
|
||||
break;
|
||||
case OP_SLEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_sle(args[0], args[1], result);
|
||||
st = mk_sle(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SGEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_sge(args[0], args[1], result);
|
||||
st = mk_sge(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SLT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_slt(args[0], args[1], result);
|
||||
st = mk_slt(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SGT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_slt(args[1], args[0], result);
|
||||
st = mk_slt(args[1], args[0], result);
|
||||
break;
|
||||
case OP_BADD:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_bv_add(num_args, args, result);
|
||||
st = mk_bv_add(num_args, args, result);
|
||||
break;
|
||||
case OP_BMUL:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_bv_mul(num_args, args, result);
|
||||
st = mk_bv_mul(num_args, args, result);
|
||||
break;
|
||||
case OP_BSUB:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_sub(num_args, args, result);
|
||||
st = mk_sub(num_args, args, result);
|
||||
break;
|
||||
case OP_BNEG:
|
||||
SASSERT(num_args == 1);
|
||||
return mk_uminus(args[0], result);
|
||||
st = mk_uminus(args[0], result);
|
||||
break;
|
||||
case OP_BNEG_OVFL:
|
||||
SASSERT(num_args == 1);
|
||||
return mk_bvneg_overflow(args[0], result);
|
||||
|
|
@ -220,6 +234,13 @@ br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
|
|||
default:
|
||||
return BR_FAILED;
|
||||
}
|
||||
|
||||
CTRACE("bv", st != BR_FAILED, tout << mk_pp(f, m) << "\n";
|
||||
for (unsigned i = 0; i < num_args; ++i)
|
||||
tout << " " << mk_bounded_pp(args[i], m) << "\n";
|
||||
tout << mk_bounded_pp(result, m, 3) << "\n");
|
||||
|
||||
return st;
|
||||
}
|
||||
|
||||
br_status bv_rewriter::mk_ule(expr * a, expr * b, expr_ref & result) {
|
||||
|
|
@ -541,7 +562,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
|
|||
const br_status cst = rw_leq_concats(is_signed, a, b, result);
|
||||
if (cst != BR_FAILED) {
|
||||
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
|
||||
<< mk_ismt2_pp(a, m, 2) << "\n" << mk_ismt2_pp(b, m, 2) << "\n--->\n"<< mk_ismt2_pp(result, m, 2) << "\n";);
|
||||
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
|
||||
return cst;
|
||||
}
|
||||
}
|
||||
|
|
@ -550,7 +571,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
|
|||
const br_status cst = rw_leq_overflow(is_signed, a, b, result);
|
||||
if (cst != BR_FAILED) {
|
||||
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
|
||||
<< mk_ismt2_pp(a, m, 2) << "\n" << mk_ismt2_pp(b, m, 2) << "\n--->\n"<< mk_ismt2_pp(result, m, 2) << "\n";);
|
||||
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
|
||||
return cst;
|
||||
}
|
||||
}
|
||||
|
|
@ -802,8 +823,8 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
|
|||
const unsigned ep_rm = propagate_extract(high, arg, ep_res);
|
||||
if (ep_rm != 0) {
|
||||
result = m_mk_extract(high, low, ep_res);
|
||||
TRACE("extract_prop", tout << mk_ismt2_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
|
||||
<< mk_ismt2_pp(result.get(), m) << "\n";);
|
||||
TRACE("extract_prop", tout << mk_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
|
||||
<< mk_pp(result.get(), m) << "\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
}
|
||||
|
|
@ -1132,7 +1153,7 @@ br_status bv_rewriter::mk_bv_udiv_core(expr * arg1, expr * arg2, bool hi_div0, e
|
|||
m_util.mk_bv_udiv0(arg1),
|
||||
m_util.mk_bv_udiv_i(arg1, arg2));
|
||||
|
||||
TRACE("bv_udiv", tout << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n---->\n" << mk_ismt2_pp(result, m) << "\n";);
|
||||
TRACE("bv_udiv", tout << mk_pp(arg1, m) << "\n" << mk_pp(arg2, m) << "\n---->\n" << mk_pp(result, m) << "\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
|
||||
|
|
@ -1792,8 +1813,8 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
|
|||
std::reverse(exs.begin(), exs.end());
|
||||
result = m_util.mk_concat(exs.size(), exs.data());
|
||||
TRACE("mask_bug",
|
||||
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_ismt2_pp(t, m) << ")\n";
|
||||
tout << mk_ismt2_pp(result, m) << "))\n";);
|
||||
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_pp(t, m) << ")\n";
|
||||
tout << mk_pp(result, m) << "))\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
|
||||
|
|
@ -2463,7 +2484,7 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
|
|||
unsigned sz = get_bv_size(lhs);
|
||||
if (sz == 1)
|
||||
return BR_FAILED;
|
||||
TRACE("blast_eq_value", tout << "sz: " << sz << "\n" << mk_ismt2_pp(lhs, m) << "\n";);
|
||||
TRACE("blast_eq_value", tout << "sz: " << sz << "\n" << mk_pp(lhs, m) << "\n";);
|
||||
if (is_numeral(lhs))
|
||||
std::swap(lhs, rhs);
|
||||
|
||||
|
|
@ -2573,7 +2594,6 @@ void bv_rewriter::mk_t1_add_t2_eq_c(expr * t1, expr * t2, expr * c, expr_ref & r
|
|||
result = m.mk_eq(t1, m_util.mk_bv_sub(c, t2));
|
||||
}
|
||||
|
||||
#include "ast/ast_pp.h"
|
||||
|
||||
bool bv_rewriter::isolate_term(expr* lhs, expr* rhs, expr_ref& result) {
|
||||
if (!m_util.is_numeral(lhs) || !is_add(rhs)) {
|
||||
|
|
@ -2730,13 +2750,13 @@ br_status bv_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
|||
|
||||
st = mk_mul_eq(lhs, rhs, result);
|
||||
if (st != BR_FAILED) {
|
||||
TRACE("mk_mul_eq", tout << mk_ismt2_pp(lhs, m) << "\n=\n" << mk_ismt2_pp(rhs, m) << "\n----->\n" << mk_ismt2_pp(result,m) << "\n";);
|
||||
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
|
||||
return st;
|
||||
}
|
||||
|
||||
st = mk_mul_eq(rhs, lhs, result);
|
||||
if (st != BR_FAILED) {
|
||||
TRACE("mk_mul_eq", tout << mk_ismt2_pp(lhs, m) << "\n=\n" << mk_ismt2_pp(rhs, m) << "\n----->\n" << mk_ismt2_pp(result,m) << "\n";);
|
||||
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
|
||||
return st;
|
||||
}
|
||||
|
||||
|
|
@ -2851,8 +2871,8 @@ bool bv_rewriter::is_eq_bit(expr * t, expr * & x, unsigned & val) {
|
|||
|
||||
|
||||
br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & result) {
|
||||
TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_ismt2_pp(c, m) << "?\n"
|
||||
<< mk_ismt2_pp(t, m) << "\n:" << mk_ismt2_pp(e, m) << "\n";);
|
||||
TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_pp(c, m) << "?\n"
|
||||
<< mk_pp(t, m) << "\n:" << mk_pp(e, m) << "\n";);
|
||||
if (m.are_equal(t, e)) {
|
||||
result = e;
|
||||
return BR_REWRITE1;
|
||||
|
|
|
|||
|
|
@ -157,9 +157,7 @@ expr_ref pb_rewriter::mk_validate_rewrite(app_ref& e1, app_ref& e2) {
|
|||
continue;
|
||||
}
|
||||
|
||||
std::ostringstream strm;
|
||||
strm << 'x' << i;
|
||||
name = symbol(strm.str());
|
||||
name = symbol('x' + std::to_string(i));
|
||||
trail.push_back(m.mk_const(name, a.mk_int()));
|
||||
expr* x = trail.back();
|
||||
m.is_not(e,e);
|
||||
|
|
@ -188,9 +186,7 @@ void pb_rewriter::validate_rewrite(func_decl* f, unsigned sz, expr*const* args,
|
|||
}
|
||||
|
||||
void pb_rewriter::dump_pb_rewrite(expr* fml) {
|
||||
std::ostringstream strm;
|
||||
strm << "pb_rewrite_" << (s_lemma++) << ".smt2";
|
||||
std::ofstream out(strm.str());
|
||||
std::ofstream out("pb_rewrite_" + std::to_string(s_lemma++) + ".smt2");
|
||||
ast_smt_pp pp(m());
|
||||
pp.display_smt2(out, fml);
|
||||
out.close();
|
||||
|
|
|
|||
|
|
@ -3478,7 +3478,7 @@ expr_ref seq_rewriter::mk_antimirov_deriv_union(expr* d1, expr* d2) {
|
|||
//
|
||||
// restrict(d, false) = []
|
||||
//
|
||||
// it is already assumed that the restriction takes place witin a branch
|
||||
// it is already assumed that the restriction takes place within a branch
|
||||
// so the condition is not added explicitly but propagated down in order to eliminate
|
||||
// infeasible cases
|
||||
expr_ref seq_rewriter::mk_antimirov_deriv_restrict(expr* e, expr* d, expr* cond) {
|
||||
|
|
@ -3717,7 +3717,7 @@ expr_ref seq_rewriter::mk_regex_concat(expr* r, expr* s) {
|
|||
result = re().mk_plus(re().mk_full_char(ele_sort));
|
||||
else if (re().is_concat(r, r1, r2))
|
||||
// create the resulting concatenation in right-associative form except for the following case
|
||||
// TODO: maintain the followig invariant for A ++ B{m,n} + C
|
||||
// TODO: maintain the following invariant for A ++ B{m,n} + C
|
||||
// concat(concat(A, B{m,n}), C) (if A != () and C != ())
|
||||
// concat(B{m,n}, C) (if A == () and C != ())
|
||||
// where A, B, C are regexes
|
||||
|
|
@ -3725,11 +3725,11 @@ expr_ref seq_rewriter::mk_regex_concat(expr* r, expr* s) {
|
|||
// In other words, do not make A ++ B{m,n} into right-assoc form, but keep B{m,n} at the top
|
||||
// This will help to identify this situation in the merge routine:
|
||||
// concat(concat(A, B{0,m}), C) | concat(concat(A, B{0,n}), C)
|
||||
// simplies to
|
||||
// simplifies to
|
||||
// concat(concat(A, B{0,max(m,n)}), C)
|
||||
// analogously:
|
||||
// concat(concat(A, B{0,m}), C) & concat(concat(A, B{0,n}), C)
|
||||
// simplies to
|
||||
// simplifies to
|
||||
// concat(concat(A, B{0,min(m,n)}), C)
|
||||
result = mk_regex_concat(r1, mk_regex_concat(r2, s));
|
||||
else {
|
||||
|
|
@ -3850,12 +3850,12 @@ bool seq_rewriter::pred_implies(expr* a, expr* b) {
|
|||
Utility function to decide if two BDDs (nested if-then-else terms)
|
||||
have exactly the same structure and conditions.
|
||||
*/
|
||||
bool seq_rewriter::ite_bdds_compatabile(expr* a, expr* b) {
|
||||
bool seq_rewriter::ite_bdds_compatible(expr* a, expr* b) {
|
||||
expr* ca = nullptr, *a1 = nullptr, *a2 = nullptr;
|
||||
expr* cb = nullptr, *b1 = nullptr, *b2 = nullptr;
|
||||
if (m().is_ite(a, ca, a1, a2) && m().is_ite(b, cb, b1, b2)) {
|
||||
return (ca == cb) && ite_bdds_compatabile(a1, b1)
|
||||
&& ite_bdds_compatabile(a2, b2);
|
||||
return (ca == cb) && ite_bdds_compatible(a1, b1)
|
||||
&& ite_bdds_compatible(a2, b2);
|
||||
}
|
||||
else if (m().is_ite(a) || m().is_ite(b)) {
|
||||
return false;
|
||||
|
|
@ -3915,7 +3915,7 @@ expr_ref seq_rewriter::mk_der_op_rec(decl_kind k, expr* a, expr* b) {
|
|||
// sophisticated: in an antimirov union of n terms, we really
|
||||
// want to check if any pair of them is compatible.
|
||||
else if (m().is_ite(a) && m().is_ite(b) &&
|
||||
!ite_bdds_compatabile(a, b)) {
|
||||
!ite_bdds_compatible(a, b)) {
|
||||
k = _OP_RE_ANTIMIROV_UNION;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -4269,7 +4269,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
|
|||
}
|
||||
else if (re().is_reverse(r, r1)) {
|
||||
if (re().is_to_re(r1, r2)) {
|
||||
// First try to exctract hd and tl such that r = hd ++ tl and |tl|=1
|
||||
// First try to extract hd and tl such that r = hd ++ tl and |tl|=1
|
||||
expr_ref hd(m()), tl(m());
|
||||
if (get_head_tail_reversed(r2, hd, tl)) {
|
||||
// Use mk_der_cond to normalize
|
||||
|
|
|
|||
|
|
@ -201,7 +201,7 @@ class seq_rewriter {
|
|||
expr_ref mk_der_compl(expr* a);
|
||||
expr_ref mk_der_cond(expr* cond, expr* ele, sort* seq_sort);
|
||||
expr_ref mk_der_antimirov_union(expr* r1, expr* r2);
|
||||
bool ite_bdds_compatabile(expr* a, expr* b);
|
||||
bool ite_bdds_compatible(expr* a, expr* b);
|
||||
/* if r has the form deriv(en..deriv(e1,to_re(s))..) returns 's = [e1..en]' else returns '() in r'*/
|
||||
expr_ref is_nullable_symbolic_regex(expr* r, sort* seq_sort);
|
||||
#ifdef Z3DEBUG
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Module Name:
|
|||
Abstract:
|
||||
|
||||
Skolem function support for sequences.
|
||||
Skolem functions are auxiliary funcions useful for axiomatizing sequence
|
||||
Skolem functions are auxiliary functions useful for axiomatizing sequence
|
||||
operations.
|
||||
|
||||
Author:
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue