mirror of
https://github.com/Z3Prover/z3
synced 2025-04-28 19:35:50 +00:00
testing maxres with sat core
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
parent
b928734348
commit
8814ba0629
12 changed files with 187 additions and 298 deletions
|
|
@ -321,9 +321,12 @@ public:
|
|||
}
|
||||
|
||||
lbool minimize_core(ptr_vector<expr>& core) {
|
||||
if (m_sat_enabled) {
|
||||
return l_true;
|
||||
}
|
||||
m_mus.reset();
|
||||
for (unsigned i = 0; i < core.size(); ++i) {
|
||||
m_mus.add_soft(core[i], 1, core.c_ptr() + i);
|
||||
m_mus.add_soft(core[i]);
|
||||
}
|
||||
unsigned_vector mus_idx;
|
||||
lbool is_sat = m_mus.get_mus(mus_idx);
|
||||
|
|
|
|||
|
|
@ -27,16 +27,9 @@ using namespace opt;
|
|||
|
||||
|
||||
class maxres : public maxsmt_solver_base {
|
||||
struct info {
|
||||
app* m_cls;
|
||||
rational m_weight;
|
||||
info(app* cls, rational const& w):
|
||||
m_cls(cls), m_weight(w) {}
|
||||
info(): m_cls(0) {}
|
||||
};
|
||||
expr_ref_vector m_B;
|
||||
expr_ref_vector m_asms;
|
||||
obj_map<expr, info> m_asm2info;
|
||||
obj_map<expr, rational> m_asm2weight;
|
||||
ptr_vector<expr> m_new_core;
|
||||
mus m_mus;
|
||||
expr_ref_vector m_trail;
|
||||
|
|
@ -63,14 +56,12 @@ public:
|
|||
TRACE("opt", tout << mk_pp(e, m) << "\n";);
|
||||
expr_ref asum(m), fml(m);
|
||||
app_ref cls(m);
|
||||
info inf(0,rational(0));
|
||||
if (m_asm2info.find(e, inf)) {
|
||||
inf.m_weight += w;
|
||||
m_asm2info.insert(e, inf);
|
||||
rational weight(0);
|
||||
if (m_asm2weight.find(e, weight)) {
|
||||
weight += w;
|
||||
m_asm2weight.insert(e, weight);
|
||||
return;
|
||||
}
|
||||
cls = mk_cls(e);
|
||||
m_trail.push_back(cls);
|
||||
if (is_literal(e)) {
|
||||
asum = e;
|
||||
}
|
||||
|
|
@ -79,21 +70,18 @@ public:
|
|||
fml = m.mk_iff(asum, e);
|
||||
m_s->assert_expr(fml);
|
||||
}
|
||||
new_assumption(asum, cls, w);
|
||||
new_assumption(asum, w);
|
||||
m_upper += w;
|
||||
}
|
||||
|
||||
void new_assumption(expr* e, app* cls, rational const& w) {
|
||||
void new_assumption(expr* e, rational const& w) {
|
||||
TRACE("opt", tout << "insert: " << mk_pp(e, m) << " : " << w << "\n";);
|
||||
info inf(cls, w);
|
||||
m_asm2info.insert(e, inf);
|
||||
m_asm2weight.insert(e, w);
|
||||
m_asms.push_back(e);
|
||||
m_trail.push_back(e);
|
||||
}
|
||||
|
||||
lbool operator()() {
|
||||
expr_ref fml(m);
|
||||
ptr_vector<expr> core;
|
||||
solver::scoped_push _sc(*m_s.get());
|
||||
init();
|
||||
init_local();
|
||||
|
|
@ -125,28 +113,13 @@ public:
|
|||
m_upper = m_lower;
|
||||
return l_true;
|
||||
}
|
||||
case l_false:
|
||||
is_sat = process_unsat();
|
||||
if (is_sat != l_true) return is_sat;
|
||||
break;
|
||||
case l_undef:
|
||||
return l_undef;
|
||||
default:
|
||||
core.reset();
|
||||
m_s->get_unsat_core(core);
|
||||
TRACE("opt", display_vec(tout << "core: ", core.size(), core.c_ptr()););
|
||||
SASSERT(!core.empty());
|
||||
is_sat = minimize_core(core);
|
||||
SASSERT(!core.empty());
|
||||
if (core.empty()) {
|
||||
return l_false;
|
||||
}
|
||||
if (is_sat != l_true) {
|
||||
return is_sat;
|
||||
}
|
||||
remove_core(core);
|
||||
rational w = split_core(core);
|
||||
TRACE("opt", display_vec(tout << "minimized core: ", core.size(), core.c_ptr()););
|
||||
max_resolve(core, w);
|
||||
fml = m.mk_not(m.mk_and(m_B.size(), m_B.c_ptr()));
|
||||
m_s->assert_expr(fml);
|
||||
m_lower += w;
|
||||
break;
|
||||
}
|
||||
IF_VERBOSE(1, verbose_stream() << "(opt.max_res [" << m_lower << ":" << m_upper << "])\n";);
|
||||
|
|
@ -154,13 +127,78 @@ public:
|
|||
return l_true;
|
||||
}
|
||||
|
||||
lbool get_cores(vector<ptr_vector<expr> >& cores) {
|
||||
// assume m_s is unsat.
|
||||
lbool is_sat = l_false;
|
||||
expr_ref_vector asms(m_asms);
|
||||
cores.reset();
|
||||
ptr_vector<expr> core;
|
||||
while (is_sat == l_false) {
|
||||
core.reset();
|
||||
m_s->get_unsat_core(core);
|
||||
is_sat = minimize_core(core);
|
||||
if (is_sat != l_true) {
|
||||
break;
|
||||
}
|
||||
cores.push_back(core);
|
||||
// TBD: ad hoc to avoid searching for large cores..
|
||||
if (core.size() >= 3) {
|
||||
break;
|
||||
}
|
||||
remove_soft(core, asms);
|
||||
TRACE("opt",
|
||||
display_vec(tout << "core: ", core.size(), core.c_ptr());
|
||||
display_vec(tout << "assumptions: ", asms.size(), asms.c_ptr()););
|
||||
is_sat = m_s->check_sat(asms.size(), asms.c_ptr());
|
||||
}
|
||||
TRACE("opt",
|
||||
tout << "num cores: " << cores.size() << "\n";
|
||||
for (unsigned i = 0; i < cores.size(); ++i) {
|
||||
for (unsigned j = 0; j < cores[i].size(); ++j) {
|
||||
tout << mk_pp(cores[i][j], m) << " ";
|
||||
}
|
||||
tout << "\n";
|
||||
}
|
||||
tout << "num satisfying: " << asms.size() << "\n";);
|
||||
|
||||
return is_sat;
|
||||
}
|
||||
|
||||
|
||||
lbool process_unsat() {
|
||||
vector<ptr_vector<expr> > cores;
|
||||
lbool is_sat = get_cores(cores);
|
||||
if (is_sat != l_true) {
|
||||
return is_sat;
|
||||
}
|
||||
if (cores.empty()) {
|
||||
return l_false;
|
||||
}
|
||||
for (unsigned i = 0; is_sat == l_true && i < cores.size(); ++i) {
|
||||
is_sat = process_unsat(cores[i]);
|
||||
}
|
||||
return is_sat;
|
||||
}
|
||||
|
||||
lbool process_unsat(ptr_vector<expr>& core) {
|
||||
expr_ref fml(m);
|
||||
remove_core(core);
|
||||
rational w = split_core(core);
|
||||
TRACE("opt", display_vec(tout << "minimized core: ", core.size(), core.c_ptr()););
|
||||
max_resolve(core, w);
|
||||
fml = m.mk_not(m.mk_and(m_B.size(), m_B.c_ptr()));
|
||||
m_s->assert_expr(fml);
|
||||
m_lower += w;
|
||||
return l_true;
|
||||
}
|
||||
|
||||
lbool minimize_core(ptr_vector<expr>& core) {
|
||||
if (m_sat_enabled) {
|
||||
return l_true;
|
||||
}
|
||||
m_mus.reset();
|
||||
for (unsigned i = 0; i < core.size(); ++i) {
|
||||
app* cls = get_clause(core[i]);
|
||||
SASSERT(cls);
|
||||
SASSERT(m.is_or(cls));
|
||||
m_mus.add_soft(core[i], cls->get_num_args(), cls->get_args());
|
||||
m_mus.add_soft(core[i]);
|
||||
}
|
||||
unsigned_vector mus_idx;
|
||||
lbool is_sat = m_mus.get_mus(mus_idx);
|
||||
|
|
@ -177,11 +215,7 @@ public:
|
|||
}
|
||||
|
||||
rational get_weight(expr* e) {
|
||||
return m_asm2info.find(e).m_weight;
|
||||
}
|
||||
|
||||
app* get_clause(expr* e) {
|
||||
return m_asm2info.find(e).m_cls;
|
||||
return m_asm2weight.find(e);
|
||||
}
|
||||
|
||||
rational split_core(ptr_vector<expr> const& core) {
|
||||
|
|
@ -200,7 +234,7 @@ public:
|
|||
rational w2 = get_weight(core[i]);
|
||||
if (w2 > w) {
|
||||
rational w3 = w2 - w;
|
||||
new_assumption(core[i], get_clause(core[i]), w3);
|
||||
new_assumption(core[i], w3);
|
||||
}
|
||||
}
|
||||
return w;
|
||||
|
|
@ -246,55 +280,25 @@ public:
|
|||
asum = mk_fresh_bool("a");
|
||||
cls = m.mk_or(b_i1, d);
|
||||
fml = m.mk_iff(asum, cls);
|
||||
cls = mk_cls(cls);
|
||||
m_trail.push_back(cls);
|
||||
new_assumption(asum, cls, w);
|
||||
new_assumption(asum, w);
|
||||
m_s->assert_expr(fml);
|
||||
}
|
||||
}
|
||||
|
||||
app_ref mk_cls(expr* e) {
|
||||
expr_ref_vector disj(m), todo(m);
|
||||
expr_ref f(m);
|
||||
app_ref result(m);
|
||||
expr* e1, *e2;
|
||||
todo.push_back(e);
|
||||
while (!todo.empty()) {
|
||||
f = todo.back();
|
||||
todo.pop_back();
|
||||
if (m.is_implies(f, e1, e2)) {
|
||||
todo.push_back(m.mk_not(e1));
|
||||
todo.push_back(e2);
|
||||
}
|
||||
else if (m.is_not(f, e1) && m.is_not(e1, e2)) {
|
||||
todo.push_back(e2);
|
||||
}
|
||||
else if (m.is_or(f)) {
|
||||
todo.append(to_app(f)->get_num_args(), to_app(f)->get_args());
|
||||
}
|
||||
else if (m.is_not(f, e1) && m.is_and(e1)) {
|
||||
for (unsigned i = 0; i < to_app(e1)->get_num_args(); ++i) {
|
||||
todo.push_back(m.mk_not(to_app(e1)->get_arg(i)));
|
||||
}
|
||||
}
|
||||
else {
|
||||
disj.push_back(f);
|
||||
}
|
||||
}
|
||||
result = m.mk_or(disj.size(), disj.c_ptr());
|
||||
return result;
|
||||
}
|
||||
|
||||
void remove_core(ptr_vector<expr> const& core) {
|
||||
for (unsigned i = 0; i < m_asms.size(); ++i) {
|
||||
if (core.contains(m_asms[i].get())) {
|
||||
m_asms[i] = m_asms.back();
|
||||
m_asms.pop_back();
|
||||
void remove_soft(ptr_vector<expr> const& core, expr_ref_vector& asms) {
|
||||
for (unsigned i = 0; i < asms.size(); ++i) {
|
||||
if (core.contains(asms[i].get())) {
|
||||
asms[i] = asms.back();
|
||||
asms.pop_back();
|
||||
--i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void remove_core(ptr_vector<expr> const& core) {
|
||||
remove_soft(core, m_asms);
|
||||
}
|
||||
|
||||
virtual void set_cancel(bool f) {
|
||||
maxsmt_solver_base::set_cancel(f);
|
||||
m_mus.set_cancel(f);
|
||||
|
|
@ -303,7 +307,6 @@ public:
|
|||
void init_local() {
|
||||
m_upper.reset();
|
||||
m_lower.reset();
|
||||
m_asm2info.reset();
|
||||
m_trail.reset();
|
||||
for (unsigned i = 0; i < m_soft.size(); ++i) {
|
||||
add_soft(m_soft[i].get(), m_weights[i]);
|
||||
|
|
|
|||
|
|
@ -130,6 +130,7 @@ namespace opt {
|
|||
}
|
||||
|
||||
void maxsmt_solver_base::enable_inc_bvsat() {
|
||||
m_params.set_bool("minimize_core", true);
|
||||
solver* sat_solver = mk_inc_sat_solver(m, m_params);
|
||||
unsigned sz = s().get_num_assertions();
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
|
|
@ -138,25 +139,11 @@ namespace opt {
|
|||
m_s = sat_solver;
|
||||
}
|
||||
|
||||
void maxsmt_solver_base::enable_noninc_bvsat() {
|
||||
tactic_ref pb2bv = mk_card2bv_tactic(m, m_params);
|
||||
tactic_ref bv2sat = mk_qfbv_tactic(m, m_params);
|
||||
tactic_ref tac = and_then(pb2bv.get(), bv2sat.get());
|
||||
solver* sat_solver = mk_tactic2solver(m, tac.get(), m_params);
|
||||
unsigned sz = s().get_num_assertions();
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
sat_solver->assert_expr(s().get_assertion(i));
|
||||
}
|
||||
unsigned lvl = m_s->get_scope_level();
|
||||
while (lvl > 0) { sat_solver->push(); --lvl; }
|
||||
m_s = sat_solver;
|
||||
}
|
||||
|
||||
|
||||
void maxsmt_solver_base::enable_bvsat() {
|
||||
if (m_enable_sat && !m_sat_enabled && probe_bv()) {
|
||||
enable_inc_bvsat();
|
||||
// enable_noninc_bvsat();
|
||||
m_sat_enabled = true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,7 +99,6 @@ namespace opt {
|
|||
app* mk_fresh_bool(char const* name);
|
||||
private:
|
||||
void enable_inc_bvsat();
|
||||
void enable_noninc_bvsat();
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
133
src/opt/mus.cpp
133
src/opt/mus.cpp
|
|
@ -7,7 +7,7 @@ Module Name:
|
|||
|
||||
Abstract:
|
||||
|
||||
Faster MUS extraction based on Belov et.al. HYB (Algorithm 3, 4)
|
||||
MUS extraction.
|
||||
|
||||
Author:
|
||||
|
||||
|
|
@ -35,58 +35,28 @@ struct mus::imp {
|
|||
ast_manager& m;
|
||||
expr_ref_vector m_cls2expr;
|
||||
obj_map<expr, unsigned> m_expr2cls;
|
||||
vector<smt::literal_vector> m_cls2lits;
|
||||
expr_ref_vector m_vars;
|
||||
obj_map<expr, unsigned> m_var2idx;
|
||||
volatile bool m_cancel;
|
||||
bool m_rmr_enabled;
|
||||
|
||||
imp(ref<solver>& s, ast_manager& m):
|
||||
m_s(s), m(m), m_cls2expr(m), m_vars(m), m_cancel(false),
|
||||
m_rmr_enabled(false) {}
|
||||
m_s(s), m(m), m_cls2expr(m), m_cancel(false)
|
||||
{}
|
||||
|
||||
void reset() {
|
||||
m_cls2expr.reset();
|
||||
m_expr2cls.reset();
|
||||
m_cls2lits.reset();
|
||||
m_vars.reset();
|
||||
m_var2idx.reset();
|
||||
m_vars.push_back(m.mk_true());
|
||||
}
|
||||
|
||||
void set_cancel(bool f) {
|
||||
m_cancel = f;
|
||||
}
|
||||
|
||||
unsigned add_var(expr* v) {
|
||||
unsigned idx = m_vars.size();
|
||||
if (!m_var2idx.find(v, idx)) {
|
||||
m_var2idx.insert(v, idx);
|
||||
m_vars.push_back(v);
|
||||
}
|
||||
return idx;
|
||||
}
|
||||
|
||||
unsigned add_soft(expr* cls, unsigned sz, expr* const* args) {
|
||||
unsigned add_soft(expr* cls) {
|
||||
SASSERT(is_uninterp_const(cls) || m.is_not(cls) && is_uninterp_const(to_app(cls)->get_arg(0)));
|
||||
smt::literal_vector lits;
|
||||
expr* arg;
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
if (m.is_not(args[i], arg)) {
|
||||
lits.push_back(smt::literal(add_var(arg), true));
|
||||
}
|
||||
else {
|
||||
lits.push_back(smt::literal(add_var(args[i]), false));
|
||||
}
|
||||
}
|
||||
unsigned idx = m_cls2lits.size();
|
||||
unsigned idx = m_cls2expr.size();
|
||||
m_expr2cls.insert(cls, idx);
|
||||
m_cls2expr.push_back(cls);
|
||||
m_cls2lits.push_back(lits);
|
||||
TRACE("opt",
|
||||
tout << idx << ": " << mk_pp(cls, m) << "\n";
|
||||
display_vec(tout, lits);
|
||||
);
|
||||
TRACE("opt", tout << idx << ": " << mk_pp(cls, m) << "\n";);
|
||||
return idx;
|
||||
}
|
||||
|
||||
|
|
@ -99,11 +69,6 @@ struct mus::imp {
|
|||
|
||||
lbool get_mus(unsigned_vector& mus) {
|
||||
// SASSERT: mus does not have duplicates.
|
||||
TRACE("opt",
|
||||
for (unsigned i = 0; i < m_cls2lits.size(); ++i) {
|
||||
display_vec(tout, m_cls2lits[i]);
|
||||
}
|
||||
);
|
||||
unsigned_vector core;
|
||||
for (unsigned i = 0; i < m_cls2expr.size(); ++i) {
|
||||
core.push_back(i);
|
||||
|
|
@ -114,16 +79,13 @@ struct mus::imp {
|
|||
}
|
||||
mus.reset();
|
||||
expr_ref_vector assumptions(m);
|
||||
svector<bool> model;
|
||||
ptr_vector<expr> core_exprs;
|
||||
model.resize(m_vars.size());
|
||||
while (!core.empty()) {
|
||||
IF_VERBOSE(1, verbose_stream() << "(opt.mus reducing core: " << core.size() << " new core: " << mus.size() << ")\n";);
|
||||
unsigned cls_id = core.back();
|
||||
TRACE("opt",
|
||||
display_vec(tout << "core: ", core);
|
||||
display_vec(tout << "mus: ", mus);
|
||||
// display_vec(tout << "model: ", model);
|
||||
);
|
||||
core.pop_back();
|
||||
expr* cls = m_cls2expr[cls_id].get();
|
||||
|
|
@ -140,13 +102,6 @@ struct mus::imp {
|
|||
case l_true:
|
||||
assumptions.push_back(cls);
|
||||
mus.push_back(cls_id);
|
||||
if (m_rmr_enabled) {
|
||||
extract_model(model);
|
||||
sz = core.size();
|
||||
core.append(mus);
|
||||
rmr(core, mus, model);
|
||||
core.resize(sz);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
core_exprs.reset();
|
||||
|
|
@ -192,78 +147,6 @@ struct mus::imp {
|
|||
out << "\n";
|
||||
}
|
||||
|
||||
void extract_model(svector<bool>& model) {
|
||||
model_ref mdl;
|
||||
m_s->get_model(mdl);
|
||||
for (unsigned i = 0; i < m_vars.size(); ++i) {
|
||||
expr_ref tmp(m);
|
||||
mdl->eval(m_vars[i].get(), tmp);
|
||||
model[i] = m.is_true(tmp);
|
||||
}
|
||||
TRACE("opt",
|
||||
display_vec(tout << "model: ", model);
|
||||
model_smt2_pp(tout, m, *mdl, 0);
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
Recursive model rotation.
|
||||
*/
|
||||
void rmr(unsigned_vector& M, unsigned_vector& mus, svector<bool>& model) {
|
||||
TRACE("opt",
|
||||
display_vec(tout << "core: ", M);
|
||||
display_vec(tout << "mus: ", mus);
|
||||
display_vec(tout << "model: ", model););
|
||||
|
||||
unsigned cls_id = mus.back();
|
||||
smt::literal_vector const& cls = m_cls2lits[cls_id];
|
||||
for (unsigned i = 0; i < cls.size(); ++i) {
|
||||
smt::literal lit = cls[i];
|
||||
SASSERT(model[lit.var()] == lit.sign()); // literal evaluates to false.
|
||||
model[lit.var()] = !model[lit.var()]; // swap assignment
|
||||
if (has_single_unsat(model, cls_id) &&
|
||||
!mus.contains(cls_id) &&
|
||||
model_check(model, cls_id)) {
|
||||
mus.push_back(cls_id);
|
||||
rmr(M, mus, model);
|
||||
}
|
||||
model[lit.var()] = !model[lit.var()]; // swap assignment back
|
||||
}
|
||||
}
|
||||
|
||||
bool model_check(svector<bool> const& model, unsigned cls_id) {
|
||||
// model has to work for hard constraints.
|
||||
return false;
|
||||
}
|
||||
|
||||
bool has_single_unsat(svector<bool> const& model, unsigned& cls_id) const {
|
||||
cls_id = UINT_MAX;
|
||||
for (unsigned i = 0; i < m_cls2lits.size(); ++i) {
|
||||
if (!eval(model, m_cls2lits[i])) {
|
||||
if (cls_id == UINT_MAX) {
|
||||
cls_id = i;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
TRACE("opt", display_vec(tout << "clause: " << cls_id << " model: ", model););
|
||||
return cls_id != UINT_MAX;
|
||||
}
|
||||
|
||||
bool eval(svector<bool> const& model, smt::literal_vector const& cls) const {
|
||||
bool result = false;
|
||||
for (unsigned i = 0; !result && i < cls.size(); ++i) {
|
||||
result = (model[cls[i].var()] != cls[i].sign());
|
||||
}
|
||||
TRACE("opt", display_vec(tout << "model: ", model);
|
||||
display_vec(tout << "clause: ", cls);
|
||||
tout << "result: " << result << "\n";);
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
mus::mus(ref<solver>& s, ast_manager& m) {
|
||||
|
|
@ -274,8 +157,8 @@ mus::~mus() {
|
|||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
unsigned mus::add_soft(expr* cls, unsigned sz, expr* const* args) {
|
||||
return m_imp->add_soft(cls, sz, args);
|
||||
unsigned mus::add_soft(expr* cls) {
|
||||
return m_imp->add_soft(cls);
|
||||
}
|
||||
|
||||
lbool mus::get_mus(unsigned_vector& mus) {
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ namespace opt {
|
|||
cls is equivalent to a disjunction of args.
|
||||
Assume also that cls is a literal.
|
||||
*/
|
||||
unsigned add_soft(expr* cls, unsigned sz, expr* const* args);
|
||||
unsigned add_soft(expr* cls);
|
||||
|
||||
lbool get_mus(unsigned_vector& mus);
|
||||
|
||||
|
|
|
|||
|
|
@ -104,6 +104,7 @@ namespace sat {
|
|||
m_gc_increment = p.gc_increment();
|
||||
}
|
||||
m_minimize_lemmas = p.minimize_lemmas();
|
||||
m_minimize_core = p.minimize_core();
|
||||
m_dyn_sub_res = p.dyn_sub_res();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -68,6 +68,8 @@ namespace sat {
|
|||
|
||||
bool m_minimize_lemmas;
|
||||
bool m_dyn_sub_res;
|
||||
bool m_minimize_core;
|
||||
|
||||
|
||||
symbol m_always_true;
|
||||
symbol m_always_false;
|
||||
|
|
|
|||
|
|
@ -15,8 +15,6 @@ Author:
|
|||
|
||||
Notes:
|
||||
|
||||
Model rotation needs fixes to ensure that hard constraints are satisfied
|
||||
under pertubed model. Model rotation also has o be consistent with theories.
|
||||
|
||||
--*/
|
||||
|
||||
|
|
@ -32,26 +30,23 @@ namespace sat {
|
|||
void mus::reset() {
|
||||
m_core.reset();
|
||||
m_mus.reset();
|
||||
m_assumptions.reset();
|
||||
}
|
||||
|
||||
void mus::set_core() {
|
||||
void mus::set_core() {
|
||||
m_core.append(m_mus);
|
||||
s.m_core.reset();
|
||||
s.m_core.append(m_core);
|
||||
}
|
||||
|
||||
lbool mus::operator()() {
|
||||
flet<bool> _disable_min(s.m_config.m_minimize_core, false);
|
||||
TRACE("sat", tout << "old core: " << s.get_core() << "\n";);
|
||||
IF_VERBOSE(2, verbose_stream() << "(sat.mus " << s.get_core() << ")\n";);
|
||||
reset();
|
||||
literal_vector& core = m_core;
|
||||
literal_vector& mus = m_mus;
|
||||
literal_vector& assumptions = m_assumptions;
|
||||
core.append(s.get_core());
|
||||
SASSERT(!core.empty());
|
||||
|
||||
if (core.size() == 1) {
|
||||
return l_true;
|
||||
}
|
||||
while (!core.empty()) {
|
||||
TRACE("sat",
|
||||
tout << "core: " << core << "\n";
|
||||
|
|
@ -63,29 +58,38 @@ namespace sat {
|
|||
}
|
||||
literal lit = core.back();
|
||||
core.pop_back();
|
||||
unsigned sz = assumptions.size();
|
||||
assumptions.push_back(~lit);
|
||||
assumptions.append(core);
|
||||
lbool is_sat = s.check(assumptions.size(), assumptions.c_ptr());
|
||||
assumptions.resize(sz);
|
||||
unsigned sz = mus.size();
|
||||
//mus.push_back(~lit); // TBD: measure
|
||||
mus.append(core);
|
||||
lbool is_sat = s.check(mus.size(), mus.c_ptr());
|
||||
mus.resize(sz);
|
||||
switch (is_sat) {
|
||||
case l_undef:
|
||||
core.push_back(lit);
|
||||
set_core();
|
||||
return l_undef;
|
||||
case l_true: {
|
||||
assumptions.push_back(lit);
|
||||
SASSERT(value_at(lit, s.get_model()) == l_false);
|
||||
mus.push_back(lit);
|
||||
unsigned sz = core.size();
|
||||
if (core.empty()) {
|
||||
break;
|
||||
}
|
||||
sz = core.size();
|
||||
core.append(mus);
|
||||
rmr();
|
||||
core.resize(sz);
|
||||
IF_VERBOSE(2, verbose_stream() << "(sat.mus.new " << mus << " " << core << ")\n";);
|
||||
break;
|
||||
}
|
||||
case l_false:
|
||||
literal_vector const& new_core = s.get_core();
|
||||
if (new_core.contains(~lit)) {
|
||||
break;
|
||||
}
|
||||
IF_VERBOSE(2, verbose_stream() << "(sat.mus.new " << new_core << ")\n";);
|
||||
core.reset();
|
||||
for (unsigned i = 0; i < s.get_core().size(); ++i) {
|
||||
literal lit = s.get_core()[i];
|
||||
for (unsigned i = 0; i < new_core.size(); ++i) {
|
||||
literal lit = new_core[i];
|
||||
if (!mus.contains(lit)) {
|
||||
core.push_back(lit);
|
||||
}
|
||||
|
|
@ -93,22 +97,23 @@ namespace sat {
|
|||
break;
|
||||
}
|
||||
}
|
||||
TRACE("sat", tout << "new core: " << mus << "\n";);
|
||||
set_core();
|
||||
return l_true;
|
||||
}
|
||||
|
||||
lbool mus::eval(literal l) const {
|
||||
return value_at(l, s.get_model());
|
||||
}
|
||||
|
||||
void mus::rmr() {
|
||||
model& model = s.m_model;
|
||||
literal lit = m_mus.back();
|
||||
literal assumption_lit;
|
||||
SASSERT(eval(lit) == l_false); // literal is false in current model.
|
||||
SASSERT(value_at(lit, model) == l_false);
|
||||
// literal is false in current model.
|
||||
unsigned sz = m_toswap.size();
|
||||
find_swappable(lit);
|
||||
for (unsigned i = 0; i < m_toswap.size(); ++i) {
|
||||
unsigned sz1 = m_toswap.size();
|
||||
for (unsigned i = sz; i < sz1; ++i) {
|
||||
lit = m_toswap[i];
|
||||
SASSERT(eval(lit) == l_false);
|
||||
SASSERT(value_at(lit, model) == l_false);
|
||||
model[lit.var()] = ~model[lit.var()]; // swap assignment
|
||||
if (has_single_unsat(assumption_lit) && !m_mus.contains(assumption_lit)) {
|
||||
m_mus.push_back(assumption_lit);
|
||||
|
|
@ -116,6 +121,7 @@ namespace sat {
|
|||
}
|
||||
model[lit.var()] = ~model[lit.var()]; // swap assignment back
|
||||
}
|
||||
m_toswap.resize(sz);
|
||||
}
|
||||
|
||||
bool mus::has_single_unsat(literal& assumption_lit) {
|
||||
|
|
@ -123,41 +129,50 @@ namespace sat {
|
|||
return false;
|
||||
}
|
||||
|
||||
//
|
||||
// lit is false in model.
|
||||
// find clauses where ~lit occurs, and all other literals
|
||||
// are false in model.
|
||||
// for each of the probed literals, determine if swapping the
|
||||
// assignment falsifies a hard clause, if not, add to m_toswap.
|
||||
//
|
||||
|
||||
void mus::find_swappable(literal lit) {
|
||||
m_toswap.reset();
|
||||
IF_VERBOSE(2, verbose_stream() << "(sat.mus swap " << lit << ")\n";);
|
||||
unsigned sz = m_toswap.size();
|
||||
literal lit2, lit3;
|
||||
model const& model = s.get_model();
|
||||
SASSERT(value_at(lit, model) == l_false);
|
||||
watch_list const& wlist = s.get_wlist(lit);
|
||||
watch_list::const_iterator it = wlist.begin();
|
||||
watch_list::const_iterator end = wlist.end();
|
||||
for (; it != end; ++it) {
|
||||
switch (it->get_kind()) {
|
||||
case watched::BINARY:
|
||||
lit2 = it->get_literal();
|
||||
TRACE("sat", tout << ~lit << " " << lit2 << "\n";);
|
||||
break;
|
||||
case watched::TERNARY:
|
||||
lit2 = it->get_literal1();
|
||||
lit3 = it->get_literal2();
|
||||
TRACE("sat", tout << ~lit << " " << lit2 << " " << lit3 << "\n";);
|
||||
break;
|
||||
case watched::CLAUSE: {
|
||||
clause_offset cls_off = it->get_clause_offset();
|
||||
clause& c = *(s.m_cls_allocator.get_clause(cls_off));
|
||||
if (c.is_learned()) {
|
||||
break;
|
||||
}
|
||||
TRACE("sat", tout << c << "\n";);
|
||||
break;
|
||||
}
|
||||
case watched::EXT_CONSTRAINT:
|
||||
TRACE("sat", tout << "external constraint - should avoid rmr\n";);
|
||||
m_toswap.resize(sz);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
||||
|
||||
bool has_single_unsat(svector<bool> const& model, unsigned& cls_id) const {
|
||||
cls_id = UINT_MAX;
|
||||
for (unsigned i = 0; i < m_cls2lits.size(); ++i) {
|
||||
if (!eval(model, m_cls2lits[i])) {
|
||||
if (cls_id == UINT_MAX) {
|
||||
cls_id = i;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
TRACE("opt", display_vec(tout << "clause: " << cls_id << " model: ", model););
|
||||
return cls_id != UINT_MAX;
|
||||
}
|
||||
|
||||
bool eval(svector<bool> const& model, smt::literal_vector const& cls) const {
|
||||
bool result = false;
|
||||
for (unsigned i = 0; !result && i < cls.size(); ++i) {
|
||||
result = (model[cls[i].var()] != cls[i].sign());
|
||||
}
|
||||
TRACE("opt", display_vec(tout << "model: ", model);
|
||||
display_vec(tout << "clause: ", cls);
|
||||
tout << "result: " << result << "\n";);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@ Notes:
|
|||
namespace sat {
|
||||
class mus {
|
||||
literal_vector m_core;
|
||||
literal_vector m_assumptions;
|
||||
literal_vector m_mus;
|
||||
literal_vector m_toswap;
|
||||
solver& s;
|
||||
|
|
@ -31,12 +30,12 @@ namespace sat {
|
|||
~mus();
|
||||
lbool operator()();
|
||||
private:
|
||||
lbool mus2();
|
||||
void rmr();
|
||||
bool has_single_unsat(literal& assumption_lit);
|
||||
void find_swappable(literal lit);
|
||||
void reset();
|
||||
void set_core();
|
||||
lbool eval(literal l) const;
|
||||
};
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -46,8 +46,7 @@ namespace sat {
|
|||
m_case_split_queue(m_activity),
|
||||
m_qhead(0),
|
||||
m_scope_lvl(0),
|
||||
m_params(p),
|
||||
m_minimize_core(p.get_bool("minimize_core", false)) {
|
||||
m_params(p) {
|
||||
m_config.updt_params(p);
|
||||
}
|
||||
|
||||
|
|
@ -1045,7 +1044,7 @@ namespace sat {
|
|||
}
|
||||
if (!m_mc.check_model(m))
|
||||
ok = false;
|
||||
TRACE("sat", tout << "checl: " << ok << "\n" << m << "\n";);
|
||||
TRACE("sat", tout << "check: " << ok << "\n" << m << "\n";);
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
|
@ -1621,7 +1620,7 @@ namespace sat {
|
|||
}
|
||||
while (idx > 0);
|
||||
reset_unmark(old_size);
|
||||
if (m_minimize_core) {
|
||||
if (m_config.m_minimize_core) {
|
||||
m_mus(); //ignore return value on cancelation.
|
||||
}
|
||||
}
|
||||
|
|
@ -2236,7 +2235,6 @@ namespace sat {
|
|||
m_probing.updt_params(p);
|
||||
m_scc.updt_params(p);
|
||||
m_rand.set_seed(p.get_uint("random_seed", 0));
|
||||
m_minimize_core = p.get_bool("minimize_core", false);
|
||||
}
|
||||
|
||||
void solver::collect_param_descrs(param_descrs & d) {
|
||||
|
|
|
|||
|
|
@ -123,7 +123,6 @@ namespace sat {
|
|||
literal_vector m_assumptions;
|
||||
literal_set m_assumption_set;
|
||||
literal_vector m_core;
|
||||
bool m_minimize_core;
|
||||
|
||||
void del_clauses(clause * const * begin, clause * const * end);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue