mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-20 04:43:39 +00:00
Code Activity

xor to xr to avoid clang issue

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-02-07 15:25:02 -08:00
parent fa0c75e76e
commit 61f99b242e
5 changed files with 114 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

128
src/sat/ba_solver.cpp
View file

@ -7,7 +7,7 @@ Module Name:
Abstract: Abstract:
Extension for cardinality and xor reasoning. Extension for cardinality and xr reasoning.
Author: Author:
@ -47,14 +47,14 @@ namespace sat {
return static_cast<pb const&>(*this); return static_cast<pb const&>(*this);
} }
ba_solver::xor& ba_solver::constraint::to_xor() { ba_solver::xr& ba_solver::constraint::to_xr() {
SASSERT(is_xor()); SASSERT(is_xr());
return static_cast<xor&>(*this); return static_cast<xr&>(*this);
} }
ba_solver::xor const& ba_solver::constraint::to_xor() const{ ba_solver::xr const& ba_solver::constraint::to_xr() const{
SASSERT(is_xor()); SASSERT(is_xr());
return static_cast<xor const&>(*this); return static_cast<xr const&>(*this);
} }
std::ostream& operator<<(std::ostream& out, ba_solver::constraint const& cnstr) { std::ostream& operator<<(std::ostream& out, ba_solver::constraint const& cnstr) {
@ -77,8 +77,8 @@ namespace sat {
out << " >= " << p.k(); out << " >= " << p.k();
break; break;
} }
case ba_solver::xor_t: { case ba_solver::xr_t: {
ba_solver::xor const& x = cnstr.to_xor(); ba_solver::xr const& x = cnstr.to_xr();
for (unsigned i = 0; i < x.size(); ++i) { for (unsigned i = 0; i < x.size(); ++i) {
out << x[i] << " "; out << x[i] << " ";
if (i + 1 < x.size()) out << "x "; if (i + 1 < x.size()) out << "x ";
@ -187,22 +187,22 @@ namespace sat {
// ----------------------------------- // -----------------------------------
// xor // xr
ba_solver::xor::xor(unsigned id, literal_vector const& lits): ba_solver::xr::xr(unsigned id, literal_vector const& lits):
constraint(xor_t, id, null_literal, lits.size(), get_obj_size(lits.size())) { constraint(xr_t, id, null_literal, lits.size(), get_obj_size(lits.size())) {
for (unsigned i = 0; i < size(); ++i) { for (unsigned i = 0; i < size(); ++i) {
m_lits[i] = lits[i]; m_lits[i] = lits[i];
} }
} }
bool ba_solver::xor::is_watching(literal l) const { bool ba_solver::xr::is_watching(literal l) const {
return return
l == (*this)[0] || l == (*this)[1] || l == (*this)[0] || l == (*this)[1] ||
~l == (*this)[0] || ~l == (*this)[1]; ~l == (*this)[0] || ~l == (*this)[1];
} }
bool ba_solver::xor::well_formed() const { bool ba_solver::xr::well_formed() const {
uint_set vars; uint_set vars;
if (lit() != null_literal) vars.insert(lit().var()); if (lit() != null_literal) vars.insert(lit().var());
for (literal l : *this) { for (literal l : *this) {
@ -305,7 +305,7 @@ namespace sat {
UNREACHABLE(); UNREACHABLE();
} }
SASSERT(validate_conflict(c)); SASSERT(validate_conflict(c));
if (c.is_xor() && value(lit) == l_true) lit.neg(); if (c.is_xr() && value(lit) == l_true) lit.neg();
SASSERT(value(lit) == l_false); SASSERT(value(lit) == l_false);
set_conflict(justification::mk_ext_justification(c.index()), ~lit); set_conflict(justification::mk_ext_justification(c.index()), ~lit);
SASSERT(inconsistent()); SASSERT(inconsistent());
@ -892,16 +892,16 @@ namespace sat {
// -------------------- // --------------------
// xor: // xr:
void ba_solver::clear_watch(xor& x) { void ba_solver::clear_watch(xr& x) {
unwatch_literal(x[0], x); unwatch_literal(x[0], x);
unwatch_literal(x[1], x); unwatch_literal(x[1], x);
unwatch_literal(~x[0], x); unwatch_literal(~x[0], x);
unwatch_literal(~x[1], x); unwatch_literal(~x[1], x);
} }
bool ba_solver::parity(xor const& x, unsigned offset) const { bool ba_solver::parity(xr const& x, unsigned offset) const {
bool odd = false; bool odd = false;
unsigned sz = x.size(); unsigned sz = x.size();
for (unsigned i = offset; i < sz; ++i) { for (unsigned i = offset; i < sz; ++i) {
@ -913,7 +913,7 @@ namespace sat {
return odd; return odd;
} }
bool ba_solver::init_watch(xor& x) { bool ba_solver::init_watch(xr& x) {
clear_watch(x); clear_watch(x);
if (x.lit() != null_literal && value(x.lit()) == l_false) { if (x.lit() != null_literal && value(x.lit()) == l_false) {
x.negate(); x.negate();
@ -957,7 +957,7 @@ namespace sat {
} }
lbool ba_solver::add_assign(xor& x, literal alit) { lbool ba_solver::add_assign(xr& x, literal alit) {
// literal is assigned // literal is assigned
unsigned sz = x.size(); unsigned sz = x.size();
TRACE("ba", tout << "assign: " << ~alit << "@" << lvl(~alit) << " " << x << "\n"; display(tout, x, true); ); TRACE("ba", tout << "assign: " << ~alit << "@" << lvl(~alit) << " " << x << "\n"; display(tout, x, true); );
@ -1223,12 +1223,12 @@ namespace sat {
for (literal l : m_lemma) process_antecedent(~l, offset); for (literal l : m_lemma) process_antecedent(~l, offset);
break; break;
} }
case xor_t: { case xr_t: {
// jus.push_back(js); // jus.push_back(js);
m_lemma.reset(); m_lemma.reset();
inc_bound(offset); inc_bound(offset);
inc_coeff(consequent, offset); inc_coeff(consequent, offset);
get_xor_antecedents(consequent, idx, js, m_lemma); get_xr_antecedents(consequent, idx, js, m_lemma);
for (literal l : m_lemma) process_antecedent(~l, offset); for (literal l : m_lemma) process_antecedent(~l, offset);
break; break;
} }
@ -1593,7 +1593,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: return init_watch(c.to_card()); case card_t: return init_watch(c.to_card());
case pb_t: return init_watch(c.to_pb()); case pb_t: return init_watch(c.to_pb());
case xor_t: return init_watch(c.to_xor()); case xr_t: return init_watch(c.to_xr());
} }
UNREACHABLE(); UNREACHABLE();
return false; return false;
@ -1603,7 +1603,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: return add_assign(c.to_card(), l); case card_t: return add_assign(c.to_card(), l);
case pb_t: return add_assign(c.to_pb(), l); case pb_t: return add_assign(c.to_pb(), l);
case xor_t: return add_assign(c.to_xor(), l); case xr_t: return add_assign(c.to_xr(), l);
} }
UNREACHABLE(); UNREACHABLE();
return l_undef; return l_undef;
@ -1632,13 +1632,13 @@ namespace sat {
add_pb_ge(lit, wlits, k, false); add_pb_ge(lit, wlits, k, false);
} }
void ba_solver::add_xor(literal_vector const& lits) { void ba_solver::add_xr(literal_vector const& lits) {
add_xor(lits, false); add_xr(lits, false);
} }
ba_solver::constraint* ba_solver::add_xor(literal_vector const& lits, bool learned) { ba_solver::constraint* ba_solver::add_xr(literal_vector const& lits, bool learned) {
void * mem = m_allocator.allocate(xor::get_obj_size(lits.size())); void * mem = m_allocator.allocate(xr::get_obj_size(lits.size()));
xor* x = new (mem) xor(next_id(), lits); xr* x = new (mem) xr(next_id(), lits);
x->set_learned(learned); x->set_learned(learned);
add_constraint(x); add_constraint(x);
for (literal l : lits) s().set_external(l.var()); // TBD: determine if goal2sat does this. for (literal l : lits) s().set_external(l.var()); // TBD: determine if goal2sat does this.
@ -1709,7 +1709,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: return get_reward(c.to_card(), occs); case card_t: return get_reward(c.to_card(), occs);
case pb_t: return get_reward(c.to_pb(), occs); case pb_t: return get_reward(c.to_pb(), occs);
case xor_t: return 0; case xr_t: return 0;
default: UNREACHABLE(); return 0; default: UNREACHABLE(); return 0;
} }
} }
@ -1737,11 +1737,11 @@ namespace sat {
} }
/** /**
\brief perform parity resolution on xor premises. \brief perform parity resolution on xr premises.
The idea is to collect premises based on xor resolvents. The idea is to collect premises based on xr resolvents.
Variables that are repeated an even number of times cancel out. Variables that are repeated an even number of times cancel out.
*/ */
void ba_solver::get_xor_antecedents(literal l, unsigned index, justification js, literal_vector& r) { void ba_solver::get_xr_antecedents(literal l, unsigned index, justification js, literal_vector& r) {
unsigned level = lvl(l); unsigned level = lvl(l);
bool_var v = l.var(); bool_var v = l.var();
SASSERT(js.get_kind() == justification::EXT_JUSTIFICATION); SASSERT(js.get_kind() == justification::EXT_JUSTIFICATION);
@ -1758,11 +1758,11 @@ namespace sat {
if (js.get_kind() == justification::EXT_JUSTIFICATION) { if (js.get_kind() == justification::EXT_JUSTIFICATION) {
constraint& c = index2constraint(js.get_ext_justification_idx()); constraint& c = index2constraint(js.get_ext_justification_idx());
TRACE("ba", tout << c << "\n";); TRACE("ba", tout << c << "\n";);
if (!c.is_xor()) { if (!c.is_xr()) {
r.push_back(l); r.push_back(l);
} }
else { else {
xor& x = c.to_xor(); xr& x = c.to_xr();
if (x[1].var() == l.var()) { if (x[1].var() == l.var()) {
x.swap(0, 1); x.swap(0, 1);
} }
@ -1959,7 +1959,7 @@ namespace sat {
} }
} }
void ba_solver::simplify(xor& x) { void ba_solver::simplify(xr& x) {
// no-op // no-op
} }
@ -1979,7 +1979,7 @@ namespace sat {
} }
} }
void ba_solver::get_antecedents(literal l, xor const& x, literal_vector& r) { void ba_solver::get_antecedents(literal l, xr const& x, literal_vector& r) {
if (x.lit() != null_literal) r.push_back(x.lit()); if (x.lit() != null_literal) r.push_back(x.lit());
// TRACE("ba", display(tout << l << " ", x, true);); // TRACE("ba", display(tout << l << " ", x, true););
SASSERT(x.lit() == null_literal || value(x.lit()) == l_true); SASSERT(x.lit() == null_literal || value(x.lit()) == l_true);
@ -2021,7 +2021,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: get_antecedents(l, c.to_card(), r); break; case card_t: get_antecedents(l, c.to_card(), r); break;
case pb_t: get_antecedents(l, c.to_pb(), r); break; case pb_t: get_antecedents(l, c.to_pb(), r); break;
case xor_t: get_antecedents(l, c.to_xor(), r); break; case xr_t: get_antecedents(l, c.to_xr(), r); break;
default: UNREACHABLE(); break; default: UNREACHABLE(); break;
} }
} }
@ -2042,8 +2042,8 @@ namespace sat {
case pb_t: case pb_t:
clear_watch(c.to_pb()); clear_watch(c.to_pb());
break; break;
case xor_t: case xr_t:
clear_watch(c.to_xor()); clear_watch(c.to_xr());
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();
@ -2066,7 +2066,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: return validate_unit_propagation(c.to_card(), l); case card_t: return validate_unit_propagation(c.to_card(), l);
case pb_t: return validate_unit_propagation(c.to_pb(), l); case pb_t: return validate_unit_propagation(c.to_pb(), l);
case xor_t: return true; case xr_t: return true;
default: UNREACHABLE(); break; default: UNREACHABLE(); break;
} }
return false; return false;
@ -2081,7 +2081,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: return eval(v1, eval(c.to_card())); case card_t: return eval(v1, eval(c.to_card()));
case pb_t: return eval(v1, eval(c.to_pb())); case pb_t: return eval(v1, eval(c.to_pb()));
case xor_t: return eval(v1, eval(c.to_xor())); case xr_t: return eval(v1, eval(c.to_xr()));
default: UNREACHABLE(); break; default: UNREACHABLE(); break;
} }
return l_undef; return l_undef;
@ -2120,7 +2120,7 @@ namespace sat {
return l_undef; return l_undef;
} }
lbool ba_solver::eval(xor const& x) const { lbool ba_solver::eval(xr const& x) const {
bool odd = false; bool odd = false;
for (auto l : x) { for (auto l : x) {
@ -2393,9 +2393,9 @@ namespace sat {
if (!clausify(c.to_pb())) if (!clausify(c.to_pb()))
simplify(c.to_pb()); simplify(c.to_pb());
break; break;
case xor_t: case xr_t:
if (!clausify(c.to_xor())) if (!clausify(c.to_xr()))
simplify(c.to_xor()); simplify(c.to_xr());
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();
@ -2551,7 +2551,7 @@ namespace sat {
case pb_t: case pb_t:
recompile(c.to_pb()); recompile(c.to_pb());
break; break;
case xor_t: case xr_t:
NOT_IMPLEMENTED_YET(); NOT_IMPLEMENTED_YET();
break; break;
default: default:
@ -2664,7 +2664,7 @@ namespace sat {
return false; return false;
} }
bool ba_solver::clausify(xor& x) { bool ba_solver::clausify(xr& x) {
return false; return false;
} }
@ -2730,7 +2730,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: split_root(c.to_card()); break; case card_t: split_root(c.to_card()); break;
case pb_t: split_root(c.to_pb()); break; case pb_t: split_root(c.to_pb()); break;
case xor_t: NOT_IMPLEMENTED_YET(); break; case xr_t: NOT_IMPLEMENTED_YET(); break;
} }
} }
@ -2843,8 +2843,8 @@ namespace sat {
} }
break; break;
} }
case xor_t: { case xr_t: {
xor& x = cp->to_xor(); xr& x = cp->to_xr();
for (literal l : x) { for (literal l : x) {
m_cnstr_use_list[l.index()].push_back(&x); m_cnstr_use_list[l.index()].push_back(&x);
m_cnstr_use_list[(~l).index()].push_back(&x); m_cnstr_use_list[(~l).index()].push_back(&x);
@ -3319,11 +3319,11 @@ namespace sat {
result->add_pb_ge(p.lit(), wlits, p.k(), p.learned()); result->add_pb_ge(p.lit(), wlits, p.k(), p.learned());
break; break;
} }
case xor_t: { case xr_t: {
xor const& x = cp->to_xor(); xr const& x = cp->to_xr();
lits.reset(); lits.reset();
for (literal l : x) lits.push_back(l); for (literal l : x) lits.push_back(l);
result->add_xor(lits, x.learned()); result->add_xr(lits, x.learned());
break; break;
} }
default: default:
@ -3355,8 +3355,8 @@ namespace sat {
} }
break; break;
} }
case xor_t: { case xr_t: {
xor const& x = cp->to_xor(); xr const& x = cp->to_xr();
for (literal l : x) { for (literal l : x) {
ul.insert(l, idx); ul.insert(l, idx);
ul.insert(~l, idx); ul.insert(~l, idx);
@ -3450,8 +3450,8 @@ namespace sat {
out << ">= " << ineq.m_k << "\n"; out << ">= " << ineq.m_k << "\n";
} }
void ba_solver::display(std::ostream& out, xor const& x, bool values) const { void ba_solver::display(std::ostream& out, xr const& x, bool values) const {
out << "xor: "; out << "xr: ";
for (literal l : x) { for (literal l : x) {
out << l; out << l;
if (values) { if (values) {
@ -3520,7 +3520,7 @@ namespace sat {
switch (c.tag()) { switch (c.tag()) {
case card_t: display(out, c.to_card(), values); break; case card_t: display(out, c.to_card(), values); break;
case pb_t: display(out, c.to_pb(), values); break; case pb_t: display(out, c.to_pb(), values); break;
case xor_t: display(out, c.to_xor(), values); break; case xr_t: display(out, c.to_xr(), values); break;
default: UNREACHABLE(); break; default: UNREACHABLE(); break;
} }
} }
@ -3612,7 +3612,7 @@ namespace sat {
return false; return false;
} }
bool ba_solver::validate_unit_propagation(xor const& x, literal alit) const { bool ba_solver::validate_unit_propagation(xr const& x, literal alit) const {
if (value(x.lit()) != l_true) return false; if (value(x.lit()) != l_true) return false;
for (unsigned i = 1; i < x.size(); ++i) { for (unsigned i = 1; i < x.size(); ++i) {
if (value(x[i]) == l_undef) return false; if (value(x[i]) == l_undef) return false;
@ -3827,14 +3827,14 @@ namespace sat {
if (p.lit() != null_literal) ineq.push(~p.lit(), p.k()); if (p.lit() != null_literal) ineq.push(~p.lit(), p.k());
break; break;
} }
case xor_t: { case xr_t: {
xor& x = cnstr.to_xor(); xr& x = cnstr.to_xr();
literal_vector ls; literal_vector ls;
get_antecedents(lit, x, ls); get_antecedents(lit, x, ls);
ineq.reset(offset); ineq.reset(offset);
for (literal l : ls) ineq.push(~l, offset); for (literal l : ls) ineq.push(~l, offset);
literal lxor = x.lit(); literal lxr = x.lit();
if (lxor != null_literal) ineq.push(~lxor, offset); if (lxr != null_literal) ineq.push(~lxr, offset);
break; break;
} }
default: default:

48
src/sat/ba_solver.h
View file

@ -51,12 +51,12 @@ namespace sat {
enum tag_t { enum tag_t {
card_t, card_t,
pb_t, pb_t,
xor_t xr_t
}; };
class card; class card;
class pb; class pb;
class xor; class xr;
class constraint { class constraint {
protected: protected:
@ -91,13 +91,13 @@ namespace sat {
size_t obj_size() const { return m_obj_size; } size_t obj_size() const { return m_obj_size; }
card& to_card(); card& to_card();
pb& to_pb(); pb& to_pb();
xor& to_xor(); xr& to_xr();
card const& to_card() const; card const& to_card() const;
pb const& to_pb() const; pb const& to_pb() const;
xor const& to_xor() const; xr const& to_xr() const;
bool is_card() const { return m_tag == card_t; } bool is_card() const { return m_tag == card_t; }
bool is_pb() const { return m_tag == pb_t; } bool is_pb() const { return m_tag == pb_t; }
bool is_xor() const { return m_tag == xor_t; } bool is_xr() const { return m_tag == xr_t; }
virtual bool is_watching(literal l) const { UNREACHABLE(); return false; }; virtual bool is_watching(literal l) const { UNREACHABLE(); return false; };
virtual literal_vector literals() const { UNREACHABLE(); return literal_vector(); } virtual literal_vector literals() const { UNREACHABLE(); return literal_vector(); }
@ -174,11 +174,11 @@ namespace sat {
virtual unsigned get_coeff(unsigned i) const { return m_wlits[i].first; } virtual unsigned get_coeff(unsigned i) const { return m_wlits[i].first; }
}; };
class xor : public constraint { class xr : public constraint {
literal m_lits[0]; literal m_lits[0];
public: public:
static size_t get_obj_size(unsigned num_lits) { return sizeof(xor) + num_lits * sizeof(literal); } static size_t get_obj_size(unsigned num_lits) { return sizeof(xr) + num_lits * sizeof(literal); }
xor(unsigned id, literal_vector const& lits); xr(unsigned id, literal_vector const& lits);
literal operator[](unsigned i) const { return m_lits[i]; } literal operator[](unsigned i) const { return m_lits[i]; }
literal const* begin() const { return m_lits; } literal const* begin() const { return m_lits; }
literal const* end() const { return begin() + m_size; } literal const* end() const { return begin() + m_size; }
@ -351,17 +351,17 @@ namespace sat {
double get_reward(card const& c, literal_occs_fun& occs) const; double get_reward(card const& c, literal_occs_fun& occs) const;
// xor specific functionality // xr specific functionality
void clear_watch(xor& x); void clear_watch(xr& x);
bool init_watch(xor& x); bool init_watch(xr& x);
bool parity(xor const& x, unsigned offset) const; bool parity(xr const& x, unsigned offset) const;
lbool add_assign(xor& x, literal alit); lbool add_assign(xr& x, literal alit);
void get_xor_antecedents(literal l, unsigned index, justification js, literal_vector& r); void get_xr_antecedents(literal l, unsigned index, justification js, literal_vector& r);
void get_antecedents(literal l, xor const& x, literal_vector & r); void get_antecedents(literal l, xr const& x, literal_vector & r);
void simplify(xor& x); void simplify(xr& x);
bool clausify(xor& x); bool clausify(xr& x);
void flush_roots(xor& x); void flush_roots(xr& x);
lbool eval(xor const& x) const; lbool eval(xr const& x) const;
// pb functionality // pb functionality
unsigned m_a_max; unsigned m_a_max;
@ -425,14 +425,14 @@ namespace sat {
// validation utilities // validation utilities
bool validate_conflict(card const& c) const; bool validate_conflict(card const& c) const;
bool validate_conflict(xor const& x) const; bool validate_conflict(xr const& x) const;
bool validate_conflict(pb const& p) const; bool validate_conflict(pb const& p) const;
bool validate_assign(literal_vector const& lits, literal lit); bool validate_assign(literal_vector const& lits, literal lit);
bool validate_lemma(); bool validate_lemma();
bool validate_unit_propagation(card const& c, literal alit) const; bool validate_unit_propagation(card const& c, literal alit) const;
bool validate_unit_propagation(pb const& p, literal alit) const; bool validate_unit_propagation(pb const& p, literal alit) const;
bool validate_unit_propagation(pb const& p, literal_vector const& r, literal alit) const; bool validate_unit_propagation(pb const& p, literal_vector const& r, literal alit) const;
bool validate_unit_propagation(xor const& x, literal alit) const; bool validate_unit_propagation(xr const& x, literal alit) const;
bool validate_conflict(literal_vector const& lits, ineq& p); bool validate_conflict(literal_vector const& lits, ineq& p);
bool validate_watch_literals() const; bool validate_watch_literals() const;
bool validate_watch_literal(literal lit) const; bool validate_watch_literal(literal lit) const;
@ -456,11 +456,11 @@ namespace sat {
void display(std::ostream& out, constraint const& c, bool values) const; void display(std::ostream& out, constraint const& c, bool values) const;
void display(std::ostream& out, card const& c, bool values) const; void display(std::ostream& out, card const& c, bool values) const;
void display(std::ostream& out, pb const& p, bool values) const; void display(std::ostream& out, pb const& p, bool values) const;
void display(std::ostream& out, xor const& c, bool values) const; void display(std::ostream& out, xr const& c, bool values) const;
constraint* add_at_least(literal l, literal_vector const& lits, unsigned k, bool learned); constraint* add_at_least(literal l, literal_vector const& lits, unsigned k, bool learned);
constraint* add_pb_ge(literal l, svector<wliteral> const& wlits, unsigned k, bool learned); constraint* add_pb_ge(literal l, svector<wliteral> const& wlits, unsigned k, bool learned);
constraint* add_xor(literal_vector const& lits, bool learned); constraint* add_xr(literal_vector const& lits, bool learned);
void copy_core(ba_solver* result, bool learned); void copy_core(ba_solver* result, bool learned);
void copy_constraints(ba_solver* result, ptr_vector<constraint> const& constraints); void copy_constraints(ba_solver* result, ptr_vector<constraint> const& constraints);
@ -472,7 +472,7 @@ namespace sat {
virtual void set_unit_walk(unit_walk* u) { m_unit_walk = u; } virtual void set_unit_walk(unit_walk* u) { m_unit_walk = u; }
void add_at_least(bool_var v, literal_vector const& lits, unsigned k); void add_at_least(bool_var v, literal_vector const& lits, unsigned k);
void add_pb_ge(bool_var v, svector<wliteral> const& wlits, unsigned k); void add_pb_ge(bool_var v, svector<wliteral> const& wlits, unsigned k);
void add_xor(literal_vector const& lits); void add_xr(literal_vector const& lits);
virtual bool propagate(literal l, ext_constraint_idx idx); virtual bool propagate(literal l, ext_constraint_idx idx);
virtual lbool resolve_conflict(); virtual lbool resolve_conflict();

2
src/sat/sat_local_search.cpp
View file

@ -400,7 +400,7 @@ namespace sat {
} }
break; break;
} }
case ba_solver::xor_t: case ba_solver::xr_t:
NOT_IMPLEMENTED_YET(); NOT_IMPLEMENTED_YET();
break; break;
} }

36
src/sat/sat_solver/inc_sat_solver.cpp
View file

@ -104,7 +104,7 @@ public:
virtual ~inc_sat_solver() {} virtual ~inc_sat_solver() {}
virtual solver* translate(ast_manager& dst_m, params_ref const& p) { solver* translate(ast_manager& dst_m, params_ref const& p) override {
if (m_num_scopes > 0) { if (m_num_scopes > 0) {
throw default_exception("Cannot translate sat solver at non-base level"); throw default_exception("Cannot translate sat solver at non-base level");
} }
@ -128,7 +128,7 @@ public:
return result; return result;
} }
virtual void set_progress_callback(progress_callback * callback) {} void set_progress_callback(progress_callback * callback) override {}
void display_weighted(std::ostream& out, unsigned sz, expr * const * assumptions, unsigned const* weights) { void display_weighted(std::ostream& out, unsigned sz, expr * const * assumptions, unsigned const* weights) {
if (weights != 0) { if (weights != 0) {
@ -160,7 +160,7 @@ public:
(m.is_not(e, e) && is_uninterp_const(e)); (m.is_not(e, e) && is_uninterp_const(e));
} }
virtual lbool check_sat(unsigned sz, expr * const * assumptions) { lbool check_sat(unsigned sz, expr * const * assumptions) override {
m_solver.pop_to_base_level(); m_solver.pop_to_base_level();
m_core.reset(); m_core.reset();
if (m_solver.inconsistent()) return l_false; if (m_solver.inconsistent()) return l_false;
@ -213,7 +213,8 @@ public:
} }
return r; return r;
} }
virtual void push() {
void push() override {
internalize_formulas(); internalize_formulas();
m_solver.user_push(); m_solver.user_push();
++m_num_scopes; ++m_num_scopes;
@ -223,7 +224,8 @@ public:
if (m_bb_rewriter) m_bb_rewriter->push(); if (m_bb_rewriter) m_bb_rewriter->push();
m_map.push(); m_map.push();
} }
virtual void pop(unsigned n) {
void pop(unsigned n) override {
if (n > m_num_scopes) { // allow inc_sat_solver to if (n > m_num_scopes) { // allow inc_sat_solver to
n = m_num_scopes; // take over for another solver. n = m_num_scopes; // take over for another solver.
} }
@ -243,9 +245,11 @@ public:
--n; --n;
} }
} }
unsigned get_scope_level() const override { unsigned get_scope_level() const override {
return m_num_scopes; return m_num_scopes;
} }
void assert_expr_core2(expr * t, expr * a) override { void assert_expr_core2(expr * t, expr * a) override {
if (a) { if (a) {
m_asmsf.push_back(a); m_asmsf.push_back(a);
@ -256,18 +260,18 @@ public:
} }
} }
virtual ast_manager& get_manager() const { return m; } ast_manager& get_manager() const override { return m; }
virtual void assert_expr_core(expr * t) { void assert_expr_core(expr * t) override {
TRACE("goal2sat", tout << mk_pp(t, m) << "\n";); TRACE("goal2sat", tout << mk_pp(t, m) << "\n";);
m_fmls.push_back(t); m_fmls.push_back(t);
} }
virtual void set_produce_models(bool f) {} void set_produce_models(bool f) override {}
virtual void collect_param_descrs(param_descrs & r) { void collect_param_descrs(param_descrs & r) override {
solver::collect_param_descrs(r); solver::collect_param_descrs(r);
goal2sat::collect_param_descrs(r); goal2sat::collect_param_descrs(r);
sat::solver::collect_param_descrs(r); sat::solver::collect_param_descrs(r);
} }
virtual void updt_params(params_ref const & p) { void updt_params(params_ref const & p) override {
m_params.append(p); m_params.append(p);
sat_params p1(p); sat_params p1(p);
m_params.set_bool("keep_cardinality_constraints", p1.cardinality_solver()); m_params.set_bool("keep_cardinality_constraints", p1.cardinality_solver());
@ -279,20 +283,20 @@ public:
m_solver.set_incremental(is_incremental() && !override_incremental()); m_solver.set_incremental(is_incremental() && !override_incremental());
} }
virtual void collect_statistics(statistics & st) const { void collect_statistics(statistics & st) const override {
if (m_preprocess) m_preprocess->collect_statistics(st); if (m_preprocess) m_preprocess->collect_statistics(st);
m_solver.collect_statistics(st); m_solver.collect_statistics(st);
} }
virtual void get_unsat_core(ptr_vector<expr> & r) { void get_unsat_core(ptr_vector<expr> & r) override {
r.reset(); r.reset();
r.append(m_core.size(), m_core.c_ptr()); r.append(m_core.size(), m_core.c_ptr());
} }
virtual proof * get_proof() { proof * get_proof() override {
UNREACHABLE(); UNREACHABLE();
return 0; return 0;
} }
virtual expr_ref_vector cube(expr_ref_vector& vs, unsigned backtrack_level) { expr_ref_vector cube(expr_ref_vector& vs, unsigned backtrack_level) override {
if (!is_internalized()) { if (!is_internalized()) {
lbool r = internalize_formulas(); lbool r = internalize_formulas();
if (r != l_true) return expr_ref_vector(m); if (r != l_true) return expr_ref_vector(m);
@ -332,7 +336,7 @@ public:
return fmls; return fmls;
} }
virtual lbool get_consequences_core(expr_ref_vector const& assumptions, expr_ref_vector const& vars, expr_ref_vector& conseq) { lbool get_consequences_core(expr_ref_vector const& assumptions, expr_ref_vector const& vars, expr_ref_vector& conseq) override {
init_preprocess(); init_preprocess();
TRACE("sat", tout << assumptions << "\n" << vars << "\n";); TRACE("sat", tout << assumptions << "\n" << vars << "\n";);
sat::literal_vector asms; sat::literal_vector asms;
@ -780,7 +784,7 @@ private:
} }
} }
virtual void get_model_core(model_ref & mdl) { void get_model_core(model_ref & mdl) override {
TRACE("sat", tout << "retrieve model " << (m_solver.model_is_current()?"present":"absent") << "\n";); TRACE("sat", tout << "retrieve model " << (m_solver.model_is_current()?"present":"absent") << "\n";);
if (!m_solver.model_is_current()) { if (!m_solver.model_is_current()) {
mdl = nullptr; mdl = nullptr;

8
src/sat/tactic/goal2sat.cpp
View file

@ -400,7 +400,7 @@ struct goal2sat::imp {
lits[i].neg(); lits[i].neg();
} }
ensure_extension(); ensure_extension();
m_ext->add_xor(lits); m_ext->add_xr(lits);
sat::literal lit(v, sign); sat::literal lit(v, sign);
if (root) { if (root) {
m_result_stack.reset(); m_result_stack.reset();
@ -1115,7 +1115,7 @@ struct sat2goal::imp {
r.assert_expr(fml); r.assert_expr(fml);
} }
void assert_xor(ref<mc>& mc, goal & r, sat::ba_solver::xor const& x) { void assert_xor(ref<mc>& mc, goal & r, sat::ba_solver::xr const& x) {
ptr_buffer<expr> lits; ptr_buffer<expr> lits;
for (sat::literal l : x) { for (sat::literal l : x) {
lits.push_back(lit2expr(mc, l)); lits.push_back(lit2expr(mc, l));
@ -1185,8 +1185,8 @@ struct sat2goal::imp {
case sat::ba_solver::pb_t: case sat::ba_solver::pb_t:
assert_pb(mc, r, c->to_pb()); assert_pb(mc, r, c->to_pb());
break; break;
case sat::ba_solver::xor_t: case sat::ba_solver::xr_t:
assert_xor(mc, r, c->to_xor()); assert_xor(mc, r, c->to_xr());
break; break;
} }
} }