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

re-organize proof and model converters to be associated with goals instead of external

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2017-11-18 16:33:54 -08:00
parent 00f5308a0e
commit 4bbece6616
118 changed files with 617 additions and 1070 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/tactic/arith/add_bounds_tactic.cpp
View file

@ -112,9 +112,8 @@ class add_bounds_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
mc = 0; core = 0;
core = 0;
tactic_report report("add-bounds", *g);
bound_manager bm(m);
expr_fast_mark1 visited;
@ -161,9 +160,8 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_imp)(g, result, mc, core);
(*m_imp)(g, result, core);
}
virtual void cleanup() {

1
src/tactic/arith/arith_bounds_tactic.cpp
View file

@ -25,7 +25,6 @@ struct arith_bounds_tactic : public tactic {
virtual void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result,
/* out */ model_converter_ref & mc,
/* out */ expr_dependency_ref & core) {
bounds_arith_subsumption(in, result);
}

9
src/tactic/arith/card2bv_tactic.cpp
View file

@ -54,11 +54,10 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
TRACE("card2bv-before", g->display(tout););
SASSERT(g->is_well_sorted());
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("card2bv", *g);
th_rewriter rw1(m, m_params);
pb2bv_rewriter rw2(m, m_params);
@ -89,10 +88,8 @@ public:
func_decl_ref_vector const& fns = rw2.fresh_constants();
if (!fns.empty()) {
generic_model_converter* filter = alloc(generic_model_converter, m);
for (unsigned i = 0; i < fns.size(); ++i) {
filter->hide(fns[i]);
}
mc = filter;
for (func_decl* f : fns) filter->hide(f);
g->add(filter);
}
g->inc_depth();

8
src/tactic/arith/degree_shift_tactic.cpp
View file

@ -224,14 +224,14 @@ class degree_shift_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
m_produce_proofs = g->proofs_enabled();
m_produce_models = g->models_enabled();
tactic_report report("degree_shift", *g);
collect(*g);
model_converter_ref mc;
discard_non_candidates();
if (!m_var2degree.empty()) {
prepare_substitution(mc);
@ -269,6 +269,7 @@ class degree_shift_tactic : public tactic {
}
}
g->inc_depth();
g->add(mc.get());
result.push_back(g.get());
TRACE("degree_shift", g->display(tout); if (mc) mc->display(tout););
SASSERT(g->is_well_sorted());
@ -291,9 +292,8 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
virtual void cleanup() {

11
src/tactic/arith/diff_neq_tactic.cpp
View file

@ -314,11 +314,10 @@ class diff_neq_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
m_produce_models = g->models_enabled();
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("diff-neq", *g);
fail_if_proof_generation("diff-neq", g);
fail_if_unsat_core_generation("diff-neq", g);
@ -331,8 +330,9 @@ class diff_neq_tactic : public tactic {
bool r = search();
report_tactic_progress(":conflicts", m_num_conflicts);
if (r) {
if (m_produce_models)
mc = model2model_converter(mk_model());
if (m_produce_models) {
g->add(model2model_converter(mk_model()));
}
g->reset();
}
else {
@ -384,9 +384,8 @@ public:
*/
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
virtual void cleanup() {

17
src/tactic/arith/elim01_tactic.cpp
View file

@ -41,8 +41,7 @@ public:
m_refs(m)
{}
virtual void operator()(model_ref & old_model, unsigned goal_idx) {
SASSERT(goal_idx == 0);
virtual void operator()(model_ref & old_model) {
model * new_model = alloc(model, m);
unsigned num = old_model->get_num_constants();
for (unsigned i = 0; i < m_nums_as_int.size(); ++i) {
@ -154,16 +153,14 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("elim01", *g);
expr_safe_replace sub(m);
bool2int_model_converter* b2i = alloc(bool2int_model_converter, m);
mc = b2i;
ref<bool2int_model_converter> b2i = alloc(bool2int_model_converter, m);
bound_manager bounds(m);
expr_ref_vector axioms(m);
bounds(*g);
@ -178,7 +175,7 @@ public:
if (a.is_int(x) &&
bounds.has_lower(x, lo, s1) && !s1 && zero <= lo &&
bounds.has_upper(x, hi, s2) && !s2 && hi <= m_max_hi && lo <= hi) {
add_variable(b2i, sub, x, lo.get_unsigned(), hi.get_unsigned(), axioms);
add_variable(b2i.get(), sub, x, lo.get_unsigned(), hi.get_unsigned(), axioms);
}
else if (a.is_int(x)) {
TRACE("pb", tout << "Not adding variable " << mk_pp(x, m) << " has lower: "
@ -204,9 +201,9 @@ public:
}
g->update(i, new_curr, new_pr, g->dep(i));
}
for (unsigned i = 0; i < axioms.size(); ++i) {
g->assert_expr(axioms[i].get());
}
for (expr* a : axioms)
g->assert_expr(a);
g->add(b2i.get());
g->inc_depth();
result.push_back(g.get());
TRACE("pb", g->display(tout););

5
src/tactic/arith/eq2bv_tactic.cpp
View file

@ -152,10 +152,9 @@ public:
virtual void operator()(
goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
m_trail.reset();
m_fd.reset();
m_max.reset();
@ -211,7 +210,7 @@ public:
}
}
g->inc_depth();
mc = mc1.get();
g->add(mc1.get());
result.push_back(g.get());
TRACE("pb", g->display(tout););
SASSERT(g->is_well_sorted());

6
src/tactic/arith/factor_tactic.cpp
View file

@ -258,10 +258,9 @@ class factor_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("factor", *g);
bool produce_proofs = g->proofs_enabled();
@ -313,10 +312,9 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
catch (z3_error & ex) {
throw ex;

12
src/tactic/arith/fix_dl_var_tactic.cpp
View file

@ -250,10 +250,9 @@ class fix_dl_var_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("fix-dl-var", *g);
bool produce_proofs = g->proofs_enabled();
m_produce_models = g->models_enabled();
@ -269,9 +268,9 @@ class fix_dl_var_tactic : public tactic {
m_rw.set_substitution(&subst);
if (m_produce_models) {
generic_model_converter * _mc = alloc(generic_model_converter, m);
_mc->add(var, zero);
mc = _mc;
generic_model_converter * mc = alloc(generic_model_converter, m);
mc->add(var, zero);
g->add(mc);
}
expr_ref new_curr(m);
@ -321,10 +320,9 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
catch (rewriter_exception & ex) {
throw tactic_exception(ex.msg());

10
src/tactic/arith/fm_tactic.cpp
View file

@ -180,7 +180,7 @@ class fm_tactic : public tactic {
m_clauses.back().swap(c);
}
virtual void operator()(model_ref & md, unsigned goal_idx) {
virtual void operator()(model_ref & md) {
TRACE("fm_mc", model_v2_pp(tout, *md); display(tout););
model_evaluator ev(*(md.get()));
ev.set_model_completion(true);
@ -1551,10 +1551,9 @@ class fm_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("fm", *g);
fail_if_proof_generation("fm", g);
m_produce_models = g->models_enabled();
@ -1602,7 +1601,7 @@ class fm_tactic : public tactic {
report_tactic_progress(":fm-cost", m_counter);
if (!m_inconsistent) {
copy_remaining();
mc = m_mc.get();
m_new_goal->add(concat(g->mc(), m_mc.get()));
}
}
reset_constraints();
@ -1675,9 +1674,8 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
};

11
src/tactic/arith/lia2card_tactic.cpp
View file

@ -160,10 +160,9 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
m_01s->reset();
tactic_report report("cardinality-intro", *g);
@ -172,9 +171,7 @@ public:
bounds(*g);
bound_manager::iterator bit = bounds.begin(), bend = bounds.end();
for (; bit != bend; ++bit) {
expr* x = *bit;
for (expr* x : bounds) {
bool s1 = false, s2 = false;
rational lo, hi;
if (a.is_int(x) &&
@ -196,9 +193,7 @@ public:
g->update(i, new_curr, new_pr, g->dep(i));
mark_rec(subfmls, new_curr);
}
expr_set::iterator it = m_01s->begin(), end = m_01s->end();
for (; it != end; ++it) {
expr* v = *it;
for (expr* v : *m_01s) {
if (subfmls.is_marked(v)) {
g->assert_expr(a.mk_le(v, a.mk_numeral(rational(1), true)));
g->assert_expr(a.mk_le(a.mk_numeral(rational(0), true), v));

10
src/tactic/arith/lia2pb_tactic.cpp
View file

@ -189,13 +189,12 @@ class lia2pb_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("lia2pb", g);
m_produce_models = g->models_enabled();
m_produce_unsat_cores = g->unsat_core_enabled();
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("lia2pb", *g);
m_bm.reset(); m_rw.reset(); m_new_deps.reset();
@ -222,10 +221,9 @@ class lia2pb_tactic : public tactic {
if (!check_num_bits())
throw tactic_exception("lia2pb failed, number of necessary bits exceeds specified threshold (use option :lia2pb-total-bits to increase threshold)");
generic_model_converter * gmc = 0;
ref<generic_model_converter> gmc;
if (m_produce_models) {
gmc = alloc(generic_model_converter, m);
mc = gmc;
}
expr_ref zero(m);
@ -295,6 +293,7 @@ class lia2pb_tactic : public tactic {
g->update(idx, new_curr, new_pr, dep);
}
g->inc_depth();
g->add(gmc.get());
result.push_back(g.get());
TRACE("lia2pb", g->display(tout););
SASSERT(g->is_well_sorted());
@ -330,10 +329,9 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
catch (rewriter_exception & ex) {
throw tactic_exception(ex.msg());

6
src/tactic/arith/nla2bv_tactic.cpp
View file

@ -441,17 +441,17 @@ public:
*/
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("nla2bv", g);
fail_if_unsat_core_generation("nla2bv", g);
mc = 0; core = 0; result.reset();
core = 0; result.reset();
imp proc(g->m(), m_params);
scoped_set_imp setter(*this, proc);
model_converter_ref mc;
proc(*(g.get()), mc);
g->add(mc.get());
result.push_back(g.get());
SASSERT(g->is_well_sorted());
}

13
src/tactic/arith/normalize_bounds_tactic.cpp
View file

@ -81,9 +81,8 @@ class normalize_bounds_tactic : public tactic {
void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
mc = 0; core = 0;
core = 0;
bool produce_models = in->models_enabled();
bool produce_proofs = in->proofs_enabled();
tactic_report report("normalize-bounds", *in);
@ -99,16 +98,13 @@ class normalize_bounds_tactic : public tactic {
generic_model_converter * gmc = 0;
if (produce_models) {
gmc = alloc(generic_model_converter, m);
mc = gmc;
in->add(gmc);
}
unsigned num_norm_bounds = 0;
expr_substitution subst(m);
rational val;
bound_manager::iterator it = m_bm.begin();
bound_manager::iterator end = m_bm.end();
for (; it != end; ++it) {
expr * x = *it;
for (expr * x : m_bm) {
if (is_target(x, val)) {
num_norm_bounds++;
sort * s = m.get_sort(x);
@ -171,10 +167,9 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
catch (rewriter_exception & ex) {
throw tactic_exception(ex.msg());

63
src/tactic/arith/pb2bv_model_converter.cpp
View file

@ -27,17 +27,12 @@ pb2bv_model_converter::pb2bv_model_converter(ast_manager & _m) : m(_m) {
pb2bv_model_converter::pb2bv_model_converter(ast_manager & _m, obj_map<func_decl, expr*> const & c2bit, bound_manager const & bm):
m(_m) {
obj_map<func_decl, expr*>::iterator it = c2bit.begin();
obj_map<func_decl, expr*>::iterator end = c2bit.end();
for ( ; it != end; it++) {
m_c2bit.push_back(func_decl_pair(it->m_key, to_app(it->m_value)->get_decl()));
m.inc_ref(it->m_key);
m.inc_ref(to_app(it->m_value)->get_decl());
for (auto const& kv : c2bit) {
m_c2bit.push_back(func_decl_pair(kv.m_key, to_app(kv.m_value)->get_decl()));
m.inc_ref(kv.m_key);
m.inc_ref(to_app(kv.m_value)->get_decl());
}
bound_manager::iterator it2 = bm.begin();
bound_manager::iterator end2 = bm.end();
for (; it2 != end2; ++it2) {
expr * c = *it2;
for (expr* c : bm) {
SASSERT(is_uninterp_const(c));
func_decl * d = to_app(c)->get_decl();
if (!c2bit.contains(d)) {
@ -49,53 +44,43 @@ pb2bv_model_converter::pb2bv_model_converter(ast_manager & _m, obj_map<func_decl
}
pb2bv_model_converter::~pb2bv_model_converter() {
svector<func_decl_pair>::const_iterator it = m_c2bit.begin();
svector<func_decl_pair>::const_iterator end = m_c2bit.end();
for (; it != end; ++it) {
m.dec_ref(it->first);
m.dec_ref(it->second);
for (auto const& kv : m_c2bit) {
m.dec_ref(kv.first);
m.dec_ref(kv.second);
}
}
void pb2bv_model_converter::operator()(model_ref & md) {
(*this)(md, 0);
}
void pb2bv_model_converter::operator()(model_ref & md, unsigned goal_idx) {
SASSERT(goal_idx == 0);
void pb2bv_model_converter::operator()(model_ref & md) {
TRACE("pb2bv", tout << "converting model:\n"; model_v2_pp(tout, *md); display(tout););
arith_util a_util(m);
svector<func_decl_pair>::const_iterator it = m_c2bit.begin();
svector<func_decl_pair>::const_iterator end = m_c2bit.end();
for (; it != end; ++it) {
if (it->second) {
expr * val = md->get_const_interp(it->second);
for (auto const& kv : m_c2bit) {
if (kv.second) {
expr * val = md->get_const_interp(kv.second);
if (val == 0 || m.is_false(val)) {
/* false's and don't cares get the integer 0 solution*/
md->register_decl(it->first, a_util.mk_numeral(rational(0), true));
md->register_decl(kv.first, a_util.mk_numeral(rational(0), true));
}
else {
md->register_decl(it->first, a_util.mk_numeral(rational(1), true));
md->register_decl(kv.first, a_util.mk_numeral(rational(1), true));
}
}
else {
// it->first is a don't care.
md->register_decl(it->first, a_util.mk_numeral(rational(0), true));
// kv.first is a don't care.
md->register_decl(kv.first, a_util.mk_numeral(rational(0), true));
}
}
}
void pb2bv_model_converter::display(std::ostream & out) {
out << "(pb2bv-model-converter";
svector<func_decl_pair>::const_iterator it = m_c2bit.begin();
svector<func_decl_pair>::const_iterator end = m_c2bit.end();
for (; it != end; ++it) {
out << "\n (" << it->first->get_name() << " ";
if (it->second == 0)
for (auto const& kv : m_c2bit) {
out << "\n (" << kv.first->get_name() << " ";
if (kv.second == 0)
out << "0";
else
out << it->second->get_name();
out << kv.second->get_name();
out << ")";
}
out << ")\n";
@ -104,11 +89,9 @@ void pb2bv_model_converter::display(std::ostream & out) {
model_converter * pb2bv_model_converter::translate(ast_translation & translator) {
ast_manager & to = translator.to();
pb2bv_model_converter * res = alloc(pb2bv_model_converter, to);
svector<func_decl_pair>::iterator it = m_c2bit.begin();
svector<func_decl_pair>::iterator end = m_c2bit.end();
for (; it != end; it++) {
func_decl * f1 = translator(it->first);
func_decl * f2 = translator(it->second);
for (auto const& kv : m_c2bit) {
func_decl * f1 = translator(kv.first);
func_decl * f2 = translator(kv.second);
res->m_c2bit.push_back(func_decl_pair(f1, f2));
to.inc_ref(f1);
to.inc_ref(f2);

7
src/tactic/arith/pb2bv_model_converter.h
View file

@ -31,10 +31,9 @@ public:
pb2bv_model_converter(ast_manager & _m);
pb2bv_model_converter(ast_manager & _m, obj_map<func_decl, expr*> const & c2bit, bound_manager const & bm);
virtual ~pb2bv_model_converter();
virtual void operator()(model_ref & md);
virtual void operator()(model_ref & md, unsigned goal_idx);
virtual void display(std::ostream & out);
virtual model_converter * translate(ast_translation & translator);
void operator()(model_ref & md) override;
void display(std::ostream & out) override;
model_converter * translate(ast_translation & translator) override;
};
#endif

10
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -887,14 +887,13 @@ private:
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
TRACE("pb2bv", g->display(tout););
SASSERT(g->is_well_sorted());
fail_if_proof_generation("pb2bv", g);
m_produce_models = g->models_enabled();
m_produce_unsat_cores = g->unsat_core_enabled();
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("pb2bv", *g);
m_bm.reset(); m_rw.reset(); m_new_deps.reset();
@ -948,6 +947,7 @@ private:
g->update(idx, new_exprs[idx].get(), 0, (m_produce_unsat_cores) ? new_deps[idx].get() : g->dep(idx));
if (m_produce_models) {
model_converter_ref mc;
generic_model_converter * mc1 = alloc(generic_model_converter, m);
for (auto const& kv : m_const2bit)
mc1->hide(kv.m_value);
@ -956,7 +956,8 @@ private:
for (unsigned i = 0; i < num_temps; i++)
mc1->hide(m_temporary_ints.get(i));
pb2bv_model_converter * mc2 = alloc(pb2bv_model_converter, m, m_const2bit, m_bm);
mc = concat(mc1, mc2);
mc = concat(mc1, mc2);
g->add(mc.get());
}
g->inc_depth();
@ -999,9 +1000,8 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_imp)(in, result, mc, core);
(*m_imp)(in, result, core);
}
virtual void cleanup() {

5
src/tactic/arith/propagate_ineqs_tactic.cpp
View file

@ -52,7 +52,7 @@ public:
virtual void updt_params(params_ref const & p);
virtual void collect_param_descrs(param_descrs & r) {}
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, expr_dependency_ref & core);
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, expr_dependency_ref & core);
virtual void cleanup();
};
@ -528,12 +528,11 @@ void propagate_ineqs_tactic::updt_params(params_ref const & p) {
void propagate_ineqs_tactic::operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("propagate-ineqs", g);
fail_if_unsat_core_generation("propagate-ineqs", g);
mc = 0; core = 0; result.reset();
core = 0; result.reset();
goal_ref r;
(*m_imp)(g.get(), r);
result.push_back(r.get());

9
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -822,11 +822,10 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("purify-arith", *g);
TRACE("purify_arith", g->display(tout););
bool produce_proofs = g->proofs_enabled();
@ -834,10 +833,10 @@ public:
bool elim_root_objs = m_params.get_bool("elim_root_objects", true);
bool elim_inverses = m_params.get_bool("elim_inverses", true);
bool complete = m_params.get_bool("complete", true);
purify_arith_proc proc(*(g.get()), m_util, produce_proofs, elim_root_objs, elim_inverses, complete);
purify_arith_proc proc(*(g.get()), m_util, produce_proofs, elim_root_objs, elim_inverses, complete);
model_converter_ref mc;
proc(mc, produce_models);
g->add(mc.get());
g->inc_depth();
result.push_back(g.get());
TRACE("purify_arith", g->display(tout););

25
src/tactic/arith/recover_01_tactic.cpp
View file

@ -293,13 +293,12 @@ class recover_01_tactic : public tactic {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("recover-01", g);
fail_if_unsat_core_generation("recover-01", g);
m_produce_models = g->models_enabled();
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("recover-01", *g);
bool saved = false;
@ -307,7 +306,9 @@ class recover_01_tactic : public tactic {
SASSERT(new_goal->depth() == g->depth());
SASSERT(new_goal->prec() == g->prec());
new_goal->inc_depth();
new_goal->add(g->mc());
new_goal->add(g->pc());
unsigned sz = g->size();
for (unsigned i = 0; i < sz; i++) {
expr * f = g->form(i);
@ -326,7 +327,7 @@ class recover_01_tactic : public tactic {
if (m_produce_models) {
gmc = alloc(generic_model_converter, m);
mc = gmc;
new_goal->add(gmc);
}
dec_ref_key_values(m, bool2int);
@ -335,25 +336,20 @@ class recover_01_tactic : public tactic {
bool recovered = false;
expr_substitution _subst(m);
subst = &_subst;
var2clauses::iterator it = m_var2clauses.begin();
var2clauses::iterator end = m_var2clauses.end();
for (; it != end; ++it) {
if (process(it->m_key, it->m_value)) {
for (auto& kv : m_var2clauses) {
if (process(kv.m_key, kv.m_value)) {
recovered = true;
counter++;
}
else {
ptr_vector<app>::iterator it2 = it->m_value.begin();
ptr_vector<app>::iterator end2 = it->m_value.end();
for (; it2 != end2; ++it2) {
new_goal->assert_expr(*it2);
for (app* a : kv.m_value) {
new_goal->assert_expr(a);
}
}
}
if (!recovered) {
result.push_back(g.get());
mc = 0;
return;
}
@ -406,10 +402,9 @@ public:
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(g, result, mc, core);
(*m_imp)(g, result, core);
}
catch (rewriter_exception & ex) {
throw tactic_exception(ex.msg());