debug emons

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

src/smt/smt_context_pp.cpp

@@ -493,6 +493,7 @@ namespace smt {
         TRACE("lemma", tout << strm.str() << "\n";);
         display_lemma_as_smt_problem(out, num_antecedents, antecedents, num_eq_antecedents, eq_antecedents, consequent, logic);
         out.close();
+        if (m_lemma_id==6998) exit(0);
         return m_lemma_id;
     }
 

src/util/lp/emonomials.cpp

@@ -40,6 +40,7 @@ namespace nla {
     m_lim.push_back(m_monomials.size());
     m_region.push_scope();
     m_ve.push();
+    SASSERT(monomials_are_canonized());
 }
 
 void emonomials::pop(unsigned n) {
@@ -61,6 +62,7 @@ namespace nla {
     m_monomials.shrink(old_sz);
     m_region.pop_scope(n);
     m_lim.shrink(m_lim.size() - n);
+    SASSERT(monomials_are_canonized());
 }
 
 void emonomials::remove_cell(head_tail& v, unsigned mIndex) {
@@ -274,6 +276,22 @@ namespace nla {
     m.sort_rvars();
 }
 
+bool emonomials::is_canonized(const monomial & m) const {
+    monomial mm(m);
+    do_canonize(mm);
+    return mm.rvars() == m.rvars();
+}
+
+bool emonomials:: monomials_are_canonized() const {
+    for (auto & m: m_monomials) {
+        if (! is_canonized(m)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+
 bool emonomials::canonize_divides(monomial& m, monomial & n) const {
     if (m.size() > n.size()) return false;
     unsigned ms = m.size(), ns = n.size();
@@ -344,7 +362,7 @@ std::ostream& emonomials::display(const core& cr, std::ostream& out) const {
     out << "monomials\n";
     unsigned idx = 0;
     for (auto const& m : m_monomials) {
-           out << (idx++) << ": " << pp_mon(cr, m) << "\n";
+        out << (idx++) << ": " << pp_rmon(cr, m) << "\n";
     }
     out << "use lists\n";
     idx = 0;

src/util/lp/emonomials.h

@@ -100,7 +100,6 @@ class emonomials : public var_eqs_merge_handler {
     void rehash_cg(lpvar v) { remove_cg(v); insert_cg(v); }
 
     void do_canonize(monomial& m) const; 
-
     cell* head(lpvar v) const;
     void set_visited(monomial& m) const;
     bool is_visited(monomial const& m) const;
@@ -141,6 +140,8 @@ public:
     */
     monomial const& operator[](lpvar v) const { return m_monomials[m_var2index[v]]; }
     monomial & operator[](lpvar v) { return m_monomials[m_var2index[v]]; }
+    bool is_canonized(const monomial&) const;    
+    bool monomials_are_canonized() const;
     
     /**
        \brief obtain the representative canonized monomial 
@@ -204,7 +205,9 @@ public:
     public:
         pf_iterator(emonomials const& m, monomial& mon, bool at_end);
         pf_iterator(emonomials const& m, lpvar v, bool at_end);
-        monomial & operator*() { return *m_it; }
+        monomial & operator*() {
+            return *m_it;
+        }
         pf_iterator& operator++() { ++m_it; fast_forward(); return *this; }
         pf_iterator operator++(int) { pf_iterator tmp = *this; ++*this; return tmp; }
         bool operator==(pf_iterator const& other) const { return m_it == other.m_it; }

src/util/lp/monomial.h

@@ -63,7 +63,7 @@ public:
     svector<lpvar> const& rvars() const { return m_rvars; }
     bool sign() const { return m_rsign; }
     rational rsign() const { return rational(m_rsign ? -1 : 1); }
-    void reset_rfields() { m_rsign = false; m_rvars.reset(); }
+    void reset_rfields() { m_rsign = false; m_rvars.reset(); SASSERT(m_rvars.size() == 0); }
     void push_rvar(signed_var sv) { m_rsign ^= sv.sign(); m_rvars.push_back(sv.var()); }
     void sort_rvars() {
         std::sort(m_rvars.begin(), m_rvars.end());

src/util/lp/nla_basics_lemmas.cpp

@@ -121,11 +121,13 @@ bool basics::basic_sign_lemma_on_mon(lpvar v, std::unordered_set<unsigned> & exp
     if (!try_insert(v, explored)) {
         return false;
     }
-
     const monomial& m_v = c().m_emons[v];
-    TRACE("nla_solver_details", tout << "mon = " << pp_mon(c(), m_v););
+    TRACE("nla_solver", tout << "m_v = " << pp_rmon(c(), m_v););
+    SASSERT(c().m_emons.is_canonized(m_v));
 
     for (auto const& m : c().m_emons.enum_sign_equiv_monomials(v)) {
+        TRACE("nla_solver_details", tout << "m = " << pp_rmon(c(), m););
+        SASSERT(m.rvars() == m_v.rvars());
         if (m_v.var() != m.var() && basic_sign_lemma_on_two_monomials(m_v, m) && done()) 
             return true;
     }
@@ -154,12 +156,14 @@ bool basics::basic_sign_lemma(bool derived) {
 void basics::generate_sign_lemma(const monomial& m, const monomial& n, const rational& sign) {
     add_empty_lemma();
     TRACE("nla_solver",
-          tout << "m = "; c().print_monomial_with_vars(m, tout);
+          tout << "m = " << pp_rmon(_(), m);
-          tout << "n = "; c().print_monomial_with_vars(n, tout);
+          tout << "n = " << pp_rmon(_(), n);
           );
     c().mk_ineq(m.var(), -sign, n.var(), llc::EQ);
     explain(m);
+    TRACE("nla_solver", tout << "m exp = "; _().print_explanation(_().current_expl(), tout););
     explain(n);        
+    TRACE("nla_solver", tout << "n exp = "; _().print_explanation(_().current_expl(), tout););
     TRACE("nla_solver", c().print_lemma(tout););
 }
 // try to find a variable j such that val(j) = 0

src/util/lp/nla_core.cpp

@@ -112,7 +112,9 @@ void core::push() {
      
 void core::pop(unsigned n) {
     TRACE("nla_solver", tout << "n = " << n << "\n";);
+    TRACE("nla_solver", tout << "before pop mons = " << pp_emons(*this, m_emons) << "\n";);   
     m_emons.pop(n); 
+    TRACE("nla_solver", tout << "after pop mons = " << pp_emons(*this, m_emons) << "\n";);   
 }
 
 rational core::product_value(const unsigned_vector & m) const {
@@ -718,7 +720,8 @@ std::ostream & core::print_var(lpvar j, std::ostream & out) const {
         out << " = " << val(j);;
     }
         
-    m_lar_solver.print_column_info(j, out) <<";";
+    m_lar_solver.print_column_info(j, out);
+    out << "root=" << m_evars.find(j) << "\n";
     return out;
 }
 

src/util/lp/var_eqs.cpp

@@ -120,6 +120,8 @@ void var_eqs::explain_dfs(signed_var v1, signed_var v2, lp::explanation& e) cons
 }
 
 void var_eqs::explain_bfs(signed_var v1, signed_var v2, lp::explanation& e) const {
+    static int ddd=0;
+    TRACE("nla_solver", tout << ++ddd << "\n";);
     SASSERT(find(v1) == find(v2));
     if (v1 == v2) {
         return;