cave in to supporting proofs (partially) in simplifiers, updated doc

Z3Prover · Dec 7, 2022 · 80033e8 · 80033e8
1 parent aaabbfb
commit 80033e8
Show file tree

Hide file tree

Showing 36 changed files with 157 additions and 108 deletions.
diff --git a/doc/mk_tactic_doc.py b/doc/mk_tactic_doc.py
@@ -21,16 +21,14 @@ def doc_path(path):
 
 def extract_params(ous, tac):
     z3_exe = BUILD_DIR + "/z3"
-    out = subprocess.Popen([z3_exe, f"-tactics:{tac}"], stdout=subprocess.PIPE).communicate()[0]
+    out = subprocess.Popen([z3_exe, f"-tacticsmd:{tac}"], stdout=subprocess.PIPE).communicate()[0]
     if not out:
         return
     out = out.decode(sys.stdout.encoding)
-    ous.write("#### Parameters\n")
-    ous.write("```\n")
+    ous.write("### Parameters\n\n")
     for line in out:
         ous.write(line.replace("\r",""))
     ous.write("\n")
-    ous.write("```\n")
 
 def generate_tactic_doc(ous, f, ins):
     tac_name = None

diff --git a/src/ast/simplifiers/bit2int.h b/src/ast/simplifiers/bit2int.h
@@ -35,8 +35,10 @@ class bit2int_simplifier : public dependent_expr_simplifier {
         for (unsigned idx : indices()) {
             auto const& d = m_fmls[idx];
             m_rewriter(d.fml(), r, pr);
-            m_fmls.update(idx, dependent_expr(m, r, d.dep()));
+            m_fmls.update(idx, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
         }
     }
+
+    bool supports_proofs() const override { return true; }
 };
 
diff --git a/src/ast/simplifiers/bit_blaster.cpp b/src/ast/simplifiers/bit_blaster.cpp
@@ -38,13 +38,13 @@ void bit_blaster::reduce() {
     proof_ref  new_pr(m);
     bool change = false;
     for (unsigned idx : indices()) {
-        auto [curr, d] = m_fmls[idx]();
+        auto [curr, p, d] = m_fmls[idx]();
         m_rewriter(curr, new_curr, new_pr);        
         if (curr != new_curr) {
             m_num_steps += m_rewriter.get_num_steps();
             change = true;                    
             TRACE("bit_blaster", tout << mk_pp(curr, m) << " -> " << new_curr << "\n";);
-            m_fmls.update(idx, dependent_expr(m, new_curr, d));
+            m_fmls.update(idx, dependent_expr(m, new_curr, mp(p, new_pr), d));
         }
     }
 

diff --git a/src/ast/simplifiers/bv_elim.h b/src/ast/simplifiers/bv_elim.h
@@ -36,7 +36,7 @@ class elim_simplifier : public dependent_expr_simplifier {
             if (!has_quantifiers(d.fml()))
                 continue;
             m_rewriter(d.fml(), r);
-            m_fmls.update(idx, dependent_expr(m, r, d.dep()));
+            m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
         }
     }
 };

diff --git a/src/ast/simplifiers/bv_slice.cpp b/src/ast/simplifiers/bv_slice.cpp
@@ -28,7 +28,7 @@ namespace bv {
 
     void slice::process_eqs() {
         for (unsigned i : indices()) {
-            auto const [f, d] = m_fmls[i]();
+            auto const [f, p, d] = m_fmls[i]();
             process_eq(f);
         }  
     }
@@ -137,7 +137,7 @@ namespace bv {
         ptr_vector<expr> todo, args;
         expr* c;
         for (unsigned i : indices()) {
-            auto const [f, d] = m_fmls[i]();
+            auto const [f, p, d] = m_fmls[i]();
             todo.push_back(f);
             pin.push_back(f);
             while (!todo.empty()) {
@@ -191,7 +191,7 @@ namespace bv {
             }
             c = cache.get(f->get_id());
             if (c != f)                 
-                m_fmls.update(i, dependent_expr(m, c, d));            
+                m_fmls.update(i, dependent_expr(m, c, nullptr, d));            
         }
     }
 

diff --git a/src/ast/simplifiers/card2bv.cpp b/src/ast/simplifiers/card2bv.cpp
@@ -30,20 +30,20 @@ void card2bv::reduce() {
     expr_ref new_f1(m), new_f2(m);
     proof_ref new_pr(m);
     for (unsigned idx : indices()) {
-        auto [f, d] = m_fmls[idx]();
+        auto [f, p, d] = m_fmls[idx]();
         rw1(f, new_f1);        
         rw2(false, new_f1, new_f2, new_pr);        
         if (new_f2 != f) {
             TRACE("card2bv", tout << "Rewriting " << new_f1 << "\n" << new_f2 << "\n");
-            m_fmls.update(idx, dependent_expr(m, new_f2, d));
+            m_fmls.update(idx, dependent_expr(m, new_f2, mp(p, new_pr), d));
             ++m_stats.m_num_rewrites;
         }
     }
 
     expr_ref_vector fmls(m);
     rw2.flush_side_constraints(fmls);
     for (expr* e : fmls)
-        m_fmls.add(dependent_expr(m, e, nullptr));
+        m_fmls.add(dependent_expr(m, e, nullptr, nullptr));
 
     func_decl_ref_vector const& fns = rw2.fresh_constants();
     for (func_decl* f : fns)

diff --git a/src/ast/simplifiers/cnf_nnf.h b/src/ast/simplifiers/cnf_nnf.h
@@ -48,12 +48,13 @@ class cnf_nnf_simplifier : public dependent_expr_simplifier {
             push_todo.reset();
             push_todo_prs.reset();
             apply_nnf(d.fml(), push_todo, push_todo_prs, r, pr);
-            m_fmls.update(i, dependent_expr(m, r, d.dep()));
+            m_fmls.update(i, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
             for (expr* f : push_todo) {
                 if (!m.inc())
                     break;
                 m_rewriter(f, r, pr);
-                m_fmls.add(dependent_expr(m, r, d.dep()));
+                if (f != r)
+                    m_fmls.add(dependent_expr(m, r, pr, d.dep()));
             }
         }
     }

diff --git a/src/ast/simplifiers/demodulator_simplifier.cpp b/src/ast/simplifiers/demodulator_simplifier.cpp
@@ -108,7 +108,7 @@ void demodulator_simplifier::rewrite(unsigned i) {
     expr_dependency_ref d(dep(i), m);
     for (unsigned j : m_dependencies)
         d = m.mk_join(d, dep(j));
-    m_fmls.update(i, dependent_expr(m, r, d));
+    m_fmls.update(i, dependent_expr(m, r, nullptr, d));
 }
 
 bool demodulator_simplifier::rewrite1(func_decl* f, expr_ref_vector const& args, expr_ref& np) {

diff --git a/src/ast/simplifiers/dependent_expr.h b/src/ast/simplifiers/dependent_expr.h
@@ -24,21 +24,26 @@ Module Name:
 class dependent_expr {
     ast_manager& m;
     expr*            m_fml;
+    proof*           m_proof;
     expr_dependency* m_dep;
 public:
-    dependent_expr(ast_manager& m, expr* fml, expr_dependency* d):
+    dependent_expr(ast_manager& m, expr* fml, proof* p, expr_dependency* d):
         m(m),
         m_fml(fml),
+        m_proof(p),
         m_dep(d) {
         SASSERT(fml);
         m.inc_ref(fml);
         m.inc_ref(d);
+        m.inc_ref(p);
     }
 
     dependent_expr(ast_translation& tr, dependent_expr const& src) :
         m(tr.to()) {
         m_fml = tr(src.fml());
         m.inc_ref(m_fml);
+        m_proof = tr(src.pr());
+        m.inc_ref(m_proof);
         expr_dependency_translation dtr(tr);
         m_dep = dtr(src.dep());
         m.inc_ref(m_dep);
@@ -49,45 +54,56 @@ class dependent_expr {
         if (this != &other) {
             m.inc_ref(other.m_fml);
             m.inc_ref(other.m_dep);
+            m.inc_ref(other.m_proof);
             m.dec_ref(m_fml);
             m.dec_ref(m_dep);
+            m.dec_ref(m_proof);
             m_fml = other.m_fml;
             m_dep = other.m_dep;
+            m_proof = other.m_proof;
         }
         return *this;
     }
 
     dependent_expr(dependent_expr const& other):
         m(other.m),
         m_fml(other.m_fml),
+        m_proof(other.m_proof),
         m_dep(other.m_dep) {
         m.inc_ref(m_fml);
+        m.inc_ref(m_proof);
         m.inc_ref(m_dep);
     }
 
     dependent_expr(dependent_expr && other) noexcept :
         m(other.m),
         m_fml(nullptr),
+        m_proof(nullptr),
         m_dep(nullptr) {
         std::swap(m_fml, other.m_fml);
+        std::swap(m_proof, other.m_proof);
         std::swap(m_dep, other.m_dep);
     }
 
     ~dependent_expr() {
         m.dec_ref(m_fml);
         m.dec_ref(m_dep);
+        m.dec_ref(m_proof);
         m_fml = nullptr;
         m_dep = nullptr;
+        m_proof = nullptr;
     }
 
     ast_manager& get_manager() const { return m; }
 
     expr* fml() const { return m_fml; }
 
     expr_dependency* dep() const { return m_dep; }
+
+    proof* pr() const { return m_proof; }
 
-    std::tuple<expr*, expr_dependency*> operator()() const { 
-        return { m_fml, m_dep }; 
+    std::tuple<expr*, proof*, expr_dependency*> operator()() const { 
+        return { m_fml, m_proof, m_dep }; 
     }
 
     std::ostream& display(std::ostream& out) const {
@@ -99,6 +115,8 @@ class dependent_expr {
             for (expr* arg : deps)
                 out << mk_pp(arg, m) << " ";
         }
+        if (m_proof)
+            out << "\n:- " << mk_pp(m_proof, m);
         return out;
     }
 };

diff --git a/src/ast/simplifiers/dependent_expr_state.h b/src/ast/simplifiers/dependent_expr_state.h
@@ -135,6 +135,8 @@ class dependent_expr_simplifier {
 
     index_set indices() { return index_set(*this); }
 
+    proof* mp(proof* a, proof* b) { return (a && b) ? m.mk_modus_ponens(a, b) : nullptr;  }
+
 public:
     dependent_expr_simplifier(ast_manager& m, dependent_expr_state& s) : m(m), m_fmls(s), m_trail(s.m_trail) {}
     virtual ~dependent_expr_simplifier() {}
@@ -146,6 +148,7 @@ class dependent_expr_simplifier {
     virtual void reset_statistics() {}
     virtual void updt_params(params_ref const& p) {}
     virtual void collect_param_descrs(param_descrs& r) {}
+    virtual bool supports_proofs() const { return false; }
     ast_manager& get_manager() { return m; }
     dependent_expr_state& get_fmls() { return m_fmls; }
 };
diff --git a/src/ast/simplifiers/distribute_forall.h b/src/ast/simplifiers/distribute_forall.h
@@ -38,7 +38,7 @@ class distribute_forall_simplifier : public dependent_expr_simplifier {
             if (!has_quantifiers(d.fml()))
                 continue;
             m_dist(d.fml(), r);
-            m_fmls.update(idx, dependent_expr(m, r, d.dep()));
+            m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
         }
     }
 };

diff --git a/src/ast/simplifiers/elim_bounds.h b/src/ast/simplifiers/elim_bounds.h
@@ -38,7 +38,7 @@ class elim_bounds_simplifier : public dependent_expr_simplifier {
             if (!has_quantifiers(d.fml()))
                 continue;
             m_rewriter(d.fml(), r);
-            m_fmls.update(idx, dependent_expr(m, r, d.dep()));
+            m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
         }
     }
 };

diff --git a/src/ast/simplifiers/elim_term_ite.h b/src/ast/simplifiers/elim_term_ite.h
@@ -33,13 +33,17 @@ class elim_term_ite_simplifier : public dependent_expr_simplifier {
 
     void reduce() override {
         expr_ref r(m);
+        proof_ref pr(m);
         for (unsigned idx : indices()) {
             auto const& d = m_fmls[idx];
-            m_rewriter(d.fml(), r);
-            m_fmls.update(idx, dependent_expr(m, r, d.dep()));
+            m_rewriter(d.fml(), r, pr);
+            if (d.fml() != r)
+                m_fmls.update(idx, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
         }
     }
 
+    bool supports_proofs() const override { return true; }
+
     void push() override { dependent_expr_simplifier::push(); m_df.push(); m_rewriter.push(); }
 
     void pop(unsigned n) override { m_rewriter.pop(n); m_df.pop(n); dependent_expr_simplifier::pop(n); }

diff --git a/src/ast/simplifiers/elim_unconstrained.cpp b/src/ast/simplifiers/elim_unconstrained.cpp
@@ -258,13 +258,13 @@ void elim_unconstrained::reconstruct_terms() {
 void elim_unconstrained::assert_normalized(vector<dependent_expr>& old_fmls) {
 
     for (unsigned i : indices()) {
-        auto [f, d] = m_fmls[i]();
+        auto [f, p, d] = m_fmls[i]();
         node& n = get_node(f);
         expr* g = n.m_term;
         if (f == g)
             continue;
         old_fmls.push_back(m_fmls[i]);
-        m_fmls.update(i, dependent_expr(m, g, d));
+        m_fmls.update(i, dependent_expr(m, g, nullptr, d));
         IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(f, m, 3) << " -> " << mk_bounded_pp(g, m, 3) << "\n");
         TRACE("elim_unconstrained", tout << mk_bounded_pp(f, m) << " -> " << mk_bounded_pp(g, m) << "\n");
     }

diff --git a/src/ast/simplifiers/eliminate_predicates.cpp b/src/ast/simplifiers/eliminate_predicates.cpp
@@ -536,7 +536,7 @@ void eliminate_predicates::reduce_definitions() {
         macro_expander.insert(v->m_head, v->m_def, v->m_dep);
 
     for (unsigned i : indices()) {
-        auto [f, d] = m_fmls[i]();
+        auto [f, p, d] = m_fmls[i]();
         expr_ref fml(f, m), new_fml(m);
         expr_dependency_ref dep(d, m);
         while (true) {
@@ -546,7 +546,7 @@ void eliminate_predicates::reduce_definitions() {
             rewrite(new_fml);
             fml = new_fml;
         }
-        m_fmls.update(i, dependent_expr(m, fml, dep));
+        m_fmls.update(i, dependent_expr(m, fml, nullptr, dep));
     }
     reset();
     init_clauses();
@@ -770,7 +770,7 @@ void eliminate_predicates::process_to_exclude(ast_mark& exclude_set) {
 
 
 eliminate_predicates::clause* eliminate_predicates::init_clause(unsigned i) {
-    auto [f, d] = m_fmls[i]();
+    auto [f, p, d] = m_fmls[i]();
     return init_clause(f, d, i);
 }
 
@@ -821,12 +821,12 @@ void eliminate_predicates::decompile() {
         if (cl->m_fml_index != UINT_MAX) {
             if (cl->m_alive)
                 continue;
-            dependent_expr de(m, m.mk_true(), nullptr);
+            dependent_expr de(m, m.mk_true(), nullptr, nullptr);
             m_fmls.update(cl->m_fml_index, de);
         }
         else if (cl->m_alive) {
             expr_ref new_cl = cl->m_fml;
-            dependent_expr de(m, new_cl, cl->m_dep);
+            dependent_expr de(m, new_cl, nullptr, cl->m_dep);
             m_fmls.add(de);
         }        
     }

diff --git a/src/ast/simplifiers/euf_completion.cpp b/src/ast/simplifiers/euf_completion.cpp
@@ -82,7 +82,7 @@ namespace euf {
 
         for (unsigned i = qhead(); i < sz; ++i) {
             expr* x, * y;
-            auto [f, d] = m_fmls[i]();
+            auto [f, p, d] = m_fmls[i]();
             if (m.is_eq(f, x, y)) {
                 enode* a = mk_enode(x);
                 enode* b = mk_enode(y);
@@ -108,19 +108,19 @@ namespace euf {
 
         if (m_egraph.inconsistent()) {
             auto* d = explain_conflict();
-            dependent_expr de(m, m.mk_false(), d);
+            dependent_expr de(m, m.mk_false(), nullptr, d);
             m_fmls.update(0, de);
             return;
         }
 
         unsigned sz = qtail();
         for (unsigned i = qhead(); i < sz; ++i) {
-            auto [f, d] = m_fmls[i]();
+            auto [f, p, d] = m_fmls[i]();
 
             expr_dependency_ref dep(d, m);
             expr_ref g = canonize_fml(f, dep);
             if (g != f) {
-                m_fmls.update(i, dependent_expr(m, g, dep));
+                m_fmls.update(i, dependent_expr(m, g, nullptr, dep));
                 m_stats.m_num_rewrites++;
                 IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(f, m, 3) << " -> " << mk_bounded_pp(g, m, 3) << "\n");
                 update_has_new_eq(g);

diff --git a/src/ast/simplifiers/extract_eqs.cpp b/src/ast/simplifiers/extract_eqs.cpp
@@ -39,7 +39,7 @@ namespace euf {
         }
 
         void get_eqs(dependent_expr const& e, dep_eq_vector& eqs) override {
-            auto [f, d] = e();
+            auto [f, p, d] = e();
             expr* x, * y;
             if (m.is_eq(f, x, y)) {
                 if (x == y)
@@ -246,7 +246,7 @@ namespace euf {
         void get_eqs(dependent_expr const& e, dep_eq_vector& eqs) override {
             if (!m_enabled)
                 return;
-            auto [f, d] = e();
+            auto [f, p, d] = e();
             expr* x, * y;
             if (m.is_eq(f, x, y) && a.is_int_real(x)) {
                 solve_eq(f, x, y, d, eqs);