mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-19 20:33:38 +00:00
Code Activity

a more efficient encoding for pseudo-Boolean inequality constraints into bit-vectors

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2016-10-24 08:25:02 -07:00
parent 4f3f21bff1
commit 6cf54a226e
1 changed files with 103 additions and 134 deletions
Download patch file Download diff file Expand all files Collapse all files

237
src/ast/rewriter/pb2bv_rewriter.cpp
View file

@ -24,6 +24,7 @@ Notes:
#include"sorting_network.h" #include"sorting_network.h"
#include"ast_util.h" #include"ast_util.h"
#include"ast_pp.h" #include"ast_pp.h"
#include"lbool.h"
struct pb2bv_rewriter::imp { struct pb2bv_rewriter::imp {
@ -79,150 +80,118 @@ struct pb2bv_rewriter::imp {
bv_util bv; bv_util bv;
expr_ref_vector m_trail; expr_ref_vector m_trail;
unsigned get_num_bits(func_decl* f) { template<lbool is_le>
rational r(0); expr_ref mk_le_ge(expr_ref_vector& fmls, expr* a, expr* b, expr* bound) {
unsigned sz = f->get_arity(); expr_ref x(m), y(m), result(m);
for (unsigned i = 0; i < sz; ++i) { unsigned nb = bv.get_bv_size(a);
r += pb.get_coeff(f, i); x = bv.mk_zero_extend(1, a);
y = bv.mk_zero_extend(1, b);
result = bv.mk_bv_add(x, y);
x = bv.mk_extract(nb, nb, result);
result = bv.mk_extract(nb-1, 0, result);
if (is_le != l_false) {
fmls.push_back(m.mk_eq(x, bv.mk_numeral(rational::zero(), 1)));
fmls.push_back(bv.mk_ule(result, bound));
} }
r = r > pb.get_k(f)? r : pb.get_k(f); else {
return r.get_num_bits(); fmls.push_back(m.mk_eq(x, bv.mk_numeral(rational::one(), 1)));
fmls.push_back(bv.mk_ule(bound, result));
}
return result;
} }
void mk_bv(func_decl * f, unsigned sz, expr * const* args, expr_ref & result) { //
// create a circuit of size sz*log(k)
expr_ref zero(m), a(m), b(m); // by forming a binary tree adding pairs of values that are assumed <= k,
expr_ref_vector es(m); // and in each step we check that the result is <= k by checking the overflow
unsigned bw = get_num_bits(f); // bit and that the non-overflow bits are <= k.
zero = bv.mk_numeral(rational(0), bw); // The procedure for checking >= k is symmetric and checking for = k is
// achieved by checking <= k on intermediary addends and the resulting sum is = k.
//
template<lbool is_le>
expr_ref mk_le_ge(func_decl *f, unsigned sz, expr * const* args, rational const & k) {
if (k.is_zero()) {
if (is_le != l_false) {
return expr_ref(m.mk_not(mk_or(m, sz, args)), m);
}
else {
return expr_ref(m.mk_true(), m);
}
}
SASSERT(k.is_pos());
expr_ref zero(m), bound(m);
expr_ref_vector es(m), fmls(m);
unsigned nb = k.get_num_bits();
zero = bv.mk_numeral(rational(0), nb);
bound = bv.mk_numeral(k, nb);
for (unsigned i = 0; i < sz; ++i) { for (unsigned i = 0; i < sz; ++i) {
es.push_back(mk_ite(args[i], bv.mk_numeral(pb.get_coeff(f, i), bw), zero)); if (pb.get_coeff(f, i) > k) {
} if (is_le != l_false) {
switch (es.size()) { fmls.push_back(m.mk_not(args[i]));
case 0: a = zero; break;
case 1: a = es[0].get(); break;
default:
a = es[0].get();
for (unsigned i = 1; i < es.size(); ++i) {
a = bv.mk_bv_add(a, es[i].get());
}
break;
}
b = bv.mk_numeral(pb.get_k(f), bw);
switch (f->get_decl_kind()) {
case OP_AT_MOST_K:
case OP_PB_LE:
result = bv.mk_ule(a, b);
break;
case OP_AT_LEAST_K:
case OP_PB_GE:
result = bv.mk_ule(b, a);
break;
case OP_PB_EQ:
result = m.mk_eq(a, b);
break;
default:
UNREACHABLE();
}
TRACE("pb", tout << result << "\n";);
}
bool mk_shannon(func_decl * f, unsigned sz, expr * const* args, expr_ref & result) {
decl_kind kind = f->get_decl_kind();
if (kind != OP_PB_GE && kind != OP_AT_LEAST_K) {
return false;
}
unsigned max_clauses = sz*10;
vector<argc_t> argcs;
for (unsigned i = 0; i < sz; ++i) {
argcs.push_back(argc_t(args[i], pb.get_coeff(f, i)));
}
std::sort(argcs.begin(), argcs.end(), argc_gt());
DEBUG_CODE(
for (unsigned i = 0; i + 1 < sz; ++i) {
SASSERT(argcs[i].m_coeff >= argcs[i+1].m_coeff);
});
result = m.mk_app(f, sz, args);
TRACE("pb", tout << result << "\n";);
argc_cache cache;
expr_ref_vector trail(m);
vector<rational> todo_k;
unsigned_vector todo_i;
todo_k.push_back(pb.get_k(f));
todo_i.push_back(0);
argc_entry entry1;
while (!todo_i.empty()) {
SASSERT(todo_i.size() == todo_k.size());
if (cache.size() > max_clauses) {
return false;
}
unsigned i = todo_i.back();
rational k = todo_k.back();
argc_entry entry(i, k);
if (cache.contains(entry)) {
todo_i.pop_back();
todo_k.pop_back();
continue;
}
SASSERT(i < sz);
SASSERT(!k.is_neg());
rational const& coeff = argcs[i].m_coeff;
expr* arg = argcs[i].m_arg;
if (i + 1 == sz) {
if (k.is_zero()) {
entry.m_value = m.mk_true();
}
else if (coeff < k) {
entry.m_value = m.mk_false();
}
else if (coeff.is_zero()) {
entry.m_value = m.mk_true();
} }
else { else {
SASSERT(coeff >= k && k.is_pos()); fmls.push_back(args[i]);
entry.m_value = arg;
} }
todo_i.pop_back();
todo_k.pop_back();
cache.insert(entry);
continue;
}
entry.m_index++;
expr* lo = 0, *hi = 0;
if (cache.find(entry, entry1)) {
lo = entry1.m_value;
} }
else { else {
todo_i.push_back(i+1); es.push_back(mk_ite(args[i], bv.mk_numeral(pb.get_coeff(f, i), nb), zero));
todo_k.push_back(k);
}
entry.m_k -= coeff;
if (!entry.m_k.is_pos()) {
hi = m.mk_true();
} }
else if (cache.find(entry, entry1)) { }
hi = entry1.m_value; while (es.size() > 1) {
for (unsigned i = 0; i + 1 < es.size(); i += 2) {
es[i/2] = mk_le_ge<is_le>(fmls, es[i].get(), es[i+1].get(), bound);
} }
else { if ((es.size() % 2) == 1) {
todo_i.push_back(i+1); es[es.size()/2] = es.back();
todo_k.push_back(entry.m_k);
} }
if (hi && lo) { es.shrink((1 + es.size())/2);
todo_i.pop_back(); }
todo_k.pop_back(); switch (is_le) {
entry.m_index = i; case l_true:
entry.m_k = k; return mk_and(fmls);
entry.m_value = mk_ite(arg, hi, lo); case l_false:
trail.push_back(entry.m_value); fmls.push_back(bv.mk_ule(bound, es.back()));
cache.insert(entry); return mk_or(fmls);
} case l_undef:
} fmls.push_back(m.mk_eq(bound, es.back()));
argc_entry entry(0, pb.get_k(f)); return mk_and(fmls);
VERIFY(cache.find(entry, entry)); default:
result = entry.m_value; UNREACHABLE();
TRACE("pb", tout << result << "\n";); return expr_ref(m.mk_true(), m);
return true; }
}
expr_ref mk_bv(func_decl * f, unsigned sz, expr * const* args) {
decl_kind kind = f->get_decl_kind();
rational k = pb.get_k(f);
SASSERT(!k.is_neg());
switch (kind) {
case OP_PB_GE:
case OP_AT_LEAST_K: {
expr_ref_vector nargs(m);
nargs.append(sz, args);
dualize(f, nargs, k);
SASSERT(!k.is_neg());
return mk_le_ge<l_true>(f, sz, nargs.c_ptr(), k);
}
case OP_PB_LE:
case OP_AT_MOST_K:
return mk_le_ge<l_true>(f, sz, args, k);
case OP_PB_EQ:
return mk_le_ge<l_undef>(f, sz, args, k);
default:
UNREACHABLE();
return expr_ref(m.mk_true(), m);
}
}
void dualize(func_decl* f, expr_ref_vector & args, rational & k) {
k.neg();
for (unsigned i = 0; i < args.size(); ++i) {
k += pb.get_coeff(f, i);
args[i] = ::mk_not(m, args[i].get());
}
} }
expr* negate(expr* e) { expr* negate(expr* e) {
@ -346,8 +315,8 @@ struct pb2bv_rewriter::imp {
else if (pb.is_ge(f) && pb.get_k(f).is_unsigned() && pb.has_unit_coefficients(f)) { else if (pb.is_ge(f) && pb.get_k(f).is_unsigned() && pb.has_unit_coefficients(f)) {
result = m_sort.ge(true, pb.get_k(f).get_unsigned(), sz, args); result = m_sort.ge(true, pb.get_k(f).get_unsigned(), sz, args);
} }
else if (!mk_shannon(f, sz, args, result)) { else {
mk_bv(f, sz, args, result); result = mk_bv(f, sz, args);
} }
} }