mirror of
https://github.com/Z3Prover/z3
synced 2025-04-05 17:14:07 +00:00
QEL: Fast Approximated Quantifier Elimination (#6820)
* qe_lite: cleanup and comment
no change to code
* mbp_arrays: refactor out partial equality (peq)
Partial array equality, PEQ, is used as an intermediate
expression during MBP for arrays. We need to factor it out
so that it can be shared between MBP-QEL and existing MBP.
Partial array equality (peq) is used in MBP for arrays.
Factoring this out to be used by multiple MBP implementations.
* rewriter: new rewrite rules
These rules are specializes for terms that are created in QEL.
QEL commit is comming later
* datatype_rw: new rewrite rule for ADTs
The rule handles this special case:
(cons (head x) (tail x)) --> x
* array_rewriter rules for rewriting PEQs
Special rules to simplify PEQs
* th_rewriter: wire PEQ simplifications
* spacer_iuc: avoid terms with default in IUC
Spacer prfers to not have a term representing default value of an array.
This guides IUC from picking such terms in interpolation
* mbp_term_graph: replace root with repr
* mbp_term_graph: formatting
* mbp_term_graph: class_props, getters, setters
Class properties allow to keep information for an equivalence class.
Getters and setters for terms allow accessing information
* mbp_term_graph: auxiliary methods for qel
QEL commit is comming later in the history
* mbp_term_graph: bug fix
* mbp_term_graph: pick, refine repr, compute cgrnd
* mbp_term_graph: internalize deq
* mbp_term_graph: constructor
* mbp_term_graph: optionally internalize equalities
Reperesent equalities explicitly by nodes in the term_graph
* qel
* formatting
* comments on term_lt
* get terms and other api for mbp_qel
* plugins for mbp_qel
* mbp_qel_util: utilities for mbp_qel
* qe_mbp: QEL-based mbp
* qel: expose QEL API
* spacer: replace qe_lite in qe_project_spacer by qel
This changes the default projection engine that spacer uses.
* cmd_context: debug commands for qel and mbp_qel
New commands are
mbp-qel -- MBP with term graphs
qel -- QEL with term graphs
qe-lite -- older qelite
* qe_mbp: model-based rewriters for arrays
* qe_mbp: QEL-based projection functions
* qsat: wire in QEL-based mbp
* qsat: debug code
* qsat: maybe a bug fix
Changed the code to follow the paper by adding all predicates above a given
level, not just predicates of immediately preceding level.
* chore: use new api to create solver in qsat
* mbp_term_graph use all_of idiom
* feat: solver for integer multiplication
* array_peq: formatting, no change to code
* mbp_qel_util: block comment + format
* mbt_term_graph: clang-format
* bug fix. Move dt rewrite to qe_mbp
* array_peq: add header
* run clang format on mbp plugins
* clang format on mul solver
* format do-while
* format
* format do-while
* update release notes
---------
Co-authored-by: hgvk94 <hgvk94@gmail.com>
Co-authored-by: Isabel Garcia <igarciac@uwaterloo.ca>
This commit is contained in:
Arie Gurfinkel
GitHub
parent
5b2519d7a3
commit
51d3c279d0
|
|
@ -9,6 +9,7 @@ Version 4.next
|
|||
- polysat
|
||||
- native word level bit-vector solving.
|
||||
- introduction of simple induction lemmas to handle a limited repertoire of induction proofs.
|
||||
- Light quantifier elimination based on term graphs (egraphs), and corresponding Model Based Projection for arrays and ADTs. Used by Spacer and QSAT.
|
||||
|
||||
Version 4.12.3
|
||||
==============
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ z3_add_component(ast
|
|||
act_cache.cpp
|
||||
arith_decl_plugin.cpp
|
||||
array_decl_plugin.cpp
|
||||
array_peq.cpp
|
||||
ast.cpp
|
||||
ast_ll_pp.cpp
|
||||
ast_lt.cpp
|
||||
|
|
|
|||
107
src/ast/array_peq.cpp
Normal file
107
src/ast/array_peq.cpp
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
/*++
|
||||
Copyright (c) 2023 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_peq.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Partial equality for arrays
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2015-06-13
|
||||
Hari Govind V K
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include "ast/array_peq.h"
|
||||
|
||||
#define PARTIAL_EQ "!partial_eq"
|
||||
bool is_partial_eq(const func_decl *f) {
|
||||
SASSERT(f);
|
||||
return f->get_name() == PARTIAL_EQ;
|
||||
}
|
||||
|
||||
bool is_partial_eq(const app *a) {
|
||||
SASSERT(a);
|
||||
return is_partial_eq(a->get_decl());
|
||||
}
|
||||
|
||||
app_ref mk_peq(expr *e0, expr *e1, vector<expr_ref_vector> const &indices,
|
||||
ast_manager &m) {
|
||||
peq p(e0, e1, indices, m);
|
||||
return p.mk_peq();
|
||||
}
|
||||
|
||||
app_ref peq::mk_eq(app_ref_vector &aux_consts, bool stores_on_rhs) {
|
||||
if (!m_eq) {
|
||||
expr_ref lhs(m_lhs, m), rhs(m_rhs, m);
|
||||
if (!stores_on_rhs) { std::swap(lhs, rhs); }
|
||||
// lhs = (...(store (store rhs i0 v0) i1 v1)...)
|
||||
sort *val_sort = get_array_range(lhs->get_sort());
|
||||
for (expr_ref_vector const &diff : m_diff_indices) {
|
||||
ptr_vector<expr> store_args;
|
||||
store_args.push_back(rhs);
|
||||
store_args.append(diff.size(), diff.data());
|
||||
app_ref val(m.mk_fresh_const("diff", val_sort), m);
|
||||
store_args.push_back(val);
|
||||
aux_consts.push_back(val);
|
||||
rhs = m_arr_u.mk_store(store_args);
|
||||
}
|
||||
m_eq = m.mk_eq(lhs, rhs);
|
||||
}
|
||||
return m_eq;
|
||||
}
|
||||
|
||||
app_ref peq::mk_peq() {
|
||||
if (!m_peq) {
|
||||
ptr_vector<expr> args;
|
||||
args.push_back(m_lhs);
|
||||
args.push_back(m_rhs);
|
||||
for (auto const &v : m_diff_indices) {
|
||||
args.append(v.size(), v.data());
|
||||
}
|
||||
m_peq = m.mk_app(m_decl, args.size(), args.data());
|
||||
}
|
||||
return m_peq;
|
||||
}
|
||||
|
||||
peq::peq(expr *lhs, expr *rhs, vector<expr_ref_vector> const &diff_indices,
|
||||
ast_manager &m)
|
||||
: m(m), m_lhs(lhs, m), m_rhs(rhs, m), m_diff_indices(diff_indices),
|
||||
m_decl(m), m_peq(m), m_eq(m), m_arr_u(m) {
|
||||
SASSERT(m_arr_u.is_array(lhs));
|
||||
SASSERT(m_arr_u.is_array(rhs));
|
||||
SASSERT(lhs->get_sort() == rhs->get_sort());
|
||||
ptr_vector<sort> sorts;
|
||||
sorts.push_back(m_lhs->get_sort());
|
||||
sorts.push_back(m_rhs->get_sort());
|
||||
|
||||
for (auto const &v : diff_indices) {
|
||||
SASSERT(v.size() == get_array_arity(m_lhs->get_sort()));
|
||||
for (expr *e : v) sorts.push_back(e->get_sort());
|
||||
}
|
||||
m_decl = m.mk_func_decl(symbol(PARTIAL_EQ), sorts.size(), sorts.data(),
|
||||
m.mk_bool_sort());
|
||||
}
|
||||
|
||||
peq::peq(app *p, ast_manager &m)
|
||||
: m(m), m_lhs(p->get_arg(0), m), m_rhs(p->get_arg(1), m),
|
||||
m_decl(p->get_decl(), m), m_peq(p, m), m_eq(m), m_arr_u(m),
|
||||
m_name(symbol(PARTIAL_EQ)) {
|
||||
SASSERT(is_partial_eq(p));
|
||||
|
||||
SASSERT(m_arr_u.is_array(m_lhs));
|
||||
SASSERT(m_arr_u.is_array(m_rhs));
|
||||
SASSERT(m_lhs->get_sort() == m_rhs->get_sort());
|
||||
unsigned arity = get_array_arity(m_lhs->get_sort());
|
||||
for (unsigned i = 2; i < p->get_num_args(); i += arity) {
|
||||
SASSERT(arity + i <= p->get_num_args());
|
||||
expr_ref_vector vec(m);
|
||||
vec.append(arity, p->get_args() + i);
|
||||
m_diff_indices.push_back(std::move(vec));
|
||||
}
|
||||
}
|
||||
91
src/ast/array_peq.h
Normal file
91
src/ast/array_peq.h
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/*++
|
||||
Copyright (c) 2023 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_peq.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Partial equality for arrays
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2015-06-13
|
||||
Hari Govind V K
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#pragma once
|
||||
|
||||
#include "ast/array_decl_plugin.h"
|
||||
#include "ast/ast.h"
|
||||
|
||||
/**
|
||||
* \brief utility class for partial equalities
|
||||
*
|
||||
* A partial equality (a ==I b), for two arrays a, b and a finite set of indices
|
||||
* I holds iff (forall i :: i \not\in I => a[i] == b[i]). In other words, peq is
|
||||
* a restricted form of the extensionality axiom
|
||||
*
|
||||
* Using this class, we denote (a =I b) as f(a,b,i0,i1,...),
|
||||
* where f is an uninterpreted predicate with the name PARTIAL_EQ and
|
||||
* I = {i0,i1,...}
|
||||
*/
|
||||
|
||||
class peq {
|
||||
ast_manager &m;
|
||||
expr_ref m_lhs;
|
||||
expr_ref m_rhs;
|
||||
vector<expr_ref_vector> m_diff_indices;
|
||||
func_decl_ref m_decl; // the partial equality declaration
|
||||
app_ref m_peq; // partial equality application
|
||||
app_ref m_eq; // equivalent std equality using def. of partial eq
|
||||
array_util m_arr_u;
|
||||
symbol m_name;
|
||||
|
||||
public:
|
||||
peq(app *p, ast_manager &m);
|
||||
|
||||
peq(expr *lhs, expr *rhs, vector<expr_ref_vector> const &diff_indices,
|
||||
ast_manager &m);
|
||||
|
||||
expr_ref lhs() { return m_lhs; }
|
||||
|
||||
expr_ref rhs() { return m_rhs; }
|
||||
|
||||
void get_diff_indices(vector<expr_ref_vector> &result) {
|
||||
result.append(m_diff_indices);
|
||||
}
|
||||
|
||||
/** Convert peq into a peq expression */
|
||||
app_ref mk_peq();
|
||||
|
||||
/** Convert peq into an equality
|
||||
|
||||
For peq of the form (a =I b) returns (a = b[i0 := v0, i1 := v1, ...])
|
||||
where i0, i1 \in I, and v0, v1 are fresh skolem constants
|
||||
|
||||
Skolems are returned in aux_consts
|
||||
|
||||
The left and right hand arguments are reversed when stores_on_rhs is
|
||||
false
|
||||
*/
|
||||
app_ref mk_eq(app_ref_vector &aux_consts, bool stores_on_rhs = true);
|
||||
};
|
||||
|
||||
/**
|
||||
* mk (e0 ==indices e1)
|
||||
*
|
||||
* result has stores if either e0 or e1 or an index term has stores
|
||||
*/
|
||||
app_ref mk_peq(expr *e0, expr *e1, vector<expr_ref_vector> const &indices,
|
||||
ast_manager &m);
|
||||
|
||||
bool is_partial_eq(const func_decl *f);
|
||||
|
||||
bool is_partial_eq(const app *a);
|
||||
|
||||
inline bool is_peq(const func_decl *f) { return is_partial_eq(f); }
|
||||
inline bool is_peq(const app *a) { return is_partial_eq(a); }
|
||||
|
|
@ -24,6 +24,7 @@ Notes:
|
|||
#include "ast/rewriter/var_subst.h"
|
||||
#include "params/array_rewriter_params.hpp"
|
||||
#include "util/util.h"
|
||||
#include "ast/array_peq.h"
|
||||
|
||||
void array_rewriter::updt_params(params_ref const & _p) {
|
||||
array_rewriter_params p(_p);
|
||||
|
|
@ -40,8 +41,48 @@ void array_rewriter::get_param_descrs(param_descrs & r) {
|
|||
}
|
||||
|
||||
br_status array_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
|
||||
br_status st = BR_FAILED;
|
||||
|
||||
// BEGIN: rewrite rules for PEQs
|
||||
if (is_partial_eq(f)) {
|
||||
SASSERT(num_args >= 2);
|
||||
expr *e0, *e1;
|
||||
e0 = args[0];
|
||||
e1 = args[1];
|
||||
|
||||
expr_ref a(m()), val(m());
|
||||
expr_ref_vector vindex(m());
|
||||
|
||||
if (e0 == e1) {
|
||||
// t peq t --> true
|
||||
result = m().mk_true();
|
||||
st = BR_DONE;
|
||||
}
|
||||
else if (m_util.is_store_ext(e0, a, vindex, val)) {
|
||||
if (num_args == 2 && a == e1) {
|
||||
// (a[i := x] peq_{\emptyset} a) ---> a[i] == x
|
||||
mk_select(vindex.size(), vindex.data(), result);
|
||||
result = m().mk_eq(result, val);
|
||||
st = BR_REWRITE_FULL;
|
||||
}
|
||||
else if (a == e1 && vindex.size() == num_args + 2) {
|
||||
// a [i: = x] peq_{i} a -- > true
|
||||
bool all_eq = true;
|
||||
for (unsigned i = 0, sz = vindex.size(); all_eq && i < sz;
|
||||
++i) {
|
||||
all_eq &= vindex.get(i) == args[2+i];
|
||||
}
|
||||
if (all_eq) {
|
||||
result = m().mk_true();
|
||||
st = BR_DONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return st;
|
||||
}
|
||||
// END: rewrite rules for PEQs
|
||||
|
||||
SASSERT(f->get_family_id() == get_fid());
|
||||
br_status st;
|
||||
switch (f->get_decl_kind()) {
|
||||
case OP_SELECT:
|
||||
st = mk_select_core(num_args, args, result);
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@ Notes:
|
|||
br_status datatype_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
|
||||
SASSERT(f->get_family_id() == get_fid());
|
||||
switch(f->get_decl_kind()) {
|
||||
case OP_DT_CONSTRUCTOR: return BR_FAILED;
|
||||
case OP_DT_CONSTRUCTOR:
|
||||
return BR_FAILED;
|
||||
case OP_DT_RECOGNISER:
|
||||
SASSERT(num_args == 1);
|
||||
result = m_util.mk_is(m_util.get_recognizer_constructor(f), args[0]);
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ Notes:
|
|||
#include "ast/ast_util.h"
|
||||
#include "ast/well_sorted.h"
|
||||
#include "ast/for_each_expr.h"
|
||||
#include "ast/array_peq.h"
|
||||
|
||||
namespace {
|
||||
struct th_rewriter_cfg : public default_rewriter_cfg {
|
||||
|
|
@ -644,6 +645,10 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
|
|||
else
|
||||
st = pull_ite(result);
|
||||
}
|
||||
if (st == BR_FAILED && f->get_family_id() == null_family_id && is_partial_eq(f)) {
|
||||
st = m_ar_rw.mk_app_core(f, num, args, result);
|
||||
}
|
||||
|
||||
CTRACE("th_rewriter_step", st != BR_FAILED,
|
||||
tout << f->get_name() << "\n";
|
||||
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ Notes:
|
|||
|
||||
--*/
|
||||
#include<iomanip>
|
||||
#include "ast/ast.h"
|
||||
#include "cmd_context/cmd_context.h"
|
||||
#include "cmd_context/cmd_util.h"
|
||||
#include "ast/rewriter/rewriter.h"
|
||||
|
|
@ -34,7 +35,9 @@ Notes:
|
|||
#include "qe/qe_mbp.h"
|
||||
#include "qe/qe_mbi.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
|
||||
#include "qe/mbp/mbp_qel.h"
|
||||
#include "qe/lite/qe_lite_tactic.h"
|
||||
#include "qe/lite/qel.h"
|
||||
|
||||
BINARY_SYM_CMD(get_quantifier_body_cmd,
|
||||
"dbg-get-qbody",
|
||||
|
|
@ -369,7 +372,7 @@ public:
|
|||
}
|
||||
vars.push_back(to_app(v));
|
||||
}
|
||||
qe::mbproj mbp(m);
|
||||
qe::mbproj mbp(m, gparams::get_module("smt"));
|
||||
expr_ref fml(m_fml, m);
|
||||
mbp.spacer(vars, *mdl.get(), fml);
|
||||
ctx.regular_stream() << fml << "\n";
|
||||
|
|
@ -572,6 +575,190 @@ public:
|
|||
|
||||
};
|
||||
|
||||
class mbp_qel_cmd : public cmd {
|
||||
unsigned m_arg_index;
|
||||
ptr_vector<expr> m_lits;
|
||||
ptr_vector<expr> m_vars;
|
||||
|
||||
public:
|
||||
mbp_qel_cmd() : cmd("mbp-qel"){};
|
||||
char const *get_usage() const override { return "(exprs) (vars)"; }
|
||||
char const *get_descr(cmd_context &ctx) const override {
|
||||
return "Model based projection using e-graphs";
|
||||
}
|
||||
unsigned get_arity() const override { return 2; }
|
||||
cmd_arg_kind next_arg_kind(cmd_context &ctx) const override {
|
||||
return CPK_EXPR_LIST;
|
||||
}
|
||||
void set_next_arg(cmd_context &ctx, unsigned num,
|
||||
expr *const *args) override {
|
||||
if (m_arg_index == 0) {
|
||||
m_lits.append(num, args);
|
||||
m_arg_index = 1;
|
||||
}
|
||||
else { m_vars.append(num, args); }
|
||||
}
|
||||
void prepare(cmd_context &ctx) override {
|
||||
m_arg_index = 0;
|
||||
m_lits.reset();
|
||||
m_vars.reset();
|
||||
}
|
||||
void execute(cmd_context &ctx) override {
|
||||
ast_manager &m = ctx.m();
|
||||
app_ref_vector vars(m);
|
||||
expr_ref fml(m);
|
||||
expr_ref_vector lits(m);
|
||||
for (expr *v : m_vars) vars.push_back(to_app(v));
|
||||
for (expr *e : m_lits) lits.push_back(e);
|
||||
fml = mk_and(lits);
|
||||
solver_factory &sf = ctx.get_solver_factory();
|
||||
params_ref pa;
|
||||
solver_ref s = sf(m, pa, false, true, true, symbol::null);
|
||||
s->assert_expr(fml);
|
||||
lbool r = s->check_sat();
|
||||
if (r != l_true) return;
|
||||
model_ref mdl;
|
||||
s->get_model(mdl);
|
||||
mbp::mbp_qel mbptg(m, pa);
|
||||
mbptg(vars, fml, *mdl.get());
|
||||
|
||||
ctx.regular_stream() << "------------------------------ " << std::endl;
|
||||
ctx.regular_stream() << "Orig tg: " << mk_and(lits) << std::endl;
|
||||
ctx.regular_stream() << "To elim: ";
|
||||
for (expr *v : m_vars) {
|
||||
ctx.regular_stream() << to_app(v)->get_decl()->get_name() << " ";
|
||||
}
|
||||
ctx.regular_stream() << std::endl;
|
||||
ctx.regular_stream() << "output " << fml << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
class qel_cmd : public cmd {
|
||||
unsigned m_arg_index;
|
||||
ptr_vector<expr> m_lits;
|
||||
ptr_vector<func_decl> m_vars;
|
||||
|
||||
public:
|
||||
qel_cmd() : cmd("qel"){};
|
||||
char const *get_usage() const override { return "(lits) (vars)"; }
|
||||
char const *get_descr(cmd_context &ctx) const override {
|
||||
return "QE lite over e-graphs";
|
||||
}
|
||||
unsigned get_arity() const override { return 2; }
|
||||
cmd_arg_kind next_arg_kind(cmd_context &ctx) const override {
|
||||
if (m_arg_index == 0) return CPK_EXPR_LIST;
|
||||
return CPK_FUNC_DECL_LIST;
|
||||
}
|
||||
void set_next_arg(cmd_context &ctx, unsigned num,
|
||||
expr *const *args) override {
|
||||
m_lits.append(num, args);
|
||||
m_arg_index = 1;
|
||||
}
|
||||
void set_next_arg(cmd_context &ctx, unsigned num,
|
||||
func_decl *const *ts) override {
|
||||
m_vars.append(num, ts);
|
||||
}
|
||||
void prepare(cmd_context &ctx) override {
|
||||
m_arg_index = 0;
|
||||
m_lits.reset();
|
||||
m_vars.reset();
|
||||
}
|
||||
void execute(cmd_context &ctx) override {
|
||||
ast_manager &m = ctx.m();
|
||||
func_decl_ref_vector vars(m);
|
||||
app_ref_vector vars_apps(m);
|
||||
expr_ref_vector lits(m);
|
||||
|
||||
ctx.regular_stream() << "------------------------------ " << std::endl;
|
||||
|
||||
for (func_decl *v : m_vars) {
|
||||
vars.push_back(v);
|
||||
vars_apps.push_back(m.mk_const(v));
|
||||
}
|
||||
for (expr *e : m_lits) lits.push_back(e);
|
||||
|
||||
expr_ref fml(m.mk_and(lits), m);
|
||||
ctx.regular_stream() << "[tg] Before: " << fml << std::endl
|
||||
<< "[tg] Vars: ";
|
||||
for (app *a : vars_apps) ctx.regular_stream() << app_ref(a, m) << " ";
|
||||
|
||||
ctx.regular_stream() << std::endl;
|
||||
|
||||
params_ref pa;
|
||||
|
||||
// the following is the same code as in qe_mbp in spacer
|
||||
qel qe(m, pa);
|
||||
qe(vars_apps, fml);
|
||||
ctx.regular_stream() << "[tg] After: " << fml << std::endl
|
||||
<< "[tg] Vars: ";
|
||||
for (app *a : vars_apps) ctx.regular_stream() << app_ref(a, m) << " ";
|
||||
|
||||
ctx.regular_stream() << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
class qe_lite_cmd : public cmd {
|
||||
unsigned m_arg_index;
|
||||
ptr_vector<expr> m_lits;
|
||||
ptr_vector<func_decl> m_vars;
|
||||
|
||||
public:
|
||||
qe_lite_cmd() : cmd("qe-lite"){};
|
||||
char const *get_usage() const override { return "(lits) (vars)"; }
|
||||
char const *get_descr(cmd_context &ctx) const override {
|
||||
return "QE lite over e-graphs";
|
||||
}
|
||||
unsigned get_arity() const override { return 2; }
|
||||
cmd_arg_kind next_arg_kind(cmd_context &ctx) const override {
|
||||
if (m_arg_index == 0) return CPK_EXPR_LIST;
|
||||
return CPK_FUNC_DECL_LIST;
|
||||
}
|
||||
void set_next_arg(cmd_context &ctx, unsigned num,
|
||||
expr *const *args) override {
|
||||
m_lits.append(num, args);
|
||||
m_arg_index = 1;
|
||||
}
|
||||
void set_next_arg(cmd_context &ctx, unsigned num,
|
||||
func_decl *const *ts) override {
|
||||
m_vars.append(num, ts);
|
||||
}
|
||||
void prepare(cmd_context &ctx) override {
|
||||
m_arg_index = 0;
|
||||
m_lits.reset();
|
||||
m_vars.reset();
|
||||
}
|
||||
void execute(cmd_context &ctx) override {
|
||||
ast_manager &m = ctx.m();
|
||||
func_decl_ref_vector vars(m);
|
||||
app_ref_vector vars_apps(m);
|
||||
expr_ref_vector lits(m);
|
||||
|
||||
ctx.regular_stream() << "------------------------------ " << std::endl;
|
||||
|
||||
for (func_decl *v : m_vars) {
|
||||
vars.push_back(v);
|
||||
vars_apps.push_back(m.mk_const(v));
|
||||
}
|
||||
for (expr *e : m_lits) lits.push_back(e);
|
||||
|
||||
expr_ref fml(m.mk_and(lits), m);
|
||||
ctx.regular_stream() << "[der] Before: " << fml << std::endl
|
||||
<< "[der] Vars: ";
|
||||
for (app *a : vars_apps) ctx.regular_stream() << app_ref(a, m) << " ";
|
||||
|
||||
ctx.regular_stream() << std::endl;
|
||||
|
||||
params_ref pa;
|
||||
// the following is the same code as in qe_mbp in spacer
|
||||
qe_lite qe(m, pa, false);
|
||||
qe(vars_apps, fml);
|
||||
ctx.regular_stream() << "[der] After: " << fml << std::endl
|
||||
<< "[der] Vars: ";
|
||||
for (app *a : vars_apps) ctx.regular_stream() << app_ref(a, m) << " ";
|
||||
|
||||
ctx.regular_stream() << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
void install_dbg_cmds(cmd_context &ctx) {
|
||||
ctx.insert(alloc(print_dimacs_cmd));
|
||||
|
|
@ -598,7 +785,10 @@ void install_dbg_cmds(cmd_context & ctx) {
|
|||
ctx.insert(alloc(set_next_id));
|
||||
ctx.insert(alloc(get_interpolant_cmd));
|
||||
ctx.insert(alloc(mbp_cmd));
|
||||
ctx.insert(alloc(mbp_qel_cmd));
|
||||
ctx.insert(alloc(mbi_cmd));
|
||||
ctx.insert(alloc(euf_project_cmd));
|
||||
ctx.insert(alloc(eufi_cmd));
|
||||
ctx.insert(alloc(qel_cmd));
|
||||
ctx.insert(alloc(qe_lite_cmd));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ namespace spacer {
|
|||
// the current step needs to be interpolated:
|
||||
expr* fact = m.get_fact(pf);
|
||||
// if we trust the current step and we are able to use it
|
||||
if (m_ctx.is_b_pure (pf) && (m.is_asserted(pf) || spacer::is_literal(m, fact))) {
|
||||
if (m_ctx.is_b_pure (pf) && (m.is_asserted(pf) || spacer::is_literal(m, fact)) && !spacer::contains_defaults(fact, m)) {
|
||||
// just add it to the core
|
||||
m_ctx.add_lemma_to_core(fact);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@ Notes:
|
|||
#include "ast/ast_pp.h"
|
||||
#include "ast/bv_decl_plugin.h"
|
||||
#include "ast/datatype_decl_plugin.h"
|
||||
#include "ast/expr_functors.h"
|
||||
#include "ast/for_each_expr.h"
|
||||
#include "ast/occurs.h"
|
||||
#include "ast/rewriter/bool_rewriter.h"
|
||||
|
|
@ -51,7 +52,7 @@ Notes:
|
|||
#include "model/model_smt2_pp.h"
|
||||
#include "smt/params/smt_params.h"
|
||||
|
||||
#include "qe/lite/qe_lite_tactic.h"
|
||||
#include "qe/lite/qel.h"
|
||||
#include "qe/mbp/mbp_plugin.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "qe/qe_mbp.h"
|
||||
|
|
@ -69,6 +70,21 @@ Notes:
|
|||
|
||||
namespace spacer {
|
||||
|
||||
class contains_def_pred : public i_expr_pred {
|
||||
array_util m_autil;
|
||||
public:
|
||||
contains_def_pred(ast_manager& m): m_autil(m) {}
|
||||
bool operator()(expr* e) override {
|
||||
return m_autil.is_default(e);
|
||||
}
|
||||
};
|
||||
|
||||
bool contains_defaults(expr *fml, ast_manager &m) {
|
||||
contains_def_pred pred(m);
|
||||
check_pred check(pred, m, false);
|
||||
return check(fml);
|
||||
}
|
||||
|
||||
bool is_clause(ast_manager &m, expr *n) {
|
||||
if (spacer::is_literal(m, n)) return true;
|
||||
if (m.is_or(n)) {
|
||||
|
|
@ -173,7 +189,7 @@ void qe_project_spacer(ast_manager &m, app_ref_vector &vars, expr_ref &fml,
|
|||
|
||||
while (true) {
|
||||
params_ref p;
|
||||
qe_lite qe(m, p, false);
|
||||
qel qe(m, p);
|
||||
qe(vars, fml);
|
||||
rw(fml);
|
||||
|
||||
|
|
|
|||
|
|
@ -121,6 +121,7 @@ void ground_expr(expr *e, expr_ref &out, app_ref_vector &vars);
|
|||
void mbqi_project(model &mdl, app_ref_vector &vars, expr_ref &fml);
|
||||
|
||||
bool contains_selects(expr *fml, ast_manager &m);
|
||||
bool contains_defaults(expr *fml, ast_manager &m);
|
||||
void get_select_indices(expr *fml, app_ref_vector &indices);
|
||||
|
||||
void find_decls(expr *fml, app_ref_vector &decls, std::string &prefix);
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
z3_add_component(qe_lite
|
||||
SOURCES
|
||||
qe_lite_tactic.cpp
|
||||
qel.cpp
|
||||
COMPONENT_DEPENDENCIES
|
||||
tactic
|
||||
mbp
|
||||
TACTIC_HEADERS
|
||||
qe_lite_tactic.h
|
||||
qel.h
|
||||
)
|
||||
|
|
|
|||
|
|
@ -487,7 +487,7 @@ namespace qel {
|
|||
ptr_vector<var> vs;
|
||||
expr_ref_vector ts(m);
|
||||
expr_ref t(m);
|
||||
if (is_var_def(is_exists, args[i], vs, ts)) {
|
||||
if (is_var_def(is_exists, args[i], vs, ts)) { // vs is the variable, ts is the definition
|
||||
for (unsigned j = 0; j < vs.size(); ++j) {
|
||||
var* v = vs[j];
|
||||
t = ts.get(j);
|
||||
|
|
@ -2376,7 +2376,7 @@ public:
|
|||
m_array_der.set_is_variable_proc(is_var);
|
||||
m_der(fmls);
|
||||
m_fm(fmls);
|
||||
// AG: disalble m_array_der() since it interferes with other array handling
|
||||
// AG: disable m_array_der() since it interferes with other array handling
|
||||
if (m_use_array_der) m_array_der(fmls);
|
||||
TRACE("qe_lite", for (unsigned i = 0; i < fmls.size(); ++i) tout << mk_pp(fmls[i].get(), m) << "\n";);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ class tactic;
|
|||
class qe_lite {
|
||||
class impl;
|
||||
impl * m_impl;
|
||||
|
||||
public:
|
||||
/**
|
||||
use_array_der controls whether equalities over array reads are simplified
|
||||
|
|
|
|||
54
src/qe/lite/qel.cpp
Normal file
54
src/qe/lite/qel.cpp
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
/*++
|
||||
|
||||
Module Name:
|
||||
|
||||
qel.cpp
|
||||
|
||||
Abstract:
|
||||
Light weight quantifier elimination (QEL) based on term graph.
|
||||
|
||||
The implementation is based on the following paper:
|
||||
|
||||
Isabel Garcia-Contreras, Hari Govind V. K., Sharon Shoham, Arie Gurfinkel:
|
||||
Fast Approximations of Quantifier Elimination. Computer-Aided Verification
|
||||
(CAV). 2023. URL: https://arxiv.org/abs/2306.10009
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94)
|
||||
Isabel Garcia (igcontreras)
|
||||
|
||||
Revision History:
|
||||
|
||||
|
||||
--*/
|
||||
#include "qe/lite/qel.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
|
||||
class qel::impl {
|
||||
private:
|
||||
ast_manager &m;
|
||||
|
||||
public:
|
||||
impl(ast_manager &m, params_ref const &p) : m(m) {}
|
||||
|
||||
void operator()(app_ref_vector &vars, expr_ref &fml) {
|
||||
if (vars.empty()) return;
|
||||
|
||||
mbp::term_graph tg(m);
|
||||
tg.set_vars(vars);
|
||||
|
||||
expr_ref_vector lits(m);
|
||||
flatten_and(fml, lits);
|
||||
tg.add_lits(lits);
|
||||
tg.qel(vars, fml);
|
||||
}
|
||||
};
|
||||
|
||||
qel::qel(ast_manager &m, params_ref const &p) { m_impl = alloc(impl, m, p); }
|
||||
|
||||
qel::~qel() { dealloc(m_impl); }
|
||||
|
||||
void qel::operator()(app_ref_vector &vars, expr_ref &fml) {
|
||||
(*m_impl)(vars, fml);
|
||||
}
|
||||
49
src/qe/lite/qel.h
Normal file
49
src/qe/lite/qel.h
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
/*++
|
||||
|
||||
Module Name:
|
||||
|
||||
qel.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Light weight quantifier elimination (QEL) based on term graph.
|
||||
|
||||
The implementation is based on the following paper:
|
||||
|
||||
Isabel Garcia-Contreras, Hari Govind V. K., Sharon Shoham, Arie Gurfinkel:
|
||||
Fast Approximations of Quantifier Elimination. Computer-Aided Verification
|
||||
(CAV). 2023. URL: https://arxiv.org/abs/2306.10009
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94)
|
||||
Isabel Garcia (igcontreras)
|
||||
|
||||
Revision History:
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ast/ast.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "util/params.h"
|
||||
#include "util/uint_set.h"
|
||||
|
||||
class qel {
|
||||
class impl;
|
||||
impl *m_impl;
|
||||
|
||||
public:
|
||||
qel(ast_manager &m, params_ref const &p);
|
||||
|
||||
~qel();
|
||||
|
||||
/**
|
||||
\brief Applies light-weight elimination of `vars` provided as vector
|
||||
of expressions to the cube `fml`. Returns the updated formula and updated
|
||||
set of variables that were not eliminated.
|
||||
*/
|
||||
void operator()(app_ref_vector &vars, expr_ref &fml);
|
||||
};
|
||||
|
|
@ -2,7 +2,12 @@ z3_add_component(mbp
|
|||
SOURCES
|
||||
mbp_arith.cpp
|
||||
mbp_arrays.cpp
|
||||
mbp_arrays_tg.cpp
|
||||
mbp_basic_tg.cpp
|
||||
mbp_datatypes.cpp
|
||||
mbp_dt_tg.cpp
|
||||
mbp_qel.cpp
|
||||
mbp_qel_util.cpp
|
||||
mbp_plugin.cpp
|
||||
mbp_solve_plugin.cpp
|
||||
mbp_term_graph.cpp
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ Revision History:
|
|||
|
||||
--*/
|
||||
|
||||
|
||||
#include "util/lbool.h"
|
||||
#include "ast/rewriter/rewriter_def.h"
|
||||
#include "ast/expr_functors.h"
|
||||
|
|
@ -26,134 +25,11 @@ Revision History:
|
|||
#include "ast/rewriter/th_rewriter.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/array_peq.h"
|
||||
#include "model/model_evaluator.h"
|
||||
#include "qe/mbp/mbp_arrays.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
|
||||
|
||||
namespace {
|
||||
bool is_partial_eq (app* a);
|
||||
|
||||
/**
|
||||
* \brief utility class for partial equalities
|
||||
*
|
||||
* A partial equality (a ==I b), for two arrays a,b and a finite set of indices I holds
|
||||
* iff (Forall i. i \not\in I => a[i] == b[i]); in other words, it is a
|
||||
* restricted form of the extensionality axiom
|
||||
*
|
||||
* using this class, we denote (a =I b) as f(a,b,i0,i1,...)
|
||||
* where f is an uninterpreted predicate with name PARTIAL_EQ and
|
||||
* I = {i0,i1,...}
|
||||
*/
|
||||
|
||||
// TBD: make work for arrays with multiple arguments.
|
||||
class peq {
|
||||
ast_manager& m;
|
||||
expr_ref m_lhs;
|
||||
expr_ref m_rhs;
|
||||
vector<expr_ref_vector> m_diff_indices;
|
||||
func_decl_ref m_decl; // the partial equality declaration
|
||||
app_ref m_peq; // partial equality application
|
||||
app_ref m_eq; // equivalent std equality using def. of partial eq
|
||||
array_util m_arr_u;
|
||||
|
||||
public:
|
||||
static const char* PARTIAL_EQ;
|
||||
|
||||
peq (app* p, ast_manager& m):
|
||||
m (m),
|
||||
m_lhs (p->get_arg (0), m),
|
||||
m_rhs (p->get_arg (1), m),
|
||||
m_decl (p->get_decl (), m),
|
||||
m_peq (p, m),
|
||||
m_eq (m),
|
||||
m_arr_u (m)
|
||||
{
|
||||
VERIFY (is_partial_eq (p));
|
||||
SASSERT (m_arr_u.is_array (m_lhs) &&
|
||||
m_arr_u.is_array (m_rhs) &&
|
||||
m_lhs->get_sort() == m_rhs->get_sort());
|
||||
unsigned arity = get_array_arity(m_lhs->get_sort());
|
||||
for (unsigned i = 2; i < p->get_num_args (); i += arity) {
|
||||
SASSERT(arity + i <= p->get_num_args());
|
||||
expr_ref_vector vec(m);
|
||||
vec.append(arity, p->get_args() + i);
|
||||
m_diff_indices.push_back (vec);
|
||||
}
|
||||
}
|
||||
|
||||
peq (expr* lhs, expr* rhs, vector<expr_ref_vector> const& diff_indices, ast_manager& m):
|
||||
m (m),
|
||||
m_lhs (lhs, m),
|
||||
m_rhs (rhs, m),
|
||||
m_diff_indices (diff_indices),
|
||||
m_decl (m),
|
||||
m_peq (m),
|
||||
m_eq (m),
|
||||
m_arr_u (m) {
|
||||
SASSERT (m_arr_u.is_array (lhs) &&
|
||||
m_arr_u.is_array (rhs) &&
|
||||
lhs->get_sort() == rhs->get_sort());
|
||||
ptr_vector<sort> sorts;
|
||||
sorts.push_back (m_lhs->get_sort ());
|
||||
sorts.push_back (m_rhs->get_sort ());
|
||||
for (auto const& v : diff_indices) {
|
||||
SASSERT(v.size() == get_array_arity(m_lhs->get_sort()));
|
||||
for (expr* e : v)
|
||||
sorts.push_back (e->get_sort());
|
||||
}
|
||||
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.data (), m.mk_bool_sort ());
|
||||
}
|
||||
|
||||
expr_ref lhs () { return m_lhs; }
|
||||
|
||||
expr_ref rhs () { return m_rhs; }
|
||||
|
||||
void get_diff_indices (vector<expr_ref_vector>& result) { result.append(m_diff_indices); }
|
||||
|
||||
app_ref mk_peq () {
|
||||
if (!m_peq) {
|
||||
ptr_vector<expr> args;
|
||||
args.push_back (m_lhs);
|
||||
args.push_back (m_rhs);
|
||||
for (auto const& v : m_diff_indices) {
|
||||
args.append (v.size(), v.data());
|
||||
}
|
||||
m_peq = m.mk_app (m_decl, args.size (), args.data ());
|
||||
}
|
||||
return m_peq;
|
||||
}
|
||||
|
||||
app_ref mk_eq (app_ref_vector& aux_consts, bool stores_on_rhs = true) {
|
||||
if (!m_eq) {
|
||||
expr_ref lhs (m_lhs, m), rhs (m_rhs, m);
|
||||
if (!stores_on_rhs) {
|
||||
std::swap (lhs, rhs);
|
||||
}
|
||||
// lhs = (...(store (store rhs i0 v0) i1 v1)...)
|
||||
sort* val_sort = get_array_range (lhs->get_sort());
|
||||
for (expr_ref_vector const& diff : m_diff_indices) {
|
||||
ptr_vector<expr> store_args;
|
||||
store_args.push_back (rhs);
|
||||
store_args.append (diff.size(), diff.data());
|
||||
app_ref val(m.mk_fresh_const ("diff", val_sort), m);
|
||||
store_args.push_back (val);
|
||||
aux_consts.push_back (val);
|
||||
rhs = m_arr_u.mk_store (store_args);
|
||||
}
|
||||
m_eq = m.mk_eq (lhs, rhs);
|
||||
}
|
||||
return m_eq;
|
||||
}
|
||||
};
|
||||
|
||||
const char* peq::PARTIAL_EQ = "!partial_eq";
|
||||
|
||||
bool is_partial_eq (app* a) {
|
||||
return a->get_decl ()->get_name () == peq::PARTIAL_EQ;
|
||||
}
|
||||
}
|
||||
|
||||
namespace mbp {
|
||||
|
||||
|
||||
|
|
@ -366,20 +242,10 @@ namespace mbp {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* mk (e0 ==indices e1)
|
||||
*
|
||||
* result has stores if either e0 or e1 or an index term has stores
|
||||
*/
|
||||
app_ref mk_peq (expr* e0, expr* e1, vector<expr_ref_vector> const& indices) {
|
||||
peq p (e0, e1, indices, m);
|
||||
return p.mk_peq ();
|
||||
}
|
||||
|
||||
void find_subst_term (app* eq) {
|
||||
SASSERT(m.is_eq(eq));
|
||||
vector<expr_ref_vector> empty;
|
||||
app_ref p_exp = mk_peq (eq->get_arg (0), eq->get_arg (1), empty);
|
||||
app_ref p_exp = mk_peq (eq->get_arg (0), eq->get_arg (1), empty, m);
|
||||
bool subst_eq_found = false;
|
||||
while (true) {
|
||||
TRACE ("qe", tout << "processing peq:\n" << p_exp << "\n";);
|
||||
|
|
@ -434,7 +300,7 @@ namespace mbp {
|
|||
);
|
||||
|
||||
// arr0 ==I arr1
|
||||
p_exp = mk_peq (arr0, arr1, I);
|
||||
p_exp = mk_peq (arr0, arr1, I, m);
|
||||
|
||||
TRACE ("qe",
|
||||
tout << "new peq:\n";
|
||||
|
|
@ -445,7 +311,7 @@ namespace mbp {
|
|||
m_idx_lits_v.append (idx_diseq);
|
||||
// arr0 ==I+idx arr1
|
||||
I.push_back (idxs);
|
||||
p_exp = mk_peq (arr0, arr1, I);
|
||||
p_exp = mk_peq (arr0, arr1, I, m);
|
||||
|
||||
TRACE ("qe", tout << "new peq:\n" << p_exp << "\n"; );
|
||||
|
||||
|
|
|
|||
394
src/qe/mbp/mbp_arrays_tg.cpp
Normal file
394
src/qe/mbp/mbp_arrays_tg.cpp
Normal file
|
|
@ -0,0 +1,394 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_arrays_tg.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for arrays on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include "qe/mbp/mbp_arrays_tg.h"
|
||||
#include "ast/array_decl_plugin.h"
|
||||
#include "ast/array_peq.h"
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
#include "util/obj_pair_hashtable.h"
|
||||
|
||||
namespace mbp {
|
||||
|
||||
struct mbp_array_tg::impl {
|
||||
typedef std::pair<expr *, expr *> expr_pair;
|
||||
ast_manager &m;
|
||||
array_util m_array_util;
|
||||
mbp::term_graph &m_tg;
|
||||
// TODO: cache mdl evaluation eventhough we extend m_mdl
|
||||
model &m_mdl;
|
||||
|
||||
// set of variables on which to apply MBP rules
|
||||
obj_hashtable<app> &m_vars_set;
|
||||
|
||||
// variables created in the last iteration of MBP application
|
||||
app_ref_vector m_new_vars;
|
||||
|
||||
expr_sparse_mark &m_seen;
|
||||
obj_pair_hashtable<expr, expr> m_seenp;
|
||||
|
||||
// apply rules that split on model
|
||||
bool m_use_mdl;
|
||||
|
||||
// m_has_store.is_marked(t) if t has a subterm store(v) where v is a
|
||||
// variable to be eliminated
|
||||
ast_mark m_has_stores;
|
||||
// variables required for applying rules
|
||||
vector<expr_ref_vector> indices;
|
||||
expr_ref_vector terms, rdTerms;
|
||||
|
||||
bool has_var(expr *t) { return contains_vars(t, m_vars_set, m); }
|
||||
|
||||
bool has_arr_var(expr *t) {
|
||||
return contains_vars(t, m_vars_set, m, m_array_util.get_family_id(),
|
||||
ARRAY_SORT);
|
||||
}
|
||||
|
||||
bool is_var(expr *t) { return is_uninterp_const(t) && has_var(t); }
|
||||
|
||||
bool is_wr_on_rhs(expr *e) {
|
||||
return is_app(e) && is_partial_eq(to_app(e)) &&
|
||||
is_wr_on_rhs(to_app(e)->get_arg(0), to_app(e)->get_arg(1));
|
||||
}
|
||||
|
||||
bool is_wr_on_rhs(expr *lhs, expr *rhs) {
|
||||
return (is_arr_write(rhs) && !is_arr_write(lhs));
|
||||
}
|
||||
|
||||
bool is_arr_write(expr *t) {
|
||||
if (!m_array_util.is_store(t)) return false;
|
||||
return has_var(to_app(t));
|
||||
}
|
||||
|
||||
// Returns true if e has a subterm store(v) where v is a variable to be
|
||||
// eliminated. Assumes that has_store has already been called for
|
||||
// subexpressions of e
|
||||
bool has_stores(expr *e) {
|
||||
if (m_has_stores.is_marked(e)) return true;
|
||||
if (!is_app(e)) return false;
|
||||
if (m_array_util.is_store(e) && is_var(to_app(e)->get_arg(0))) {
|
||||
m_has_stores.mark(e, true);
|
||||
return true;
|
||||
}
|
||||
for (auto c : *(to_app(e))) {
|
||||
if (m_has_stores.is_marked(c)) {
|
||||
m_has_stores.mark(e, true);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool is_rd_wr(expr *t) {
|
||||
if (!m_array_util.is_select(t)) return false;
|
||||
return m_array_util.is_store(to_app(t)->get_arg(0)) &&
|
||||
has_stores(to_app(t)->get_arg(0));
|
||||
}
|
||||
|
||||
bool is_implicit_peq(expr *e) {
|
||||
return m.is_eq(e) &&
|
||||
is_implicit_peq(to_app(e)->get_arg(0), to_app(e)->get_arg(1));
|
||||
}
|
||||
|
||||
bool is_implicit_peq(expr *lhs, expr *rhs) {
|
||||
return m_array_util.is_array(lhs) && m_array_util.is_array(rhs) &&
|
||||
(has_var(lhs) || has_var(rhs));
|
||||
}
|
||||
|
||||
void mark_seen(expr *t) { m_seen.mark(t); }
|
||||
bool is_seen(expr *t) { return m_seen.is_marked(t); }
|
||||
void mark_seen(expr *t1, expr *t2) { m_seenp.insert(expr_pair(t1, t2)); }
|
||||
bool is_seen(expr *t1, expr *t2) {
|
||||
return m_seenp.contains(expr_pair(t1, t2)) ||
|
||||
m_seenp.contains(expr_pair(t2, t1));
|
||||
}
|
||||
|
||||
impl(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen)
|
||||
: m(man), m_array_util(m), m_tg(tg), m_mdl(mdl), m_vars_set(vars_set),
|
||||
m_new_vars(m), m_seen(seen), m_use_mdl(false), terms(m), rdTerms(m) {}
|
||||
|
||||
// create a peq where write terms are preferred on the left hand side
|
||||
peq mk_wr_peq(expr *e1, expr *e2) {
|
||||
vector<expr_ref_vector> empty;
|
||||
return mk_wr_peq(e1, e2, empty);
|
||||
}
|
||||
|
||||
// create a peq where write terms are preferred on the left hand side
|
||||
peq mk_wr_peq(expr *e1, expr *e2, vector<expr_ref_vector> &indices) {
|
||||
expr *n_lhs = e1, *n_rhs = e2;
|
||||
if (is_wr_on_rhs(e1, e2)) std::swap(n_lhs, n_rhs);
|
||||
return peq(n_lhs, n_rhs, indices, m);
|
||||
}
|
||||
|
||||
// rewrite store(x, j, elem) \peq_{indices} y
|
||||
// into either j = i && x \peq_{indices} y (for some i in
|
||||
// indices) or &&_{i \in indices} j \neq i &&
|
||||
// x \peq_{indices, j} y &&
|
||||
// select(y, j) = elem
|
||||
// rewrite negation !(store(x, j, elem) \peq_{indices} y) into
|
||||
// into either j = i && !(x \peq_{indices} y) (for some i in
|
||||
// indices) or &&_{i \in indices} j \neq i &&
|
||||
// !(x \peq_{indices, j} y) &&
|
||||
// or &&_{i \in indices} j \neq i &&
|
||||
// !(select(y, j) = elem)
|
||||
void elimwreq(peq p, bool is_neg) {
|
||||
SASSERT(is_arr_write(p.lhs()));
|
||||
TRACE("mbp_tg",
|
||||
tout << "applying elimwreq on " << expr_ref(p.mk_peq(), m););
|
||||
vector<expr_ref_vector> indices;
|
||||
expr *j = to_app(p.lhs())->get_arg(1);
|
||||
expr *elem = to_app(p.lhs())->get_arg(2);
|
||||
bool in = false;
|
||||
p.get_diff_indices(indices);
|
||||
expr_ref eq_index(m);
|
||||
expr_ref_vector deq(m);
|
||||
for (expr_ref_vector &e : indices) {
|
||||
for (expr *i : e) {
|
||||
if (m_mdl.are_equal(j, i)) {
|
||||
in = true;
|
||||
// save for later
|
||||
eq_index = i;
|
||||
break;
|
||||
} else
|
||||
deq.push_back(i);
|
||||
}
|
||||
}
|
||||
if (in) {
|
||||
SASSERT(m_mdl.are_equal(j, eq_index));
|
||||
peq p_new =
|
||||
mk_wr_peq(to_app(p.lhs())->get_arg(0), p.rhs(), indices);
|
||||
m_tg.add_eq(j, eq_index);
|
||||
expr_ref p_new_expr(m);
|
||||
p_new_expr = is_neg ? m.mk_not(p_new.mk_peq()) : p_new.mk_peq();
|
||||
m_tg.add_lit(p_new_expr);
|
||||
m_tg.add_eq(p_new_expr, p.mk_peq());
|
||||
return;
|
||||
}
|
||||
for (expr *d : deq) { m_tg.add_deq(j, d); }
|
||||
expr_ref_vector setOne(m);
|
||||
setOne.push_back(j);
|
||||
indices.push_back(setOne);
|
||||
peq p_new = mk_wr_peq(to_app(p.lhs())->get_arg(0), p.rhs(), indices);
|
||||
expr *args[2] = {p.rhs(), j};
|
||||
expr_ref rd(m_array_util.mk_select(2, args), m);
|
||||
if (!is_neg) {
|
||||
m_tg.add_lit(p_new.mk_peq());
|
||||
m_tg.add_eq(rd, elem);
|
||||
m_tg.add_eq(p.mk_peq(), p_new.mk_peq());
|
||||
} else {
|
||||
SASSERT(m_mdl.is_false(p_new.mk_peq()) ||
|
||||
!m_mdl.are_equal(rd, elem));
|
||||
if (m_mdl.is_false(p_new.mk_peq())) {
|
||||
expr_ref npeq(mk_not(p_new.mk_peq()), m);
|
||||
m_tg.add_lit(npeq);
|
||||
m_tg.add_eq(p.mk_peq(), p_new.mk_peq());
|
||||
}
|
||||
if (!m_mdl.are_equal(rd, elem)) { m_tg.add_deq(rd, elem); }
|
||||
}
|
||||
}
|
||||
|
||||
// add equality v = rd where v is a fresh variable
|
||||
void add_rdVar(expr *rd) {
|
||||
// do not assign new variable if rd is already equal to a value
|
||||
if (m_tg.has_val_in_class(rd)) return;
|
||||
TRACE("mbp_tg", tout << "applying add_rdVar on " << expr_ref(rd, m););
|
||||
app_ref u = new_var(to_app(rd)->get_sort(), m);
|
||||
m_new_vars.push_back(u);
|
||||
m_tg.add_var(u);
|
||||
m_tg.add_eq(u, rd);
|
||||
m_mdl.register_decl(u->get_decl(), m_mdl(rd));
|
||||
}
|
||||
|
||||
// given a \peq_{indices} t, where a is a variable, merge equivalence class
|
||||
// of a with store(t, indices, elems) where elems are fresh constants
|
||||
void elimeq(peq p) {
|
||||
TRACE("mbp_tg",
|
||||
tout << "applying elimeq on " << expr_ref(p.mk_peq(), m););
|
||||
app_ref_vector aux_consts(m);
|
||||
expr_ref eq(m);
|
||||
expr_ref sel(m);
|
||||
eq = p.mk_eq(aux_consts, true);
|
||||
vector<expr_ref_vector> indices;
|
||||
p.get_diff_indices(indices);
|
||||
vector<expr_ref_vector>::iterator itr = indices.begin();
|
||||
unsigned i = 0;
|
||||
for (app *a : aux_consts) {
|
||||
m_new_vars.push_back(a);
|
||||
m_tg.add_var(a);
|
||||
auto const &indx = std::next(itr, i);
|
||||
SASSERT(indx->size() == 1);
|
||||
expr *args[2] = {to_app(p.lhs()), to_app(indx->get(0))};
|
||||
sel = m_array_util.mk_select(2, args);
|
||||
m_mdl.register_decl(a->get_decl(), m_mdl(sel));
|
||||
i++;
|
||||
}
|
||||
m_tg.add_lit(eq);
|
||||
m_tg.add_eq(p.mk_peq(), m.mk_true());
|
||||
TRACE("mbp_tg", tout << "added lit " << eq;);
|
||||
}
|
||||
|
||||
// rewrite select(store(a, i, k), j) into either select(a, j) or k
|
||||
void elimrdwr(expr *term) {
|
||||
SASSERT(is_rd_wr(term));
|
||||
TRACE("mbp_tg", tout << "applying elimrdwr on " << expr_ref(term, m););
|
||||
expr *wr_ind = to_app(to_app(term)->get_arg(0))->get_arg(1);
|
||||
expr *rd_ind = to_app(term)->get_arg(1);
|
||||
expr *e;
|
||||
if (m_mdl.are_equal(wr_ind, rd_ind)) {
|
||||
m_tg.add_eq(wr_ind, rd_ind);
|
||||
e = to_app(to_app(term)->get_arg(0))->get_arg(2);
|
||||
} else {
|
||||
m_tg.add_deq(wr_ind, rd_ind);
|
||||
expr *args[2] = {to_app(to_app(term)->get_arg(0))->get_arg(0),
|
||||
to_app(term)->get_arg(1)};
|
||||
e = m_array_util.mk_select(2, args);
|
||||
}
|
||||
m_tg.add_eq(term, e);
|
||||
}
|
||||
|
||||
// iterate through all terms in m_tg and apply all array MBP rules once
|
||||
// returns true if any rules were applied
|
||||
bool apply() {
|
||||
TRACE("mbp_tg", tout << "Iterating over terms of tg";);
|
||||
indices.reset();
|
||||
rdTerms.reset();
|
||||
m_new_vars.reset();
|
||||
expr_ref e(m), rdEq(m), rdDeq(m);
|
||||
expr *nt, *term;
|
||||
bool progress = false, is_neg = false;
|
||||
|
||||
// Not resetting terms because get_terms calls resize on terms
|
||||
m_tg.get_terms(terms, false);
|
||||
for (unsigned i = 0; i < terms.size(); i++) {
|
||||
term = terms.get(i);
|
||||
SASSERT(!m.is_distinct(term));
|
||||
if (m_seen.is_marked(term)) continue;
|
||||
if (m_tg.is_cgr(term)) continue;
|
||||
TRACE("mbp_tg", tout << "processing " << expr_ref(term, m););
|
||||
if (is_implicit_peq(term)) {
|
||||
// rewrite array eq as peq
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
e = mk_wr_peq(to_app(term)->get_arg(0),
|
||||
to_app(term)->get_arg(1))
|
||||
.mk_peq();
|
||||
m_tg.add_lit(e);
|
||||
m_tg.add_eq(term, e);
|
||||
continue;
|
||||
}
|
||||
nt = term;
|
||||
is_neg = m.is_not(term, nt);
|
||||
if (is_app(nt) && is_partial_eq(to_app(nt))) {
|
||||
peq p(to_app(nt), m);
|
||||
if (m_use_mdl && is_arr_write(p.lhs())) {
|
||||
mark_seen(nt);
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
elimwreq(p, is_neg);
|
||||
continue;
|
||||
}
|
||||
if (!m_array_util.is_store(p.lhs()) && has_var(p.lhs())) {
|
||||
// TODO: don't apply this rule if vars in p.lhs() also
|
||||
// appear in p.rhs()
|
||||
mark_seen(p.lhs());
|
||||
mark_seen(nt);
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
elimeq(p);
|
||||
continue;
|
||||
}
|
||||
// eliminate eq when the variable is on the rhs
|
||||
if (!m_array_util.is_store(p.rhs()) && has_var(p.rhs())) {
|
||||
mark_seen(p.rhs());
|
||||
p.get_diff_indices(indices);
|
||||
peq p_new = mk_wr_peq(p.rhs(), p.lhs(), indices);
|
||||
mark_seen(nt);
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
elimeq(p_new);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (m_use_mdl && is_rd_wr(term)) {
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
elimrdwr(term);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// iterate over term graph again to collect read terms
|
||||
// irrespective of whether they have been marked or not
|
||||
rdTerms.reset();
|
||||
for (unsigned i = 0; i < terms.size(); i++) {
|
||||
term = terms.get(i);
|
||||
if (m_array_util.is_select(term) &&
|
||||
has_var(to_app(term)->get_arg(0))) {
|
||||
rdTerms.push_back(term);
|
||||
if (is_seen(term)) continue;
|
||||
add_rdVar(term);
|
||||
mark_seen(term);
|
||||
}
|
||||
}
|
||||
if (!m_use_mdl) return progress;
|
||||
expr *e1, *e2, *a1, *a2, *i1, *i2;
|
||||
for (unsigned i = 0; i < rdTerms.size(); i++) {
|
||||
e1 = rdTerms.get(i);
|
||||
a1 = to_app(e1)->get_arg(0);
|
||||
i1 = to_app(e1)->get_arg(1);
|
||||
for (unsigned j = i + 1; j < rdTerms.size(); j++) {
|
||||
e2 = rdTerms.get(j);
|
||||
a2 = to_app(e2)->get_arg(0);
|
||||
i2 = to_app(e2)->get_arg(1);
|
||||
if (!is_seen(e1, e2) && a1->get_id() == a2->get_id()) {
|
||||
mark_seen(e1, e2);
|
||||
progress = true;
|
||||
if (m_mdl.are_equal(i1, i2)) {
|
||||
m_tg.add_eq(i1, i2);
|
||||
} else {
|
||||
SASSERT(!m_mdl.are_equal(i1, i2));
|
||||
m_tg.add_deq(i1, i2);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
return progress;
|
||||
}
|
||||
};
|
||||
|
||||
void mbp_array_tg::use_model() { m_impl->m_use_mdl = true; }
|
||||
bool mbp_array_tg::apply() { return m_impl->apply(); }
|
||||
void mbp_array_tg::reset() {
|
||||
m_impl->m_seen.reset();
|
||||
m_impl->m_vars_set.reset();
|
||||
}
|
||||
void mbp_array_tg::get_new_vars(app_ref_vector *&t) { t = &m_impl->m_new_vars; }
|
||||
family_id mbp_array_tg::get_family_id() const {
|
||||
return m_impl->m_array_util.get_family_id();
|
||||
}
|
||||
mbp_array_tg::mbp_array_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set,
|
||||
expr_sparse_mark &seen) {
|
||||
m_impl = alloc(mbp_array_tg::impl, man, tg, mdl, vars_set, seen);
|
||||
}
|
||||
mbp_array_tg::~mbp_array_tg() { dealloc(m_impl); }
|
||||
|
||||
} // namespace mbp
|
||||
47
src/qe/mbp/mbp_arrays_tg.h
Normal file
47
src/qe/mbp/mbp_arrays_tg.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_arrays_tg.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for arrays on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ast/ast.h"
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "qe/mbp/mbp_tg_plugins.h"
|
||||
#include "util/memory_manager.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
#include "util/obj_pair_hashtable.h"
|
||||
|
||||
namespace mbp {
|
||||
class mbp_array_tg : public mbp_tg_plugin {
|
||||
struct impl;
|
||||
impl *m_impl;
|
||||
|
||||
public:
|
||||
mbp_array_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen);
|
||||
void use_model() override;
|
||||
void reset();
|
||||
// iterate through all terms in m_tg and apply all array MBP rules once
|
||||
// returns true if any rules were applied
|
||||
bool apply() override;
|
||||
~mbp_array_tg() override;
|
||||
void get_new_vars(app_ref_vector *&t) override;
|
||||
family_id get_family_id() const override;
|
||||
};
|
||||
} // namespace mbp
|
||||
101
src/qe/mbp/mbp_basic_tg.cpp
Normal file
101
src/qe/mbp/mbp_basic_tg.cpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_basic_tg.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for basic types, on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include "qe/mbp/mbp_basic_tg.h"
|
||||
#include "ast/ast.h"
|
||||
#include "ast/expr_functors.h"
|
||||
#include "util/debug.h"
|
||||
#include "util/memory_manager.h"
|
||||
|
||||
struct mbp_basic_tg::impl {
|
||||
ast_manager &m;
|
||||
mbp::term_graph &m_tg;
|
||||
// TODO: cache mdl evaluation eventhough we extend m_mdl
|
||||
model &m_mdl;
|
||||
|
||||
// set of variables on which to apply MBP rules
|
||||
obj_hashtable<app> &m_vars_set;
|
||||
|
||||
// variables created in the last iteration of MBP application
|
||||
app_ref_vector m_new_vars;
|
||||
|
||||
expr_sparse_mark &m_seen;
|
||||
|
||||
expr_ref_vector terms;
|
||||
bool m_use_mdl;
|
||||
|
||||
void mark_seen(expr *t) { m_seen.mark(t); }
|
||||
bool is_seen(expr *t) { return m_seen.is_marked(t); }
|
||||
|
||||
bool apply() {
|
||||
if (!m_use_mdl) return false;
|
||||
expr *term, *c, *th, *el;
|
||||
expr_ref nterm(m);
|
||||
bool progress = false;
|
||||
TRACE("mbp_tg", tout << "Iterating over terms of tg";);
|
||||
// Not resetting terms because get_terms calls resize on terms
|
||||
m_tg.get_terms(terms, false);
|
||||
for (unsigned i = 0; i < terms.size(); i++) {
|
||||
term = terms.get(i);
|
||||
// Unsupported operators
|
||||
SASSERT(!m.is_and(term));
|
||||
SASSERT(!m.is_or(term));
|
||||
SASSERT(!m.is_distinct(term));
|
||||
SASSERT(!m.is_implies(term));
|
||||
|
||||
if (is_seen(term)) continue;
|
||||
if (m_tg.is_cgr(term)) continue;
|
||||
if (m.is_ite(term, c, th, el)) {
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
if (m_mdl.is_true(c)) {
|
||||
m_tg.add_lit(c);
|
||||
m_tg.add_eq(term, th);
|
||||
} else {
|
||||
if (m.is_not(c))
|
||||
nterm = to_app(c)->get_arg(0);
|
||||
else
|
||||
nterm = m.mk_not(c);
|
||||
m_tg.add_lit(nterm);
|
||||
m_tg.add_eq(term, el);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return progress;
|
||||
}
|
||||
|
||||
impl(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen)
|
||||
: m(man), m_tg(tg), m_mdl(mdl), m_vars_set(vars_set), m_new_vars(m),
|
||||
m_seen(seen), terms(m), m_use_mdl(false) {}
|
||||
};
|
||||
|
||||
bool mbp_basic_tg::apply() { return m_impl->apply(); }
|
||||
void mbp_basic_tg::use_model() { m_impl->m_use_mdl = true; }
|
||||
void mbp_basic_tg::get_new_vars(app_ref_vector *&t) { t = &m_impl->m_new_vars; }
|
||||
family_id mbp_basic_tg::get_family_id() const {
|
||||
return m_impl->m.get_basic_family_id();
|
||||
}
|
||||
mbp_basic_tg::mbp_basic_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set,
|
||||
expr_sparse_mark &seen) {
|
||||
m_impl = alloc(mbp_basic_tg::impl, man, tg, mdl, vars_set, seen);
|
||||
}
|
||||
mbp_basic_tg::~mbp_basic_tg() { dealloc(m_impl); }
|
||||
40
src/qe/mbp/mbp_basic_tg.h
Normal file
40
src/qe/mbp/mbp_basic_tg.h
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_basic_tg.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for basic types, on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#pragma once
|
||||
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "qe/mbp/mbp_tg_plugins.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
|
||||
class mbp_basic_tg : public mbp_tg_plugin {
|
||||
struct impl;
|
||||
impl *m_impl;
|
||||
|
||||
public:
|
||||
mbp_basic_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen);
|
||||
// iterate through all terms in m_tg and apply all basic MBP rules once
|
||||
// returns true if any rules were applied
|
||||
bool apply() override;
|
||||
~mbp_basic_tg() override;
|
||||
void use_model() override;
|
||||
void get_new_vars(app_ref_vector *&t) override;
|
||||
family_id get_family_id() const override;
|
||||
};
|
||||
202
src/qe/mbp/mbp_dt_tg.cpp
Normal file
202
src/qe/mbp/mbp_dt_tg.cpp
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_dt_tg.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for datatypes on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include "qe/mbp/mbp_dt_tg.h"
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "util/memory_manager.h"
|
||||
|
||||
namespace mbp {
|
||||
|
||||
struct mbp_dt_tg::impl {
|
||||
ast_manager &m;
|
||||
datatype_util m_dt_util;
|
||||
mbp::term_graph &m_tg;
|
||||
// TODO: cache mdl evaluation eventhough we extend m_mdl
|
||||
model &m_mdl;
|
||||
|
||||
// set of variables on which to apply MBP rules
|
||||
obj_hashtable<app> &m_vars_set;
|
||||
|
||||
// variables created in the last iteration of MBP application
|
||||
app_ref_vector m_new_vars;
|
||||
|
||||
expr_sparse_mark &m_seen;
|
||||
|
||||
expr_ref_vector terms;
|
||||
bool m_use_mdl;
|
||||
|
||||
void mark_seen(expr *t) { m_seen.mark(t); }
|
||||
bool is_seen(expr *t) { return m_seen.is_marked(t); }
|
||||
|
||||
bool is_var(expr *t) { return is_uninterp_const(t) && has_var(t); }
|
||||
|
||||
bool has_var(expr *t) { return contains_vars(t, m_vars_set, m); }
|
||||
|
||||
bool is_constructor(expr *t) {
|
||||
return is_app(t) && m_dt_util.is_constructor(to_app(t)->get_decl()) &&
|
||||
has_var(t);
|
||||
}
|
||||
|
||||
bool is_constructor_app(expr *e, expr *&cons, expr *&rhs) {
|
||||
if (!m.is_eq(e, cons, rhs)) return false;
|
||||
// TODO: does it matter whether vars in cons appear in rhs?
|
||||
if (is_constructor(cons)) {
|
||||
return true;
|
||||
} else if (is_constructor(rhs)) {
|
||||
cons = rhs;
|
||||
rhs = to_app(e)->get_arg(0);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
impl(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen)
|
||||
: m(man), m_dt_util(m), m_tg(tg), m_mdl(mdl), m_vars_set(vars_set),
|
||||
m_new_vars(m), m_seen(seen), terms(m), m_use_mdl(false) {}
|
||||
|
||||
// rewrite head(x) with y
|
||||
// and x with list(y, z)
|
||||
void rm_select(expr *term) {
|
||||
SASSERT(is_app(term) &&
|
||||
m_dt_util.is_accessor(to_app(term)->get_decl()) &&
|
||||
is_var(to_app(term)->get_arg(0)));
|
||||
TRACE("mbp_tg", tout << "applying rm_select on " << expr_ref(term, m););
|
||||
expr *v = to_app(term)->get_arg(0);
|
||||
expr_ref sel(m);
|
||||
app_ref u(m);
|
||||
app_ref_vector new_vars(m);
|
||||
func_decl *cons =
|
||||
m_dt_util.get_accessor_constructor(to_app(term)->get_decl());
|
||||
ptr_vector<func_decl> const *accessors =
|
||||
m_dt_util.get_constructor_accessors(cons);
|
||||
for (unsigned i = 0; i < accessors->size(); i++) {
|
||||
func_decl *d = accessors->get(i);
|
||||
sel = m.mk_app(d, v);
|
||||
u = m_tg.get_const_in_class(sel);
|
||||
if (u) {
|
||||
new_vars.push_back(u);
|
||||
continue;
|
||||
}
|
||||
u = new_var(d->get_range(), m);
|
||||
m_new_vars.push_back(u);
|
||||
m_tg.add_var(u);
|
||||
new_vars.push_back(u);
|
||||
m_tg.add_eq(sel, u);
|
||||
m_mdl.register_decl(u->get_decl(), m_mdl(sel));
|
||||
}
|
||||
expr_ref new_cons(m.mk_app(cons, new_vars), m);
|
||||
m_tg.add_eq(v, new_cons);
|
||||
}
|
||||
|
||||
// rewrite cons(v, u) = x with v = head(x) and u = tail(x)
|
||||
// where u or v contain variables
|
||||
void deconstruct_eq(expr *cons, expr *rhs) {
|
||||
TRACE("mbp_tg",
|
||||
tout << "applying deconstruct_eq on " << expr_ref(cons, m););
|
||||
ptr_vector<func_decl> const *accessors =
|
||||
m_dt_util.get_constructor_accessors(to_app(cons)->get_decl());
|
||||
for (unsigned i = 0; i < accessors->size(); i++) {
|
||||
expr_ref a(m.mk_app(accessors->get(i), rhs), m);
|
||||
expr *newRhs = to_app(cons)->get_arg(i);
|
||||
m_tg.add_eq(a, newRhs);
|
||||
}
|
||||
func_decl *is_cons =
|
||||
m_dt_util.get_constructor_recognizer(to_app(cons)->get_decl());
|
||||
expr_ref is(m.mk_app(is_cons, rhs), m);
|
||||
m_tg.add_lit(is);
|
||||
}
|
||||
|
||||
// rewrite cons(v, u) != x into one of !cons(x) or v != head(x) or u !=
|
||||
// tail(x) where u or v contain variables
|
||||
void deconstruct_neq(expr *cons, expr *rhs) {
|
||||
TRACE("mbp_tg",
|
||||
tout << "applying deconstruct_neq on " << expr_ref(cons, m););
|
||||
ptr_vector<func_decl> const *accessors =
|
||||
m_dt_util.get_constructor_accessors(to_app(cons)->get_decl());
|
||||
func_decl *is_cons =
|
||||
m_dt_util.get_constructor_recognizer(to_app(cons)->get_decl());
|
||||
expr_ref a(m.mk_app(is_cons, rhs), m);
|
||||
if (m_mdl.is_false(a)) {
|
||||
expr_ref not_cons(m.mk_not(a), m);
|
||||
m_tg.add_lit(not_cons);
|
||||
return;
|
||||
}
|
||||
m_tg.add_lit(a);
|
||||
|
||||
for (unsigned i = 0; i < accessors->size(); i++) {
|
||||
expr_ref a(m.mk_app(accessors->get(i), rhs), m);
|
||||
expr *newRhs = to_app(cons)->get_arg(i);
|
||||
if (!m_mdl.are_equal(a, newRhs)) {
|
||||
m_tg.add_deq(a, newRhs);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool apply() {
|
||||
expr *cons, *rhs, *f, *term;
|
||||
bool progress = false;
|
||||
m_new_vars.reset();
|
||||
TRACE("mbp_tg", tout << "Iterating over terms of tg";);
|
||||
// Not resetting terms because get_terms calls resize on terms
|
||||
m_tg.get_terms(terms, false);
|
||||
for (unsigned i = 0; i < terms.size(); i++) {
|
||||
term = terms.get(i);
|
||||
SASSERT(!m.is_distinct(term));
|
||||
if (is_seen(term)) continue;
|
||||
if (m_tg.is_cgr(term)) continue;
|
||||
if (is_app(term) &&
|
||||
m_dt_util.is_accessor(to_app(term)->get_decl()) &&
|
||||
is_var(to_app(term)->get_arg(0))) {
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
rm_select(term);
|
||||
continue;
|
||||
}
|
||||
if (is_constructor_app(term, cons, rhs)) {
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
deconstruct_eq(cons, rhs);
|
||||
continue;
|
||||
}
|
||||
if (m_use_mdl && m.is_not(term, f) &&
|
||||
is_constructor_app(f, cons, rhs)) {
|
||||
mark_seen(term);
|
||||
progress = true;
|
||||
deconstruct_neq(cons, rhs);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return progress;
|
||||
}
|
||||
};
|
||||
|
||||
bool mbp_dt_tg::apply() { return m_impl->apply(); }
|
||||
mbp_dt_tg::mbp_dt_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen) {
|
||||
m_impl = alloc(mbp_dt_tg::impl, man, tg, mdl, vars_set, seen);
|
||||
}
|
||||
void mbp_dt_tg::use_model() { m_impl->m_use_mdl = true; }
|
||||
void mbp_dt_tg::get_new_vars(app_ref_vector *&t) { t = &m_impl->m_new_vars; }
|
||||
family_id mbp_dt_tg::get_family_id() const {
|
||||
return m_impl->m_dt_util.get_family_id();
|
||||
}
|
||||
mbp_dt_tg::~mbp_dt_tg() { dealloc(m_impl); }
|
||||
|
||||
} // namespace mbp
|
||||
44
src/qe/mbp/mbp_dt_tg.h
Normal file
44
src/qe/mbp/mbp_dt_tg.h
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_dt_tg.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Apply rules for model based projection for datatypes on a term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ast/datatype_decl_plugin.h"
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "qe/mbp/mbp_tg_plugins.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
|
||||
namespace mbp {
|
||||
class mbp_dt_tg : public mbp_tg_plugin {
|
||||
struct impl;
|
||||
impl *m_impl;
|
||||
|
||||
public:
|
||||
mbp_dt_tg(ast_manager &man, mbp::term_graph &tg, model &mdl,
|
||||
obj_hashtable<app> &vars_set, expr_sparse_mark &seen);
|
||||
// iterate through all terms in m_tg and apply all datatype MBP rules once
|
||||
// returns true if any rules were applied
|
||||
bool apply() override;
|
||||
~mbp_dt_tg() override;
|
||||
void use_model() override;
|
||||
void get_new_vars(app_ref_vector *&t) override;
|
||||
family_id get_family_id() const override;
|
||||
};
|
||||
} // namespace mbp
|
||||
226
src/qe/mbp/mbp_qel.cpp
Normal file
226
src/qe/mbp/mbp_qel.cpp
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
/*++
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_qel.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Model Based Projection based on term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2022-07-12
|
||||
|
||||
Revision History:
|
||||
|
||||
|
||||
--*/
|
||||
#include "qe/mbp/mbp_qel.h"
|
||||
#include "ast/array_decl_plugin.h"
|
||||
#include "ast/array_peq.h"
|
||||
#include "ast/datatype_decl_plugin.h"
|
||||
#include "model/model.h"
|
||||
#include "qe/mbp/mbp_arrays.h"
|
||||
#include "qe/mbp/mbp_arrays_tg.h"
|
||||
#include "qe/mbp/mbp_basic_tg.h"
|
||||
#include "qe/mbp/mbp_dt_tg.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "qe/mbp/mbp_tg_plugins.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
|
||||
namespace mbp {
|
||||
|
||||
class mbp_qel::impl {
|
||||
private:
|
||||
ast_manager &m;
|
||||
array_util m_array_util;
|
||||
datatype_util m_dt_util;
|
||||
params_ref m_params;
|
||||
mbp::term_graph m_tg;
|
||||
|
||||
ptr_vector<mbp_tg_plugin> m_plugins;
|
||||
|
||||
// set of non_basic variables to be projected. MBP rules are applied to
|
||||
// terms containing these variables
|
||||
obj_hashtable<app> m_non_basic_vars;
|
||||
|
||||
// Utilities to keep track of which terms have been processed
|
||||
expr_sparse_mark m_seen;
|
||||
void mark_seen(expr *t) { m_seen.mark(t); }
|
||||
bool is_seen(expr *t) { return m_seen.is_marked(t); }
|
||||
|
||||
bool is_non_basic(app *v) {
|
||||
return m_dt_util.is_datatype(v->get_sort()) || m_array_util.is_array(v);
|
||||
}
|
||||
|
||||
void add_vars(mbp_tg_plugin *p, app_ref_vector &vars) {
|
||||
app_ref_vector *new_vars;
|
||||
p->get_new_vars(new_vars);
|
||||
for (auto v : *new_vars) {
|
||||
if (is_non_basic(v)) m_non_basic_vars.insert(v);
|
||||
vars.push_back(v);
|
||||
}
|
||||
}
|
||||
|
||||
// apply all plugins till saturation
|
||||
void saturate(app_ref_vector &vars) {
|
||||
bool progress;
|
||||
do {
|
||||
progress = false;
|
||||
for (auto *p : m_plugins) {
|
||||
if (p->apply()) {
|
||||
progress = true;
|
||||
add_vars(p, vars);
|
||||
}
|
||||
}
|
||||
}
|
||||
while (progress);
|
||||
}
|
||||
|
||||
void init(app_ref_vector &vars, expr_ref &fml, model &mdl) {
|
||||
// variables to apply projection rules on
|
||||
for (auto v : vars)
|
||||
if (is_non_basic(v)) m_non_basic_vars.insert(v);
|
||||
|
||||
// mark vars as non-ground.
|
||||
m_tg.add_vars(vars);
|
||||
// treat eq literals as term in the egraph
|
||||
m_tg.set_explicit_eq();
|
||||
|
||||
expr_ref_vector fmls(m);
|
||||
flatten_and(fml, fmls);
|
||||
m_tg.add_lits(fmls);
|
||||
|
||||
add_plugin(alloc(mbp_array_tg, m, m_tg, mdl, m_non_basic_vars, m_seen));
|
||||
add_plugin(alloc(mbp_dt_tg, m, m_tg, mdl, m_non_basic_vars, m_seen));
|
||||
add_plugin(alloc(mbp_basic_tg, m, m_tg, mdl, m_non_basic_vars, m_seen));
|
||||
}
|
||||
|
||||
void add_plugin(mbp_tg_plugin *p) { m_plugins.push_back(p); }
|
||||
|
||||
void enable_model_splitting() {
|
||||
for (auto p : m_plugins) p->use_model();
|
||||
}
|
||||
|
||||
mbp_tg_plugin *get_plugin(family_id fid) {
|
||||
for (auto p : m_plugins)
|
||||
if (p->get_family_id() == fid) return p;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
public:
|
||||
impl(ast_manager &m, params_ref const &p)
|
||||
: m(m), m_array_util(m), m_dt_util(m), m_params(p), m_tg(m) {}
|
||||
|
||||
~impl() {
|
||||
std::for_each(m_plugins.begin(), m_plugins.end(),
|
||||
delete_proc<mbp_tg_plugin>());
|
||||
}
|
||||
|
||||
void operator()(app_ref_vector &vars, expr_ref &fml, model &mdl) {
|
||||
if (vars.empty()) return;
|
||||
|
||||
init(vars, fml, mdl);
|
||||
// Apply MBP rules till saturation
|
||||
|
||||
// First, apply rules without splitting on model
|
||||
saturate(vars);
|
||||
|
||||
enable_model_splitting();
|
||||
|
||||
// Do complete mbp
|
||||
saturate(vars);
|
||||
|
||||
TRACE("mbp_tg",
|
||||
tout << "mbp tg " << m_tg.get_lits() << " and vars " << vars;);
|
||||
TRACE("mbp_tg_verbose", obj_hashtable<app> vars_tmp;
|
||||
collect_uninterp_consts(mk_and(m_tg.get_lits()), vars_tmp);
|
||||
for (auto a
|
||||
: vars_tmp) tout
|
||||
<< mk_pp(a->get_decl(), m) << "\n";
|
||||
for (auto b
|
||||
: m_tg.get_lits()) tout
|
||||
<< expr_ref(b, m) << "\n";
|
||||
for (auto a
|
||||
: vars) tout
|
||||
<< expr_ref(a, m) << " ";);
|
||||
|
||||
// 1. Apply qe_lite to remove all c-ground variables
|
||||
// 2. Collect all core variables in the output (variables used as array
|
||||
// indices/values)
|
||||
// 3. Re-apply qe_lite to remove non-core variables
|
||||
|
||||
// Step 1.
|
||||
m_tg.qel(vars, fml);
|
||||
|
||||
// Step 2.
|
||||
// Variables that appear as array indices or values cannot be
|
||||
// eliminated if they are not c-ground. They are core variables All
|
||||
// other Array/ADT variables can be eliminated, they are redundant.
|
||||
obj_hashtable<app> core_vars;
|
||||
collect_selstore_vars(fml, core_vars, m);
|
||||
|
||||
std::function<bool(app *)> is_red = [&](app *v) {
|
||||
if (!m_dt_util.is_datatype(v->get_sort()) &&
|
||||
!m_array_util.is_array(v))
|
||||
return false;
|
||||
return !core_vars.contains(v);
|
||||
};
|
||||
expr_sparse_mark red_vars;
|
||||
for (auto v : vars)
|
||||
if (is_red(v)) red_vars.mark(v);
|
||||
CTRACE("mbp_tg", !core_vars.empty(), tout << "vars not redundant ";
|
||||
for (auto v
|
||||
: core_vars) tout
|
||||
<< " " << app_ref(v, m);
|
||||
tout << "\n";);
|
||||
|
||||
std::function<bool(expr *)> non_core = [&](expr *e) {
|
||||
if (is_app(e) && is_partial_eq(to_app(e))) return true;
|
||||
if (m.is_ite(e)) return true;
|
||||
return red_vars.is_marked(e);
|
||||
};
|
||||
|
||||
// Step 3.
|
||||
m_tg.qel(vars, fml, &non_core);
|
||||
|
||||
CTRACE("mbp_tg", !vars.empty(),
|
||||
tout << "before substitution " << fml << "\n";);
|
||||
// for all remaining non-cgr bool, dt, array variables, add v = mdl(v)
|
||||
expr_sparse_mark s_vars;
|
||||
for (auto v : vars) {
|
||||
if (m_dt_util.is_datatype(v->get_sort()) ||
|
||||
m_array_util.is_array(v) || m.is_bool(v)) {
|
||||
CTRACE("mbp_tg",
|
||||
m_array_util.is_array(v) ||
|
||||
m_dt_util.is_datatype(v->get_sort()),
|
||||
tout << "Could not eliminate " << v->get_name()
|
||||
<< "\n";);
|
||||
s_vars.mark(v);
|
||||
m_tg.add_eq(v, mdl(v));
|
||||
}
|
||||
}
|
||||
|
||||
std::function<bool(expr *)> substituted = [&](expr *e) {
|
||||
if (is_app(e) && is_partial_eq(to_app(e))) return true;
|
||||
if (m.is_ite(e)) return true;
|
||||
return red_vars.is_marked(e) || s_vars.is_marked(e);
|
||||
};
|
||||
|
||||
// remove all substituted variables
|
||||
m_tg.qel(vars, fml, &substituted);
|
||||
}
|
||||
};
|
||||
|
||||
mbp_qel::mbp_qel(ast_manager &m, params_ref const &p) {
|
||||
m_impl = alloc(impl, m, p);
|
||||
}
|
||||
|
||||
mbp_qel::~mbp_qel() { dealloc(m_impl); }
|
||||
|
||||
void mbp_qel::operator()(app_ref_vector &vars, expr_ref &fml, model &mdl) {
|
||||
(*m_impl)(vars, fml, mdl);
|
||||
}
|
||||
|
||||
} // namespace mbp
|
||||
41
src/qe/mbp/mbp_qel.h
Normal file
41
src/qe/mbp/mbp_qel.h
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
/*++
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_qel.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Model Based Projection based on term graph
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2022-07-12
|
||||
|
||||
Revision History:
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ast/ast.h"
|
||||
#include "model/model.h"
|
||||
#include "util/params.h"
|
||||
|
||||
namespace mbp {
|
||||
class mbp_qel {
|
||||
class impl;
|
||||
impl *m_impl;
|
||||
|
||||
public:
|
||||
mbp_qel(ast_manager &m, params_ref const &p);
|
||||
|
||||
~mbp_qel();
|
||||
|
||||
/**
|
||||
Do model based projection
|
||||
*/
|
||||
void operator()(app_ref_vector &vars, expr_ref &fml, model &mdl);
|
||||
};
|
||||
} // namespace mbp
|
||||
110
src/qe/mbp/mbp_qel_util.cpp
Normal file
110
src/qe/mbp/mbp_qel_util.cpp
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_qel_util.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Utility methods for mbp_qel
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "ast/array_decl_plugin.h"
|
||||
#include "ast/ast.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "ast/expr_functors.h"
|
||||
#include "ast/for_each_expr.h"
|
||||
#include "ast/pp.h"
|
||||
|
||||
class check_uninterp_consts : public i_expr_pred {
|
||||
obj_hashtable<app> const &m_vars;
|
||||
family_id m_fid;
|
||||
decl_kind m_decl_kind;
|
||||
|
||||
public:
|
||||
check_uninterp_consts(obj_hashtable<app> const &vars, ast_manager &man,
|
||||
family_id fid = null_family_id,
|
||||
decl_kind dk = null_decl_kind)
|
||||
: m_vars(vars), m_fid(fid), m_decl_kind(dk) {}
|
||||
bool operator()(expr *n) override {
|
||||
return (is_app(n) && is_uninterp_const(n) &&
|
||||
m_vars.contains(to_app(n))) &&
|
||||
((m_fid == null_family_id || m_decl_kind == null_decl_kind) ||
|
||||
(is_sort_of(to_app(n)->get_sort(), m_fid, m_decl_kind)));
|
||||
}
|
||||
};
|
||||
|
||||
// check if e contains any apps from vars
|
||||
// if fid and dk are not null, check if the variable is of desired sort
|
||||
bool contains_vars(expr *e, obj_hashtable<app> const &vars, ast_manager &man,
|
||||
family_id fid, decl_kind dk) {
|
||||
check_uninterp_consts pred(vars, man, fid, dk);
|
||||
check_pred check(pred, man, false);
|
||||
return check(e);
|
||||
}
|
||||
|
||||
app_ref new_var(sort *s, ast_manager &m) {
|
||||
return app_ref(m.mk_fresh_const("mbptg", s), m);
|
||||
}
|
||||
|
||||
namespace collect_uninterp_consts_ns {
|
||||
struct proc {
|
||||
obj_hashtable<app> &m_out;
|
||||
proc(obj_hashtable<app> &out) : m_out(out) {}
|
||||
void operator()(expr *n) const {}
|
||||
void operator()(app *n) {
|
||||
if (is_uninterp_const(n)) m_out.insert(n);
|
||||
}
|
||||
};
|
||||
} // namespace collect_uninterp_consts_ns
|
||||
|
||||
// Return all uninterpreted constants of \p q
|
||||
void collect_uninterp_consts(expr *e, obj_hashtable<app> &out) {
|
||||
collect_uninterp_consts_ns::proc proc(out);
|
||||
for_each_expr(proc, e);
|
||||
}
|
||||
|
||||
namespace collect_selstore_vars_ns {
|
||||
struct proc {
|
||||
ast_manager &m;
|
||||
obj_hashtable<app> &m_vars;
|
||||
array_util m_array_util;
|
||||
datatype_util m_dt_util;
|
||||
proc(obj_hashtable<app> &vars, ast_manager &man)
|
||||
: m(man), m_vars(vars), m_array_util(m), m_dt_util(m) {}
|
||||
void operator()(expr *n) const {}
|
||||
void operator()(app *n) {
|
||||
if (m_array_util.is_select(n)) {
|
||||
expr *idx = n->get_arg(1);
|
||||
if (is_app(idx) && m_dt_util.is_accessor(to_app(idx)->get_decl()))
|
||||
return;
|
||||
collect_uninterp_consts(idx, m_vars);
|
||||
} else if (m_array_util.is_store(n)) {
|
||||
expr *idx = n->get_arg(1), *elem = n->get_arg(2);
|
||||
if (!(is_app(idx) &&
|
||||
m_dt_util.is_accessor(to_app(idx)->get_decl())))
|
||||
collect_uninterp_consts(idx, m_vars);
|
||||
if (!(is_app(elem) &&
|
||||
m_dt_util.is_accessor(to_app(elem)->get_decl())))
|
||||
collect_uninterp_consts(elem, m_vars);
|
||||
}
|
||||
}
|
||||
};
|
||||
} // namespace collect_selstore_vars_ns
|
||||
|
||||
// collect all uninterpreted consts used as array indices or values
|
||||
void collect_selstore_vars(expr *fml, obj_hashtable<app> &vars,
|
||||
ast_manager &man) {
|
||||
collect_selstore_vars_ns::proc proc(vars, man);
|
||||
quick_for_each_expr(proc, fml);
|
||||
}
|
||||
41
src/qe/mbp/mbp_qel_util.h
Normal file
41
src/qe/mbp/mbp_qel_util.h
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
/*++
|
||||
Copyright (c) 2022 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_qel_util.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Utility methods for mbp_qel
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2023-03-07
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ast/array_decl_plugin.h"
|
||||
#include "ast/ast.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "ast/for_each_expr.h"
|
||||
#include "ast/pp.h"
|
||||
|
||||
// check if e contains any apps from vars
|
||||
// if fid and dk are not null, check if the variable is of desired sort
|
||||
bool contains_vars(expr *e, obj_hashtable<app> const &vars, ast_manager &man,
|
||||
family_id fid = null_family_id,
|
||||
decl_kind dk = null_decl_kind);
|
||||
|
||||
app_ref new_var(sort *s, ast_manager &m);
|
||||
|
||||
// Return all uninterpreted constants of \p q
|
||||
void collect_uninterp_consts(expr *e, obj_hashtable<app> &out);
|
||||
// collect all uninterpreted consts used as array indices or values
|
||||
void collect_selstore_vars(expr *fml, obj_hashtable<app> &vars,
|
||||
ast_manager &man);
|
||||
|
|
@ -248,13 +248,63 @@ namespace mbp {
|
|||
return false;
|
||||
}
|
||||
|
||||
// returns `true` if a rewritting happened
|
||||
bool try_int_mul_solve(expr *atom, bool is_pos, expr_ref &res) {
|
||||
|
||||
if (!is_pos)
|
||||
return false; // negation of multiplication is not a cube for
|
||||
// integers
|
||||
|
||||
// we want k*y == x -----> y = x div k && x mod k == 0
|
||||
expr *lhs = nullptr, *rhs = nullptr;
|
||||
if (!m.is_eq(atom, lhs, rhs)) return false;
|
||||
|
||||
if (!a.is_int(lhs)) { return false; }
|
||||
|
||||
if (!a.is_mul(rhs)) {
|
||||
if (a.is_mul(lhs))
|
||||
std::swap(lhs, rhs);
|
||||
else
|
||||
return false; // no muls
|
||||
}
|
||||
|
||||
// of the form v = k*expr
|
||||
expr *first = nullptr, *second = nullptr;
|
||||
if (!a.is_mul(rhs, first, second)) return false;
|
||||
|
||||
if (!(is_app(first) && a.plugin().is_value(to_app(first)))) {
|
||||
if (is_app(second) && a.plugin().is_value(to_app(second))) {
|
||||
std::swap(first, second);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (a.is_zero(first)) {
|
||||
// SASSERT(a.is_int(lhs));
|
||||
res = m.mk_eq(lhs, a.mk_int(0));
|
||||
return true;
|
||||
};
|
||||
|
||||
// `first` is a value, different from 0
|
||||
res = m.mk_and(m.mk_eq(second, a.mk_idiv(lhs, first)),
|
||||
m.mk_eq(a.mk_int(0), a.mk_mod(lhs, first)));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
expr_ref solve(expr* atom, bool is_pos) override {
|
||||
expr *e1, *e2;
|
||||
|
||||
expr_ref res(atom, m);
|
||||
|
||||
if (try_int_mul_solve(atom, is_pos, res)) return res;
|
||||
|
||||
expr *e1, *e2;
|
||||
|
||||
if (m.is_eq(atom, e1, e2)) {
|
||||
expr_ref v(m), t(m);
|
||||
v = e1; t = e2;
|
||||
v = e1;
|
||||
t = e2;
|
||||
// -- attempt to solve using arithmetic
|
||||
solve(e1, e2, v, t);
|
||||
// -- normalize equality
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -12,6 +12,12 @@ Abstract:
|
|||
Author:
|
||||
|
||||
Arie Gurfinkel
|
||||
Hari Govind V K (hgvk94)
|
||||
Isabel Garcia (igcontreras)
|
||||
|
||||
Revision History:
|
||||
|
||||
Added implementation of qe_lite using term graph
|
||||
|
||||
Notes:
|
||||
|
||||
|
|
@ -19,91 +25,150 @@ Notes:
|
|||
#pragma once
|
||||
|
||||
#include "ast/ast.h"
|
||||
#include "ast/expr_functors.h"
|
||||
#include "ast/is_variable_test.h"
|
||||
#include "util/plugin_manager.h"
|
||||
#include "qe/mbp/mbp_solve_plugin.h"
|
||||
#include "model/model.h"
|
||||
#include "qe/mbp/mbp_solve_plugin.h"
|
||||
#include "util/plugin_manager.h"
|
||||
|
||||
namespace mbp {
|
||||
|
||||
namespace is_ground_ns {
|
||||
struct proc;
|
||||
struct found;
|
||||
} // namespace is_ground_ns
|
||||
class term;
|
||||
|
||||
class term_graph {
|
||||
class projector;
|
||||
friend struct is_ground_ns::proc;
|
||||
friend struct is_ground_ns::found;
|
||||
|
||||
class is_variable_proc : public ::is_variable_proc {
|
||||
bool m_exclude;
|
||||
obj_hashtable<func_decl> m_decls, m_solved;
|
||||
|
||||
public:
|
||||
bool operator()(const expr *e) const override;
|
||||
bool operator()(const term &t) const;
|
||||
|
||||
void set_decls(const func_decl_ref_vector &decls, bool exclude);
|
||||
void set_decls(const app_ref_vector &vars, bool exclude);
|
||||
void add_decls(const app_ref_vector &vars);
|
||||
void add_decl(app *var);
|
||||
void mark_solved(const expr *e);
|
||||
void reset_solved() { m_solved.reset(); }
|
||||
void reset() {m_decls.reset(); m_solved.reset(); m_exclude = true;}
|
||||
void reset() {
|
||||
m_decls.reset();
|
||||
m_solved.reset();
|
||||
m_exclude = true;
|
||||
}
|
||||
bool contains(func_decl *f) { return m_decls.contains(f) == m_exclude; }
|
||||
};
|
||||
|
||||
struct term_hash { unsigned operator()(term const* t) const; };
|
||||
struct term_eq { bool operator()(term const* a, term const* b) const; };
|
||||
class is_non_core : public i_expr_pred {
|
||||
std::function<bool(expr *)> *m_non_core;
|
||||
|
||||
public:
|
||||
is_non_core(std::function<bool(expr *)> *nc) : m_non_core(nc) {}
|
||||
bool operator()(expr *n) override {
|
||||
if (m_non_core == nullptr) return false;
|
||||
return (*m_non_core)(n);
|
||||
}
|
||||
};
|
||||
|
||||
struct term_hash {
|
||||
unsigned operator()(term const *t) const;
|
||||
};
|
||||
struct term_eq {
|
||||
bool operator()(term const *a, term const *b) const;
|
||||
};
|
||||
ast_manager &m;
|
||||
ptr_vector<term> m_terms;
|
||||
expr_ref_vector m_lits; // NSB: expr_ref_vector?
|
||||
u_map<term *> m_app2term;
|
||||
ast_ref_vector m_pinned;
|
||||
projector *m_projector;
|
||||
u_map<expr*> m_term2app;
|
||||
bool m_explicit_eq;
|
||||
bool m_repick_repr;
|
||||
u_map<expr *>
|
||||
m_term2app; // any representative change invalidates this cache
|
||||
plugin_manager<solve_plugin> m_plugins;
|
||||
ptr_hashtable<term, term_hash, term_eq> m_cg_table;
|
||||
vector<std::pair<term *, term *>> m_merge;
|
||||
|
||||
term_graph::is_variable_proc m_is_var;
|
||||
|
||||
void merge(term &t1, term &t2);
|
||||
void merge_flush();
|
||||
|
||||
term *mk_term(expr *t);
|
||||
term *get_term(expr *t);
|
||||
term *get_term(func_decl *f);
|
||||
|
||||
term *internalize_term(expr *t);
|
||||
void internalize_eq(expr *a1, expr *a2);
|
||||
void internalize_lit(expr *lit);
|
||||
void internalize_distinct(expr *d);
|
||||
void internalize_deq(expr *a1, expr *a2);
|
||||
|
||||
bool is_internalized(expr *a);
|
||||
bool is_ground(expr *e);
|
||||
|
||||
bool term_lt(term const &t1, term const &t2);
|
||||
void pick_root (term &t);
|
||||
void pick_roots();
|
||||
void pick_repr_percolate_up(ptr_vector<term> &todo);
|
||||
void pick_repr_class(term *t);
|
||||
void pick_repr();
|
||||
|
||||
void reset_marks();
|
||||
void reset_marks2();
|
||||
bool marks_are_clear();
|
||||
|
||||
expr *mk_app_core(expr *a);
|
||||
expr_ref mk_app(term const &t);
|
||||
expr_ref mk_app(term &t);
|
||||
expr *mk_pure(term &t);
|
||||
expr_ref mk_app(expr *a);
|
||||
void mk_equalities(term const &t, expr_ref_vector &out);
|
||||
void mk_all_equalities(term const &t, expr_ref_vector &out);
|
||||
void mk_equalities(term &t, expr_ref_vector &out);
|
||||
void mk_all_equalities(term &t, expr_ref_vector &out);
|
||||
void mk_qe_lite_equalities(term &t, expr_ref_vector &out,
|
||||
check_pred ¬_in_core);
|
||||
void display(std::ostream &out);
|
||||
|
||||
bool is_pure_def(expr *atom, expr *&v);
|
||||
void cground_percolate_up(ptr_vector<term> &);
|
||||
void cground_percolate_up(term *t);
|
||||
void compute_cground();
|
||||
|
||||
public:
|
||||
term_graph(ast_manager &m);
|
||||
~term_graph();
|
||||
|
||||
void set_vars(func_decl_ref_vector const& decls, bool exclude);
|
||||
const expr_ref_vector &get_lits() const { return m_lits; }
|
||||
void get_terms(expr_ref_vector &res, bool exclude_cground = true);
|
||||
bool is_cgr(expr *e);
|
||||
unsigned size() { return m_terms.size(); }
|
||||
|
||||
void set_vars(func_decl_ref_vector const &decls, bool exclude = true);
|
||||
void set_vars(app_ref_vector const &vars, bool exclude = true);
|
||||
void add_vars(app_ref_vector const &vars);
|
||||
void add_var(app *var);
|
||||
|
||||
ast_manager &get_ast_manager() const { return m; }
|
||||
|
||||
void add_lit(expr *lit);
|
||||
void add_lits(expr_ref_vector const &lits) { for (expr* e : lits) add_lit(e); }
|
||||
void add_lits(expr_ref_vector const &lits) {
|
||||
for (expr *e : lits) add_lit(e);
|
||||
}
|
||||
void add_eq(expr *a, expr *b) { internalize_eq(a, b); }
|
||||
void add_deq(expr *a, expr *b) { internalize_deq(a, b); }
|
||||
|
||||
void reset();
|
||||
|
||||
// deprecate?
|
||||
void to_lits(expr_ref_vector &lits, bool all_equalities = false);
|
||||
expr_ref to_expr();
|
||||
void to_lits(expr_ref_vector &lits, bool all_equalities = false,
|
||||
bool repick_repr = true);
|
||||
void to_lits_qe_lite(expr_ref_vector &lits,
|
||||
std::function<bool(expr *)> *non_core = nullptr);
|
||||
expr_ref to_expr(bool repick_repr = true);
|
||||
|
||||
/**
|
||||
* Return literals obtained by projecting added literals
|
||||
|
|
@ -146,11 +211,51 @@ namespace mbp {
|
|||
expr_ref_vector shared_occurrences(family_id fid);
|
||||
|
||||
/**
|
||||
* Map expression that occurs in added literals into representative if it exists.
|
||||
* Map expression that occurs in added literals into representative if it
|
||||
* exists.
|
||||
*/
|
||||
void add_model_based_terms(model &mdl, expr_ref_vector const &terms);
|
||||
expr *rep_of(expr *e);
|
||||
|
||||
using deqs = bit_vector;
|
||||
struct add_deq_proc {
|
||||
uint64_t m_deq_cnt = 0;
|
||||
void operator()(term *t1, term *t2);
|
||||
void operator()(ptr_vector<term> &ts);
|
||||
};
|
||||
|
||||
// -- disequalities added for output
|
||||
vector<std::pair<term *, term *>> m_deq_pairs;
|
||||
// -- maybe they are not necessary since they are in the original formula
|
||||
vector<ptr_vector<term>> m_deq_distinct;
|
||||
|
||||
expr_ref_vector non_ground_terms();
|
||||
void gr_terms_to_lits(expr_ref_vector &lits, bool all_equalities);
|
||||
// produce a quantifier reduction of the formula stored in the term graph
|
||||
// output of qel will not contain expression e s.t. non_core(e) == true
|
||||
void qel(app_ref_vector &vars, expr_ref &fml,
|
||||
std::function<bool(expr *)> *non_core = nullptr);
|
||||
bool has_val_in_class(expr *e);
|
||||
app *get_const_in_class(expr *e);
|
||||
void set_explicit_eq() { m_explicit_eq = true; }
|
||||
|
||||
private:
|
||||
add_deq_proc m_add_deq;
|
||||
void refine_repr_class(term *t);
|
||||
void refine_repr();
|
||||
bool makes_cycle(term *t);
|
||||
};
|
||||
|
||||
namespace is_ground_ns {
|
||||
struct found {};
|
||||
struct proc {
|
||||
term_graph::is_variable_proc &m_is_var;
|
||||
proc(term_graph::is_variable_proc &is_var) : m_is_var(is_var) {}
|
||||
void operator()(var *n) const {}
|
||||
void operator()(app const *n) const {
|
||||
if (m_is_var.contains(n->get_decl())) throw found();
|
||||
}
|
||||
void operator()(quantifier *n) const {}
|
||||
};
|
||||
} // namespace is_ground_ns
|
||||
} // namespace mbp
|
||||
|
|
|
|||
34
src/qe/mbp/mbp_tg_plugins.h
Normal file
34
src/qe/mbp/mbp_tg_plugins.h
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/*++
|
||||
|
||||
Module Name:
|
||||
|
||||
mbp_tg_plugins.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Model Based Projection for a theory
|
||||
|
||||
Author:
|
||||
|
||||
Hari Govind V K (hgvk94) 2022-07-12
|
||||
|
||||
Revision History:
|
||||
|
||||
|
||||
--*/
|
||||
#pragma once
|
||||
#include "ast/ast.h"
|
||||
#include "qe/mbp/mbp_qel_util.h"
|
||||
#include "qe/mbp/mbp_term_graph.h"
|
||||
#include "util/obj_hashtable.h"
|
||||
|
||||
class mbp_tg_plugin {
|
||||
public:
|
||||
// iterate through all terms in m_tg and apply all theory MBP rules once
|
||||
// returns true if any rules were applied
|
||||
virtual bool apply() { return false; };
|
||||
virtual ~mbp_tg_plugin() = default;
|
||||
virtual void use_model() { };
|
||||
virtual void get_new_vars(app_ref_vector*&) { };
|
||||
virtual family_id get_family_id() const { return null_family_id; };
|
||||
};
|
||||
|
|
@ -18,25 +18,127 @@ Revision History:
|
|||
|
||||
--*/
|
||||
|
||||
#include "ast/rewriter/expr_safe_replace.h"
|
||||
#include "qe/qe_mbp.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/ast_util.h"
|
||||
#include "ast/occurs.h"
|
||||
#include "ast/rewriter/th_rewriter.h"
|
||||
#include "ast/expr_functors.h"
|
||||
#include "ast/for_each_expr.h"
|
||||
#include "ast/occurs.h"
|
||||
#include "ast/rewriter/expr_safe_replace.h"
|
||||
#include "ast/rewriter/th_rewriter.h"
|
||||
#include "ast/rewriter/rewriter.h"
|
||||
#include "ast/rewriter/rewriter_def.h"
|
||||
#include "ast/scoped_proof.h"
|
||||
#include "qe/qe_mbp.h"
|
||||
#include "util/gparams.h"
|
||||
#include "model/model_evaluator.h"
|
||||
#include "model/model_pp.h"
|
||||
#include "qe/lite/qe_lite_tactic.h"
|
||||
#include "qe/lite/qel.h"
|
||||
#include "qe/mbp/mbp_arith.h"
|
||||
#include "qe/mbp/mbp_arrays.h"
|
||||
#include "qe/mbp/mbp_qel.h"
|
||||
#include "qe/mbp/mbp_datatypes.h"
|
||||
#include "qe/lite/qe_lite_tactic.h"
|
||||
#include "model/model_pp.h"
|
||||
#include "model/model_evaluator.h"
|
||||
|
||||
|
||||
using namespace qe;
|
||||
|
||||
namespace {
|
||||
// rewrite select(store(a, i, k), j) into k if m \models i = j and select(a, j) if m \models i != j
|
||||
struct rd_over_wr_rewriter : public default_rewriter_cfg {
|
||||
ast_manager &m;
|
||||
array_util m_arr;
|
||||
model_evaluator m_eval;
|
||||
expr_ref_vector m_sc;
|
||||
|
||||
rd_over_wr_rewriter(ast_manager& man, model& mdl): m(man), m_arr(m), m_eval(mdl), m_sc(m) {
|
||||
m_eval.set_model_completion(false);
|
||||
}
|
||||
|
||||
br_status reduce_app(func_decl *f, unsigned num, expr *const *args,
|
||||
expr_ref &result, proof_ref &result_pr) {
|
||||
if (m_arr.is_select(f) && m_arr.is_store(args[0])) {
|
||||
expr_ref ind1(m), ind2(m);
|
||||
ind1 = m_eval(args[1]);
|
||||
ind2 = m_eval(to_app(args[0])->get_arg(1));
|
||||
if (ind1 == ind2) {
|
||||
result = to_app(args[0])->get_arg(2);
|
||||
m_sc.push_back(m.mk_eq(args[1], to_app(args[0])->get_arg(1)));
|
||||
return BR_DONE;
|
||||
}
|
||||
m_sc.push_back(m.mk_not(m.mk_eq(args[1], to_app(args[0])->get_arg(1))));
|
||||
expr_ref_vector new_args(m);
|
||||
new_args.push_back(to_app(args[0])->get_arg(0));
|
||||
new_args.push_back(args[1]);
|
||||
result = m_arr.mk_select(new_args);
|
||||
return BR_REWRITE1;
|
||||
}
|
||||
return BR_FAILED;
|
||||
}
|
||||
};
|
||||
// rewrite all occurrences of (as const arr c) to (as const arr v) where v = m_eval(c)
|
||||
struct app_const_arr_rewriter : public default_rewriter_cfg {
|
||||
ast_manager &m;
|
||||
array_util m_arr;
|
||||
datatype_util m_dt_util;
|
||||
model_evaluator m_eval;
|
||||
expr_ref val;
|
||||
|
||||
app_const_arr_rewriter(ast_manager& man, model& mdl): m(man), m_arr(m), m_dt_util(m), m_eval(mdl), val(m) {
|
||||
m_eval.set_model_completion(false);
|
||||
}
|
||||
br_status reduce_app(func_decl *f, unsigned num, expr *const *args,
|
||||
expr_ref &result, proof_ref &result_pr) {
|
||||
if (m_arr.is_const(f) && !m.is_value(args[0])) {
|
||||
val = m_eval(args[0]);
|
||||
SASSERT(m.is_value(val));
|
||||
result = m_arr.mk_const_array(f->get_range(), val);
|
||||
return BR_DONE;
|
||||
}
|
||||
if (m_dt_util.is_constructor(f)) {
|
||||
// cons(head(x), tail(x)) --> x
|
||||
ptr_vector<func_decl> const *accessors =
|
||||
m_dt_util.get_constructor_accessors(f);
|
||||
|
||||
SASSERT(num == accessors->size());
|
||||
// -- all accessors must have exactly one argument
|
||||
if (any_of(*accessors, [&](const func_decl* acc) { return acc->get_arity() != 1; })) {
|
||||
return BR_FAILED;
|
||||
}
|
||||
|
||||
if (num >= 1 && is_app(args[0]) && to_app(args[0])->get_decl() == accessors->get(0)) {
|
||||
bool is_all = true;
|
||||
expr* t = to_app(args[0])->get_arg(0);
|
||||
for(unsigned i = 1; i < num && is_all; ++i) {
|
||||
is_all &= (is_app(args[i]) &&
|
||||
to_app(args[i])->get_decl() == accessors->get(i) &&
|
||||
to_app(args[i])->get_arg(0) == t);
|
||||
}
|
||||
if (is_all) {
|
||||
result = t;
|
||||
return BR_DONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return BR_FAILED;
|
||||
}
|
||||
};
|
||||
}
|
||||
void rewrite_as_const_arr(expr* in, model& mdl, expr_ref& out) {
|
||||
app_const_arr_rewriter cfg(out.m(), mdl);
|
||||
rewriter_tpl<app_const_arr_rewriter> rw(out.m(), false, cfg);
|
||||
rw(in, out);
|
||||
}
|
||||
|
||||
void rewrite_read_over_write(expr *in, model &mdl, expr_ref &out) {
|
||||
rd_over_wr_rewriter cfg(out.m(), mdl);
|
||||
rewriter_tpl<rd_over_wr_rewriter> rw(out.m(), false, cfg);
|
||||
rw(in, out);
|
||||
if (cfg.m_sc.empty()) return;
|
||||
expr_ref_vector sc(out.m());
|
||||
SASSERT(out.m().is_and(out));
|
||||
flatten_and(out, sc);
|
||||
sc.append(cfg.m_sc);
|
||||
out = mk_and(sc);
|
||||
}
|
||||
|
||||
class mbproj::impl {
|
||||
ast_manager& m;
|
||||
|
|
@ -47,6 +149,7 @@ class mbproj::impl {
|
|||
// parameters
|
||||
bool m_reduce_all_selects;
|
||||
bool m_dont_sub;
|
||||
bool m_use_qel;
|
||||
|
||||
void add_plugin(mbp::project_plugin* p) {
|
||||
family_id fid = p->get_family_id();
|
||||
|
|
@ -253,9 +356,35 @@ public:
|
|||
m_params.append(p);
|
||||
m_reduce_all_selects = m_params.get_bool("reduce_all_selects", false);
|
||||
m_dont_sub = m_params.get_bool("dont_sub", false);
|
||||
auto q = gparams::get_module("smt");
|
||||
m_params.append(q);
|
||||
m_use_qel = m_params.get_bool("qsat_use_qel", true);
|
||||
}
|
||||
|
||||
void preprocess_solve(model& model, app_ref_vector& vars, expr_ref_vector& fmls) {
|
||||
if (m_use_qel) {
|
||||
extract_literals(model, vars, fmls);
|
||||
expr_ref e(m);
|
||||
bool change = true;
|
||||
while (change && !vars.empty()) {
|
||||
change = false;
|
||||
e = mk_and(fmls);
|
||||
do_qel(vars, e);
|
||||
fmls.reset();
|
||||
flatten_and(e, fmls);
|
||||
for (auto* p : m_plugins) {
|
||||
if (p && p->solve(model, vars, fmls)) {
|
||||
change = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
//rewrite as_const_arr terms
|
||||
expr_ref fml(m);
|
||||
fml = mk_and(fmls);
|
||||
rewrite_as_const_arr(fml, model, fml);
|
||||
flatten_and(fml, fmls);
|
||||
}
|
||||
else {
|
||||
extract_literals(model, vars, fmls);
|
||||
bool change = true;
|
||||
while (change && !vars.empty()) {
|
||||
|
|
@ -267,6 +396,7 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool validate_model(model& model, expr_ref_vector const& fmls) {
|
||||
for (expr* f : fmls) {
|
||||
|
|
@ -276,6 +406,22 @@ public:
|
|||
}
|
||||
|
||||
void operator()(bool force_elim, app_ref_vector& vars, model& model, expr_ref_vector& fmls) {
|
||||
if (m_use_qel) {
|
||||
bool dsub = m_dont_sub;
|
||||
m_dont_sub = !force_elim;
|
||||
expr_ref fml(m);
|
||||
fml = mk_and(fmls);
|
||||
spacer_qel(vars, model, fml);
|
||||
fmls.reset();
|
||||
flatten_and(fml, fmls);
|
||||
m_dont_sub = dsub;
|
||||
}
|
||||
else {
|
||||
mbp(force_elim, vars, model, fmls);
|
||||
}
|
||||
}
|
||||
|
||||
void mbp(bool force_elim, app_ref_vector& vars, model& model, expr_ref_vector& fmls) {
|
||||
SASSERT(validate_model(model, fmls));
|
||||
expr_ref val(m), tmp(m);
|
||||
app_ref var(m);
|
||||
|
|
@ -341,6 +487,17 @@ public:
|
|||
SASSERT(!m.is_false(fml));
|
||||
}
|
||||
|
||||
|
||||
void do_qel(app_ref_vector &vars, expr_ref &fml) {
|
||||
qel qe(m, m_params);
|
||||
qe(vars, fml);
|
||||
m_rw(fml);
|
||||
TRACE("qe", tout << "After qel:\n"
|
||||
<< fml << "\n"
|
||||
<< "Vars: " << vars << "\n";);
|
||||
SASSERT(!m.is_false(fml));
|
||||
}
|
||||
|
||||
void do_qe_bool(model& mdl, app_ref_vector& vars, expr_ref& fml) {
|
||||
expr_ref_vector fmls(m);
|
||||
fmls.push_back(fml);
|
||||
|
|
@ -348,7 +505,86 @@ public:
|
|||
fml = mk_and(fmls);
|
||||
}
|
||||
|
||||
void qel_project(app_ref_vector &vars, model &mdl, expr_ref &fml, bool reduce_all_selects) {
|
||||
flatten_and(fml);
|
||||
mbp::mbp_qel mbptg(m, m_params);
|
||||
mbptg(vars, fml, mdl);
|
||||
if (reduce_all_selects) rewrite_read_over_write(fml, mdl, fml);
|
||||
m_rw(fml);
|
||||
TRACE("qe", tout << "After mbp_tg:\n"
|
||||
<< fml << " models " << mdl.is_true(fml) << "\n"
|
||||
<< "Vars: " << vars << "\n";);
|
||||
}
|
||||
|
||||
void spacer_qel(app_ref_vector& vars, model& mdl, expr_ref& fml) {
|
||||
TRACE("qe", tout << "Before projection:\n" << fml << "\n" << "Vars: " << vars << "\n";);
|
||||
|
||||
model_evaluator eval(mdl, m_params);
|
||||
eval.set_model_completion(true);
|
||||
app_ref_vector other_vars(m);
|
||||
app_ref_vector sub_vars(m);
|
||||
array_util arr_u(m);
|
||||
arith_util ari_u(m);
|
||||
datatype_util dt_u(m);
|
||||
|
||||
do_qel(vars, fml);
|
||||
qel_project(vars, mdl, fml, m_reduce_all_selects);
|
||||
flatten_and(fml);
|
||||
m_rw(fml);
|
||||
rewrite_as_const_arr(fml, mdl, fml);
|
||||
|
||||
for (app* v : vars) {
|
||||
SASSERT(!arr_u.is_array(v) && !dt_u.is_datatype(v->get_sort()));
|
||||
other_vars.push_back(v);
|
||||
}
|
||||
|
||||
// project reals, ints and other variables.
|
||||
if (!other_vars.empty()) {
|
||||
TRACE("qe", tout << "Other vars: " << other_vars << "\n" << mdl;);
|
||||
|
||||
expr_ref_vector fmls(m);
|
||||
flatten_and(fml, fmls);
|
||||
|
||||
mbp(false, other_vars, mdl, fmls);
|
||||
fml = mk_and(fmls);
|
||||
m_rw(fml);
|
||||
|
||||
TRACE("qe",
|
||||
tout << "Projected other vars:\n" << fml << "\n";
|
||||
tout << "Remaining other vars:\n" << other_vars << "\n";);
|
||||
SASSERT(!m.is_false(fml));
|
||||
}
|
||||
|
||||
if (!other_vars.empty()) {
|
||||
project_vars(mdl, other_vars, fml);
|
||||
m_rw(fml);
|
||||
}
|
||||
|
||||
// substitute any remaining other vars
|
||||
if (!m_dont_sub && !other_vars.empty()) {
|
||||
subst_vars(eval, other_vars, fml);
|
||||
TRACE("qe", tout << "After substituting remaining other vars:\n" << fml << "\n";);
|
||||
// an extra round of simplification because subst_vars is not simplifying
|
||||
m_rw(fml);
|
||||
other_vars.reset();
|
||||
}
|
||||
|
||||
SASSERT(!eval.is_false(fml));
|
||||
|
||||
vars.reset();
|
||||
vars.append(other_vars);
|
||||
}
|
||||
|
||||
void spacer(app_ref_vector& vars, model& mdl, expr_ref& fml) {
|
||||
if (m_use_qel) {
|
||||
spacer_qel(vars, mdl, fml);
|
||||
}
|
||||
else {
|
||||
spacer_qe_lite(vars, mdl, fml);
|
||||
}
|
||||
}
|
||||
|
||||
void spacer_qe_lite(app_ref_vector& vars, model& mdl, expr_ref& fml) {
|
||||
TRACE("qe", tout << "Before projection:\n" << fml << "\n" << "Vars: " << vars << "\n";);
|
||||
|
||||
model_evaluator eval(mdl, m_params);
|
||||
|
|
@ -428,7 +664,6 @@ public:
|
|||
vars.reset();
|
||||
vars.append(other_vars);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
mbproj::mbproj(ast_manager& m, params_ref const& p) {
|
||||
|
|
@ -447,6 +682,7 @@ void mbproj::updt_params(params_ref const& p) {
|
|||
void mbproj::get_param_descrs(param_descrs& r) {
|
||||
r.insert("reduce_all_selects", CPK_BOOL, "(default: false) reduce selects");
|
||||
r.insert("dont_sub", CPK_BOOL, "(default: false) disable substitution of values for free variables");
|
||||
r.insert("use_qel", CPK_BOOL, "(default: true) use egraph based QEL");
|
||||
}
|
||||
|
||||
void mbproj::operator()(bool force_elim, app_ref_vector& vars, model& mdl, expr_ref_vector& fmls) {
|
||||
|
|
@ -468,3 +704,5 @@ opt::inf_eps mbproj::maximize(expr_ref_vector const& fmls, model& mdl, app* t, e
|
|||
scoped_no_proof _sp(fmls.get_manager());
|
||||
return m_impl->maximize(fmls, mdl, t, ge, gt);
|
||||
}
|
||||
template class rewriter_tpl<app_const_arr_rewriter>;
|
||||
template class rewriter_tpl<rd_over_wr_rewriter>;
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ Notes:
|
|||
#include "qe/qe_mbp.h"
|
||||
#include "qe/qe.h"
|
||||
#include "ast/rewriter/label_rewriter.h"
|
||||
#include "util/params.h"
|
||||
|
||||
namespace qe {
|
||||
|
||||
|
|
@ -164,8 +165,9 @@ namespace qe {
|
|||
TRACE("qe_assumptions", model_v2_pp(tout, *mdl););
|
||||
|
||||
expr_ref val(m);
|
||||
for (unsigned j = 0; j < m_preds[level - 1].size(); ++j) {
|
||||
app* p = m_preds[level - 1][j].get();
|
||||
for (unsigned i = 0; i <= level-1; ++i) {
|
||||
for (unsigned j = 0; j < m_preds[i].size(); ++j) {
|
||||
app* p = m_preds[i][j].get();
|
||||
eval(p, val);
|
||||
if (!m.inc())
|
||||
return;
|
||||
|
|
@ -177,6 +179,7 @@ namespace qe {
|
|||
m_asms.push_back(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
asms.append(m_asms);
|
||||
|
||||
for (unsigned i = level + 1; i < m_preds.size(); i += 2) {
|
||||
|
|
@ -530,10 +533,13 @@ namespace qe {
|
|||
params_ref m_params;
|
||||
ref<solver> m_solver;
|
||||
|
||||
expr_ref m_last_assert;
|
||||
|
||||
public:
|
||||
kernel(ast_manager& m):
|
||||
m(m),
|
||||
m_solver(nullptr)
|
||||
m_solver(nullptr),
|
||||
m_last_assert(m)
|
||||
{
|
||||
m_params.set_bool("model", true);
|
||||
m_params.set_uint("relevancy", 0);
|
||||
|
|
@ -544,7 +550,7 @@ namespace qe {
|
|||
solver const& s() const { return *m_solver; }
|
||||
|
||||
void init() {
|
||||
m_solver = mk_smt_solver(m, m_params, symbol::null);
|
||||
m_solver = mk_smt2_solver(m, m_params, symbol::null);
|
||||
}
|
||||
void collect_statistics(statistics & st) const {
|
||||
if (m_solver)
|
||||
|
|
@ -561,7 +567,23 @@ namespace qe {
|
|||
void clear() {
|
||||
m_solver = nullptr;
|
||||
}
|
||||
|
||||
void assert_expr(expr *e) {
|
||||
if (!m.is_true(e))
|
||||
m_solver->assert_expr(e);
|
||||
}
|
||||
void assert_blocking_fml(expr* e) {
|
||||
if (m.is_true(e)) return;
|
||||
if (m_last_assert) {
|
||||
if (e == m_last_assert) {
|
||||
verbose_stream() << "Asserting this expression twice in a row:\n " << m_last_assert << "\n";
|
||||
SASSERT(false);
|
||||
std::exit(3);
|
||||
}
|
||||
|
||||
}
|
||||
m_last_assert = e;
|
||||
|
||||
m_solver->assert_expr(e);
|
||||
}
|
||||
|
||||
|
|
@ -618,7 +640,9 @@ namespace qe {
|
|||
lbool check_sat() {
|
||||
while (true) {
|
||||
++m_stats.m_num_rounds;
|
||||
IF_VERBOSE(3, verbose_stream() << "(check-qsat level: " << m_level << " round: " << m_stats.m_num_rounds << ")\n";);
|
||||
IF_VERBOSE(1, verbose_stream() << "(check-qsat level: " << m_level << " round: " << m_stats.m_num_rounds << ")\n";);
|
||||
TRACE("qe",
|
||||
tout << "level: " << m_level << " round: " << m_stats.m_num_rounds << "\n");
|
||||
check_cancel();
|
||||
expr_ref_vector asms(m_asms);
|
||||
m_pred_abs.get_assumptions(m_model.get(), asms);
|
||||
|
|
@ -951,7 +975,8 @@ namespace qe {
|
|||
}
|
||||
else {
|
||||
fml = m_pred_abs.mk_abstract(fml);
|
||||
get_kernel(m_level).assert_expr(fml);
|
||||
TRACE("qe_block", tout << "Blocking fml at level: " << m_level << "\n" << fml << "\n";);
|
||||
get_kernel(m_level).assert_blocking_fml(fml);
|
||||
}
|
||||
SASSERT(!m_model.get());
|
||||
return true;
|
||||
|
|
@ -1236,6 +1261,9 @@ namespace qe {
|
|||
m_was_sat(false),
|
||||
m_gt(m)
|
||||
{
|
||||
params_ref q = params_ref();
|
||||
q.set_bool("use_qel", false);
|
||||
m_mbp.updt_params(q);
|
||||
}
|
||||
|
||||
~qsat() override {
|
||||
|
|
|
|||
|
|
@ -132,6 +132,7 @@ def_module_params(module_name='smt',
|
|||
('core.extend_patterns.max_distance', UINT, UINT_MAX, 'limits the distance of a pattern-extended unsat core'),
|
||||
('core.extend_nonlocal_patterns', BOOL, False, 'extend unsat cores with literals that have quantifiers with patterns that contain symbols which are not in the quantifier\'s body'),
|
||||
('lemma_gc_strategy', UINT, 0, 'lemma garbage collection strategy: 0 - fixed, 1 - geometric, 2 - at restart, 3 - none'),
|
||||
('dt_lazy_splits', UINT, 1, 'How lazy datatype splits are performed: 0- eager, 1- lazy for infinite types, 2- lazy')
|
||||
('dt_lazy_splits', UINT, 1, 'How lazy datatype splits are performed: 0- eager, 1- lazy for infinite types, 2- lazy'),
|
||||
('qsat_use_qel', BOOL, True, 'Use QEL for lite quantifier elimination and model-based projection in QSAT')
|
||||
))
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue