mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 09:05:31 +00:00
working on #5614
there are some different sources for the performance regression illustrated by the example. The mitigations will be enabled separately: - m_bv_to_propagate is too expensive - lp_bound_propagator misses equalities in two different ways: - it resets row checks after backtracking even though they could still propagate - it misses equalities for fixed rows when the fixed constant value does not correspond to a fixed variable. FYI @levnach
This commit is contained in:
Nikolaj Bjorner
parent
a94e2e62af
commit
87d4ce2659
13 changed files with 422 additions and 385 deletions
|
|
@ -262,22 +262,30 @@ namespace smt {
|
|||
}
|
||||
|
||||
void context::display_eqc(std::ostream & out) const {
|
||||
bool first = true;
|
||||
for (enode * x : m_enodes) {
|
||||
expr * n = x->get_expr();
|
||||
expr * r = x->get_root()->get_expr();
|
||||
if (n != r) {
|
||||
if (first) {
|
||||
out << "equivalence classes:\n";
|
||||
first = false;
|
||||
}
|
||||
out << "#" << n->get_id() << " -> #" << r->get_id() << ": ";
|
||||
out << mk_pp(n, m) << " -> " << mk_pp(r, m) << "\n";
|
||||
if (m_enodes.empty())
|
||||
return;
|
||||
unsigned count = 0;
|
||||
for (enode * r : m_enodes)
|
||||
if (r->is_root())
|
||||
++count;
|
||||
|
||||
out << "equivalence classes: " << count << "\n";
|
||||
for (enode * r : m_enodes) {
|
||||
if (!r->is_root())
|
||||
continue;
|
||||
out << "#" << enode_pp(r, *this) << "\n";
|
||||
if (r->get_class_size() == 1)
|
||||
continue;
|
||||
for (enode* n : *r) {
|
||||
if (n != r)
|
||||
out << " #" << enode_pp(n, *this) << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void context::display_app_enode_map(std::ostream & out) const {
|
||||
return;
|
||||
// mainly useless
|
||||
if (!m_e_internalized_stack.empty()) {
|
||||
out << "expression -> enode:\n";
|
||||
unsigned sz = m_e_internalized_stack.size();
|
||||
|
|
|
|||
|
|
@ -453,9 +453,6 @@ namespace smt {
|
|||
|
||||
std::ostream& display_flat_app(std::ostream & out, app * n) const;
|
||||
|
||||
std::ostream& display_var_def(std::ostream & out, theory_var v) const { return display_app(out, get_enode(v)->get_expr()); }
|
||||
|
||||
std::ostream& display_var_flat_def(std::ostream & out, theory_var v) const { return display_flat_app(out, get_enode(v)->get_expr()); }
|
||||
|
||||
protected:
|
||||
void log_axiom_instantiation(app * r, unsigned axiom_id = UINT_MAX, unsigned num_bindings = 0,
|
||||
|
|
|
|||
|
|
@ -2239,17 +2239,17 @@ namespace smt {
|
|||
|
||||
ctx.push_trail(value_trail<unsigned>(m_assume_eq_head));
|
||||
while (m_assume_eq_head < m_assume_eq_candidates.size()) {
|
||||
std::pair<theory_var, theory_var> const & p = m_assume_eq_candidates[m_assume_eq_head];
|
||||
theory_var v1 = p.first;
|
||||
theory_var v2 = p.second;
|
||||
auto const& [v1, v2] = m_assume_eq_candidates[m_assume_eq_head];
|
||||
enode* n1 = get_enode(v1);
|
||||
enode* n2 = get_enode(v2);
|
||||
m_assume_eq_head++;
|
||||
CTRACE("func_interp_bug",
|
||||
get_value(v1) == get_value(v2) &&
|
||||
get_enode(v1)->get_root() != get_enode(v2)->get_root(),
|
||||
tout << "assuming eq: #" << get_enode(v1)->get_owner_id() << " = #" << get_enode(v2)->get_owner_id() << "\n";);
|
||||
n1->get_root() != n2->get_root(),
|
||||
tout << "assuming eq: #" << n1->get_owner_id() << " = #" << n2->get_owner_id() << "\n";);
|
||||
if (get_value(v1) == get_value(v2) &&
|
||||
get_enode(v1)->get_root() != get_enode(v2)->get_root() &&
|
||||
assume_eq(get_enode(v1), get_enode(v2))) {
|
||||
n1->get_root() != n2->get_root() &&
|
||||
assume_eq(n1, n2)) {
|
||||
++m_stats.m_assume_eqs;
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,18 +82,17 @@ namespace smt {
|
|||
|
||||
template<typename Ext>
|
||||
void theory_arith<Ext>::display_row(std::ostream & out, row const & r, bool compact) const {
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
|
||||
out << "(v" << r.get_base_var() << ") : ";
|
||||
bool first = true;
|
||||
for (; it != end; ++it) {
|
||||
if (!it->is_dead()) {
|
||||
for (auto const& e : r) {
|
||||
if (!e.is_dead()) {
|
||||
if (first)
|
||||
first = false;
|
||||
else
|
||||
out << " + ";
|
||||
theory_var s = it->m_var;
|
||||
numeral const & c = it->m_coeff;
|
||||
theory_var s = e.m_var;
|
||||
numeral const & c = e.m_coeff;
|
||||
if (!c.is_one())
|
||||
out << c << "*";
|
||||
if (compact) {
|
||||
|
|
@ -103,7 +102,7 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
else
|
||||
display_var_flat_def(out, s);
|
||||
out << enode_pp(get_enode(s), ctx);
|
||||
}
|
||||
}
|
||||
out << "\n";
|
||||
|
|
@ -117,20 +116,16 @@ namespace smt {
|
|||
else
|
||||
out << "rows (expanded view):\n";
|
||||
unsigned num = m_rows.size();
|
||||
for (unsigned r_id = 0; r_id < num; r_id++) {
|
||||
if (m_rows[r_id].m_base_var != null_theory_var) {
|
||||
for (unsigned r_id = 0; r_id < num; r_id++)
|
||||
if (m_rows[r_id].m_base_var != null_theory_var)
|
||||
display_row(out, r_id, compact);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
void theory_arith<Ext>::display_row_shape(std::ostream & out, row const & r) const {
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it) {
|
||||
if (!it->is_dead()) {
|
||||
numeral const & c = it->m_coeff;
|
||||
for (auto const& e : r) {
|
||||
if (!e.is_dead()) {
|
||||
numeral const & c = e.m_coeff;
|
||||
if (c.is_one())
|
||||
out << "1";
|
||||
else if (c.is_minus_one())
|
||||
|
|
@ -150,11 +145,9 @@ namespace smt {
|
|||
|
||||
template<typename Ext>
|
||||
bool theory_arith<Ext>::is_one_minus_one_row(row const & r) const {
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it) {
|
||||
if (!it->is_dead()) {
|
||||
numeral const & c = it->m_coeff;
|
||||
for (auto const& e : r) {
|
||||
if (!e.is_dead()) {
|
||||
numeral const & c = e.m_coeff;
|
||||
if (!c.is_one() && !c.is_minus_one())
|
||||
return false;
|
||||
}
|
||||
|
|
@ -184,11 +177,9 @@ namespace smt {
|
|||
for (unsigned r_id = 0; r_id < num; r_id++) {
|
||||
row const & r = m_rows[r_id];
|
||||
if (r.m_base_var != null_theory_var) {
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it) {
|
||||
if (!it->is_dead()) {
|
||||
numeral const & c = it->m_coeff;
|
||||
for (auto const& e : r) {
|
||||
if (!e.is_dead()) {
|
||||
numeral const & c = e.m_coeff;
|
||||
if (c.to_rational().is_big()) {
|
||||
std::string str = c.to_rational().to_string();
|
||||
if (str.length() > 48)
|
||||
|
|
@ -215,11 +206,9 @@ namespace smt {
|
|||
row const & r = m_rows[r_id];
|
||||
if (r.m_base_var != null_theory_var) {
|
||||
num_rows++;
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it) {
|
||||
if (!it->is_dead()) {
|
||||
numeral const & c = it->m_coeff;
|
||||
for (auto const& e : r) {
|
||||
if (!e.is_dead()) {
|
||||
numeral const & c = e.m_coeff;
|
||||
num_non_zeros++;
|
||||
if (c.is_one())
|
||||
num_ones++;
|
||||
|
|
@ -284,11 +273,9 @@ namespace smt {
|
|||
template<typename Ext>
|
||||
void theory_arith<Ext>::display_row_info(std::ostream & out, row const & r) const {
|
||||
display_row(out, r, true);
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it)
|
||||
if (!it->is_dead())
|
||||
display_var(out, it->m_var);
|
||||
for (auto const& e : r)
|
||||
if (!e.is_dead())
|
||||
display_var(out, e.m_var);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -298,15 +285,14 @@ namespace smt {
|
|||
void theory_arith<Ext>::display_simplified_row(std::ostream & out, row const & r) const {
|
||||
bool has_rat_coeff = false;
|
||||
numeral k;
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
|
||||
out << "(v" << r.get_base_var() << ") : ";
|
||||
bool first = true;
|
||||
for (; it != end; ++it) {
|
||||
if (it->is_dead())
|
||||
for (auto const& e : r) {
|
||||
if (e.is_dead())
|
||||
continue;
|
||||
theory_var v = it->m_var;
|
||||
numeral const & c = it->m_coeff;
|
||||
theory_var v = e.m_var;
|
||||
numeral const & c = e.m_coeff;
|
||||
if (is_fixed(v)) {
|
||||
k += c * lower_bound(v).get_rational();
|
||||
continue;
|
||||
|
|
@ -328,11 +314,9 @@ namespace smt {
|
|||
}
|
||||
out << "\n";
|
||||
if (has_rat_coeff) {
|
||||
typename vector<row_entry>::const_iterator it = r.begin_entries();
|
||||
typename vector<row_entry>::const_iterator end = r.end_entries();
|
||||
for (; it != end; ++it)
|
||||
if (!it->is_dead() && (is_base(it->m_var) || (!is_fixed(it->m_var) && (lower(it->m_var) || upper(it->m_var)))))
|
||||
display_var(out, it->m_var);
|
||||
for (auto const& e : r)
|
||||
if (!e.is_dead() && (is_base(e.m_var) || (!is_fixed(e.m_var) && (lower(e.m_var) || upper(e.m_var)))))
|
||||
display_var(out, e.m_var);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -385,8 +369,7 @@ namespace smt {
|
|||
out << ", shared: " << get_context().is_shared(get_enode(v));
|
||||
out << ", unassigned: " << m_unassigned_atoms[v];
|
||||
out << ", rel: " << get_context().is_relevant(get_enode(v));
|
||||
out << ", def: ";
|
||||
display_var_flat_def(out, v);
|
||||
out << ", def: " << enode_pp(get_enode(v), ctx);
|
||||
out << "\n";
|
||||
}
|
||||
|
||||
|
|
@ -477,28 +460,17 @@ namespace smt {
|
|||
theory_var v = a->get_var();
|
||||
inf_numeral const & k = a->get_k();
|
||||
enode * e = get_enode(v);
|
||||
if (show_sign) {
|
||||
if (!a->is_true())
|
||||
out << "not ";
|
||||
else
|
||||
out << " ";
|
||||
}
|
||||
if (show_sign)
|
||||
out << (a->is_true()?" ":"not ");
|
||||
out << "v";
|
||||
out.width(3);
|
||||
out << std::left << v << " #";
|
||||
out.width(3);
|
||||
out << e->get_owner_id();
|
||||
out << std::right;
|
||||
out << " ";
|
||||
if (a->get_atom_kind() == A_LOWER)
|
||||
out << ">=";
|
||||
else
|
||||
out << "<=";
|
||||
out << " ";
|
||||
out << " " << ((a->get_atom_kind() == A_LOWER)? ">=" : "<=") << " ";
|
||||
out.width(6);
|
||||
out << k << " ";
|
||||
display_var_flat_def(out, v);
|
||||
out << "\n";
|
||||
out << k << " " << enode_pp(get_enode(v), ctx) << "\n";
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
|
|
|
|||
|
|
@ -173,8 +173,8 @@ class theory_lra::imp {
|
|||
unsigned_vector m_bounds_trail;
|
||||
unsigned m_asserted_qhead;
|
||||
|
||||
svector<unsigned> m_to_check; // rows that should be checked for theory propagation
|
||||
|
||||
svector<unsigned> m_bv_to_propagate; // Boolean variables that can be propagated
|
||||
|
||||
svector<std::pair<theory_var, theory_var> > m_assume_eq_candidates;
|
||||
unsigned m_assume_eq_head;
|
||||
lp::u_set m_tmp_var_set;
|
||||
|
|
@ -233,6 +233,7 @@ class theory_lra::imp {
|
|||
resource_limit m_resource_limit;
|
||||
lp_bounds m_new_bounds;
|
||||
symbol m_farkas;
|
||||
vector<parameter> m_bound_params;
|
||||
lp::lp_bound_propagator<imp> m_bp;
|
||||
|
||||
context& ctx() const { return th.get_context(); }
|
||||
|
|
@ -870,6 +871,10 @@ public:
|
|||
m_bound_terms(m),
|
||||
m_bound_predicate(m)
|
||||
{
|
||||
m_bound_params.push_back(parameter(m_farkas));
|
||||
m_bound_params.push_back(parameter(rational(1)));
|
||||
m_bound_params.push_back(parameter(rational(1)));
|
||||
|
||||
}
|
||||
|
||||
~imp() {
|
||||
|
|
@ -1071,7 +1076,7 @@ public:
|
|||
lp().pop(num_scopes);
|
||||
// VERIFY(l_false != make_feasible());
|
||||
m_new_bounds.reset();
|
||||
m_to_check.reset();
|
||||
m_bv_to_propagate.reset();
|
||||
if (m_nla)
|
||||
m_nla->pop(num_scopes);
|
||||
TRACE("arith", tout << "num scopes: " << num_scopes << " new scope level: " << m_scopes.size() << "\n";);
|
||||
|
|
@ -1493,29 +1498,24 @@ public:
|
|||
|
||||
ctx().push_trail(value_trail<unsigned>(m_assume_eq_head));
|
||||
while (m_assume_eq_head < m_assume_eq_candidates.size()) {
|
||||
std::pair<theory_var, theory_var> const & p = m_assume_eq_candidates[m_assume_eq_head];
|
||||
theory_var v1 = p.first;
|
||||
theory_var v2 = p.second;
|
||||
auto const [v1, v2] = m_assume_eq_candidates[m_assume_eq_head];
|
||||
enode* n1 = get_enode(v1);
|
||||
enode* n2 = get_enode(v2);
|
||||
m_assume_eq_head++;
|
||||
CTRACE("arith",
|
||||
is_eq(v1, v2) && n1->get_root() != n2->get_root(),
|
||||
tout << "assuming eq: v" << v1 << " = v" << v2 << "\n";);
|
||||
if (is_eq(v1, v2) && n1->get_root() != n2->get_root() && th.assume_eq(n1, n2)) {
|
||||
if (is_eq(v1, v2) && n1->get_root() != n2->get_root() && th.assume_eq(n1, n2))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool is_eq(theory_var v1, theory_var v2) {
|
||||
if (use_nra_model()) {
|
||||
if (use_nra_model())
|
||||
return m_nla->am().eq(nl_value(v1, *m_a1), nl_value(v2, *m_a2));
|
||||
}
|
||||
else {
|
||||
else
|
||||
return get_ivalue(v1) == get_ivalue(v2);
|
||||
}
|
||||
}
|
||||
|
||||
bool has_delayed_constraints() const {
|
||||
|
|
@ -1523,6 +1523,8 @@ public:
|
|||
}
|
||||
|
||||
final_check_status final_check_eh() {
|
||||
if (propagate_core())
|
||||
return FC_CONTINUE;
|
||||
m_model_is_initialized = false;
|
||||
IF_VERBOSE(12, verbose_stream() << "final-check " << lp().get_status() << "\n");
|
||||
lbool is_sat = l_true;
|
||||
|
|
@ -1534,9 +1536,7 @@ public:
|
|||
|
||||
switch (is_sat) {
|
||||
case l_true:
|
||||
TRACE("arith", display(tout);
|
||||
/* ctx().display(tout);*/
|
||||
);
|
||||
TRACE("arith", display(tout));
|
||||
|
||||
switch (check_lia()) {
|
||||
case l_true:
|
||||
|
|
@ -2048,41 +2048,59 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
bool m_new_def{ false };
|
||||
bool m_new_def = false ;
|
||||
|
||||
bool adaptive() const { return ctx().get_fparams().m_arith_adaptive; }
|
||||
double adaptive_assertion_threshold() const { return ctx().get_fparams().m_arith_adaptive_assertion_threshold; }
|
||||
|
||||
bool process_atoms() const {
|
||||
if (!adaptive())
|
||||
return true;
|
||||
unsigned total_conflicts = ctx().get_num_conflicts();
|
||||
if (total_conflicts < 10)
|
||||
return true;
|
||||
double f = static_cast<double>(m_num_conflicts)/static_cast<double>(total_conflicts);
|
||||
return f >= adaptive_assertion_threshold();
|
||||
}
|
||||
|
||||
bool can_propagate() {
|
||||
return process_atoms() && can_propagate_core();
|
||||
}
|
||||
|
||||
bool can_propagate_core() {
|
||||
return m_asserted_atoms.size() > m_asserted_qhead || m_new_def;
|
||||
}
|
||||
|
||||
void propagate() {
|
||||
bool propagate() {
|
||||
return process_atoms() && propagate_core();
|
||||
}
|
||||
|
||||
bool propagate_core() {
|
||||
m_model_is_initialized = false;
|
||||
flush_bound_axioms();
|
||||
if (!can_propagate()) {
|
||||
return;
|
||||
}
|
||||
m_new_def = false;
|
||||
if (!can_propagate_core())
|
||||
return false;
|
||||
m_new_def = false;
|
||||
while (m_asserted_qhead < m_asserted_atoms.size() && !ctx().inconsistent() && m.inc()) {
|
||||
bool_var bv = m_asserted_atoms[m_asserted_qhead].m_bv;
|
||||
bool is_true = m_asserted_atoms[m_asserted_qhead].m_is_true;
|
||||
m_to_check.push_back(bv);
|
||||
auto [bv, is_true] = m_asserted_atoms[m_asserted_qhead];
|
||||
|
||||
m_bv_to_propagate.push_back(bv);
|
||||
|
||||
api_bound* b = nullptr;
|
||||
TRACE("arith", tout << "propagate: " << literal(bv, !is_true) << "\n";);
|
||||
if (m_bool_var2bound.find(bv, b)) {
|
||||
TRACE("arith", tout << "propagate: " << literal(bv, !is_true) << "\n";
|
||||
if (!m_bool_var2bound.contains(bv)) tout << "not found\n");
|
||||
if (m_bool_var2bound.find(bv, b))
|
||||
assert_bound(bv, is_true, *b);
|
||||
}
|
||||
else {
|
||||
TRACE("arith", tout << "not found " << bv << "\n";);
|
||||
}
|
||||
++m_asserted_qhead;
|
||||
}
|
||||
if (ctx().inconsistent()) {
|
||||
m_to_check.reset();
|
||||
return;
|
||||
m_bv_to_propagate.reset();
|
||||
return true;
|
||||
}
|
||||
|
||||
lbool lbl = make_feasible();
|
||||
if (!m.inc())
|
||||
return;
|
||||
return false;
|
||||
|
||||
switch(lbl) {
|
||||
case l_false:
|
||||
|
|
@ -2096,7 +2114,7 @@ public:
|
|||
case l_undef:
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool should_propagate() const {
|
||||
|
|
@ -2246,26 +2264,28 @@ public:
|
|||
assign(bound, m_core, m_eqs, m_params);
|
||||
}
|
||||
|
||||
void add_eq(lpvar u, lpvar v, lp::explanation const& e) {
|
||||
bool add_eq(lpvar u, lpvar v, lp::explanation const& e, bool is_fixed) {
|
||||
if (ctx().inconsistent())
|
||||
return;
|
||||
return false;
|
||||
theory_var uv = lp().local_to_external(u); // variables that are returned should have external representations
|
||||
theory_var vv = lp().local_to_external(v); // so maybe better to have them already transformed to external form
|
||||
enode* n1 = get_enode(uv);
|
||||
enode* n2 = get_enode(vv);
|
||||
|
||||
TRACE("arith", tout << "add-eq " << mk_pp(n1->get_expr(), m) << " == " << mk_pp(n2->get_expr(), m) << " " << n1->get_expr_id() << " == " << n2->get_expr_id() << "\n";);
|
||||
if (n1->get_root() == n2->get_root())
|
||||
return;
|
||||
return false;
|
||||
expr* e1 = n1->get_expr();
|
||||
expr* e2 = n2->get_expr();
|
||||
if (e1->get_sort() != e2->get_sort())
|
||||
return;
|
||||
if (m.is_ite(e1) || m.is_ite(e2))
|
||||
return;
|
||||
return false;
|
||||
if (!is_fixed && !a.is_numeral(e1) && !a.is_numeral(e2) && (m.is_ite(e1) || m.is_ite(e2)))
|
||||
return false;
|
||||
reset_evidence();
|
||||
for (auto ev : e)
|
||||
set_evidence(ev.ci(), m_core, m_eqs);
|
||||
assign_eq(uv, vv);
|
||||
return true;
|
||||
}
|
||||
|
||||
literal_vector m_core2;
|
||||
|
|
@ -2440,6 +2460,7 @@ public:
|
|||
typedef lp_bounds::iterator iterator;
|
||||
|
||||
void flush_bound_axioms() {
|
||||
|
||||
CTRACE("arith", !m_new_bounds.empty(), tout << "flush bound axioms\n";);
|
||||
|
||||
while (!m_new_bounds.empty()) {
|
||||
|
|
@ -2458,7 +2479,7 @@ public:
|
|||
CTRACE("arith", atoms.size() > 1,
|
||||
for (auto* a : atoms) a->display(tout) << "\n";);
|
||||
lp_bounds occs(m_bounds[v]);
|
||||
|
||||
|
||||
std::sort(atoms.begin(), atoms.end(), compare_bounds());
|
||||
std::sort(occs.begin(), occs.end(), compare_bounds());
|
||||
|
||||
|
|
@ -2558,14 +2579,15 @@ public:
|
|||
}
|
||||
|
||||
void propagate_basic_bounds() {
|
||||
for (auto const& bv : m_to_check) {
|
||||
for (auto const& bv : m_bv_to_propagate) {
|
||||
api_bound* b = nullptr;
|
||||
if (m_bool_var2bound.find(bv, b)) {
|
||||
propagate_bound(bv, ctx().get_assignment(bv) == l_true, *b);
|
||||
if (ctx().inconsistent()) break;
|
||||
if (ctx().inconsistent())
|
||||
break;
|
||||
}
|
||||
}
|
||||
m_to_check.reset();
|
||||
m_bv_to_propagate.reset();
|
||||
}
|
||||
|
||||
// for glb lo': lo' < lo:
|
||||
|
|
@ -2633,10 +2655,7 @@ public:
|
|||
ctx().display_literals_verbose(tout, m_core);
|
||||
ctx().display_literal_verbose(tout << " => ", lit2);
|
||||
tout << "\n";);
|
||||
m_params.push_back(parameter(m_farkas));
|
||||
m_params.push_back(parameter(rational(1)));
|
||||
m_params.push_back(parameter(rational(1)));
|
||||
assign(lit2, m_core, m_eqs, m_params);
|
||||
assign(lit2, m_core, m_eqs, m_bound_params);
|
||||
++m_stats.m_bounds_propagations;
|
||||
}
|
||||
|
||||
|
|
@ -3194,7 +3213,7 @@ public:
|
|||
m_assume_eq_head = 0;
|
||||
m_scopes.reset();
|
||||
m_stats.reset();
|
||||
m_to_check.reset();
|
||||
m_bv_to_propagate.reset();
|
||||
m_model_is_initialized = false;
|
||||
}
|
||||
|
||||
|
|
@ -3661,7 +3680,7 @@ public:
|
|||
else if (can_get_value(v)) out << " = " << get_value(v);
|
||||
if (is_int(v)) out << ", int";
|
||||
if (ctx().is_shared(get_enode(v))) out << ", shared";
|
||||
out << " := "; th.display_var_flat_def(out, v) << "\n";
|
||||
out << " := " << enode_pp(get_enode(v), ctx()) << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue