mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-07-25 05:37:00 +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

100
src/tactic/proof_converter.cpp
View file

@ -17,6 +17,7 @@ Notes:
--*/
#include "tactic/proof_converter.h"
#include "tactic/goal.h"
#include "ast/ast_smt2_pp.h"
class concat_proof_converter : public concat_converter<proof_converter> {
@ -25,14 +26,14 @@ public:
virtual char const * get_name() const { return "concat-proof-converter"; }
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 {
proof_ref tmp(m);
this->m_c2->operator()(m, num_source, source, tmp);
tmp = this->m_c2->operator()(m, num_source, source);
proof * new_source = tmp.get();
this->m_c1->operator()(m, 1, &new_source, result);
return this->m_c1->operator()(m, 1, &new_source);
}
virtual proof_converter * translate(ast_translation & translator) {
proof_converter * translate(ast_translation & translator) override {
return this->translate_core<concat_proof_converter>(translator);
}
};
@ -45,66 +46,39 @@ proof_converter * concat(proof_converter * pc1, proof_converter * pc2) {
return alloc(concat_proof_converter, pc1, pc2);
}
class concat_star_proof_converter : public concat_star_converter<proof_converter> {
class subgoal_proof_converter : public proof_converter {
proof_converter_ref m_pc;
goal_ref_buffer m_goals;
public:
concat_star_proof_converter(proof_converter * pc1, unsigned num, proof_converter * const * pc2s, unsigned * szs):
concat_star_converter<proof_converter>(pc1, num, pc2s, szs) {
subgoal_proof_converter(proof_converter* pc, unsigned n, goal * const* goals):
m_pc(pc)
{
for (unsigned i = 0; i < n; ++i) m_goals.push_back(goals[i]);
}
virtual char const * get_name() const { return "concat-star-proof-converter"; }
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
unsigned num = this->m_szs.size();
#ifdef Z3DEBUG
unsigned sum = 0;
for (unsigned i = 0; i < num; i++) {
sum += this->m_szs[i];
}
SASSERT(sum == num_source);
#endif
proof_ref_buffer tmp_prs(m);
for (unsigned i = 0; i < num; i++) {
unsigned sz = m_szs[i];
proof_converter * c2 = m_c2s[i];
proof_ref pr(m);
if (c2) {
(*c2)(m, sz, source, pr);
}
else {
SASSERT(sz == 1);
pr = *source;
}
source += sz;
tmp_prs.push_back(pr.get());
}
if (m_c1) {
(*m_c1)(m, tmp_prs.size(), tmp_prs.c_ptr(), result);
}
else {
SASSERT(tmp_prs.size() == 1);
result = tmp_prs[0];
proof_ref operator()(ast_manager & m, unsigned num_source, proof * const * source) override {
// ignore the proofs from the arguments, instead obtain the proofs fromt he subgoals.
SASSERT(num_source == 0);
proof_converter_ref_buffer pc_buffer;
for (goal_ref g : m_goals) {
pc_buffer.push_back(g->pc());
}
return apply(m, m_pc, pc_buffer);
}
virtual proof_converter * translate(ast_translation & translator) {
return this->translate_core<concat_star_proof_converter>(translator);
proof_converter* translate(ast_translation& tr) override {
proof_converter_ref pc1 = m_pc->translate(tr);
goal_ref_buffer goals;
for (goal_ref g : m_goals) goals.push_back(g->translate(tr));
return alloc(subgoal_proof_converter, pc1.get(), goals.size(), goals.c_ptr());
}
void display(std::ostream& out) override {}
};
proof_converter * concat(proof_converter * pc1, unsigned num, proof_converter * const * pc2s, unsigned * szs) {
SASSERT(num > 0);
if (num == 1)
return concat(pc1, pc2s[0]);
unsigned i;
for (i = 0; i < num; i++) {
if (pc2s[i] != 0)
break;
}
if (i == num) {
// all pc2s are 0
return pc1;
}
return alloc(concat_star_proof_converter, pc1, num, pc2s, szs);
proof_converter * concat(proof_converter *pc, unsigned n, goal* const* goals) {
return alloc(subgoal_proof_converter, pc, n, goals);
}
class proof2pc : public proof_converter {
@ -113,16 +87,16 @@ public:
proof2pc(ast_manager & m, proof * pr):m_pr(pr, m) {}
virtual ~proof2pc() {}
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 {
SASSERT(num_source == 0);
result = m_pr;
return m_pr;
}
virtual proof_converter * translate(ast_translation & translator) {
proof_converter * translate(ast_translation & translator) override {
return alloc(proof2pc, translator.to(), translator(m_pr.get()));
}
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(proof->proof-converter-wrapper\n" << mk_ismt2_pp(m_pr.get(), m_pr.get_manager()) << ")\n";
}
};
@ -136,7 +110,7 @@ proof_converter * proof2proof_converter(ast_manager & m, proof * pr) {
void apply(ast_manager & m, proof_converter * pc, proof_ref & pr) {
if (pc) {
proof * _pr = pr.get();
(*pc)(m, 1, &_pr, pr);
pr = (*pc)(m, 1, &_pr);
}
}
@ -148,15 +122,15 @@ void apply(ast_manager & m, proof_converter * pc, proof_ref & pr) {
pc1 and pc2s must be different from 0.
*/
void apply(ast_manager & m, proof_converter_ref & pc1, proof_converter_ref_buffer & pc2s, proof_ref & result) {
proof_ref apply(ast_manager & m, proof_converter_ref & pc1, proof_converter_ref_buffer & pc2s) {
SASSERT(pc1);
proof_ref_buffer prs(m);
unsigned sz = pc2s.size();
for (unsigned i = 0; i < sz; i++) {
proof_ref pr(m);
SASSERT(pc2s[i]); // proof production is enabled
pc2s[i]->operator()(m, 0, 0, pr);
pr = pc2s[i]->operator()(m, 0, 0);
prs.push_back(pr);
}
(*pc1)(m, sz, prs.c_ptr(), result);
return (*pc1)(m, sz, prs.c_ptr());
}