mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-29 03:45:51 +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/core/blast_term_ite_tactic.cpp
View file

@ -115,10 +115,9 @@ class blast_term_ite_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("blast-term-ite", *g);
bool produce_proofs = g->proofs_enabled();
@ -172,9 +171,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() {

3
src/tactic/core/cofactor_term_ite_tactic.cpp
View file

@ -56,13 +56,12 @@ 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("cofactor-term-ite", g);
fail_if_unsat_core_generation("cofactor-term-ite", g);
tactic_report report("cofactor-term-ite", *g);
mc = 0; core = 0;
core = 0;
process(*(g.get()));
g->inc_depth();
result.push_back(g.get());

8
src/tactic/core/collect_statistics_tactic.cpp
View file

@ -64,9 +64,7 @@ public:
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) {
mc = 0;
tactic_report report("collect-statistics", *g);
collect_proc cp(m, m_stats);
@ -76,10 +74,8 @@ public:
for_each_expr(cp, visited, g->form(i));
std::cout << "(" << std::endl;
stats_type::iterator it = m_stats.begin();
stats_type::iterator end = m_stats.end();
for (; it != end; it++)
std::cout << " :" << it->first << " " << it->second << std::endl;
for (auto const& kv : m_stats)
std::cout << " :" << kv.first << " " << kv.second << std::endl;
std::cout << ")" << std::endl;
g->inc_depth();

3
src/tactic/core/ctx_simplify_tactic.cpp
View file

@ -622,9 +622,8 @@ void ctx_simplify_tactic::get_param_descrs(param_descrs & r) {
void ctx_simplify_tactic::operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
mc = 0; core = 0;
core = 0;
(*m_imp)(*(in.get()));
in->inc_depth();
result.push_back(in.get());

1
src/tactic/core/ctx_simplify_tactic.h
View file

@ -56,7 +56,6 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core);
virtual void cleanup();

3
src/tactic/core/der_tactic.cpp
View file

@ -75,9 +75,8 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
mc = 0; core = 0;
core = 0;
(*m_imp)(*(in.get()));
in->inc_depth();
result.push_back(in.get());

3
src/tactic/core/distribute_forall_tactic.cpp
View file

@ -101,14 +101,13 @@ 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());
ast_manager & m = g->m();
bool produce_proofs = g->proofs_enabled();
rw r(m, produce_proofs);
m_rw = &r;
mc = 0; core = 0; result.reset();
core = 0; result.reset();
tactic_report report("distribute-forall", *g);
expr_ref new_curr(m);

3
src/tactic/core/dom_simplify_tactic.cpp
View file

@ -186,9 +186,8 @@ tactic * dom_simplify_tactic::translate(ast_manager & m) {
void dom_simplify_tactic::operator()(
goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
mc = 0; core = 0;
core = 0;
tactic_report report("dom-simplify", *in.get());
simplify_goal(*(in.get()));

1
src/tactic/core/dom_simplify_tactic.h
View file

@ -139,7 +139,6 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core);
virtual void cleanup();

8
src/tactic/core/elim_term_ite_tactic.cpp
View file

@ -101,10 +101,9 @@ class elim_term_ite_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("elim-term-ite", *g);
bool produce_proofs = g->proofs_enabled();
m_rw.cfg().m_produce_models = g->models_enabled();
@ -123,7 +122,7 @@ class elim_term_ite_tactic : public tactic {
}
g->update(idx, new_curr, new_pr, g->dep(idx));
}
mc = m_rw.m_cfg.m_mc.get();
g->add(m_rw.m_cfg.m_mc.get());
report_tactic_progress(":elim-term-ite-consts", m_rw.m_cfg.m_num_fresh);
g->inc_depth();
result.push_back(g.get());
@ -162,9 +161,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() {

18
src/tactic/core/elim_uncnstr_tactic.cpp
View file

@ -816,10 +816,9 @@ class elim_uncnstr_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;
goal_ref_buffer & result,
expr_dependency_ref & core) {
core = 0;
bool produce_models = g->models_enabled();
bool produce_proofs = g->proofs_enabled();
@ -864,8 +863,7 @@ class elim_uncnstr_tactic : public tactic {
g->update(idx, new_f, new_pr, g->dep(idx));
}
if (!modified) {
if (round == 0) {
mc = 0;
if (round == 0) {
}
else {
app_ref_vector & fresh_vars = m_rw->cfg().m_fresh_vars;
@ -874,15 +872,14 @@ class elim_uncnstr_tactic : public tactic {
generic_model_converter * fmc = alloc(generic_model_converter, m());
for (app * f : fresh_vars)
fmc->hide(f);
mc = concat(fmc, m_mc.get());
g->add(concat(fmc, m_mc.get()));
}
else {
mc = 0;
g->set((model_converter*)nullptr);
}
}
m_mc = 0;
m_rw = 0;
TRACE("elim_uncnstr", if (mc) mc->display(tout););
result.push_back(g.get());
g->inc_depth();
return;
@ -933,9 +930,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);
report_tactic_progress(":num-elim-apps", get_num_elim_apps());
}

6
src/tactic/core/injectivity_tactic.cpp
View file

@ -145,10 +145,9 @@ class injectivity_tactic : public tactic {
void operator()(goal_ref const & goal,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
SASSERT(goal->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("injectivity", *goal);
fail_if_unsat_core_generation("injectivity", goal); // TODO: Support UNSAT cores
fail_if_proof_generation("injectivity", goal);
@ -271,9 +270,8 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
(*m_finder)(g, result, mc, core);
(*m_finder)(g, result, core);
for (unsigned i = 0; i < g->size(); ++i) {
expr* curr = g->form(i);

5
src/tactic/core/nnf_tactic.cpp
View file

@ -55,11 +55,10 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
TRACE("nnf", tout << "params: " << m_params << "\n"; g->display(tout););
SASSERT(g->is_well_sorted());
mc = 0; core = 0;
core = 0;
tactic_report report("nnf", *g);
bool produce_proofs = g->proofs_enabled();
@ -97,7 +96,7 @@ public:
unsigned num_extra_names = dnames.get_num_names();
if (num_extra_names > 0) {
generic_model_converter * fmc = alloc(generic_model_converter, m);
mc = fmc;
g->add(fmc);
for (unsigned i = 0; i < num_extra_names; i++)
fmc->hide(dnames.get_name_decl(i));
}

8
src/tactic/core/occf_tactic.cpp
View file

@ -129,10 +129,9 @@ class occf_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;
fail_if_proof_generation("occf", g);
@ -157,7 +156,7 @@ class occf_tactic : public tactic {
continue;
if (produce_models && !m_mc) {
m_mc = alloc(generic_model_converter, m);
mc = m_mc;
g->add(m_mc);
}
expr * keep = 0;
new_lits.reset();
@ -211,9 +210,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() {

6
src/tactic/core/pb_preprocess_tactic.cpp
View file

@ -48,8 +48,7 @@ class pb_preproc_model_converter : public model_converter {
public:
pb_preproc_model_converter(ast_manager& m):m(m), pb(m), m_refs(m) {}
virtual void operator()(model_ref & mdl, unsigned goal_idx) {
SASSERT(goal_idx == 0);
virtual void operator()(model_ref & mdl) {
for (auto const& kv : m_const) {
mdl->register_decl(kv.first->get_decl(), kv.second);
}
@ -151,7 +150,6 @@ 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());
core = 0;
@ -161,7 +159,7 @@ public:
}
pb_preproc_model_converter* pp = alloc(pb_preproc_model_converter, m);
mc = pp;
g->add(pp);
g->inc_depth();
result.push_back(g.get());

6
src/tactic/core/propagate_values_tactic.cpp
View file

@ -137,10 +137,9 @@ class propagate_values_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("propagate-values", *g);
m_goal = g.get();
@ -241,10 +240,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());

13
src/tactic/core/reduce_args_tactic.cpp
View file

@ -73,7 +73,7 @@ public:
virtual ~reduce_args_tactic();
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();
};
@ -439,7 +439,7 @@ struct reduce_args_tactic::imp {
return f_mc;
}
void operator()(goal & g, model_converter_ref & mc) {
void operator()(goal & g) {
if (g.inconsistent())
return;
TRACE("reduce_args", g.display(tout););
@ -468,9 +468,9 @@ struct reduce_args_tactic::imp {
report_tactic_progress(":reduced-funcs", decl2args.size());
if (g.models_enabled())
mc = mk_mc(decl2args, ctx.m_decl2arg2funcs);
g.add(mk_mc(decl2args, ctx.m_decl2arg2funcs));
TRACE("reduce_args", g.display(tout); if (mc) mc->display(tout););
TRACE("reduce_args", g.display(tout); if (g.mc()) g.mc()->display(tout););
}
};
@ -484,13 +484,12 @@ reduce_args_tactic::~reduce_args_tactic() {
void reduce_args_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("reduce-args", g);
fail_if_unsat_core_generation("reduce-args", g);
mc = 0; core = 0; result.reset();
m_imp->operator()(*(g.get()), mc);
core = 0; result.reset();
m_imp->operator()(*(g.get()));
g->inc_depth();
result.push_back(g.get());
SASSERT(g->is_well_sorted());

3
src/tactic/core/simplify_tactic.cpp
View file

@ -94,13 +94,12 @@ void simplify_tactic::get_param_descrs(param_descrs & r) {
void simplify_tactic::operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
try {
(*m_imp)(*(in.get()));
in->inc_depth();
result.push_back(in.get());
mc = 0; core = 0;
core = 0;
}
catch (rewriter_exception & ex) {
throw tactic_exception(ex.msg());

1
src/tactic/core/simplify_tactic.h
View file

@ -36,7 +36,6 @@ public:
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core);
virtual void cleanup();

9
src/tactic/core/solve_eqs_tactic.cpp
View file

@ -668,10 +668,10 @@ class solve_eqs_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;
model_converter_ref mc;
tactic_report report("solve_eqs", *g);
m_produce_models = g->models_enabled();
m_produce_proofs = g->proofs_enabled();
@ -691,7 +691,6 @@ class solve_eqs_tactic : public tactic {
normalize();
substitute(*(g.get()));
if (g->inconsistent()) {
mc = 0;
break;
}
save_elim_vars(mc);
@ -699,6 +698,7 @@ class solve_eqs_tactic : public tactic {
}
}
g->inc_depth();
g->add(mc.get());
result.push_back(g.get());
TRACE("solve_eqs", g->display(tout););
SASSERT(g->is_well_sorted());
@ -734,9 +734,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);
report_tactic_progress(":num-elim-vars", m_imp->get_num_eliminated_vars());
}

52
src/tactic/core/split_clause_tactic.cpp
View file

@ -46,21 +46,16 @@ class split_clause_tactic : public tactic {
}
class split_pc : public proof_converter {
ast_manager & m_manager;
app * m_clause;
proof * m_clause_pr;
ast_manager & m;
app_ref m_clause;
proof_ref m_clause_pr;
public:
split_pc(ast_manager & m, app * cls, proof * pr):m_manager(m), m_clause(cls), m_clause_pr(pr) {
m.inc_ref(cls);
m.inc_ref(pr);
split_pc(ast_manager & m, app * cls, proof * pr):m(m), m_clause(cls, m), m_clause_pr(pr, m) {
}
~split_pc() {
m_manager.dec_ref(m_clause);
m_manager.dec_ref(m_clause_pr);
}
virtual ~split_pc() { }
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
proof_ref operator()(ast_manager & m, unsigned num_source, proof * const * source) override {
// Let m_clause be of the form (l_0 or ... or l_{num_source - 1})
// Each source[i] proof is a proof for "false" using l_i as a hypothesis
// So, I use lemma for producing a proof for (not l_i) that does not contain the hypothesis,
@ -73,14 +68,14 @@ class split_clause_tactic : public tactic {
expr * not_li = m.mk_not(m_clause->get_arg(i));
prs.push_back(m.mk_lemma(pr_i, not_li));
}
result = m.mk_unit_resolution(prs.size(), prs.c_ptr());
return proof_ref(m.mk_unit_resolution(prs.size(), prs.c_ptr()), m);
}
virtual proof_converter * translate(ast_translation & translator) {
return alloc(split_pc, translator.to(), translator(m_clause), translator(m_clause_pr));
proof_converter * translate(ast_translation & translator) override {
return alloc(split_pc, translator.to(), translator(m_clause.get()), translator(m_clause_pr.get()));
}
virtual void display(std::ostream & out) { out << "(split-clause-pc)\n"; }
void display(std::ostream & out) override { out << "(split-clause-pc)\n"; }
};
public:
@ -97,22 +92,21 @@ public:
virtual ~split_clause_tactic() {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_largest_clause = p.get_bool("split_largest_clause", false);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("split_largest_clause", CPK_BOOL, "(default: false) split the largest clause in the goal.");
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
void operator()(goal_ref const & in,
goal_ref_buffer & result,
expr_dependency_ref & core) override {
SASSERT(in->is_well_sorted());
tactic_report report("split-clause", *in);
TRACE("before_split_clause", in->display(tout););
mc = 0; core = 0;
core = 0;
ast_manager & m = in->m();
unsigned cls_pos = select_clause(m, in);
if (cls_pos == UINT_MAX) {
@ -123,15 +117,10 @@ public:
expr_dependency * cls_dep = in->dep(cls_pos);
if (produce_proofs)
in->set(alloc(split_pc, m, cls, in->pr(cls_pos)));
unsigned cls_sz = cls->get_num_args();
report_tactic_progress(":num-new-branches", cls_sz);
for (unsigned i = 0; i < cls_sz; i++) {
goal * subgoal_i;
if (i == cls_sz - 1)
subgoal_i = in.get();
else
subgoal_i = alloc(goal, *in);
expr * lit_i = cls->get_arg(i);
report_tactic_progress(":num-new-branches", cls->get_num_args());
for (expr* lit_i : *cls) {
goal * subgoal_i = alloc(goal, *in);
subgoal_i->set(in->mc());
proof * pr_i = 0;
if (produce_proofs)
pr_i = m.mk_hypothesis(lit_i);
@ -139,6 +128,7 @@ public:
subgoal_i->inc_depth();
result.push_back(subgoal_i);
}
in->set(concat(in->pc(), result.size(), result.c_ptr()));
}
virtual void cleanup() {

4
src/tactic/core/symmetry_reduce_tactic.cpp
View file

@ -40,7 +40,6 @@ public:
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core);
virtual void cleanup();
};
@ -635,11 +634,10 @@ symmetry_reduce_tactic::~symmetry_reduce_tactic() {
void symmetry_reduce_tactic::operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
expr_dependency_ref & core) {
fail_if_proof_generation("symmetry_reduce", g);
fail_if_unsat_core_generation("symmetry_reduce", g);
mc = 0; core = 0; result.reset();
core = 0; result.reset();
(*m_imp)(*(g.get()));
g->inc_depth();
result.push_back(g.get());

10
src/tactic/core/tseitin_cnf_tactic.cpp
View file

@ -800,10 +800,9 @@ class tseitin_cnf_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("tseitin-cnf", *g);
fail_if_proof_generation("tseitin-cnf", g);
m_produce_models = g->models_enabled();
@ -842,9 +841,7 @@ class tseitin_cnf_tactic : public tactic {
g->assert_expr(cls);
}
if (m_produce_models && !m_fresh_vars.empty())
mc = m_mc.get();
else
mc = 0;
g->add(m_mc.get());
g->inc_depth();
result.push_back(g.get());
TRACE("tseitin_cnf", g->display(tout););
@ -884,9 +881,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);
report_tactic_progress(":cnf-aux-vars", m_imp->m_num_aux_vars);
}