Spacer engine for HORN logic

The algorithms implemented in the engine are described in the following papers

Anvesh Komuravelli, Nikolaj Bjørner, Arie Gurfinkel, Kenneth L. McMillan:
Compositional Verification of Procedural Programs using Horn Clauses over Integers and Arrays. FMCAD 2015: 89-96

Nikolaj Bjørner, Arie Gurfinkel:
Property Directed Polyhedral Abstraction. VMCAI 2015: 263-281

Anvesh Komuravelli, Arie Gurfinkel, Sagar Chaki:
SMT-Based Model Checking for Recursive Programs. CAV 2014: 17-34

src/muz/spacer/spacer_legacy_frames.cpp

@@ -0,0 +1,170 @@
+/*
+  Copyright (c) 2017 Arie Gurfinkel
+
+  Legacy implementations of frames. To be removed.
+ */
+#include "spacer_context.h"
+#include <sstream>
+#include <iomanip>
+
+#include "dl_util.h"
+#include "rewriter.h"
+#include "rewriter_def.h"
+#include "var_subst.h"
+#include "util.h"
+#include "spacer_prop_solver.h"
+#include "spacer_context.h"
+#include "spacer_generalizers.h"
+#include "for_each_expr.h"
+#include "dl_rule_set.h"
+#include "unit_subsumption_tactic.h"
+#include "model_smt2_pp.h"
+#include "dl_mk_rule_inliner.h"
+#include "ast_smt2_pp.h"
+#include "ast_ll_pp.h"
+#include "ast_util.h"
+#include "proof_checker.h"
+#include "smt_value_sort.h"
+#include "proof_utils.h"
+#include "scoped_proof.h"
+#include "spacer_qe_project.h"
+#include "blast_term_ite_tactic.h"
+
+#include "timeit.h"
+#include "luby.h"
+#include "expr_safe_replace.h"
+#include "expr_abstract.h"
+#include "obj_equiv_class.h"
+
+
+namespace spacer {
+// ------------------
+// legacy_frames
+void pred_transformer::legacy_frames::simplify_formulas(tactic& tac,
+        expr_ref_vector& v)
+{
+    ast_manager &m = m_pt.get_ast_manager();
+    goal_ref g(alloc(goal, m, false, false, false));
+    for (unsigned j = 0; j < v.size(); ++j) { g->assert_expr(v[j].get()); }
+    model_converter_ref mc;
+    proof_converter_ref pc;
+    expr_dependency_ref core(m);
+    goal_ref_buffer result;
+    tac(g, result, mc, pc, core);
+    SASSERT(result.size() == 1);
+    goal* r = result[0];
+    v.reset();
+    for (unsigned j = 0; j < r->size(); ++j) { v.push_back(r->form(j)); }
+}
+
+void pred_transformer::legacy_frames::simplify_formulas()
+{
+    ast_manager &m = m_pt.get_ast_manager();
+    tactic_ref us = mk_unit_subsumption_tactic(m);
+    simplify_formulas(*us, m_invariants);
+    for (unsigned i = 0; i < m_levels.size(); ++i) {
+        simplify_formulas(*us, m_levels[i]);
+    }
+}
+
+void pred_transformer::legacy_frames::get_frame_geq_lemmas(unsigned lvl,
+        expr_ref_vector &out)
+{
+    get_frame_lemmas(infty_level(), out);
+    for (unsigned i = lvl, sz = m_levels.size(); i < sz; ++i)
+    { get_frame_lemmas(i, out); }
+}
+
+bool pred_transformer::legacy_frames::propagate_to_next_level(unsigned src_level)
+{
+
+    ast_manager &m = m_pt.get_ast_manager();
+    if (m_levels.size() <= src_level) { return true; }
+    if (m_levels [src_level].empty()) { return true; }
+
+    unsigned tgt_level = next_level(src_level);
+    m_pt.ensure_level(next_level(tgt_level));
+
+    TRACE("spacer",
+          tout << "propagating " << src_level << " to " << tgt_level;
+          tout << " for relation " << m_pt.head()->get_name() << "\n";);
+
+    for (unsigned i = 0; i < m_levels[src_level].size();) {
+        expr_ref_vector &src = m_levels[src_level];
+        expr * curr = src[i].get();
+        unsigned stored_lvl;
+        VERIFY(m_prop2level.find(curr, stored_lvl));
+        SASSERT(stored_lvl >= src_level);
+        unsigned solver_level;
+        if (stored_lvl > src_level) {
+            TRACE("spacer", tout << "at level: " << stored_lvl << " " << mk_pp(curr, m) << "\n";);
+            src[i] = src.back();
+            src.pop_back();
+        } else if (m_pt.is_invariant(tgt_level, curr, solver_level)) {
+            // -- might invalidate src reference
+            add_lemma(curr, solver_level);
+            TRACE("spacer", tout << "is invariant: " << pp_level(solver_level) << " " << mk_pp(curr, m) << "\n";);
+            // shadow higher-level src
+            expr_ref_vector &src = m_levels[src_level];
+            src[i] = src.back();
+            src.pop_back();
+            ++m_pt.m_stats.m_num_propagations;
+        } else {
+            TRACE("spacer", tout << "not propagated: " << mk_pp(curr, m) << "\n";);
+            ++i;
+        }
+    }
+
+    CTRACE("spacer", m_levels[src_level].empty(),
+           tout << "Fully propagated level "
+           << src_level << " of " << m_pt.head()->get_name() << "\n";);
+
+    return m_levels[src_level].empty();
+}
+
+bool pred_transformer::legacy_frames::add_lemma(expr * lemma, unsigned lvl)
+{
+    if (is_infty_level(lvl)) {
+        if (!m_invariants.contains(lemma)) {
+            m_invariants.push_back(lemma);
+            m_prop2level.insert(lemma, lvl);
+        //m_pt.add_lemma_core (lemma, lvl);
+        return true;
+    }
+    return false;
+    }
+
+    unsigned old_level;
+    if (!m_prop2level.find(lemma, old_level) || old_level < lvl) {
+        m_levels[lvl].push_back(lemma);
+        m_prop2level.insert(lemma, lvl);
+        //m_pt.add_lemma_core (lemma, lvl);
+        return true;
+    }
+    return false;
+}
+
+void  pred_transformer::legacy_frames::propagate_to_infinity(unsigned level)
+{
+    TRACE("spacer", tout << "propagating to oo from lvl " << level
+          << " of " << m_pt.m_head->get_name() << "\n";);
+
+    if (m_levels.empty()) { return; }
+
+    for (unsigned i = m_levels.size(); i > level; --i) {
+        expr_ref_vector &lemmas = m_levels [i - 1];
+        for (unsigned j = 0; j < lemmas.size(); ++j)
+        { add_lemma(lemmas.get(j), infty_level()); }
+        lemmas.reset();
+    }
+}
+
+void pred_transformer::legacy_frames::inherit_frames(legacy_frames& other)
+{
+
+    SASSERT(m_pt.m_head == other.m_pt.m_head);
+    obj_map<expr, unsigned>::iterator it  = other.m_prop2level.begin();
+    obj_map<expr, unsigned>::iterator end = other.m_prop2level.end();
+    for (; it != end; ++it) { add_lemma(it->m_key, it->m_value); }
+}
+}