adding trail/levels

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/smt/smt_context.cpp

@@ -4423,6 +4423,22 @@ namespace smt {
             m = const_cast<model*>(m_model.get());
     }
 
+    void context::get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth) {
+        unsigned sz = vars.size(); 
+        depth.resize(sz);
+        for (unsigned i = 0; i < sz; ++i) {
+            expr* v = vars[i];
+            bool_var bv = m_expr2bool_var.get(v->get_id(), null_bool_var);
+            depth[i] = bv == null_bool_var ? UINT_MAX : get_assign_level(bv);            
+        }
+    }
+
+    expr_ref_vector context::get_trail() {        
+        expr_ref_vector result(get_manager());
+        get_assignments(result);
+        return result;
+    }
+
     void context::get_proto_model(proto_model_ref & m) const {
         m = const_cast<proto_model*>(m_proto_model.get());
     }

src/smt/smt_context.h

@@ -1575,6 +1575,10 @@ namespace smt {
             return m_unsat_core.get(idx);
         }
 
+        void get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth);
+
+        expr_ref_vector get_trail();
+
         void get_model(model_ref & m) const;
 
         bool update_model(bool refinalize);

src/smt/smt_internalizer.cpp

@@ -196,7 +196,7 @@ namespace smt {
         TRACE("incompleteness_bug", tout << "[internalize-assertion]: #" << n->get_id() << "\n";);
         flet<unsigned> l(m_generation, generation);
         m_stats.m_max_generation = std::max(m_generation, m_stats.m_max_generation);
-        if (get_depth(n) > DEEP_EXPR_THRESHOLD) {
+        if (::get_depth(n) > DEEP_EXPR_THRESHOLD) {
             // if the expression is deep, then execute topological sort to avoid
             // stack overflow.
             // a caveat is that theory internalizers do rely on recursive descent so

src/smt/smt_kernel.cpp

@@ -146,6 +146,14 @@ namespace smt {
         expr * get_unsat_core_expr(unsigned idx) const {
             return m_kernel.get_unsat_core_expr(idx);
         }
+
+        void get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth) {
+            m_kernel.get_levels(vars, depth);
+        }
+
+        expr_ref_vector get_trail() {
+            return m_kernel.get_trail();
+        }
         
         failure last_failure() const {
             return m_kernel.get_last_search_failure();
@@ -396,4 +404,13 @@ namespace smt {
         return m_imp->m_kernel;
     }
 
+    void kernel::get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth) {
+        m_imp->get_levels(vars, depth);
+    }
+
+    expr_ref_vector kernel::get_trail() {
+        return m_imp->get_trail();
+    }
+
+
 };

src/smt/smt_kernel.h

@@ -219,6 +219,16 @@ namespace smt {
         */
         expr* next_decision();
 
+        /**
+           \brief retrieve depth of variables from decision stack.
+        */
+        void get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth);
+
+        /**
+           \brief retrieve trail of assignment stack.
+        */
+        expr_ref_vector get_trail();
+
         /**
            \brief (For debubbing purposes) Prints the state of the kernel
         */

src/smt/smt_solver.cpp

@@ -195,6 +195,14 @@ namespace smt {
             return m_context.check(cube, clauses);
         }
 
+        void get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth) override {
+            m_context.get_levels(vars, depth);
+        }
+
+        expr_ref_vector get_trail() override {
+            return m_context.get_trail();
+        }
+
         struct scoped_minimize_core {
             smt_solver& s;
             expr_ref_vector m_assumptions;