mirror of
https://github.com/Z3Prover/z3
synced 2025-04-29 20:05:51 +00:00
mbp (#4741)
* adding dt-solver Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * dt Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * move mbp to self-contained module Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * files Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Create CMakeLists.txt * dt Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * rename to bool_var2expr to indicate type class * mbp * na * add projection * na * na * na * na * na Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * deps Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * testing arith/q * na * newline for model printing Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
GitHub
parent
e5cc613bf1
commit
72d407a49f
51 changed files with 903 additions and 618 deletions
|
|
@ -16,7 +16,12 @@ Author:
|
|||
--*/
|
||||
|
||||
#include "ast/ast_trail.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "ast/rewriter/var_subst.h"
|
||||
#include "ast/rewriter/expr_safe_replace.h"
|
||||
#include "qe/mbp/mbp_arith.h"
|
||||
#include "qe/mbp/mbp_arrays.h"
|
||||
#include "qe/mbp/mbp_datatypes.h"
|
||||
#include "sat/smt/sat_th.h"
|
||||
#include "sat/smt/q_mbi.h"
|
||||
#include "sat/smt/q_solver.h"
|
||||
|
|
@ -25,21 +30,25 @@ Author:
|
|||
|
||||
namespace q {
|
||||
|
||||
mbqi::mbqi(euf::solver& ctx, solver& s):
|
||||
ctx(ctx),
|
||||
qs(s),
|
||||
m(s.get_manager()),
|
||||
m_model_fixer(ctx, qs),
|
||||
m_model_finder(ctx),
|
||||
m_fresh_trail(m)
|
||||
{}
|
||||
mbqi::mbqi(euf::solver& ctx, solver& s) :
|
||||
ctx(ctx),
|
||||
m_qs(s),
|
||||
m(s.get_manager()),
|
||||
m_model_fixer(ctx, m_qs),
|
||||
m_fresh_trail(m)
|
||||
{
|
||||
auto* ap = alloc(mbp::arith_project_plugin, m);
|
||||
ap->set_check_purified(false);
|
||||
add_plugin(ap);
|
||||
add_plugin(alloc(mbp::datatype_project_plugin, m));
|
||||
add_plugin(alloc(mbp::array_project_plugin, m));
|
||||
}
|
||||
|
||||
void mbqi::restrict_to_universe(expr * sk, ptr_vector<expr> const & universe) {
|
||||
void mbqi::restrict_to_universe(expr* sk, ptr_vector<expr> const& universe) {
|
||||
SASSERT(!universe.empty());
|
||||
expr_ref_vector eqs(m);
|
||||
for (expr * e : universe) {
|
||||
for (expr* e : universe)
|
||||
eqs.push_back(m.mk_eq(sk, e));
|
||||
}
|
||||
expr_ref fml(m.mk_or(eqs), m);
|
||||
m_solver->assert_expr(fml);
|
||||
}
|
||||
|
|
@ -53,10 +62,8 @@ namespace q {
|
|||
m_values.push_back(values);
|
||||
}
|
||||
if (!values->contains(e)) {
|
||||
for (expr* b : *values) {
|
||||
expr_ref eq = ctx.mk_eq(e, b);
|
||||
qs.add_unit(~qs.b_internalize(eq));
|
||||
}
|
||||
for (expr* b : *values)
|
||||
m_qs.add_unit(~m_qs.eq_internalize(e, b));
|
||||
values->insert(e);
|
||||
m_fresh_trail.push_back(e);
|
||||
}
|
||||
|
|
@ -66,15 +73,14 @@ namespace q {
|
|||
// for fixed value return expr
|
||||
// new fixed value is distinct from other expr
|
||||
expr_ref mbqi::replace_model_value(expr* e) {
|
||||
if (m.is_model_value(e)) {
|
||||
if (m.is_model_value(e)) {
|
||||
register_value(e);
|
||||
return expr_ref(e, m);
|
||||
}
|
||||
if (is_app(e) && to_app(e)->get_num_args() > 0) {
|
||||
expr_ref_vector args(m);
|
||||
for (expr* arg : *to_app(e)) {
|
||||
for (expr* arg : *to_app(e))
|
||||
args.push_back(replace_model_value(arg));
|
||||
}
|
||||
return expr_ref(m.mk_app(to_app(e)->get_decl(), args), m);
|
||||
}
|
||||
return expr_ref(e, m);
|
||||
|
|
@ -84,114 +90,146 @@ namespace q {
|
|||
unsigned sz = r->class_size();
|
||||
unsigned start = ctx.s().rand()() % sz;
|
||||
unsigned i = 0;
|
||||
for (euf::enode* n : euf::enode_class(r))
|
||||
for (euf::enode* n : euf::enode_class(r))
|
||||
if (i++ >= start)
|
||||
return expr_ref(n->get_expr(), m);
|
||||
return expr_ref(nullptr, m);
|
||||
}
|
||||
|
||||
|
||||
lbool mbqi::check_forall(quantifier* q) {
|
||||
|
||||
quantifier* q_flat = m_qs.flatten(q);
|
||||
auto* qb = specialize(q_flat);
|
||||
if (!qb)
|
||||
return l_undef;
|
||||
if (m.is_false(qb->mbody))
|
||||
return l_true;
|
||||
init_solver();
|
||||
::solver::scoped_push _sp(*m_solver);
|
||||
expr_ref_vector vars(m);
|
||||
quantifier* q_flat = qs.flatten(q);
|
||||
expr_ref body = specialize(q_flat, vars);
|
||||
m_solver->assert_expr(body);
|
||||
m_solver->assert_expr(qb->mbody);
|
||||
lbool r = m_solver->check_sat(0, nullptr);
|
||||
if (r == l_undef)
|
||||
return r;
|
||||
if (r == l_false)
|
||||
return l_true;
|
||||
model_ref mdl0, mdl1;
|
||||
m_solver->get_model(mdl0);
|
||||
expr_ref proj(m);
|
||||
auto add_projection = [&](model& mdl, bool inv) {
|
||||
proj = project(mdl, q_flat, vars, inv);
|
||||
if (!proj)
|
||||
return;
|
||||
if (is_forall(q))
|
||||
qs.add_clause(~ctx.expr2literal(q), ctx.b_internalize(proj));
|
||||
else
|
||||
qs.add_clause(ctx.expr2literal(q), ~ctx.b_internalize(proj));
|
||||
};
|
||||
bool added = false;
|
||||
#if 0
|
||||
m_model_finder.restrict_instantiations(*m_solver, *mdl0, q_flat, vars);
|
||||
for (unsigned i = 0; i < m_max_cex && l_true == m_solver->check_sat(0, nullptr); ++i) {
|
||||
m_solver->get_model(mdl1);
|
||||
add_projection(*mdl1, true);
|
||||
if (!proj)
|
||||
break;
|
||||
added = true;
|
||||
m_solver->assert_expr(m.mk_not(proj));
|
||||
}
|
||||
#endif
|
||||
if (!added) {
|
||||
add_projection(*mdl0, false);
|
||||
added = proj;
|
||||
}
|
||||
return added ? l_false : l_undef;
|
||||
model_ref mdl0;
|
||||
m_solver->get_model(mdl0);
|
||||
expr_ref proj = solver_project(*mdl0, *qb);
|
||||
if (!proj)
|
||||
return l_undef;
|
||||
sat::literal qlit = ctx.expr2literal(q);
|
||||
if (is_exists(q))
|
||||
qlit.neg();
|
||||
ctx.get_rewriter()(proj);
|
||||
TRACE("q", tout << proj << "\n";);
|
||||
// TODO: add as top-level clause for relevancy
|
||||
m_qs.add_clause(~qlit, ~ctx.mk_literal(proj));
|
||||
return l_false;
|
||||
}
|
||||
|
||||
expr_ref mbqi::specialize(quantifier* q, expr_ref_vector& vars) {
|
||||
expr_ref body(m);
|
||||
unsigned sz = q->get_num_decls();
|
||||
if (!m_model->eval_expr(q->get_expr(), body, true))
|
||||
return expr_ref(m);
|
||||
vars.resize(sz, nullptr);
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
sort* s = q->get_decl_sort(i);
|
||||
vars[i] = m.mk_fresh_const(q->get_decl_name(i), s, false);
|
||||
if (m_model->has_uninterpreted_sort(s))
|
||||
restrict_to_universe(vars.get(i), m_model->get_universe(s));
|
||||
}
|
||||
mbqi::q_body* mbqi::specialize(quantifier* q) {
|
||||
mbqi::q_body* result = nullptr;
|
||||
var_subst subst(m);
|
||||
body = subst(body, vars);
|
||||
if (is_forall(q))
|
||||
body = m.mk_not(body);
|
||||
return body;
|
||||
if (!m_q2body.find(q, result)) {
|
||||
unsigned sz = q->get_num_decls();
|
||||
result = alloc(q_body, m);
|
||||
m_q2body.insert(q, result);
|
||||
ctx.push(new_obj_trail<euf::solver, q_body>(result));
|
||||
ctx.push(insert_obj_map<euf::solver, quantifier, q_body*>(m_q2body, q));
|
||||
app_ref_vector& vars = result->vars;
|
||||
vars.resize(sz, nullptr);
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
sort* s = q->get_decl_sort(i);
|
||||
vars[i] = m.mk_fresh_const(q->get_decl_name(i), s, false);
|
||||
if (m_model->has_uninterpreted_sort(s))
|
||||
restrict_to_universe(vars.get(i), m_model->get_universe(s));
|
||||
}
|
||||
expr_ref fml = subst(q->get_expr(), vars);
|
||||
if (is_forall(q))
|
||||
fml = m.mk_not(fml);
|
||||
flatten_and(fml, result->vbody);
|
||||
}
|
||||
expr_ref& mbody = result->mbody;
|
||||
unsigned sz = q->get_num_decls();
|
||||
if (!m_model->eval_expr(q->get_expr(), mbody, true))
|
||||
return nullptr;
|
||||
|
||||
mbody = subst(mbody, result->vars);
|
||||
if (is_forall(q))
|
||||
mbody = mk_not(m, mbody);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* A most rudimentary projection operator that only tries to find proxy terms from the set of existing terms.
|
||||
* Refinements:
|
||||
* - grammar based from MBQI paper
|
||||
* - grammar based from MBQI paper
|
||||
* - quantifier elimination based on projection operators defined in qe.
|
||||
*
|
||||
*
|
||||
* - eliminate as-array terms, use lambda
|
||||
* - have mode with inv-term from model-finder
|
||||
*/
|
||||
expr_ref mbqi::project(model& mdl, quantifier* q, expr_ref_vector& vars, bool inv) {
|
||||
expr_ref mbqi::basic_project(model& mdl, quantifier* q, app_ref_vector& vars) {
|
||||
unsigned sz = q->get_num_decls();
|
||||
unsigned max_generation = 0;
|
||||
expr_ref_vector vals(m);
|
||||
vals.resize(sz, nullptr);
|
||||
auto const& v2r = ctx.values2root();
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
app* v = to_app(vars.get(i));
|
||||
func_decl* f = v->get_decl();
|
||||
expr_ref val(mdl.get_some_const_interp(f), m);
|
||||
if (!val)
|
||||
return expr_ref(m);
|
||||
val = mdl.unfold_as_array(val);
|
||||
if (!val)
|
||||
return expr_ref(m);
|
||||
if (inv)
|
||||
vals[i] = m_model_finder.inv_term(mdl, q, i, val, max_generation);
|
||||
euf::enode* r = nullptr;
|
||||
if (!vals.get(i) && v2r.find(val, r))
|
||||
vals[i] = choose_term(r);
|
||||
app* v = vars.get(i);
|
||||
vals[i] = assign_value(mdl, v);
|
||||
if (!vals.get(i))
|
||||
vals[i] = replace_model_value(val);
|
||||
return expr_ref(m);
|
||||
}
|
||||
var_subst subst(m);
|
||||
return subst(q->get_expr(), vals);
|
||||
return subst(q->get_expr(), vals);
|
||||
}
|
||||
|
||||
expr_ref mbqi::solver_project(model& mdl, q_body& qb) {
|
||||
for (app* v : qb.vars)
|
||||
m_model->register_decl(v->get_decl(), mdl(v));
|
||||
expr_ref_vector fmls(qb.vbody);
|
||||
app_ref_vector vars(qb.vars);
|
||||
mbp::project_plugin proj(m);
|
||||
proj.purify(m_model_fixer, *m_model, vars, fmls);
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
app* v = vars.get(i);
|
||||
auto* p = get_plugin(v);
|
||||
if (p)
|
||||
(*p)(*m_model, vars, fmls);
|
||||
}
|
||||
if (!vars.empty()) {
|
||||
expr_safe_replace esubst(m);
|
||||
for (app* v : vars) {
|
||||
expr_ref val = assign_value(*m_model, v);
|
||||
if (!val)
|
||||
return expr_ref(m);
|
||||
esubst.insert(v, val);
|
||||
}
|
||||
esubst(fmls);
|
||||
}
|
||||
return mk_and(fmls);
|
||||
}
|
||||
|
||||
expr_ref mbqi::assign_value(model& mdl, app* v) {
|
||||
func_decl* f = v->get_decl();
|
||||
expr_ref val(mdl.get_some_const_interp(f), m);
|
||||
if (!val)
|
||||
return expr_ref(m);
|
||||
val = mdl.unfold_as_array(val);
|
||||
if (!val)
|
||||
return expr_ref(m);
|
||||
euf::enode* r = nullptr;
|
||||
auto const& v2r = ctx.values2root();
|
||||
if (v2r.find(val, r))
|
||||
val = choose_term(r);
|
||||
else
|
||||
val = replace_model_value(val);
|
||||
return val;
|
||||
}
|
||||
|
||||
lbool mbqi::operator()() {
|
||||
lbool result = l_true;
|
||||
m_model = nullptr;
|
||||
for (sat::literal lit : qs.m_universal) {
|
||||
for (sat::literal lit : m_qs.m_universal) {
|
||||
quantifier* q = to_quantifier(ctx.bool_var2expr(lit.var()));
|
||||
if (!ctx.is_relevant(q))
|
||||
continue;
|
||||
|
|
@ -232,4 +270,16 @@ namespace q {
|
|||
m_model_fixer(mdl);
|
||||
}
|
||||
|
||||
mbp::project_plugin* mbqi::get_plugin(app* var) {
|
||||
family_id fid = m.get_sort(var)->get_family_id();
|
||||
return m_plugins.get(fid, nullptr);
|
||||
}
|
||||
|
||||
void mbqi::add_plugin(mbp::project_plugin* p) {
|
||||
family_id fid = p->get_family_id();
|
||||
m_plugins.reserve(fid + 1);
|
||||
SASSERT(!m_plugins.get(fid, nullptr));
|
||||
m_plugins.set(fid, p);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue