interval

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

src/math/polysat/saturation.h

@@ -40,8 +40,6 @@ namespace polysat {
 
         void set_rule(char const* r) { m_rule = r; }      
 
-        bool find_upper_bound(pvar x, signed_constraint& c, rational& bound);
-
         void push_omega(pdd const& x, pdd const& y);
         void push_omega_bisect(pdd const& x, rational x_max, pdd const& y, rational y_max);
         signed_constraint ineq(bool strict, pdd const& lhs, pdd const& rhs);

src/math/polysat/ule_constraint.cpp

@@ -134,20 +134,22 @@ namespace polysat {
             v = p.var();
         else if (q.is_unilinear())
             v = q.var();
-        if (v != null_var) {
+        else
-            signed_constraint sc(this, is_positive);
+            return;
-            s.m_viable.intersect(v, sc);
+
-            rational val;
+        signed_constraint sc(this, is_positive);
-            switch (s.m_viable.find_viable(v, val)) {
+        if (!s.m_viable.intersect(v, sc))
-            case dd::find_t::singleton:
+            return;
-                s.propagate(v, val, sc);
+        rational val;
-                break;
+        switch (s.m_viable.find_viable(v, val)) {
-            case dd::find_t::empty:
+        case dd::find_t::singleton:
-                s.set_conflict(v);
+            s.propagate(v, val, sc); // TBD why is sc used as justification? It should be all of viable
-                break;
+            break;
-            default:
+        case dd::find_t::empty:
-                break;
+            s.set_conflict(v);
-            }                
+            break;
+        default:
+            break;
         }
     }
 

src/math/polysat/viable.cpp

@@ -64,25 +64,29 @@ namespace polysat {
         m_trail.pop_back();
     }
 
-    void viable::intersect(pvar v, signed_constraint const& c) {
+    bool viable::intersect(pvar v, signed_constraint const& c) {
         auto& fi = s.m_forbidden_intervals;
         entry* ne = alloc_entry();
-        if (!fi.get_interval(c, v, ne->interval, ne->side_cond) || ne->interval.is_currently_empty())
+        if (!fi.get_interval(c, v, ne->interval, ne->side_cond) || ne->interval.is_currently_empty()) {
             m_alloc.push_back(ne);
+            return false;
+        }
         else {
             ne->src = c;
-            intersect(v, ne);
+            return intersect(v, ne);
         }
     }
 
-    void viable::intersect(pvar v, entry* ne) {
+    bool viable::intersect(pvar v, entry* ne) {
         entry* e = m_viable[v];
-        if (e && e->interval.is_full())
+        if (e && e->interval.is_full()) {
-            return;
+            m_alloc.push_back(ne);
+            return false;
+        }
 
         if (ne->interval.is_currently_empty()) {
             m_alloc.push_back(ne);
-            return;
+            return false;
         }
 
         auto create_entry = [&]() {
@@ -98,8 +102,6 @@ namespace polysat {
             e->remove_from(m_viable[v], e);
         };
 
-        //LOG("intersect " << ne->interval);
-
         if (!e) 
             m_viable[v] = create_entry();
         else {
@@ -107,14 +109,14 @@ namespace polysat {
             do {
                 if (e->interval.contains(ne->interval)) {
                     m_alloc.push_back(ne);
-                    return;
+                    return false;
                 }
                 while (ne->interval.contains(e->interval)) {
                     entry* n = e->next();
                     remove_entry(e);
                     if (!m_viable[v]) {
                         m_viable[v] = create_entry();
-                        return;
+                        return true;
                     }
                     if (e == first) 
                         first = n;                    
@@ -124,13 +126,13 @@ namespace polysat {
                 if (e->interval.lo_val() > ne->interval.lo_val()) {
                     if (first->prev()->interval.contains(ne->interval)) {
                         m_alloc.push_back(ne);
-                        return;
+                        return false;
                     }
                     e->insert_before(create_entry());
                     if (e == first)
                         m_viable[v] = e->prev();
                     SASSERT(well_formed(m_viable[v]));
-                    return;
+                    return true;
                 }
                 e = e->next();
             }             
@@ -139,6 +141,7 @@ namespace polysat {
             first->insert_before(create_entry());
         }
         SASSERT(well_formed(m_viable[v]));
+        return true;
     }
 
     bool viable::has_viable(pvar v) {         

src/math/polysat/viable.h

@@ -44,7 +44,7 @@ namespace polysat {
 
         entry* alloc_entry();
 
-        void intersect(pvar v, entry* e);
+        bool intersect(pvar v, entry* e);
 
     public:
         viable(solver& s);
@@ -64,7 +64,7 @@ namespace polysat {
          * update state of viable for pvar v
          * based on affine constraints
          */
-        void intersect(pvar v, signed_constraint const& c);
+        bool intersect(pvar v, signed_constraint const& c);
 
         /**
          * Check whether variable v has any viable values left according to m_viable.