rebase with Z3Prover

Signed-off-by: Lev Nachmanson <levnach@hotmail.com>

src/math/lp/gomory.cpp

@@ -68,7 +68,7 @@ class gomory::imp {
             m_k.addmul(new_a, upper_bound(j).x);
             m_ex->push_justification(column_upper_bound_constraint(j));
         }
-        m_t.add_coeff_var(new_a, j);
+        m_t.add_monomial(new_a, j);
         m_lcm_den = lcm(m_lcm_den, denominator(new_a));
         TRACE("gomory_cut_detail", tout << "new_a = " << new_a << ", k = " << m_k << ", lcm_den = " << m_lcm_den << "\n";);
     }
@@ -99,7 +99,7 @@ class gomory::imp {
             m_ex->push_justification(column_upper_bound_constraint(j));
         }
         TRACE("gomory_cut_detail_real", tout << a << "*v" << j << " k: " << m_k << "\n";);
-        m_t.add_coeff_var(new_a, j);
+        m_t.add_monomial(new_a, j);
     }
 
     lia_move report_conflict_from_gomory_cut() {
@@ -124,12 +124,12 @@ class gomory::imp {
                 if (!m_k.is_int())
                     m_k = ceil(m_k);
                 // switch size
-                m_t.add_coeff_var(- mpq(1), v);
+                m_t.add_monomial(- mpq(1), v);
                 m_k.neg();
             } else {
                 if (!m_k.is_int())
                     m_k = floor(m_k);
-                m_t.add_coeff_var(mpq(1), v);
+                m_t.add_monomial(mpq(1), v);
             }
         } else {
             m_lcm_den = lcm(m_lcm_den, denominator(m_k));
@@ -145,7 +145,7 @@ class gomory::imp {
             }
             // negate everything to return -pol <= -m_k
             for (const auto & pi: pol)
-                m_t.add_coeff_var(-pi.first, pi.second);
+                m_t.add_monomial(-pi.first, pi.second);
             m_k.neg();
         }
         TRACE("gomory_cut_detail", tout << "k = " << m_k << std::endl;);

src/math/lp/hnf_cutter.h

@@ -165,7 +165,7 @@ public:
     void fill_term(const vector<mpq> & row, lar_term& t) {
         for (unsigned j = 0; j < row.size(); j++) {
             if (!is_zero(row[j]))
-                t.add_coeff_var(row[j], m_var_register.local_to_external(j));
+                t.add_monomial(row[j], m_var_register.local_to_external(j));
         }
     }
 #ifdef Z3DEBUG

src/math/lp/horner.cpp

@@ -39,7 +39,7 @@ bool horner::row_has_monomial_to_refine(const T& row) const {
 // Returns true if the row has at least two monomials sharing a variable
 template <typename T>
 bool horner::row_is_interesting(const T& row) const {
-    TRACE("nla_solver_details", m_core->print_term(row, tout););
+    TRACE("nla_solver_details", m_core->print_row(row, tout););
     if (row.size() > m_core->m_nla_settings.horner_row_length_limit()) {
         TRACE("nla_solver_details", tout << "disregard\n";);
         return false;

src/math/lp/int_solver.cpp

@@ -1000,7 +1000,7 @@ lia_move int_solver::create_branch_on_column(int j) {
     TRACE("check_main_int", tout << "branching" << std::endl;);
     lp_assert(m_t.is_empty());
     lp_assert(j != -1);
-    m_t.add_coeff_var(mpq(1), m_lar_solver->adjust_column_index_to_term_index(j));
+    m_t.add_monomial(mpq(1), m_lar_solver->adjust_column_index_to_term_index(j));
     if (is_free(j)) {
         m_upper = true;
         m_k = mpq(0);

src/math/lp/lar_solver.cpp

@@ -603,7 +603,7 @@ lar_term lar_solver::get_term_to_maximize(unsigned j_or_term) const {
     }
     if (j_or_term < m_mpq_lar_core_solver.m_r_x.size()) {
         lar_term r;
-        r.add_coeff_var(one_of_type<mpq>(), j_or_term);
+        r.add_monomial(one_of_type<mpq>(), j_or_term);
         return r;
     } 
     return lar_term(); // return an empty term

src/math/lp/lar_solver.h

@@ -56,9 +56,9 @@ class lar_solver : public column_namer {
             using std::string;
             size_t seed = 0;
             int i = 0;
-            for (const auto& p : t.coeffs()) {
+            for (const auto p : t) {
-                hash_combine(seed, p.first);
+                hash_combine(seed, p.var());
-                hash_combine(seed, p.second);
+                hash_combine(seed, p.coeff());
                 if (i++ > 10)
                     break;
             }
@@ -69,7 +69,7 @@ class lar_solver : public column_namer {
     struct term_comparer {
         bool operator()(const lar_term &a, const lar_term& b) const
         {
-            return a.coeffs() == b.coeffs();            
+            return a == b;            
         }
     };
 

src/math/lp/lar_term.h

@@ -19,7 +19,7 @@
   --*/
 #pragma once
 #include "math/lp/indexed_vector.h"
-#include <map>
+#include "util/map.h"
 
 namespace lp {
 class lar_term {
@@ -70,7 +70,7 @@ public:
     vector<std::pair<mpq, lpvar>> coeffs_as_vector() const {
         vector<std::pair<mpq, lpvar>> ret;
         for (const auto & p :  m_coeffs) {
-            ret.push_back(std::make_pair(p.second, p.first));
+            ret.push_back(std::make_pair(p.m_value, p.m_key));
         }
         return ret;
     }
@@ -95,34 +95,34 @@ public:
         m_coeffs.insert(k, b);
     }
     
-    bool contains(lpvar j) const {
+    bool contains(unsigned j) const {
-        return m_coeffs.find(j) != m_coeffs.end();
+        return m_coeffs.contains(j);
     }
 
     void negate() {
         for (auto & t : m_coeffs)
-            t.second.neg();
+            t.m_value.neg();
     }
 
     template <typename T>
     T apply(const vector<T>& x) const {
         T ret(0);
         for (const auto & t : m_coeffs) {
-            ret += t.second * x[t.first];
+            ret += t.m_value * x[t.m_key];
         }
         return ret;
     }
    
     void clear() {
-        m_coeffs.clear();
+        m_coeffs.reset();
     }
 
     struct ival {
-        lpvar m_var;
+        unsigned m_var;
         const mpq & m_coeff;
-        ival(lpvar var, const mpq & val) : m_var(var), m_coeff(val) {
+        ival(unsigned var, const mpq & val) : m_var(var), m_coeff(val) {
         }
-        lpvar var() const { return m_var;}
+        unsigned var() const { return m_var;}
         const mpq & coeff() const { return m_coeff; }
     };
     
@@ -138,19 +138,20 @@ public:
         typedef std::forward_iterator_tag iterator_category;
 
         reference operator*() const {
-            return ival(m_it->first, m_it->second);
+            return ival(m_it->m_key, m_it->m_value);
         }
         
         self_type operator++() {  self_type i = *this; m_it++; return i;  }
         self_type operator++(int) { m_it++; return *this; }
 
-        const_iterator(std::map<lpvar, mpq>::const_iterator it) : m_it(it) {}
+        const_iterator(u_map<mpq>::iterator it) : m_it(it) {}
         bool operator==(const self_type &other) const {
             return m_it == other.m_it;
         }
         bool operator!=(const self_type &other) const { return !(*this == other); }
     };
 
+    
     bool is_normalized() const {
         lpvar min_var = -1;
         mpq c;
@@ -169,23 +170,22 @@ public:
         return false;        
     }
 
-    // a is the coefficient by which we diveded the term to normalize it
+    // a is the coefficient by which we divided the term to normalize it
     lar_term get_normalized_by_min_var(mpq& a) const {
-        a = m_coeffs.begin()->second;
+        a = m_coeffs.begin()->m_value;
         if (a.is_one()) {
             return *this;
         }
         lar_term r;
         auto it = m_coeffs.begin();
-        r.add_var(it->first);
+        r.add_var(it->m_key);
         it++;
         for(;it != m_coeffs.end(); it++) {
-            r.add_coeff_var(it->second / a, it->first);
+            r.add_monomial(it->m_value / a, it->m_key);
         }
         return r;        
     }
-    const_iterator begin() const { return const_iterator(m_coeffs.begin());}
+    const_iterator begin() const { return m_coeffs.begin();}
-    const_iterator end() const { return const_iterator(m_coeffs.end()); }
+    const_iterator end() const { return m_coeffs.end(); }
-
 };
 }

src/math/lp/nla_common.cpp

@@ -169,7 +169,7 @@ template <typename T> u_dependency* common::create_sum_from_row(const T& row,
                                                                 u_dependency_manager* dep_manager
                                                                 ) {
 
-    TRACE("nla_horner", tout << "row="; m_core->print_term(row, tout) << "\n";);
+    TRACE("nla_horner", tout << "row="; m_core->print_row(row, tout) << "\n";);
     u_dependency * dep = nullptr;
     SASSERT(row.size() > 1);
     sum.reset();

src/math/lp/nla_core.cpp

@@ -69,7 +69,7 @@ lp::lar_term core::subs_terms_to_columns(const lp::lar_term& t) const {
         lpvar j = p.var();
         if (m_lar_solver.is_term(j))
             j = m_lar_solver.map_term_index_to_column_index(j);
-        r.add_coeff_var(p.coeff(), j);
+        r.add_monomial(p.coeff(), j);
     }
     return r;
 } 
@@ -453,8 +453,8 @@ void core::mk_ineq_no_expl_check(lp::lar_term& t, llc cmp, const rational& rs) {
 
 void core::mk_ineq(const rational& a, lpvar j, const rational& b, lpvar k, llc cmp, const rational& rs) {
     lp::lar_term t;
-    t.add_coeff_var(a, j);
+    t.add_monomial(a, j);
-    t.add_coeff_var(b, k);
+    t.add_monomial(b, k);
     mk_ineq(t, cmp, rs);
 }
 
@@ -484,7 +484,7 @@ void core:: mk_ineq(lpvar j, llc cmp, const rational& rs) {
 
 void core:: mk_ineq(const rational& a, lpvar j, llc cmp, const rational& rs) {
     lp::lar_term t;        
-    t.add_coeff_var(a, j);
+    t.add_monomial(a, j);
     mk_ineq(t, cmp, rs);
 }
 
@@ -1157,7 +1157,7 @@ void core::add_abs_bound(lpvar v, llc cmp) {
 void core::add_abs_bound(lpvar v, llc cmp, rational const& bound) {
     SASSERT(!val(v).is_zero());
     lp::lar_term t;  // t = abs(v)
-    t.add_coeff_var(rrat_sign(val(v)), v);
+    t.add_monomial(rrat_sign(val(v)), v);
 
     switch (cmp) {
     case llc::GT:
@@ -1638,7 +1638,7 @@ void core::display_matrix_of_m_rows(std::ostream & out) const {
     out << m_rows.size() << " rows" <<"\n";
     out << "the matrix\n";          
     for (const auto & r : matrix.m_rows) {
-        print_term(r, out) << std::endl;
+        print_row(r, out) << std::endl;
     }
 }
 

src/math/lp/nla_core.h

@@ -392,6 +392,15 @@ public:
     lpvar map_to_root(lpvar) const;
     std::ostream& print_terms(std::ostream&) const;
     std::ostream& print_term(const lp::lar_term&, std::ostream&) const;
+    template <typename T>
+    std::ostream& print_row(const T & row , std::ostream& out) const {
+        vector<std::pair<rational, lpvar>> v;
+        for (auto p : row) {
+            v.push_back(std::make_pair(p.coeff(), p.var()));
+        }
+        return lp::print_linear_combination_customized(v, [this](lpvar j) { return var_str(j); },
+        out);        
+    }
     void run_pdd_grobner();
     void find_nl_cluster();
     void prepare_rows_and_active_vars();

src/math/lp/nla_intervals.cpp

@@ -138,13 +138,13 @@ lp::lar_term intervals::expression_to_normalized_term(const nex_sum* e, rational
 
     if (a.is_one()) {
         for (auto& p : v) {
-            t.add_coeff_var(p.first, p.second);
+            t.add_monomial(p.first, p.second);
         }
     } else {
         for (unsigned k = 0; k < v.size(); k++) {
             auto& p = v[k];
             if (k != a_index) 
-                t.add_coeff_var(p.first/a, p.second);
+                t.add_monomial(p.first/a, p.second);
             else
                 t.add_var(p.second);
         }

src/math/lp/nla_tangent_lemmas.cpp

@@ -63,8 +63,8 @@ void tangents::generate_tang_plane(const rational & a, const rational& b, const
 #endif
 
     lp::lar_term t;
-    t.add_coeff_var(-a, jy);
+    t.add_monomial(-a, jy);
-    t.add_coeff_var(-b, jx);
+    t.add_monomial(-b, jx);
     t.add_var(j);
     c().mk_ineq(t, below? llc::GT : llc::LT, - a*b);
 }

src/test/lp/gomory_test.h

@@ -82,7 +82,7 @@ struct gomory_test {
             expl.push_justification(column_upper_bound_constraint(x_j), new_a);
         }
         TRACE("gomory_cut_detail_real", tout << a << "*v" << x_j << " k: " << k << "\n";);
-        pol.add_coeff_var(new_a, x_j);
+        pol.add_monomial(new_a, x_j);
     }
     
     void int_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & k, lar_term & t, explanation& expl, mpq & lcm_den, const mpq& f_0, const mpq& one_minus_f_0) {
@@ -122,7 +122,7 @@ struct gomory_test {
             expl.push_justification(column_upper_bound_constraint(x_j), new_a);
         }
         TRACE("gomory_cut_detail", tout << "new_a: " << new_a << " k: " << k << "\n";);
-        t.add_coeff_var(new_a, x_j);
+        t.add_monomial(new_a, x_j);
         lcm_den = lcm(lcm_den, denominator(new_a));
     }
 
@@ -145,12 +145,12 @@ struct gomory_test {
                 if (!k.is_int())
                     k = ceil(k);
                 // switch size
-                t.add_coeff_var(- mpq(1), v);
+                t.add_monomial(- mpq(1), v);
                 k.neg();
             } else {
                 if (!k.is_int())
                     k = floor(k);
-                t.add_coeff_var(mpq(1), v);
+                t.add_monomial(mpq(1), v);
             }
         } else {
             TRACE("gomory_cut_detail", tout << "pol.size() > 1" << std::endl;);
@@ -177,7 +177,7 @@ struct gomory_test {
             
             // negate everything to return -pol <= -k
             for (const auto & pi: pol)
-                t.add_coeff_var(-pi.first, pi.second);
+                t.add_monomial(-pi.first, pi.second);
             k.neg();
         }
         TRACE("gomory_cut_detail", tout << "k = " << k << std::endl;);

src/test/lp/nla_solver_test.cpp

@@ -118,10 +118,10 @@ void test_basic_lemma_for_mon_neutral_from_factors_to_monomial_0() {
     i0.m_term.add_var(lp_ac);
     ineq i1(llc::EQ, lp::lar_term(), rational(0));
     i1.m_term.add_var(lp_bde);
-    i1.m_term.add_coeff_var(-rational(1), lp_abcde);
+    i1.m_term.add_monomial(-rational(1), lp_abcde);
     ineq i2(llc::EQ, lp::lar_term(), rational(0));
     i2.m_term.add_var(lp_abcde);
-    i2.m_term.add_coeff_var(-rational(1), lp_bde);
+    i2.m_term.add_monomial(-rational(1), lp_bde);
     bool found0 = false;
     bool found1 = false;
     bool found2 = false;
@@ -428,7 +428,7 @@ void test_horner() {
 
     lp::lar_term t;
     t.add_var(lp_c);
-    t.add_coeff_var(rational(-1), lp_b);
+    t.add_monomial(rational(-1), lp_b);
     lpvar lp_c_min_b = s.add_term(t.coeffs_as_vector(), c_min_b);
     
     reslimit l;
@@ -573,7 +573,7 @@ void test_order_lemma_params(bool var_equiv, int sign) {
     if (var_equiv) { // make k equivalent to j
         lp::lar_term t;
         t.add_var(lp_k);
-        t.add_coeff_var(-rational(1), lp_j);
+        t.add_monomial(-rational(1), lp_j);
         lpvar kj = s.add_term(t.coeffs_as_vector(), -1);
         s.add_var_bound(kj, llc::LE, rational(0));
         s.add_var_bound(kj, llc::GE, rational(0));
@@ -630,15 +630,15 @@ void test_order_lemma_params(bool var_equiv, int sign) {
 
     SASSERT(nla.get_core()->test_check(lemma) == l_false);
     // lp::lar_term t;
-    // t.add_coeff_var(lp_bde);
+    // t.add_monomial(lp_bde);
-    // t.add_coeff_var(lp_acd);
+    // t.add_monomial(lp_acd);
     // ineq q(llc::EQ, t, rational(0));
    
     nla.get_core()->print_lemma(std::cout);
     // SASSERT(q == lemma.back());
     // ineq i0(llc::EQ, lp::lar_term(), rational(0));
-    // i0.m_term.add_coeff_var(lp_bde);
+    // i0.m_term.add_monomial(lp_bde);
-    // i0.m_term.add_coeff_var(rational(1), lp_acd);
+    // i0.m_term.add_monomial(rational(1), lp_acd);
     // bool found = false;
     // for (const auto& k : lemma){
     //     if (k == i0) {

src/test/pdd.cpp

@@ -67,6 +67,22 @@ namespace dd {
     VERIFY(r_fe == f);
 }
 
+static void test3() {
+    std::cout << "\ntest3\n";
+    pdd_manager m(4);
+    pdd a = m.mk_var(0);
+    pdd b = m.mk_var(1);
+    pdd c = m.mk_var(2);
+    pdd d = m.mk_var(3);
+        
+    pdd e = a + c;
+    for (unsigned i = 0; i < 5; i++) {
+        e = e * e;
+    }
+    e = e * b;
+    std::cout << e << "\n";
+}
+
 static void test_reset() {
     std::cout << "\ntest reset\n";
     pdd_manager m(4);
@@ -110,25 +126,6 @@ static void test5() {
     SASSERT(e == f);        
 }
 
-    static void test_reset() {
-        std::cout << "\ntest reset\n";
-        pdd_manager m(4);
-        pdd a = m.mk_var(0);
-        pdd b = m.mk_var(1);
-        pdd c = m.mk_var(2);
-        pdd d = m.mk_var(3);
-        std::cout << (a + b)*(c + d) << "\n";
-
-        unsigned_vector l2v;
-        for (unsigned i = 0; i < 4; ++i) 
-            l2v.push_back(3 - i);
-        m.reset(l2v);
-        a = m.mk_var(0);
-        b = m.mk_var(1);
-        c = m.mk_var(2);
-        d = m.mk_var(3);
-        std::cout << (a + b)*(c + d) << "\n";
-    }
 
     void test_iterator() {
         std::cout << "test iterator\n";
@@ -150,6 +147,7 @@ void tst_pdd() {
     dd::test1();
     dd::test2();
     dd::test3();
+    dd::test5();
     dd::test_reset();
     dd::test_iterator();
 }