mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-05 17:14:07 +00:00
Code Activity

QEL: Fast Approximated Quantifier Elimination (#6820)

Browse source 
* 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 2023-08-02 12:34:06 -04:00 committed by GitHub
parent 5b2519d7a3
commit 51d3c279d0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
35 changed files with 4170 additions and 1517 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
RELEASE_NOTES.md
View file

@ -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
==============

1
src/ast/CMakeLists.txt
View file

@ -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
View 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
View 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); }

43
src/ast/rewriter/array_rewriter.cpp
View file

@ -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);

3
src/ast/rewriter/datatype_rewriter.cpp
View file

@ -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]);

5
src/ast/rewriter/th_rewriter.cpp
View file

@ -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";

196
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -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,8 +575,192 @@ public:
};
class mbp_qel_cmd : public cmd {
unsigned m_arg_index;
ptr_vector<expr> m_lits;
ptr_vector<expr> m_vars;
void install_dbg_cmds(cmd_context & ctx) {
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));
ctx.insert(alloc(get_quantifier_body_cmd));
ctx.insert(alloc(set_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));
}

2
src/muz/spacer/spacer_unsat_core_plugin.cpp
View file

@ -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);
}

20
src/muz/spacer/spacer_util.cpp
View file

@ -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);

1
src/muz/spacer/spacer_util.h
View file

@ -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);

2
src/qe/lite/CMakeLists.txt
View file

@ -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
)

6
src/qe/lite/qe_lite_tactic.cpp
View file

@ -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";);
}
@ -2392,7 +2392,7 @@ qe_lite::~qe_lite() {
}
void qe_lite::operator()(app_ref_vector& vars, expr_ref& fml) {
(*m_impl)(vars, fml);
(*m_impl)(vars, fml);
}

1
src/qe/lite/qe_lite_tactic.h
View file

@ -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
View 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
View 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);
};

5
src/qe/mbp/CMakeLists.txt
View file

@ -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

142
src/qe/mbp/mbp_arrays.cpp
View file

@ -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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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);

92
src/qe/mbp/mbp_solve_plugin.cpp
View file

@ -248,30 +248,80 @@ 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 (m.is_eq (atom, e1, e2)) {
expr_ref v(m), t(m);
v = e1; t = e2;
// -- attempt to solve using arithmetic
solve(e1, e2, v, t);
// -- normalize equality
res = mk_eq_core(v, t);
}
else if (a.is_le(atom, e1, e2)) {
mk_le_core(e1, e2, res);
}
else if (a.is_ge(atom, e1, e2)) {
mk_ge_core(e1, e2, res);
}
expr_ref res(atom, m);
// restore negation
if (!is_pos) {
res = mk_not(m, res);
}
return res;
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;
// -- attempt to solve using arithmetic
solve(e1, e2, v, t);
// -- normalize equality
res = mk_eq_core(v, t);
}
else if (a.is_le(atom, e1, e2)) {
mk_le_core(e1, e2, res);
}
else if (a.is_ge(atom, e1, e2)) {
mk_ge_core(e1, e2, res);
}
// restore negation
if (!is_pos) {
res = mk_not(m, res);
}
return res;
}
};

2926
src/qe/mbp/mbp_term_graph.cpp
View file

File diff suppressed because it is too large Load diff

355
src/qe/mbp/mbp_term_graph.h
View file

@ -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,138 +25,237 @@ 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;
class term_graph {
class projector;
friend struct is_ground_ns::proc;
friend struct is_ground_ns::found;
class term_graph {
class projector;
class is_variable_proc : public ::is_variable_proc {
bool m_exclude;
obj_hashtable<func_decl> m_decls, m_solved;
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 mark_solved(const expr *e);
void reset_solved() {m_solved.reset();}
void reset() {m_decls.reset(); m_solved.reset(); m_exclude = true;}
};
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;
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 *internalize_term(expr *t);
void internalize_eq(expr *a1, expr *a2);
void internalize_lit(expr *lit);
bool is_internalized(expr *a);
bool term_lt(term const &t1, term const &t2);
void pick_root (term &t);
void pick_roots();
void reset_marks();
bool marks_are_clear();
expr* mk_app_core(expr* a);
expr_ref mk_app(term const &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 display(std::ostream &out);
bool is_pure_def(expr* atom, expr *& v);
public:
term_graph(ast_manager &m);
~term_graph();
void set_vars(func_decl_ref_vector const& decls, bool exclude);
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_eq(expr* a, expr* b) { internalize_eq(a, b); }
void reset();
// deprecate?
void to_lits(expr_ref_vector &lits, bool all_equalities = false);
expr_ref to_expr();
/**
* Return literals obtained by projecting added literals
* onto the vocabulary of decls (if exclude is false) or outside the
* vocabulary of decls (if exclude is true).
*/
expr_ref_vector project();
expr_ref_vector solve();
expr_ref_vector project(model &mdl);
/**
* Return disequalities to ensure that disequalities between
* excluded functions are preserved.
* For example if f(a) = b, f(c) = d, and b and d are not
* congruent, then produce the disequality a != c.
*/
expr_ref_vector get_ackerman_disequalities();
/**
* Produce model-based disequality
* certificate corresponding to
* definition in BGVS 2020.
* A disequality certificate is a reduced set of
* disequalities, true under mdl, such that the literals
* can be satisfied when non-shared symbols are projected.
*/
expr_ref_vector dcert(model& mdl, expr_ref_vector const& lits);
/**
* Produce a model-based partition.
*/
vector<expr_ref_vector> get_partition(model& mdl);
/**
* Extract shared occurrences of terms whose sort are
* fid, but appear in a context that is not fid.
* for example f(x + y) produces the shared occurrence
* x + y when f is uninterpreted and x + y has sort Int or Real.
*/
expr_ref_vector shared_occurrences(family_id fid);
/**
* 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);
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;
}
bool contains(func_decl *f) { return m_decls.contains(f) == m_exclude; }
};
}
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;
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_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 &t);
expr *mk_pure(term &t);
expr_ref mk_app(expr *a);
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 &not_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();
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_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,
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
* onto the vocabulary of decls (if exclude is false) or outside the
* vocabulary of decls (if exclude is true).
*/
expr_ref_vector project();
expr_ref_vector solve();
expr_ref_vector project(model &mdl);
/**
* Return disequalities to ensure that disequalities between
* excluded functions are preserved.
* For example if f(a) = b, f(c) = d, and b and d are not
* congruent, then produce the disequality a != c.
*/
expr_ref_vector get_ackerman_disequalities();
/**
* Produce model-based disequality
* certificate corresponding to
* definition in BGVS 2020.
* A disequality certificate is a reduced set of
* disequalities, true under mdl, such that the literals
* can be satisfied when non-shared symbols are projected.
*/
expr_ref_vector dcert(model &mdl, expr_ref_vector const &lits);
/**
* Produce a model-based partition.
*/
vector<expr_ref_vector> get_partition(model &mdl);
/**
* Extract shared occurrences of terms whose sort are
* fid, but appear in a context that is not fid.
* for example f(x + y) produces the shared occurrence
* x + y when f is uninterpreted and x + y has sort Int or Real.
*/
expr_ref_vector shared_occurrences(family_id fid);
/**
* 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
View 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; };
};

256
src/qe/qe_mbp.cpp
View file

@ -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>;

46
src/qe/qsat.cpp
View file

@ -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;
@ -176,6 +178,7 @@ namespace qe {
SASSERT(m.is_true(val));
m_asms.push_back(p);
}
}
}
asms.append(m_asms);
@ -529,11 +532,14 @@ namespace qe {
ast_manager& m;
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) {
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;
@ -1235,8 +1260,11 @@ namespace qe {
m_value(nullptr),
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 {
clear();

3
src/smt/params/smt_params_helper.pyg
View file

@ -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')
))