mirror of
https://github.com/Z3Prover/z3
synced 2025-04-29 20:05:51 +00:00
add fd solver for finite domain queries
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
parent
948a1e600e
commit
d060359f01
16 changed files with 676 additions and 204 deletions
|
|
@ -29,6 +29,7 @@ Revision History:
|
|||
#include "extension_model_converter.h"
|
||||
#include "var_subst.h"
|
||||
#include "ast_util.h"
|
||||
#include "fd_rewriter.h"
|
||||
|
||||
|
||||
class dt2bv_tactic : public tactic {
|
||||
|
|
@ -39,177 +40,8 @@ class dt2bv_tactic : public tactic {
|
|||
bv_util m_bv;
|
||||
obj_hashtable<sort> m_fd_sorts;
|
||||
obj_hashtable<sort> m_non_fd_sorts;
|
||||
expr_ref_vector m_bounds;
|
||||
ref<extension_model_converter> m_ext;
|
||||
ref<filter_model_converter> m_filter;
|
||||
unsigned m_num_translated;
|
||||
obj_map<func_decl, expr*>* m_translate;
|
||||
|
||||
struct rw_cfg : public default_rewriter_cfg {
|
||||
dt2bv_tactic& m_t;
|
||||
ast_manager& m;
|
||||
params_ref m_params;
|
||||
obj_map<expr, expr*> m_cache;
|
||||
expr_ref_vector m_trail;
|
||||
|
||||
rw_cfg(dt2bv_tactic& t, ast_manager & m, params_ref const & p) :
|
||||
m_t(t),
|
||||
m(m),
|
||||
m_params(p),
|
||||
m_trail(m)
|
||||
{}
|
||||
|
||||
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
|
||||
expr_ref a0(m), a1(m);
|
||||
expr_ref_vector _args(m);
|
||||
if (m.is_eq(f) && reduce_arg(args[0], a0) && reduce_arg(args[1], a1)) {
|
||||
result = m.mk_eq(a0, a1);
|
||||
return BR_DONE;
|
||||
}
|
||||
else if (m.is_distinct(f) && reduce_args(num, args, _args)) {
|
||||
result = m.mk_distinct(_args.size(), _args.c_ptr());
|
||||
return BR_DONE;
|
||||
}
|
||||
else if (m_t.m_dt.is_recognizer(f) && reduce_arg(args[0], a0)) {
|
||||
unsigned idx = m_t.m_dt.get_recognizer_constructor_idx(f);
|
||||
a1 = m_t.m_bv.mk_numeral(rational(idx), get_sort(a0));
|
||||
result = m.mk_eq(a0, a1);
|
||||
return BR_DONE;
|
||||
}
|
||||
else {
|
||||
return BR_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
bool reduce_args(unsigned sz, expr*const* as, expr_ref_vector& result) {
|
||||
expr_ref tmp(m);
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
if (!reduce_arg(as[i], tmp)) return false;
|
||||
result.push_back(tmp);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool reduce_arg(expr* a, expr_ref& result) {
|
||||
expr* b;
|
||||
if (m_cache.find(a, b)) {
|
||||
result = b;
|
||||
return true;
|
||||
}
|
||||
|
||||
sort* s = get_sort(a);
|
||||
if (!m_t.m_fd_sorts.contains(s)) {
|
||||
return false;
|
||||
}
|
||||
unsigned bv_size = get_bv_size(s);
|
||||
|
||||
if (is_var(a)) {
|
||||
result = m.mk_var(to_var(a)->get_idx(), m_t.m_bv.mk_sort(bv_size));
|
||||
return true;
|
||||
}
|
||||
SASSERT(is_app(a));
|
||||
func_decl* f = to_app(a)->get_decl();
|
||||
if (m_t.m_dt.is_constructor(f)) {
|
||||
unsigned idx = m_t.m_dt.get_constructor_idx(f);
|
||||
result = m_t.m_bv.mk_numeral(idx, bv_size);
|
||||
}
|
||||
else if (is_uninterp_const(a)) {
|
||||
// create a fresh variable, add bounds constraints for it.
|
||||
unsigned nc = m_t.m_dt.get_datatype_num_constructors(s);
|
||||
result = m.mk_fresh_const(f->get_name().str().c_str(), m_t.m_bv.mk_sort(bv_size));
|
||||
if (!is_power_of_two(nc)) {
|
||||
m_t.m_bounds.push_back(m_t.m_bv.mk_ule(result, m_t.m_bv.mk_numeral(nc-1, bv_size)));
|
||||
}
|
||||
expr_ref f_def(m);
|
||||
ptr_vector<func_decl> const& cs = *m_t.m_dt.get_datatype_constructors(s);
|
||||
f_def = m.mk_const(cs[nc-1]);
|
||||
for (unsigned i = nc - 1; i > 0; ) {
|
||||
--i;
|
||||
f_def = m.mk_ite(m.mk_eq(result, m_t.m_bv.mk_numeral(i,bv_size)), m.mk_const(cs[i]), f_def);
|
||||
}
|
||||
// update model converters.
|
||||
m_t.m_ext->insert(f, f_def);
|
||||
m_t.m_filter->insert(to_app(result)->get_decl());
|
||||
if (m_t.m_translate) {
|
||||
m_t.m_translate->insert(f, result);
|
||||
}
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
m_cache.insert(a, result);
|
||||
++m_t.m_num_translated;
|
||||
return true;
|
||||
}
|
||||
|
||||
ptr_buffer<sort> m_sorts;
|
||||
|
||||
bool reduce_quantifier(
|
||||
quantifier * q,
|
||||
expr * old_body,
|
||||
expr * const * new_patterns,
|
||||
expr * const * new_no_patterns,
|
||||
expr_ref & result,
|
||||
proof_ref & result_pr) {
|
||||
m_sorts.reset();
|
||||
expr_ref_vector bounds(m);
|
||||
bool found = false;
|
||||
for (unsigned i = 0; i < q->get_num_decls(); ++i) {
|
||||
sort* s = q->get_decl_sort(i);
|
||||
if (m_t.m_fd_sorts.contains(s)) {
|
||||
unsigned bv_size = get_bv_size(s);
|
||||
m_sorts.push_back(m_t.m_bv.mk_sort(bv_size));
|
||||
unsigned nc = m_t.m_dt.get_datatype_num_constructors(s);
|
||||
if (!is_power_of_two(nc)) {
|
||||
bounds.push_back(m_t.m_bv.mk_ule(m.mk_var(q->get_num_decls()-i-1, m_sorts[i]), m_t.m_bv.mk_numeral(nc, bv_size)));
|
||||
}
|
||||
found = true;
|
||||
}
|
||||
else {
|
||||
m_sorts.push_back(s);
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
return false;
|
||||
}
|
||||
expr_ref new_body_ref(old_body, m), tmp(m);
|
||||
if (!bounds.empty()) {
|
||||
if (q->is_forall()) {
|
||||
new_body_ref = m.mk_implies(mk_and(bounds), new_body_ref);
|
||||
}
|
||||
else {
|
||||
bounds.push_back(new_body_ref);
|
||||
new_body_ref = mk_and(bounds);
|
||||
}
|
||||
}
|
||||
result = m.mk_quantifier(q->is_forall(), q->get_num_decls(), m_sorts.c_ptr(), q->get_decl_names(), new_body_ref,
|
||||
q->get_weight(), q->get_qid(), q->get_skid(),
|
||||
q->get_num_patterns(), new_patterns,
|
||||
q->get_num_no_patterns(), new_no_patterns);
|
||||
result_pr = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
unsigned get_bv_size(sort* s) {
|
||||
unsigned nc = m_t.m_dt.get_datatype_num_constructors(s);
|
||||
unsigned bv_size = 1;
|
||||
while ((unsigned)(1 << bv_size) < nc) {
|
||||
++bv_size;
|
||||
}
|
||||
return bv_size;
|
||||
}
|
||||
};
|
||||
|
||||
struct rw : public rewriter_tpl<rw_cfg> {
|
||||
rw_cfg m_cfg;
|
||||
|
||||
rw(dt2bv_tactic& t, ast_manager & m, params_ref const & p) :
|
||||
rewriter_tpl<rw_cfg>(m, m.proofs_enabled(), m_cfg),
|
||||
m_cfg(t, m, p) {
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
obj_map<func_decl, func_decl*>* m_translate;
|
||||
|
||||
|
||||
bool is_fd(expr* a) { return is_fd(get_sort(a)); }
|
||||
bool is_fd(sort* a) { return m_dt.is_enum_sort(a); }
|
||||
|
|
@ -255,10 +87,20 @@ class dt2bv_tactic : public tactic {
|
|||
void operator()(quantifier* q) {}
|
||||
};
|
||||
|
||||
struct sort_pred : public i_sort_pred {
|
||||
dt2bv_tactic& m_t;
|
||||
sort_pred(dt2bv_tactic& t): m_t(t) {}
|
||||
virtual ~sort_pred() {}
|
||||
virtual bool operator()(sort* s) {
|
||||
return m_t.m_fd_sorts.contains(s);
|
||||
}
|
||||
};
|
||||
|
||||
sort_pred m_is_fd;
|
||||
public:
|
||||
|
||||
dt2bv_tactic(ast_manager& m, params_ref const& p, obj_map<func_decl, expr*>* tr):
|
||||
m(m), m_params(p), m_dt(m), m_bv(m), m_bounds(m), m_translate(tr) {}
|
||||
dt2bv_tactic(ast_manager& m, params_ref const& p, obj_map<func_decl, func_decl*>* tr):
|
||||
m(m), m_params(p), m_dt(m), m_bv(m), m_translate(tr), m_is_fd(*this) {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
return alloc(dt2bv_tactic, m, m_params, 0);
|
||||
|
|
@ -289,26 +131,43 @@ public:
|
|||
m_fd_sorts.remove(*it);
|
||||
}
|
||||
if (!m_fd_sorts.empty()) {
|
||||
m_bounds.reset();
|
||||
m_num_translated = 0;
|
||||
m_ext = alloc(extension_model_converter, m);
|
||||
m_filter = alloc(filter_model_converter, m);
|
||||
scoped_ptr<rw> r = alloc(rw, *this, m, m_params);
|
||||
ref<extension_model_converter> ext = alloc(extension_model_converter, m);
|
||||
ref<filter_model_converter> filter = alloc(filter_model_converter, m);
|
||||
fd_rewriter rw(m, m_params);
|
||||
rw.set_is_fd(&m_is_fd);
|
||||
expr_ref new_curr(m);
|
||||
proof_ref new_pr(m);
|
||||
for (unsigned idx = 0; idx < size; idx++) {
|
||||
(*r)(g->form(idx), new_curr, new_pr);
|
||||
rw(g->form(idx), new_curr, new_pr);
|
||||
if (produce_proofs) {
|
||||
proof * pr = g->pr(idx);
|
||||
new_pr = m.mk_modus_ponens(pr, new_pr);
|
||||
}
|
||||
g->update(idx, new_curr, new_pr, g->dep(idx));
|
||||
}
|
||||
for (unsigned i = 0; i < m_bounds.size(); ++i) {
|
||||
g->assert_expr(m_bounds[i].get());
|
||||
expr_ref_vector bounds(m);
|
||||
rw.flush_side_constraints(bounds);
|
||||
for (unsigned i = 0; i < bounds.size(); ++i) {
|
||||
g->assert_expr(bounds[i].get());
|
||||
}
|
||||
mc = concat(m_filter.get(), m_ext.get());
|
||||
report_tactic_progress(":fd-num-translated", m_num_translated);
|
||||
{
|
||||
obj_map<func_decl, func_decl*>::iterator it = rw.enum2bv().begin(), end = rw.enum2bv().end();
|
||||
for (; it != end; ++it) {
|
||||
filter->insert(it->m_value);
|
||||
if (m_translate) {
|
||||
m_translate->insert(it->m_key, it->m_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
obj_map<func_decl, expr*>::iterator it = rw.enum2def().begin(), end = rw.enum2def().end();
|
||||
for (; it != end; ++it) {
|
||||
ext->insert(it->m_key, it->m_value);
|
||||
}
|
||||
}
|
||||
|
||||
mc = concat(filter.get(), ext.get());
|
||||
report_tactic_progress(":fd-num-translated", rw.num_translated());
|
||||
}
|
||||
g->inc_depth();
|
||||
result.push_back(g.get());
|
||||
|
|
@ -319,11 +178,10 @@ public:
|
|||
virtual void cleanup() {
|
||||
m_fd_sorts.reset();
|
||||
m_non_fd_sorts.reset();
|
||||
m_bounds.reset();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
tactic * mk_dt2bv_tactic(ast_manager & m, params_ref const & p, obj_map<func_decl, expr*>* tr) {
|
||||
tactic * mk_dt2bv_tactic(ast_manager & m, params_ref const & p, obj_map<func_decl, func_decl*>* tr) {
|
||||
return alloc(dt2bv_tactic, m, p, tr);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue