diff --git a/src/math/lp/lp_bound_propagator.cpp b/src/math/lp/lp_bound_propagator.cpp
index ec59fa4f0..10f155027 100644
--- a/src/math/lp/lp_bound_propagator.cpp
+++ b/src/math/lp/lp_bound_propagator.cpp
@@ -4,7 +4,6 @@
 */
 #include "math/lp/lar_solver.h"
 #include "math/lp/nla_solver.h"
-#include "math/lp/nla_intervals.h"
 namespace lp {
 
 lp_bound_propagator::lp_bound_propagator(lar_solver & ls, nla::solver* nla):
@@ -155,7 +154,6 @@ void lp_bound_propagator::explain_implied_bound(implied_bound & ib) {
                 SASSERT(false);
             } else {
                 const ul_pair & ul =  m_lar_solver.m_columns_to_ul_pairs[j];
-                // todo : process witnesses from monomials!!!!!!!!!!!!!!!!!!!!!
                 auto witness = ul.lower_bound_witness();
                 lp_assert(is_valid(witness));
                 consume(a, witness);
diff --git a/src/math/lp/nla_intervals.cpp b/src/math/lp/nla_intervals.cpp
index ff17216d7..c15afcf8b 100755
--- a/src/math/lp/nla_intervals.cpp
+++ b/src/math/lp/nla_intervals.cpp
@@ -17,11 +17,21 @@ bool intervals::check() {
     // }
     return true;
 }
+// create a product of interval signs together with the depencies
+intervals::interval intervals::mul_signs_with_deps(int sign, const svector<lpvar>& vars) const {
+    interval a, b;
+    m_imanager.set(a, mpq(sign));
+    for (lpvar v : vars) {
+         set_var_interval(v, b);
+    }
+    return a;
+    
+}
 
 bool intervals::check(monomial const& m) {
     interval a, b, c, d;
-    m_imanager.set(a, rational(1).to_mpq());
-    set_interval(m.var(), d);
+    m_imanager.set(a, mpq(1));
+    set_var_interval(m.var(), d);
     if (m_imanager.lower_is_inf(d) && m_imanager.upper_is_inf(d)) {
         return true;
     }
@@ -32,11 +42,11 @@ bool intervals::check(monomial const& m) {
             return true;
         }
         // TBD: deal with powers v^n interval instead of multiplying v*v .. * v
-        set_interval(v, b);
+        set_var_interval(v, b);
         interval_deps deps;
         m_imanager.mul(a, b, c, deps);
         m_imanager.set(a, c);
-        m_config.set_deps(a, b, deps, a);
+        m_config.add_deps(a, b, deps, a);
     }
     if (m_imanager.before(a, d)) {
         svector<lp::constraint_index> cs;
@@ -69,7 +79,7 @@ bool intervals::check(monomial const& m) {
     return true;
 }
 
-void intervals::set_interval(lpvar v, interval& b) const {
+void intervals::set_var_interval(lpvar v, interval& b) const {
     lp::constraint_index ci;
     rational val;
     bool is_strict;
@@ -99,7 +109,31 @@ void intervals::set_interval(lpvar v, interval& b) const {
 
 rational sign(const rational& v) { return v.is_zero()? v : (rational(v.is_pos()? 1 : -1)); }
 
-void intervals::set_interval_signs(lpvar v, interval& b) const {
+void intervals::set_var_interval_signs(lpvar v, interval& b) const {
+    lp::constraint_index ci;
+    rational val;
+    bool is_strict;
+    if (ls().has_lower_bound(v, ci, val, is_strict)) {            
+        m_config.set_lower(b, sign(val));
+        m_config.set_lower_is_open(b, is_strict);
+        m_config.set_lower_is_inf(b, false);
+    }
+    else {
+        m_config.set_lower_is_open(b, true);
+        m_config.set_lower_is_inf(b, true);
+    }
+    if (ls().has_upper_bound(v, ci, val, is_strict)) {
+        m_config.set_upper(b, sign(val));
+        m_config.set_upper_is_open(b, is_strict);
+        m_config.set_upper_is_inf(b, false);
+    }
+    else {
+        m_config.set_upper_is_open(b, true);
+        m_config.set_upper_is_inf(b, true);
+    }
+}
+
+void intervals::set_var_interval_signs_with_deps(lpvar v, interval& b) const {
     lp::constraint_index ci;
     rational val;
     bool is_strict;
@@ -157,11 +191,11 @@ lp::impq intervals::get_lower_bound_of_monomial(lpvar j) const {
 
 intervals::interval intervals::mul(int sign, const svector<lpvar>& vars) const {
     interval a;
-    m_imanager.set(a, rational(sign).to_mpq());
+    m_imanager.set(a, mpq(sign));
     
     for (lpvar j : vars) {
         interval b, c;
-        set_interval(j, b);
+        set_var_interval(j, b);
         m_imanager.mul(a, b, c);
         if (m_imanager.is_zero(c)) {
             TRACE("nla_intervals", tout << "sign = " << sign << "\nproduct = ";
diff --git a/src/math/lp/nla_intervals.h b/src/math/lp/nla_intervals.h
index 819e8fe1d..be06c1733 100755
--- a/src/math/lp/nla_intervals.h
+++ b/src/math/lp/nla_intervals.h
@@ -78,7 +78,7 @@ namespace nla {
             };
 
 
-            void set_deps(interval const& a, interval const& b, interval_deps const& deps, interval& i) {
+            void add_deps(interval const& a, interval const& b, interval_deps const& deps, interval& i) {
                 ci_dependency* lo = mk_dependency(a, b, deps.m_lower_deps);
                 ci_dependency* hi = mk_dependency(a, b, deps.m_upper_deps);
                 i.m_lower_dep = lo;
@@ -149,9 +149,11 @@ namespace nla {
 
         bool check(monomial const& m);
 
-        void set_interval(lpvar v, interval & b) const;
+        void set_var_interval(lpvar v, interval & b) const;
 
-        void set_interval_signs(lpvar v, interval & b) const;
+        void set_var_interval_signs(lpvar v, interval & b) const;
+
+        void set_var_interval_signs_with_deps(lpvar v, interval & b) const;
 
         ci_dependency* mk_dep(lp::constraint_index ci) const;
 
@@ -173,5 +175,6 @@ namespace nla {
         lp::impq get_upper_bound_of_monomial(lpvar j) const;
         lp::impq get_lower_bound_of_monomial(lpvar j) const;
         interval mul(int sign, const svector<lpvar>&) const;
+        interval mul_signs_with_deps(int sign, const svector<lpvar>&) const;
     };
 } // end of namespace nla