Add functionality for BDD vectors (#5198)

* Fix XOR over BDDs

* Add operator<< for find_int_t

* Add equality assertion macro that prints expression values on failure

* Adapt contains_int and find_int to take externally-defined bits

* Add more operations on BDD vectors

* Remove old functions

* Additional bddv functions

* Rename some things

* Make bddv a class and add operators

* Fix find_num/contains_num calls

src/math/polysat/eq_constraint.cpp

@@ -57,13 +57,13 @@ namespace polysat {
         if (try_narrow_with(q, s)) {
             rational val;
             switch (s.find_viable(other_var, val)) {
-            case dd::find_int_t::empty:
+            case dd::find_result::empty:
                 s.set_conflict(*this);
                 return false;
-            case dd::find_int_t::singleton:
+            case dd::find_result::singleton:
                 s.propagate(other_var, val, *this);
                 return false;
-            case dd::find_int_t::multiple:
+            case dd::find_result::multiple:
                 /* do nothing */
                 break;
             }
@@ -95,7 +95,8 @@ namespace polysat {
             pvar v = q.var();
             rational a = q.hi().val();
             rational b = q.lo().val();
-            bdd xs = s.m_bdd.mk_affine(a, b, s.size(v));
+            bddv const& x = s.m_bdd.mk_var(s.sz2bits(s.size(v)));
+            bdd xs = (a * x + b == rational(0));
             s.intersect_viable(v, xs);
             s.push_cjust(v, this);
             return true;

src/math/polysat/solver.cpp

@@ -29,20 +29,20 @@ namespace polysat {
         return *m_pdd[sz];
     }
 
-    vector<bdd>& solver::sz2bits(unsigned sz) {
+    unsigned_vector const& solver::sz2bits(unsigned sz) {
         m_bits.reserve(sz + 1);
         auto* bits = m_bits[sz];
         if (!bits) {
-            m_bits.set(sz, alloc(vector<bdd>));
+            m_bits.set(sz, alloc(unsigned_vector));
             bits = m_bits[sz];
             for (unsigned i = 0; i < sz; ++i)
-                bits->push_back(m_bdd.mk_var(i));
+                bits->push_back(i);
         }
         return *bits;
     }
 
     bool solver::is_viable(pvar v, rational const& val) {
-        return m_viable[v].contains_int(val, size(v));
+        return m_viable[v].contains_num(val, sz2bits(size(v)));
     }
 
     void solver::add_non_viable(pvar v, rational const& val) {
@@ -60,8 +60,8 @@ namespace polysat {
             set_conflict(v);
     }
 
-    dd::find_int_t solver::find_viable(pvar v, rational & val) {
-        return m_viable[v].find_int(size(v), val);
+    dd::find_result solver::find_viable(pvar v, rational & val) {
+        return m_viable[v].find_num(sz2bits(size(v)), val);
     }
     
     solver::solver(reslimit& lim): 
@@ -323,15 +323,15 @@ namespace polysat {
         IF_LOGGING(log_viable(v));
         rational val;
         switch (find_viable(v, val)) {
-        case dd::find_int_t::empty:
+        case dd::find_result::empty:
             LOG("Conflict: no value for pvar " << v);
             set_conflict(v);
             break;
-        case dd::find_int_t::singleton:
+        case dd::find_result::singleton:
             LOG("Propagation: pvar " << v << " := " << val << " (due to unique value)");
             assign_core(v, val, justification::propagation(m_level));
             break;
-        case dd::find_int_t::multiple:
+        case dd::find_result::multiple:
             LOG("Decision: pvar " << v << " := " << val);
             push_level();
             assign_core(v, val, justification::decision(m_level));

src/math/polysat/solver.h

@@ -45,7 +45,7 @@ namespace polysat {
 
         reslimit&                m_lim;
         scoped_ptr_vector<dd::pdd_manager> m_pdd;
-        scoped_ptr_vector<vector<bdd>> m_bits;
+        scoped_ptr_vector<unsigned_vector> m_bits;
         dd::bdd_manager          m_bdd;
         dep_value_manager        m_value_manager;
         small_object_allocator   m_alloc;
@@ -132,7 +132,7 @@ namespace polysat {
         /**
          * Find a next viable value for variable.
          */
-        dd::find_int_t find_viable(pvar v, rational & val);
+        dd::find_result find_viable(pvar v, rational & val);
 
         /** Log all viable values for the given variable.
          * (Inefficient, but useful for debugging small instances.)
@@ -147,7 +147,7 @@ namespace polysat {
         void del_var();
 
         dd::pdd_manager& sz2pdd(unsigned sz);
-        vector<bdd>& sz2bits(unsigned sz);
+        unsigned_vector const& sz2bits(unsigned sz);
 
         void push_level();
         void pop_levels(unsigned num_levels);

src/math/polysat/types.h

@@ -26,6 +26,7 @@ namespace polysat {
     class solver;
     typedef dd::pdd pdd;
     typedef dd::bdd bdd;
+    typedef dd::bddv bddv;
     typedef unsigned pvar;
 
     const unsigned null_dependency = UINT_MAX;