mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-26 18:45:33 +00:00
Code Activity

bmc improvements, move fd_solver to self-contained directory

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-08-05 10:00:49 -07:00
parent fd09b1a7d0
commit e041ebbe80
21 changed files with 120 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

347
src/tactic/fd_solver/bounded_int2bv_solver.cpp Normal file
View file

@ -0,0 +1,347 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
bounded_int2bv_solver.cpp
Abstract:
This solver identifies bounded integers and rewrites them to bit-vectors.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-23
Notes:
--*/
#include "tactic/fd_solver/bounded_int2bv_solver.h"
#include "solver/solver_na2as.h"
#include "tactic/tactic.h"
#include "ast/rewriter/pb2bv_rewriter.h"
#include "tactic/generic_model_converter.h"
#include "ast/ast_pp.h"
#include "model/model_smt2_pp.h"
#include "tactic/arith/bound_manager.h"
#include "tactic/arith/bv2int_rewriter.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "ast/bv_decl_plugin.h"
#include "ast/arith_decl_plugin.h"
class bounded_int2bv_solver : public solver_na2as {
ast_manager& m;
mutable bv_util m_bv;
mutable arith_util m_arith;
mutable expr_ref_vector m_assertions;
ref<solver> m_solver;
mutable ptr_vector<bound_manager> m_bounds;
mutable func_decl_ref_vector m_bv_fns;
mutable func_decl_ref_vector m_int_fns;
unsigned_vector m_bv_fns_lim;
mutable obj_map<func_decl, func_decl*> m_int2bv;
mutable obj_map<func_decl, func_decl*> m_bv2int;
mutable obj_map<func_decl, rational> m_bv2offset;
mutable bv2int_rewriter_ctx m_rewriter_ctx;
mutable bv2int_rewriter_star m_rewriter;
public:
bounded_int2bv_solver(ast_manager& m, params_ref const& p, solver* s):
solver_na2as(m),
m(m),
m_bv(m),
m_arith(m),
m_assertions(m),
m_solver(s),
m_bv_fns(m),
m_int_fns(m),
m_rewriter_ctx(m, p),
m_rewriter(m, m_rewriter_ctx)
{
solver::updt_params(p);
m_bounds.push_back(alloc(bound_manager, m));
}
~bounded_int2bv_solver() override {
while (!m_bounds.empty()) {
dealloc(m_bounds.back());
m_bounds.pop_back();
}
}
solver* translate(ast_manager& dst_m, params_ref const& p) override {
flush_assertions();
bounded_int2bv_solver* result = alloc(bounded_int2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
ast_translation tr(m, dst_m);
for (auto& kv : m_int2bv) result->m_int2bv.insert(tr(kv.m_key), tr(kv.m_value));
for (auto& kv : m_bv2int) result->m_bv2int.insert(tr(kv.m_key), tr(kv.m_value));
for (auto& kv : m_bv2offset) result->m_bv2offset.insert(tr(kv.m_key), kv.m_value);
for (func_decl* f : m_bv_fns) result->m_bv_fns.push_back(tr(f));
for (func_decl* f : m_int_fns) result->m_int_fns.push_back(tr(f));
for (bound_manager* b : m_bounds) result->m_bounds.push_back(b->translate(dst_m));
model_converter_ref mc = external_model_converter();
if (mc) {
ast_translation tr(m, dst_m);
result->set_model_converter(mc->translate(tr));
}
return result;
}
void assert_expr_core(expr * t) override {
unsigned i = m_assertions.size();
m_assertions.push_back(t);
while (i < m_assertions.size()) {
t = m_assertions[i].get();
if (m.is_and(t)) {
m_assertions.append(to_app(t)->get_num_args(), to_app(t)->get_args());
m_assertions[i] = m_assertions.back();
m_assertions.pop_back();
}
else {
++i;
}
}
}
void push_core() override {
flush_assertions();
m_solver->push();
m_bv_fns_lim.push_back(m_bv_fns.size());
m_bounds.push_back(alloc(bound_manager, m));
}
void pop_core(unsigned n) override {
m_assertions.reset();
m_solver->pop(n);
if (n > 0) {
SASSERT(n <= m_bv_fns_lim.size());
unsigned new_sz = m_bv_fns_lim.size() - n;
unsigned lim = m_bv_fns_lim[new_sz];
for (unsigned i = m_int_fns.size(); i > lim; ) {
--i;
m_int2bv.erase(m_int_fns[i].get());
m_bv2int.erase(m_bv_fns[i].get());
m_bv2offset.erase(m_bv_fns[i].get());
}
m_bv_fns_lim.resize(new_sz);
m_bv_fns.resize(lim);
m_int_fns.resize(lim);
}
while (n > 0) {
dealloc(m_bounds.back());
m_bounds.pop_back();
--n;
}
}
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
flush_assertions();
return m_solver->check_sat(num_assumptions, assumptions);
}
void updt_params(params_ref const & p) override { solver::updt_params(p); m_solver->updt_params(p); }
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); }
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
void collect_statistics(statistics & st) const override { m_solver->collect_statistics(st); }
void get_unsat_core(expr_ref_vector & r) override { m_solver->get_unsat_core(r); }
void get_model_core(model_ref & mdl) override {
m_solver->get_model(mdl);
if (mdl) {
model_converter_ref mc = local_model_converter();
if (mc) (*mc)(mdl);
}
}
model_converter* external_model_converter() const {
return concat(mc0(), local_model_converter());
}
model_converter* local_model_converter() const {
if (m_int2bv.empty() && m_bv_fns.empty()) return nullptr;
generic_model_converter* mc = alloc(generic_model_converter, m, "bounded_int2bv");
for (func_decl* f : m_bv_fns)
mc->hide(f);
for (auto const& kv : m_int2bv) {
rational offset;
VERIFY (m_bv2offset.find(kv.m_value, offset));
expr_ref value(m_bv.mk_bv2int(m.mk_const(kv.m_value)), m);
if (!offset.is_zero()) {
value = m_arith.mk_add(value, m_arith.mk_numeral(offset, true));
}
TRACE("int2bv", tout << mk_pp(kv.m_key, m) << " " << value << "\n";);
mc->add(kv.m_key, value);
}
return mc;
}
model_converter_ref get_model_converter() const override {
model_converter_ref mc = external_model_converter();
mc = concat(mc.get(), m_solver->get_model_converter().get());
return mc;
}
proof * get_proof() override { return m_solver->get_proof(); }
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
ast_manager& get_manager() const override { return m; }
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override { return m_solver->find_mutexes(vars, mutexes); }
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
flush_assertions();
expr_ref_vector bvars(m);
for (unsigned i = 0; i < vars.size(); ++i) {
expr* v = vars[i];
func_decl* f;
rational offset;
if (is_app(v) && is_uninterp_const(v) && m_int2bv.find(to_app(v)->get_decl(), f)) {
bvars.push_back(m.mk_const(f));
}
else {
bvars.push_back(v);
}
}
lbool r = m_solver->get_consequences(asms, bvars, consequences);
// translate bit-vector consequences back to integer values
for (unsigned i = 0; i < consequences.size(); ++i) {
expr* a = nullptr, *b = nullptr, *u = nullptr, *v = nullptr;
func_decl* f;
rational num;
unsigned bvsize;
rational offset;
VERIFY(m.is_implies(consequences[i].get(), a, b));
if (m.is_eq(b, u, v) && is_uninterp_const(u) && m_bv2int.find(to_app(u)->get_decl(), f) && m_bv.is_numeral(v, num, bvsize)) {
SASSERT(num.is_unsigned());
expr_ref head(m);
VERIFY (m_bv2offset.find(to_app(u)->get_decl(), offset));
// f + offset == num
// f == num - offset
head = m.mk_eq(m.mk_const(f), m_arith.mk_numeral(num + offset, true));
consequences[i] = m.mk_implies(a, head);
}
}
return r;
}
private:
void accumulate_sub(expr_safe_replace& sub) const {
for (unsigned i = 0; i < m_bounds.size(); ++i) {
accumulate_sub(sub, *m_bounds[i]);
}
}
void accumulate_sub(expr_safe_replace& sub, bound_manager& bm) const {
bound_manager::iterator it = bm.begin(), end = bm.end();
for (; it != end; ++it) {
expr* e = *it;
rational lo, hi;
bool s1 = false, s2 = false;
SASSERT(is_uninterp_const(e));
func_decl* f = to_app(e)->get_decl();
if (bm.has_lower(e, lo, s1) && bm.has_upper(e, hi, s2) && lo <= hi && !s1 && !s2) {
func_decl* fbv;
rational offset;
if (!m_int2bv.find(f, fbv)) {
rational n = hi - lo + rational::one();
unsigned num_bits = get_num_bits(n);
expr_ref b(m);
b = m.mk_fresh_const("b", m_bv.mk_sort(num_bits));
fbv = to_app(b)->get_decl();
offset = lo;
m_int2bv.insert(f, fbv);
m_bv2int.insert(fbv, f);
m_bv2offset.insert(fbv, offset);
m_bv_fns.push_back(fbv);
m_int_fns.push_back(f);
unsigned shift;
if (!offset.is_zero() && !n.is_power_of_two(shift)) {
m_assertions.push_back(m_bv.mk_ule(b, m_bv.mk_numeral(n-rational::one(), num_bits)));
}
}
else {
VERIFY(m_bv2offset.find(fbv, offset));
}
expr_ref t(m.mk_const(fbv), m);
t = m_bv.mk_bv2int(t);
if (!offset.is_zero()) {
t = m_arith.mk_add(t, m_arith.mk_numeral(offset, true));
}
TRACE("pb", tout << lo << " <= " << hi << " offset: " << offset << "\n"; tout << mk_pp(e, m) << " |-> " << t << "\n";);
sub.insert(e, t);
}
else {
TRACE("pb",
tout << "unprocessed entry: " << mk_pp(e, m) << "\n";
if (bm.has_lower(e, lo, s1)) {
tout << "lower: " << lo << " " << s1 << "\n";
}
if (bm.has_upper(e, hi, s2)) {
tout << "upper: " << hi << " " << s2 << "\n";
});
}
}
}
unsigned get_num_bits(rational const& k) const {
SASSERT(!k.is_neg());
SASSERT(k.is_int());
rational two(2);
rational bound(1);
unsigned num_bits = 1;
while (bound <= k) {
++num_bits;
bound *= two;
}
return num_bits;
}
void flush_assertions() const {
if (m_assertions.empty()) return;
bound_manager& bm = *m_bounds.back();
for (expr* a : m_assertions) {
bm(a);
}
TRACE("int2bv", bm.display(tout););
expr_safe_replace sub(m);
accumulate_sub(sub);
proof_ref proof(m);
expr_ref fml1(m), fml2(m);
if (sub.empty()) {
m_solver->assert_expr(m_assertions);
}
else {
for (expr* a : m_assertions) {
sub(a, fml1);
m_rewriter(fml1, fml2, proof);
if (m.canceled()) {
m_rewriter.reset();
return;
}
m_solver->assert_expr(fml2);
TRACE("int2bv", tout << fml2 << "\n";);
}
}
m_assertions.reset();
m_rewriter.reset();
}
unsigned get_num_assertions() const override {
flush_assertions();
return m_solver->get_num_assertions();
}
expr * get_assertion(unsigned idx) const override {
flush_assertions();
return m_solver->get_assertion(idx);
}
};
solver * mk_bounded_int2bv_solver(ast_manager & m, params_ref const & p, solver* s) {
return alloc(bounded_int2bv_solver, m, p, s);
}

29
src/tactic/fd_solver/bounded_int2bv_solver.h Normal file
View file

@ -0,0 +1,29 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
bounded_int2bv_solver.h
Abstract:
Finite domain solver.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-23
Notes:
--*/
#ifndef BOUNDED_INT2BV_SOLVER_H_
#define BOUNDED_INT2BV_SOLVER_H_
#include "ast/ast.h"
#include "util/params.h"
class solver;
solver * mk_bounded_int2bv_solver(ast_manager & m, params_ref const & p, solver* s);
#endif

195
src/tactic/fd_solver/enum2bv_solver.cpp Normal file
View file

@ -0,0 +1,195 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
enum2bv_solver.cpp
Abstract:
Finite domain solver.
Enumeration data-types are translated into bit-vectors, and then
the incremental sat-solver is applied to the resulting assertions.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-17
Notes:
--*/
#include "ast/bv_decl_plugin.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/ast_pp.h"
#include "model/model_smt2_pp.h"
#include "tactic/tactic.h"
#include "tactic/generic_model_converter.h"
#include "solver/solver_na2as.h"
#include "ast/rewriter/enum2bv_rewriter.h"
#include "tactic/fd_solver/enum2bv_solver.h"
class enum2bv_solver : public solver_na2as {
ast_manager& m;
ref<solver> m_solver;
enum2bv_rewriter m_rewriter;
public:
enum2bv_solver(ast_manager& m, params_ref const& p, solver* s):
solver_na2as(m),
m(m),
m_solver(s),
m_rewriter(m, p)
{
solver::updt_params(p);
}
~enum2bv_solver() override {}
solver* translate(ast_manager& dst_m, params_ref const& p) override {
solver* result = alloc(enum2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
model_converter_ref mc = external_model_converter();
if (mc) {
ast_translation tr(m, dst_m);
result->set_model_converter(mc->translate(tr));
}
return result;
}
void assert_expr_core(expr * t) override {
expr_ref tmp(t, m);
expr_ref_vector bounds(m);
proof_ref tmp_proof(m);
m_rewriter(t, tmp, tmp_proof);
m_solver->assert_expr(tmp);
m_rewriter.flush_side_constraints(bounds);
m_solver->assert_expr(bounds);
}
void push_core() override {
m_rewriter.push();
m_solver->push();
}
void pop_core(unsigned n) override {
m_solver->pop(n);
m_rewriter.pop(n);
}
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
m_solver->updt_params(get_params());
return m_solver->check_sat(num_assumptions, assumptions);
}
void updt_params(params_ref const & p) override { solver::updt_params(p); m_solver->updt_params(p); }
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); }
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
void collect_statistics(statistics & st) const override { m_solver->collect_statistics(st); }
void get_unsat_core(expr_ref_vector & r) override { m_solver->get_unsat_core(r); }
void get_model_core(model_ref & mdl) override {
m_solver->get_model(mdl);
if (mdl) {
model_converter_ref mc = local_model_converter();
if (mc) (*mc)(mdl);
}
}
model_converter* local_model_converter() const {
if (m_rewriter.enum2def().empty() &&
m_rewriter.enum2bv().empty()) {
return nullptr;
}
generic_model_converter* mc = alloc(generic_model_converter, m, "enum2bv");
for (auto const& kv : m_rewriter.enum2bv())
mc->hide(kv.m_value);
for (auto const& kv : m_rewriter.enum2def())
mc->add(kv.m_key, kv.m_value);
return mc;
}
model_converter* external_model_converter() const {
return concat(mc0(), local_model_converter());
}
model_converter_ref get_model_converter() const override {
model_converter_ref mc = external_model_converter();
mc = concat(mc.get(), m_solver->get_model_converter().get());
return mc;
}
proof * get_proof() override { return m_solver->get_proof(); }
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
ast_manager& get_manager() const override { return m; }
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override {
return m_solver->find_mutexes(vars, mutexes);
}
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override {
return m_solver->cube(vars, backtrack_level);
}
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
datatype_util dt(m);
bv_util bv(m);
expr_ref_vector bvars(m), conseq(m), bounds(m);
// ensure that enumeration variables that
// don't occur in the constraints
// are also internalized.
for (expr* v : vars) {
expr_ref tmp(m.mk_eq(v, v), m);
proof_ref proof(m);
m_rewriter(tmp, tmp, proof);
}
m_rewriter.flush_side_constraints(bounds);
m_solver->assert_expr(bounds);
// translate enumeration constants to bit-vectors.
for (expr* v : vars) {
func_decl* f = 0;
if (is_app(v) && is_uninterp_const(v) && m_rewriter.enum2bv().find(to_app(v)->get_decl(), f)) {
bvars.push_back(m.mk_const(f));
}
else {
bvars.push_back(v);
}
}
lbool r = m_solver->get_consequences(asms, bvars, consequences);
// translate bit-vector consequences back to enumeration types
for (unsigned i = 0; i < consequences.size(); ++i) {
expr* a = nullptr, *b = nullptr, *u = nullptr, *v = nullptr;
func_decl* f;
rational num;
unsigned bvsize;
VERIFY(m.is_implies(consequences[i].get(), a, b));
if (m.is_eq(b, u, v) && is_uninterp_const(u) && m_rewriter.bv2enum().find(to_app(u)->get_decl(), f) && bv.is_numeral(v, num, bvsize)) {
SASSERT(num.is_unsigned());
expr_ref head(m);
ptr_vector<func_decl> const& enums = *dt.get_datatype_constructors(f->get_range());
if (enums.size() > num.get_unsigned()) {
head = m.mk_eq(m.mk_const(f), m.mk_const(enums[num.get_unsigned()]));
consequences[i] = m.mk_implies(a, head);
}
}
}
return r;
}
unsigned get_num_assertions() const override {
return m_solver->get_num_assertions();
}
expr * get_assertion(unsigned idx) const override {
return m_solver->get_assertion(idx);
}
};
solver * mk_enum2bv_solver(ast_manager & m, params_ref const & p, solver* s) {
return alloc(enum2bv_solver, m, p, s);
}

29
src/tactic/fd_solver/enum2bv_solver.h Normal file
View file

@ -0,0 +1,29 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
enum2bv_solver.h
Abstract:
Finite domain solver.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-17
Notes:
--*/
#ifndef ENUM2BV_SOLVER_H_
#define ENUM2BV_SOLVER_H_
#include "ast/ast.h"
#include "util/params.h"
class solver;
solver * mk_enum2bv_solver(ast_manager & m, params_ref const & p, solver* s);
#endif

45
src/tactic/fd_solver/fd_solver.cpp Normal file
View file

@ -0,0 +1,45 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
fd_solver.cpp
Abstract:
Finite domain solver.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-17
Notes:
--*/
#include "tactic/fd_solver/fd_solver.h"
#include "tactic/tactic.h"
#include "sat/sat_solver/inc_sat_solver.h"
#include "tactic/portfolio/enum2bv_solver.h"
#include "tactic/portfolio/pb2bv_solver.h"
#include "tactic/portfolio/bounded_int2bv_solver.h"
#include "solver/solver2tactic.h"
#include "solver/parallel_tactic.h"
#include "solver/parallel_params.hpp"
solver * mk_fd_solver(ast_manager & m, params_ref const & p, bool incremental_mode) {
solver* s = mk_inc_sat_solver(m, p, incremental_mode);
s = mk_enum2bv_solver(m, p, s);
s = mk_pb2bv_solver(m, p, s);
s = mk_bounded_int2bv_solver(m, p, s);
return s;
}
tactic * mk_fd_tactic(ast_manager & m, params_ref const& p) {
return mk_solver2tactic(mk_fd_solver(m, p, false));
}
tactic * mk_parallel_qffd_tactic(ast_manager& m, params_ref const& p) {
solver* s = mk_fd_solver(m, p);
return mk_parallel_tactic(s, p);
}

37
src/tactic/fd_solver/fd_solver.h Normal file
View file

@ -0,0 +1,37 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
fd_solver.h
Abstract:
Finite domain solver.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-17
Notes:
--*/
#ifndef FD_SOLVER_H_
#define FD_SOLVER_H_
#include "ast/ast.h"
#include "util/params.h"
class solver;
class tactic;
solver * mk_fd_solver(ast_manager & m, params_ref const & p, bool incremental_mode = true);
tactic * mk_fd_tactic(ast_manager & m, params_ref const & p);
tactic * mk_parallel_qffd_tactic(ast_manager& m, params_ref const& p);
/*
ADD_TACTIC("qffd", "builtin strategy for solving QF_FD problems.", "mk_fd_tactic(m, p)")
ADD_TACTIC("pqffd", "builtin strategy for solving QF_FD problems in parallel.", "mk_parallel_qffd_tactic(m, p)")
*/
#endif

161
src/tactic/fd_solver/pb2bv_solver.cpp Normal file
View file

@ -0,0 +1,161 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
pb2bv_solver.cpp
Abstract:
Author:
Nikolaj Bjorner (nbjorner) 2016-10-23
Notes:
--*/
#include "ast/ast_pp.h"
#include "ast/rewriter/pb2bv_rewriter.h"
#include "ast/rewriter/th_rewriter.h"
#include "model/model_smt2_pp.h"
#include "tactic/tactic.h"
#include "tactic/generic_model_converter.h"
#include "solver/solver_na2as.h"
#include "tactic/fd_solver/pb2bv_solver.h"
class pb2bv_solver : public solver_na2as {
ast_manager& m;
mutable expr_ref_vector m_assertions;
mutable ref<solver> m_solver;
mutable th_rewriter m_th_rewriter;
mutable pb2bv_rewriter m_rewriter;
public:
pb2bv_solver(ast_manager& m, params_ref const& p, solver* s):
solver_na2as(m),
m(m),
m_assertions(m),
m_solver(s),
m_th_rewriter(m, p),
m_rewriter(m, p)
{
solver::updt_params(p);
}
~pb2bv_solver() override {}
solver* translate(ast_manager& dst_m, params_ref const& p) override {
flush_assertions();
solver* result = alloc(pb2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
model_converter_ref mc = external_model_converter();
if (mc.get()) {
ast_translation tr(m, dst_m);
result->set_model_converter(mc->translate(tr));
}
return result;
}
void assert_expr_core(expr * t) override {
m_assertions.push_back(t);
}
void push_core() override {
flush_assertions();
m_rewriter.push();
m_solver->push();
}
void pop_core(unsigned n) override {
m_assertions.reset();
m_solver->pop(n);
m_rewriter.pop(n);
}
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
flush_assertions();
return m_solver->check_sat(num_assumptions, assumptions);
}
void updt_params(params_ref const & p) override { solver::updt_params(p); m_rewriter.updt_params(p); m_solver->updt_params(p); }
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); m_rewriter.collect_param_descrs(r);}
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
void collect_statistics(statistics & st) const override {
m_rewriter.collect_statistics(st);
m_solver->collect_statistics(st);
}
void get_unsat_core(expr_ref_vector & r) override { m_solver->get_unsat_core(r); }
void get_model_core(model_ref & mdl) override {
m_solver->get_model(mdl);
if (mdl) {
model_converter_ref mc = local_model_converter();
if (mc) (*mc)(mdl);
}
}
model_converter* external_model_converter() const{
return concat(mc0(), local_model_converter());
}
model_converter_ref get_model_converter() const override {
model_converter_ref mc = external_model_converter();
mc = concat(mc.get(), m_solver->get_model_converter().get());
return mc;
}
proof * get_proof() override { return m_solver->get_proof(); }
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
ast_manager& get_manager() const override { return m; }
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override { return m_solver->find_mutexes(vars, mutexes); }
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
flush_assertions();
return m_solver->get_consequences(asms, vars, consequences); }
model_converter* local_model_converter() const {
if (m_rewriter.fresh_constants().empty()) {
return nullptr;
}
generic_model_converter* filter = alloc(generic_model_converter, m, "pb2bv");
func_decl_ref_vector const& fns = m_rewriter.fresh_constants();
for (func_decl* f : fns) {
filter->hide(f);
}
return filter;
}
unsigned get_num_assertions() const override {
flush_assertions();
return m_solver->get_num_assertions();
}
expr * get_assertion(unsigned idx) const override {
flush_assertions();
return m_solver->get_assertion(idx);
}
private:
void flush_assertions() const {
if (m_assertions.empty()) return;
m_rewriter.updt_params(get_params());
proof_ref proof(m);
expr_ref fml1(m), fml(m);
expr_ref_vector fmls(m);
for (expr* a : m_assertions) {
m_th_rewriter(a, fml1, proof);
m_rewriter(false, fml1, fml, proof);
m_solver->assert_expr(fml);
}
m_rewriter.flush_side_constraints(fmls);
m_solver->assert_expr(fmls);
m_assertions.reset();
}
};
solver * mk_pb2bv_solver(ast_manager & m, params_ref const & p, solver* s) {
return alloc(pb2bv_solver, m, p, s);
}

29
src/tactic/fd_solver/pb2bv_solver.h Normal file
View file

@ -0,0 +1,29 @@
/*++
Copyright (c) 2016 Microsoft Corporation
Module Name:
pb2bv_solver.h
Abstract:
Pseudo-Boolean to bit-vector solver.
Author:
Nikolaj Bjorner (nbjorner) 2016-10-23
Notes:
--*/
#ifndef PB2BV_SOLVER_H_
#define PB2BV_SOLVER_H_
#include "ast/ast.h"
#include "util/params.h"
class solver;
solver * mk_pb2bv_solver(ast_manager & m, params_ref const & p, solver* s);
#endif