mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-07-24 05:08:55 +00:00
Code Activity

Merge branch 'master' of https://github.com/Z3Prover/z3 into nsb/master

Browse source
This commit is contained in:
Nikolaj Bjorner 2015-11-05 17:32:35 -08:00
commit 7b72486644
27 changed files with 437 additions and 378 deletions
Download patch file Download diff file Expand all files Collapse all files

6
scripts/mk_util.py
View file

@ -75,7 +75,7 @@ VER_MAJOR=None
VER_MINOR=None
VER_BUILD=None
VER_REVISION=None
PREFIX=os.path.split(os.path.split(os.path.split(PYTHON_PACKAGE_DIR)[0])[0])[0]
PREFIX=sys.prefix
GMP=False
FOCI2=False
FOCI2LIB=''
@ -531,6 +531,7 @@ if os.name == 'nt':
elif os.name == 'posix':
if os.uname()[0] == 'Darwin':
IS_OSX=True
PREFIX="/usr/local"
elif os.uname()[0] == 'Linux':
IS_LINUX=True
elif os.uname()[0] == 'FreeBSD':
@ -1984,6 +1985,7 @@ def mk_config():
print('Prefix: %s' % PREFIX)
print('64-bit: %s' % is64())
print('FP math: %s' % FPMATH)
print("Python pkg dir: %s" % PYTHON_PACKAGE_DIR)
if GPROF:
print('gprof: enabled')
print('Python version: %s' % distutils.sysconfig.get_python_version())
@ -2074,8 +2076,6 @@ def mk_makefile():
# Finalize
if VERBOSE:
print("Makefile was successfully generated.")
if not IS_WINDOWS:
print(" python packages dir: %s" % PYTHON_PACKAGE_DIR)
if DEBUG_MODE:
print(" compilation mode: Debug")
else:

4
src/api/java/Model.java
View file

@ -56,7 +56,7 @@ public class Model extends Z3Object
Native.getRange(getContext().nCtx(), f.getNativeObject())) == Z3_sort_kind.Z3_ARRAY_SORT
.toInt())
throw new Z3Exception(
"Non-zero arity functions and arrays have FunctionInterpretations as a model. Use FuncInterp.");
"Non-zero arity functions and arrays have FunctionInterpretations as a model. Use getFuncInterp.");
long n = Native.modelGetConstInterp(getContext().nCtx(), getNativeObject(),
f.getNativeObject());
@ -101,7 +101,7 @@ public class Model extends Z3Object
} else
{
throw new Z3Exception(
"Constant functions do not have a function interpretation; use ConstInterp");
"Constant functions do not have a function interpretation; use getConstInterp");
}
} else
{

3
src/api/python/z3.py
View file

@ -284,6 +284,9 @@ class AstRef(Z3PPObject):
def __repr__(self):
return obj_to_string(self)
def __hash__(self):
return self.hash()
def sexpr(self):
"""Return an string representing the AST node in s-expression notation.

56
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -36,10 +36,6 @@ fpa2bv_converter::fpa2bv_converter(ast_manager & m) :
m_mpf_manager(m_util.fm()),
m_mpz_manager(m_mpf_manager.mpz_manager()),
m_hi_fp_unspecified(true),
m_min_pn_zeros(0, m),
m_min_np_zeros(0, m),
m_max_pn_zeros(0, m),
m_max_np_zeros(0, m),
m_extra_assertions(m) {
m_plugin = static_cast<fpa_decl_plugin*>(m.get_plugin(m.mk_family_id("fpa")));
}
@ -1154,22 +1150,22 @@ expr_ref fpa2bv_converter::mk_min_unspecified(func_decl * f, expr * x, expr * y)
// The hardware interpretation is -0.0.
mk_nzero(f, res);
else {
if (m_min_pn_zeros == 0) {
m_min_pn_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_decls_to_hide.insert_if_not_there(m_min_pn_zeros->get_decl());
}
if (m_min_np_zeros == 0) {
m_min_np_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_decls_to_hide.insert_if_not_there(m_min_np_zeros->get_decl());
std::pair<app*, app*> decls(0, 0);
if (!m_specials.find(f, decls)) {
decls.first = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
decls.second = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_specials.insert(f, decls);
m.inc_ref(f);
m.inc_ref(decls.first);
m.inc_ref(decls.second);
}
expr_ref pn(m), np(m);
mk_fp(m_min_pn_zeros,
mk_fp(decls.first,
m_bv_util.mk_numeral(0, ebits),
m_bv_util.mk_numeral(0, sbits - 1),
pn);
mk_fp(m_min_np_zeros,
mk_fp(decls.second,
m_bv_util.mk_numeral(0, ebits),
m_bv_util.mk_numeral(0, sbits - 1),
np);
@ -1243,22 +1239,22 @@ expr_ref fpa2bv_converter::mk_max_unspecified(func_decl * f, expr * x, expr * y)
// The hardware interpretation is +0.0.
mk_pzero(f, res);
else {
if (m_max_pn_zeros == 0) {
m_max_pn_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_decls_to_hide.insert_if_not_there(m_max_pn_zeros->get_decl());
}
if (m_max_np_zeros == 0) {
m_max_np_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_decls_to_hide.insert_if_not_there(m_max_np_zeros->get_decl());
std::pair<app*, app*> decls(0, 0);
if (!m_specials.find(f, decls)) {
decls.first = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
decls.second = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
m_specials.insert(f, decls);
m.inc_ref(f);
m.inc_ref(decls.first);
m.inc_ref(decls.second);
}
expr_ref pn(m), np(m);
mk_fp(m_max_pn_zeros,
mk_fp(decls.first,
m_bv_util.mk_numeral(0, ebits),
m_bv_util.mk_numeral(0, sbits - 1),
pn);
mk_fp(m_max_np_zeros,
mk_fp(decls.second,
m_bv_util.mk_numeral(0, ebits),
m_bv_util.mk_numeral(0, sbits - 1),
np);
@ -3839,14 +3835,16 @@ void fpa2bv_converter::round(sort * s, expr_ref & bv_rm, expr_ref & sgn, expr_re
TRACE("fpa2bv_round", tout << "ROUND = " << mk_ismt2_pp(result, m) << std::endl; );
}
void fpa2bv_converter::reset(void) {
dec_ref_map_key_values(m, m_const2bv);
dec_ref_map_key_values(m, m_rm_const2bv);
dec_ref_map_key_values(m, m_uf2bvuf);
m_min_np_zeros = 0;
m_min_pn_zeros = 0;
m_max_np_zeros = 0;
m_max_pn_zeros = 0;
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
it != m_specials.end();
it++) {
m.dec_ref(it->m_key);
m.dec_ref(it->m_value.first);
m.dec_ref(it->m_value.second);
}
m_extra_assertions.reset();
}

13
src/ast/fpa/fpa2bv_converter.h
View file

@ -54,12 +54,10 @@ protected:
obj_map<func_decl, expr*> m_const2bv;
obj_map<func_decl, expr*> m_rm_const2bv;
obj_map<func_decl, func_decl*> m_uf2bvuf;
obj_hashtable<func_decl> m_decls_to_hide;
app_ref m_min_pn_zeros;
app_ref m_min_np_zeros;
app_ref m_max_pn_zeros;
app_ref m_max_np_zeros;
obj_map<func_decl, std::pair<app *, app *> > m_specials;
friend class fpa2bv_model_converter;
public:
fpa2bv_converter(ast_manager & m);
@ -153,11 +151,6 @@ public:
expr_ref mk_to_sbv_unspecified(unsigned width);
expr_ref mk_to_real_unspecified();
obj_map<func_decl, expr*> const & const2bv() const { return m_const2bv; }
obj_map<func_decl, expr*> const & rm_const2bv() const { return m_rm_const2bv; }
obj_map<func_decl, func_decl*> const & uf2bvuf() const { return m_uf2bvuf; }
obj_hashtable<func_decl> const & decls_to_hide() const { return m_decls_to_hide; }
void reset(void);
void dbg_decouple(const char * prefix, expr_ref & e);

7
src/ast/rewriter/arith_rewriter.cpp
View file

@ -318,6 +318,7 @@ br_status arith_rewriter::reduce_power(expr * arg1, expr * arg2, op_kind kind, e
}
br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kind, expr_ref & result) {
expr *orig_arg1 = arg1, *orig_arg2 = arg2;
expr_ref new_arg1(m());
expr_ref new_arg2(m());
if ((is_zero(arg1) && is_reduce_power_target(arg2, kind == EQ)) ||
@ -407,7 +408,11 @@ br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kin
st = BR_DONE;
}
}
if (st != BR_FAILED) {
if (st == BR_DONE && arg1 == orig_arg1 && arg2 == orig_arg2) {
// Nothing new; return BR_FAILED to avoid rewriting loops.
return BR_FAILED;
}
else if (st != BR_FAILED) {
switch (kind) {
case LE: result = m_util.mk_le(arg1, arg2); return BR_DONE;
case GE: result = m_util.mk_ge(arg1, arg2); return BR_DONE;

4
src/ast/rewriter/fpa_rewriter.cpp
View file

@ -439,7 +439,7 @@ br_status fpa_rewriter::mk_min(expr * arg1, expr * arg2, expr_ref & result) {
if (m_util.is_numeral(arg1, v1) && m_util.is_numeral(arg2, v2)) {
if (m_fm.is_zero(v1) && m_fm.is_zero(v2) && m_fm.sgn(v1) != m_fm.sgn(v2)) {
result = m().mk_app(get_fid(), OP_FPA_INTERNAL_MIN_UNSPECIFIED, arg1, arg2);
return BR_DONE;
return BR_REWRITE1;
}
else {
scoped_mpf r(m_fm);
@ -474,7 +474,7 @@ br_status fpa_rewriter::mk_max(expr * arg1, expr * arg2, expr_ref & result) {
if (m_util.is_numeral(arg1, v1) && m_util.is_numeral(arg2, v2)) {
if (m_fm.is_zero(v1) && m_fm.is_zero(v2) && m_fm.sgn(v1) != m_fm.sgn(v2)) {
result = m().mk_app(get_fid(), OP_FPA_INTERNAL_MAX_UNSPECIFIED, arg1, arg2);
return BR_DONE;
return BR_REWRITE1;
}
else {
scoped_mpf r(m_fm);

5
src/cmd_context/cmd_context.cpp
View file

@ -1604,16 +1604,13 @@ void cmd_context::mk_solver() {
bool proofs_enabled, models_enabled, unsat_core_enabled;
params_ref p;
m_params.get_solver_params(m(), p, proofs_enabled, models_enabled, unsat_core_enabled);
if(produce_interpolants()){
SASSERT(m_interpolating_solver_factory);
if (produce_interpolants() && m_interpolating_solver_factory) {
m_solver = (*m_interpolating_solver_factory)(m(), p, true /* must have proofs */, models_enabled, unsat_core_enabled, m_logic);
}
else
m_solver = (*m_solver_factory)(m(), p, proofs_enabled, models_enabled, unsat_core_enabled, m_logic);
}
void cmd_context::set_interpolating_solver_factory(solver_factory * f) {
SASSERT(!has_manager());
m_interpolating_solver_factory = f;

66
src/model/model_evaluator.cpp
View file

@ -73,6 +73,11 @@ struct evaluator_cfg : public default_rewriter_cfg {
ast_manager & m() const { return m_model.get_manager(); }
bool evaluate(func_decl* f, unsigned num, expr * const * args, expr_ref & result) {
func_interp* fi = m_model.get_func_interp(f);
return (fi != 0) && eval_fi(fi, num, args, result);
}
// Try to use the entries to quickly evaluate the fi
bool eval_fi(func_interp * fi, unsigned num, expr * const * args, expr_ref & result) {
if (fi->num_entries() == 0)
@ -101,8 +106,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
family_id fid = f->get_family_id();
if (fid == null_family_id) {
if (num == 0) {
if (fid == null_family_id && num == 0) {
expr * val = m_model.get_const_interp(f);
if (val != 0) {
result = val;
@ -118,15 +122,8 @@ struct evaluator_cfg : public default_rewriter_cfg {
}
return BR_FAILED;
}
SASSERT(num > 0);
func_interp * fi = m_model.get_func_interp(f);
if (fi != 0 && eval_fi(fi, num, args, result)) {
TRACE("model_evaluator", tout << "reduce_app " << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
tout << "---->\n" << mk_ismt2_pp(result, m()) << "\n";);
return BR_DONE;
}
}
br_status st = BR_FAILED;
if (fid == m_b_rw.get_fid()) {
decl_kind k = f->get_decl_kind();
@ -134,7 +131,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
// theory dispatch for =
SASSERT(num == 2);
family_id s_fid = m().get_sort(args[0])->get_family_id();
br_status st = BR_FAILED;
if (s_fid == m_a_rw.get_fid())
st = m_a_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_bv_rw.get_fid())
@ -148,25 +144,38 @@ struct evaluator_cfg : public default_rewriter_cfg {
}
return m_b_rw.mk_app_core(f, num, args, result);
}
if (fid == m_a_rw.get_fid())
return m_a_rw.mk_app_core(f, num, args, result);
if (fid == m_bv_rw.get_fid())
return m_bv_rw.mk_app_core(f, num, args, result);
if (fid == m_ar_rw.get_fid())
return m_ar_rw.mk_app_core(f, num, args, result);
if (fid == m_dt_rw.get_fid())
return m_dt_rw.mk_app_core(f, num, args, result);
if (fid == m_pb_rw.get_fid())
return m_pb_rw.mk_app_core(f, num, args, result);
if (fid == m_f_rw.get_fid())
return m_f_rw.mk_app_core(f, num, args, result);
return BR_FAILED;
st = m_a_rw.mk_app_core(f, num, args, result);
else if (fid == m_bv_rw.get_fid())
st = m_bv_rw.mk_app_core(f, num, args, result);
else if (fid == m_ar_rw.get_fid())
st = m_ar_rw.mk_app_core(f, num, args, result);
else if (fid == m_dt_rw.get_fid())
st = m_dt_rw.mk_app_core(f, num, args, result);
else if (fid == m_pb_rw.get_fid())
st = m_pb_rw.mk_app_core(f, num, args, result);
else if (fid == m_f_rw.get_fid())
st = m_f_rw.mk_app_core(f, num, args, result);
else if (evaluate(f, num, args, result)) {
TRACE("model_evaluator", tout << "reduce_app " << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
tout << "---->\n" << mk_ismt2_pp(result, m()) << "\n";);
return BR_DONE;
}
if (st == BR_DONE && is_app(result)) {
app* a = to_app(result);
if (evaluate(a->get_decl(), a->get_num_args(), a->get_args(), result)) {
return BR_DONE;
}
}
TRACE("model_evaluator", tout << f->get_name() << "\n";);
return st;
}
bool get_macro(func_decl * f, expr * & def, quantifier * & q, proof * & def_pr) {
if (f->get_family_id() == null_family_id) {
func_interp * fi = m_model.get_func_interp(f);
func_interp * fi = m_model.get_func_interp(f);
if (fi != 0) {
if (fi->is_partial()) {
if (m_model_completion) {
@ -178,13 +187,12 @@ struct evaluator_cfg : public default_rewriter_cfg {
return false;
}
}
def = fi->get_interp();
SASSERT(def != 0);
return true;
}
if (m_model_completion) {
if (f->get_family_id() == null_family_id && m_model_completion) {
sort * s = f->get_range();
expr * val = m_model.get_some_value(s);
func_interp * new_fi = alloc(func_interp, m(), f->get_arity());
@ -193,10 +201,10 @@ struct evaluator_cfg : public default_rewriter_cfg {
def = val;
return true;
}
}
return false;
}
bool max_steps_exceeded(unsigned num_steps) const {
cooperate("model evaluator");
if (memory::get_allocation_size() > m_max_memory)

7
src/opt/maxres.cpp
View file

@ -188,6 +188,7 @@ public:
}
lbool mus_solver() {
lbool is_sat = l_true;
init();
init_local();
trace();
@ -198,7 +199,7 @@ public:
tout << "\n";
display(tout);
);
lbool is_sat = check_sat_hill_climb(m_asms);
is_sat = check_sat_hill_climb(m_asms);
if (m_cancel) {
return l_undef;
}
@ -833,9 +834,7 @@ public:
s().assert_expr(m_asms[i].get());
}
}
else {
maxsmt_solver_base::commit_assignment();
}
// else: there is only a single assignment to these soft constraints.
}
void verify_core(exprs const& core) {

7
src/opt/maxsmt.cpp
View file

@ -159,12 +159,7 @@ namespace opt {
symbol const& maxsat_engine = m_c.maxsat_engine();
IF_VERBOSE(1, verbose_stream() << "(maxsmt)\n";);
TRACE("opt", tout << "maxsmt\n";);
if (m_soft_constraints.empty()) {
TRACE("opt", tout << "no constraints\n";);
m_msolver = 0;
is_sat = s().check_sat(0, 0);
}
else if (maxsat_engine == symbol("maxres")) {
if (m_soft_constraints.empty() || maxsat_engine == symbol("maxres")) {
m_msolver = mk_maxres(m_c, m_weights, m_soft_constraints);
}
else if (maxsat_engine == symbol("pd-maxres")) {

7
src/smt/smt_model_generator.cpp
View file

@ -400,7 +400,12 @@ namespace smt {
\brief Return true if the interpretation of the function should be included in the model.
*/
bool model_generator::include_func_interp(func_decl * f) const {
return f->get_family_id() == null_family_id;
family_id fid = f->get_family_id();
if (fid == null_family_id) return true;
if (fid == m_manager.get_basic_family_id()) return false;
theory * th = m_context->get_theory(fid);
if (!th) return true;
return th->include_func_interp(f);
}
/**

4
src/smt/smt_theory.h
View file

@ -412,6 +412,10 @@ namespace smt {
return 0;
}
virtual bool include_func_interp(func_decl* f) {
return false;
}
// -----------------------------------
//
// Model checker

8
src/smt/theory_arith_aux.h
View file

@ -1346,7 +1346,7 @@ namespace smt {
empty_column ||
(unbounded_gain(max_gain) == (x_i == null_theory_var)));
return !empty_column && safe_gain(min_gain, max_gain);
return safe_gain(min_gain, max_gain);
}
template<typename Ext>
@ -1557,14 +1557,12 @@ namespace smt {
// variable cannot be used for max/min.
continue;
}
bool picked_var = pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij,
bool safe_to_leave = pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij,
curr_min_gain, curr_max_gain,
has_shared, curr_x_i);
SASSERT(!picked_var || safe_gain(curr_min_gain, curr_max_gain));
if (!safe_gain(curr_min_gain, curr_max_gain)) {
if (!safe_to_leave) {
TRACE("opt", tout << "no variable picked\n";);
has_bound = true;
best_efforts++;

15
src/smt/theory_bv.cpp
View file

@ -1283,6 +1283,21 @@ namespace smt {
theory::reset_eh();
}
bool theory_bv::include_func_interp(func_decl* f) {
SASSERT(f->get_family_id() == get_family_id());
switch (f->get_decl_kind()) {
case OP_BSDIV0:
case OP_BUDIV0:
case OP_BSREM0:
case OP_BUREM0:
case OP_BSMOD0:
return true;
default:
return false;
}
return false;
}
theory_bv::theory_bv(ast_manager & m, theory_bv_params const & params, bit_blaster_params const & bb_params):
theory(m.mk_family_id("bv")),
m_params(params),

1
src/smt/theory_bv.h
View file

@ -236,6 +236,7 @@ namespace smt {
virtual void pop_scope_eh(unsigned num_scopes);
virtual final_check_status final_check_eh();
virtual void reset_eh();
virtual bool include_func_interp(func_decl* f);
svector<theory_var> m_merge_aux[2]; //!< auxiliary vector used in merge_zero_one_bits
bool merge_zero_one_bits(theory_var r1, theory_var r2);

34
src/smt/theory_fpa.cpp
View file

@ -555,26 +555,11 @@ namespace smt {
literal l(ctx.mk_bool_var(atom));
ctx.set_var_theory(l.var(), get_id());
expr_ref bv_atom(m);
bv_atom = convert_atom(atom);
SASSERT(is_app(bv_atom) && m.is_bool(bv_atom));
bv_atom = m.mk_and(bv_atom, mk_side_conditions());
// CMW: Do not use assert_cnstr here; the internalizer expects normalized expressions.
// See GitHub issue #227
// assert_cnstr(m.mk_iff(atom, bv_atom));
ctx.internalize(atom, false);
ctx.internalize(bv_atom, false);
literal lit1(ctx.get_literal(atom));
literal lit2(ctx.get_literal(bv_atom));
ctx.mark_as_relevant(lit1);
ctx.mark_as_relevant(lit2);
literal lits1[2] = { lit1, ~lit2 };
literal lits2[2] = { ~lit1, lit2 };
ctx.mk_th_axiom(get_id(), 2, lits1);
ctx.mk_th_axiom(get_id(), 2, lits2);
expr_ref bv_atom(convert_atom(atom));
expr_ref bv_atom_w_side_c(m);
bv_atom_w_side_c = m.mk_and(bv_atom, mk_side_conditions());
m_th_rw(bv_atom_w_side_c);
assert_cnstr(m.mk_eq(atom, bv_atom_w_side_c));
return true;
}
@ -752,10 +737,11 @@ namespace smt {
expr_ref converted(m);
converted = m.mk_and(convert(e), mk_side_conditions());
if (is_true)
assert_cnstr(m.mk_implies(e, converted));
else
assert_cnstr(m.mk_implies(m.mk_not(e), m.mk_not(converted)));
expr_ref cnstr(m);
cnstr = (is_true) ? m.mk_implies(e, converted) : m.mk_implies(converted, e);
m_th_rw(cnstr);
assert_cnstr(cnstr);
}
void theory_fpa::relevant_eh(app * n) {

61
src/tactic/fpa/fpa2bv_model_converter.cpp
View file

@ -45,6 +45,15 @@ void fpa2bv_model_converter::display(std::ostream & out) {
unsigned indent = n.size() + 4;
out << mk_ismt2_pp(it->m_value, m, indent) << ")";
}
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
it != m_specials.end();
it++) {
const symbol & n = it->m_key->get_name();
out << "\n (" << n << " ";
unsigned indent = n.size() + 4;
out << mk_ismt2_pp(it->m_value.first, m, indent) << "; " <<
mk_ismt2_pp(it->m_value.second, m, indent) << ")";
}
out << ")" << std::endl;
}
@ -79,12 +88,16 @@ model_converter * fpa2bv_model_converter::translate(ast_translation & translator
translator.to().inc_ref(k);
translator.to().inc_ref(v);
}
for (obj_hashtable<func_decl>::iterator it = m_decls_to_hide.begin();
it != m_decls_to_hide.end();
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
it != m_specials.end();
it++) {
func_decl * k = translator(*it);
res->m_decls_to_hide.insert(k);
func_decl * k = translator(it->m_key);
app * v1 = translator(it->m_value.first);
app * v2 = translator(it->m_value.second);
res->m_specials.insert(k, std::pair<app*, app*>(v1, v2));
translator.to().inc_ref(k);
translator.to().inc_ref(v1);
translator.to().inc_ref(v2);
}
return res;
}
@ -217,10 +230,34 @@ void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
obj_hashtable<func_decl> seen;
for (obj_hashtable<func_decl>::iterator it = m_decls_to_hide.begin();
it != m_decls_to_hide.end();
it++)
seen.insert(*it);
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
it != m_specials.end();
it++) {
func_decl * f = it->m_key;
expr_ref pzero(m), nzero(m);
pzero = fu.mk_pzero(f->get_range());
nzero = fu.mk_nzero(f->get_range());
expr_ref pn(m), np(m);
bv_mdl->eval(it->m_value.first, pn, true);
bv_mdl->eval(it->m_value.second, np, true);
seen.insert(it->m_value.first->get_decl());
seen.insert(it->m_value.second->get_decl());
rational pn_num, np_num;
unsigned bv_sz;
bu.is_numeral(pn, pn_num, bv_sz);
bu.is_numeral(np, np_num, bv_sz);
func_interp * flt_fi = alloc(func_interp, m, f->get_arity());
expr * pn_args[2] = { pzero, nzero };
if (pn != np) flt_fi->insert_new_entry(pn_args, (pn_num.is_one() ? nzero : pzero));
flt_fi->set_else(np_num.is_one() ? nzero : pzero);
float_mdl->register_decl(f, flt_fi);
TRACE("fpa2bv_mc", tout << "fp.min/fp.max special: " << std::endl <<
mk_ismt2_pp(f, m) << " == " << mk_ismt2_pp(flt_fi->get_interp(), m) << std::endl;);
}
for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
it != m_const2bv.end();
@ -362,10 +399,6 @@ void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
}
}
model_converter * mk_fpa2bv_model_converter(ast_manager & m,
obj_map<func_decl, expr*> const & const2bv,
obj_map<func_decl, expr*> const & rm_const2bv,
obj_map<func_decl, func_decl*> const & uf2bvuf,
obj_hashtable<func_decl> const & decls_to_hide) {
return alloc(fpa2bv_model_converter, m, const2bv, rm_const2bv, uf2bvuf, decls_to_hide);
model_converter * mk_fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv) {
return alloc(fpa2bv_model_converter, m, conv);
}

47
src/tactic/fpa/fpa2bv_model_converter.h
View file

@ -27,44 +27,41 @@ class fpa2bv_model_converter : public model_converter {
obj_map<func_decl, expr*> m_const2bv;
obj_map<func_decl, expr*> m_rm_const2bv;
obj_map<func_decl, func_decl*> m_uf2bvuf;
obj_hashtable<func_decl> m_decls_to_hide;
obj_map<func_decl, std::pair<app*, app*> > m_specials;
public:
fpa2bv_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bv,
obj_map<func_decl, expr*> const & rm_const2bv,
obj_map<func_decl, func_decl*> const & uf2bvuf,
obj_hashtable<func_decl> const & decls_to_hide) :
m(m) {
for (obj_map<func_decl, expr*>::iterator it = const2bv.begin();
it != const2bv.end();
fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv) : m(m) {
for (obj_map<func_decl, expr*>::iterator it = conv.m_const2bv.begin();
it != conv.m_const2bv.end();
it++)
{
m_const2bv.insert(it->m_key, it->m_value);
m.inc_ref(it->m_key);
m.inc_ref(it->m_value);
}
for (obj_map<func_decl, expr*>::iterator it = rm_const2bv.begin();
it != rm_const2bv.end();
for (obj_map<func_decl, expr*>::iterator it = conv.m_rm_const2bv.begin();
it != conv.m_rm_const2bv.end();
it++)
{
m_rm_const2bv.insert(it->m_key, it->m_value);
m.inc_ref(it->m_key);
m.inc_ref(it->m_value);
}
for (obj_map<func_decl, func_decl*>::iterator it = uf2bvuf.begin();
it != uf2bvuf.end();
for (obj_map<func_decl, func_decl*>::iterator it = conv.m_uf2bvuf.begin();
it != conv.m_uf2bvuf.end();
it++)
{
m_uf2bvuf.insert(it->m_key, it->m_value);
m.inc_ref(it->m_key);
m.inc_ref(it->m_value);
}
for (obj_hashtable<func_decl>::iterator it = decls_to_hide.begin();
it != decls_to_hide.end();
it++)
{
m_decls_to_hide.insert(*it);
m.inc_ref(*it);
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = conv.m_specials.begin();
it != conv.m_specials.end();
it++) {
m_specials.insert(it->m_key, it->m_value);
m.inc_ref(it->m_key);
m.inc_ref(it->m_value.first);
m.inc_ref(it->m_value.second);
}
}
@ -72,7 +69,13 @@ public:
dec_ref_map_key_values(m, m_const2bv);
dec_ref_map_key_values(m, m_rm_const2bv);
dec_ref_map_key_values(m, m_uf2bvuf);
dec_ref_collection_values(m, m_decls_to_hide);
for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
it != m_specials.end();
it++) {
m.dec_ref(it->m_key);
m.dec_ref(it->m_value.first);
m.dec_ref(it->m_value.second);
}
}
virtual void operator()(model_ref & md, unsigned goal_idx) {
@ -102,10 +105,6 @@ protected:
};
model_converter * mk_fpa2bv_model_converter(ast_manager & m,
obj_map<func_decl, expr*> const & const2bv,
obj_map<func_decl, expr*> const & rm_const2bv,
obj_map<func_decl, func_decl*> const & uf2bvuf,
obj_hashtable<func_decl> const & decls_to_hide);
model_converter * mk_fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv);
#endif

2
src/tactic/fpa/fpa2bv_tactic.cpp
View file

@ -105,7 +105,7 @@ class fpa2bv_tactic : public tactic {
}
if (g->models_enabled())
mc = mk_fpa2bv_model_converter(m, m_conv.const2bv(), m_conv.rm_const2bv(), m_conv.uf2bvuf(), m_conv.decls_to_hide());
mc = mk_fpa2bv_model_converter(m, m_conv);
g->inc_depth();
result.push_back(g.get());

4
src/tactic/smtlogics/qfaufbv_tactic.h
View file

@ -25,4 +25,8 @@ class tactic;
tactic * mk_qfaufbv_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("qfaufbv", "builtin strategy for solving QF_AUFBV problems.", "mk_qfaufbv_tactic(m, p)")
*/
#endif

4
src/tactic/smtlogics/qfauflia_tactic.h
View file

@ -25,4 +25,8 @@ class tactic;
tactic * mk_qfauflia_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("qfauflia", "builtin strategy for solving QF_AUFLIA problems.", "mk_qfauflia_tactic(m, p)")
*/
#endif

4
src/tactic/smtlogics/qfidl_tactic.h
View file

@ -25,4 +25,8 @@ class tactic;
tactic * mk_qfidl_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("qfidl", "builtin strategy for solving QF_IDL problems.", "mk_qfidl_tactic(m, p)")
*/
#endif

4
src/tactic/smtlogics/qfuf_tactic.h
View file

@ -26,4 +26,8 @@ class tactic;
tactic * mk_qfuf_tactic(ast_manager & m, params_ref const & p);
/*
ADD_TACTIC("qfuf", "builtin strategy for solving QF_UF problems.", "mk_qfuf_tactic(m, p)")
*/
#endif

4
src/tactic/smtlogics/qfufbv_tactic.h
View file

@ -25,4 +25,8 @@ class tactic;
tactic * mk_qfufbv_tactic(ast_manager & m, params_ref const & p = params_ref());
/*
ADD_TACTIC("qfufbv", "builtin strategy for solving QF_UFBV problems.", "mk_qfufbv_tactic(m, p)")
*/
#endif