add accessors for implied values to API

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

src/smt/smt_arith_value.cpp

@@ -125,9 +125,37 @@ namespace smt {
         return false;
     }
 
+    expr_ref arith_value::get_lo(expr* e) const {
+        rational lo;
+        bool s = false;
+        if (a.is_int_real(e) && get_lo(e, lo, s) && !s) {
+            return expr_ref(a.mk_numeral(lo, m.get_sort(e)), m);
+        }
+        return expr_ref(e, m);
+    }
+
+    expr_ref arith_value::get_up(expr* e) const {
+        rational up;
+        bool s = false;
+        if (a.is_int_real(e) && get_up(e, up, s) && !s) {
+            return expr_ref(a.mk_numeral(up, m.get_sort(e)), m);
+        }
+        return expr_ref(e, m);
+    }
+
+    expr_ref arith_value::get_fixed(expr* e) const {
+        rational lo, up;
+        bool s = false;
+        if (a.is_int_real(e) && get_lo(e, lo, s) && !s && get_up(e, up, s) && !s && lo == up) {
+            return expr_ref(a.mk_numeral(lo, m.get_sort(e)), m);
+        }
+        return expr_ref(e, m);
+    }    
+
     final_check_status arith_value::final_check() {
         family_id afid = a.get_family_id();
         theory * th = m_ctx->get_theory(afid);
         return th->final_check_eh();
     }
+
 };

src/smt/smt_arith_value.h

@@ -42,6 +42,9 @@ namespace smt {
         bool get_lo(expr* e, rational& lo, bool& strict) const;
         bool get_up(expr* e, rational& up, bool& strict) const;
         bool get_value(expr* e, rational& value) const;
+        expr_ref get_lo(expr* e) const;
+        expr_ref get_up(expr* e) const;
+        expr_ref get_fixed(expr* e) const;
         final_check_status final_check();
     };
 };

src/smt/smt_context.cpp

@@ -39,6 +39,7 @@ Revision History:
 #include "smt/smt_model_checker.h"
 #include "smt/smt_model_finder.h"
 #include "smt/smt_parallel.h"
+#include "smt/smt_arith_value.h"
 
 namespace smt {
 
@@ -4555,6 +4556,48 @@ namespace smt {
         TRACE("model", tout << *m_model << "\n";);
     }
 
+    expr_ref context::get_implied_value(expr* e) {
+        pop_to_search_lvl();
+        if (m.is_bool(e)) {
+            if (b_internalized(e)) {
+                bool_var v = get_bool_var(e);
+                switch (get_assignment(get_bool_var(e))) {
+                case l_true: e = m.mk_true(); break;
+                case l_false: e = m.mk_false(); break;
+                default: break;
+                }
+            }
+            return expr_ref(e, m);
+        }
+
+        if (e_internalized(e)) {
+            enode* n = get_enode(e);
+            for (enode* r : *n) {
+                if (m.is_value(r->get_owner())) {
+                    return expr_ref(r->get_owner(), m);
+                }
+            }
+        }
+
+        arith_value av(m);
+        av.init(this);
+        return av.get_fixed(e);
+    }
+
+    expr_ref context::get_implied_lower_bound(expr* e) {
+        pop_to_search_lvl();
+        arith_value av(m);
+        av.init(this);
+        return av.get_lo(e);
+    }
+
+    expr_ref context::get_implied_upper_bound(expr* e) {
+        pop_to_search_lvl();
+        arith_value av(m);
+        av.init(this);
+        return av.get_up(e);
+    }
+
 };
 
 

src/smt/smt_context.h

@@ -580,6 +580,13 @@ namespace smt {
             return get_bdata(v).get_theory();
         }
 
+        expr_ref get_implied_value(expr* e);
+
+        expr_ref get_implied_lower_bound(expr* e);
+
+        expr_ref get_implied_upper_bound(expr* e);
+
+
         friend class set_var_theory_trail;
         void set_var_theory(bool_var v, theory_id tid);
 

src/smt/smt_kernel.cpp

@@ -131,6 +131,18 @@ namespace smt {
         lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) {
             return m_kernel.find_mutexes(vars, mutexes);
         }
+
+        expr_ref get_implied_value(expr* e) {
+            return m_kernel.get_implied_value(e);
+        }
+
+        expr_ref get_implied_lower_bound(expr* e) {
+            return m_kernel.get_implied_lower_bound(e);
+        }
+
+        expr_ref get_implied_upper_bound(expr* e) {
+            return m_kernel.get_implied_upper_bound(e);
+        }
         
         void get_model(model_ref & m) {
             m_kernel.get_model(m);
@@ -412,5 +424,18 @@ namespace smt {
         return m_imp->get_trail();
     }
 
+    expr_ref kernel::get_implied_value(expr* e) {
+        return m_imp->get_implied_value(e);
+    }
+    
+    expr_ref kernel::get_implied_lower_bound(expr* e) {
+        return m_imp->get_implied_lower_bound(e);
+    }
+    
+    expr_ref kernel::get_implied_upper_bound(expr* e) {
+        return m_imp->get_implied_upper_bound(e);
+    }
+
+
 
 };

src/smt/smt_kernel.h

@@ -218,6 +218,17 @@ namespace smt {
         */
         expr_ref next_cube();
 
+        /**
+           \brief retrieve upper/lower bound for arithmetic term, if it is implied.
+           retrieve implied values if terms are fixed to a value.
+        */
+
+        expr_ref get_implied_value(expr* e);
+
+        expr_ref get_implied_lower_bound(expr* e);
+
+        expr_ref get_implied_upper_bound(expr* e);
+
         /**
            \brief retrieve depth of variables from decision stack.
         */

src/smt/smt_solver.cpp

@@ -361,6 +361,18 @@ namespace {
             }
         }
 
+        expr_ref get_implied_value(expr* e) override {
+            return m_context.get_implied_value(e);
+        }
+
+        expr_ref get_implied_lower_bound(expr* e) override {
+            return m_context.get_implied_lower_bound(e);
+        }
+
+        expr_ref get_implied_upper_bound(expr* e) override {
+            return m_context.get_implied_upper_bound(e);
+        }
+
         bool fds_intersect(func_decl_set & pattern_fds, func_decl_set & assrtn_fds) {
             for (func_decl * fd : pattern_fds) {
                 if (assrtn_fds.contains(fd))

src/smt/theory_lra.cpp

@@ -1724,6 +1724,7 @@ public:
             is_sat = make_feasible();
         }
         final_check_status st = FC_DONE;
+
         switch (is_sat) {
         case l_true:
             TRACE("arith", /*display(tout);*/