move some functionality from int_solver to int_solver::imp

src/math/lp/gomory.cpp

@@ -406,7 +406,7 @@ public:
         unsigned n = static_cast<unsigned>(sorted_vars.size());
 
         while (num_cuts-- && n > 0) {
-            unsigned k = lia.random() % n;
+            unsigned k = lia.settings().random_next() % n;
            
             double k_ratio = k / (double) n;
             k_ratio *= k_ratio*k_ratio;  // square k_ratio to make it smaller
@@ -496,7 +496,7 @@ public:
         auto _check_feasible = [&](void) {
             lra.find_feasible_solution();
             if (!lra.is_feasible() && !lia.settings().get_cancel_flag()) {
-                lra.get_infeasibility_explanation(*lia.m_ex);
+                lra.get_infeasibility_explanation(*(lia.explanation()));
                 return false;
             }
             return true;
@@ -507,7 +507,7 @@ public:
             SASSERT(is_gomory_cut_target(j));
             unsigned row_index = lia.row_of_basic_column(j);
             const row_strip<mpq>& row = lra.get_row(row_index);
-            create_cut cc(lia.m_t, lia.m_k, lia.m_ex, j, row, lia);
+            create_cut cc(lia.get_term(), lia.offset(), lia.explanation(), j, row, lia);
             auto r = cc.cut();
             if (r != lia_move::cut) {
                 if (r == lia_move::conflict)
@@ -520,7 +520,7 @@ public:
             else if (cc.m_polarity == row_polarity::MIN)
                 lra.update_column_type_and_bound(j, lp::lconstraint_kind::GE, ceil(lra.get_column_value(j).x), add_deps(cc.m_dep, row, j));
             
-            if (!is_small_cut(lia.m_t)) {
+            if (!is_small_cut(lia.get_term())) {
                 big_cuts.push_back({cc.m_t, cc.m_k, cc.m_dep});
                 continue;
             }
@@ -548,7 +548,7 @@ public:
         if (lra.get_status() == lp_status::CANCELLED)
             return lia_move::cancelled;        
         
-        if (!lia.has_inf_int())
+        if (!lra.has_inf_int())
             return lia_move::sat;
 
         if (has_small_cut || big_cuts.size())

src/math/lp/hnf_cutter.cpp

@@ -260,7 +260,7 @@ branch y_i >= ceil(y0_i) is impossible.
 #ifdef Z3DEBUG
         vector<mpq> x0 = transform_to_local_columns(lra.r_x());
 #endif
-        lia_move r =  create_cut(lia.m_t, lia.m_k, lia.m_ex, lia.m_upper
+        lia_move r =  create_cut(lia.get_term(), lia.offset(), lia.explanation(), lia.is_upper()
 #ifdef Z3DEBUG
                                  , x0
 #endif
@@ -268,18 +268,18 @@ branch y_i >= ceil(y0_i) is impossible.
         
         if (r == lia_move::cut) {      
             TRACE("hnf_cut",
-                  lra.print_term(lia.m_t, tout << "cut:"); 
+                  lra.print_term(lia.get_term(), tout << "cut:"); 
-                  tout << " <= " << lia.m_k << std::endl;
+                  tout << " <= " << lia.offset() << std::endl;
                   for (auto* dep : constraints_for_explanation()) 
                       for (auto ci : lra.flatten(dep))
                           lra.constraints().display(tout, ci);                  
                   );
             lp_assert(lia.current_solution_is_inf_on_cut());
             lia.settings().stats().m_hnf_cuts++;
-            lia.m_ex->clear();        
+            lia.explanation()->clear();        
             for (u_dependency* dep : constraints_for_explanation()) 
                 for (auto ci : lia.lra.flatten(dep))
-                    lia.m_ex->push_back(ci);            
+                    lia.explanation()->push_back(ci);            
         } 
         return r;
     }

src/math/lp/int_branch.cpp

@@ -31,22 +31,22 @@ lia_move int_branch::operator()() {
 
 lia_move int_branch::create_branch_on_column(int j) {
     TRACE("check_main_int", tout << "branching" << std::endl;);
-    lia.m_t.clear();
+    lia.get_term().clear();
 
     lp_assert(j != -1);
-    lia.m_t.add_monomial(mpq(1), j);
+    lia.get_term().add_monomial(mpq(1), j);
     if (lia.is_free(j)) {
-        lia.m_upper = lia.random() % 2;
+        lia.is_upper() = lia.settings().random_next() % 2;
-        lia.m_k = mpq(0);
+        lia.offset() = mpq(0);
     }
     else {
-        lia.m_upper = lia.random() % 2;
+        lia.is_upper() = lia.settings().random_next() % 2;
-        lia.m_k = lia.m_upper? floor(lia.get_value(j)) : ceil(lia.get_value(j));        
+        lia.offset() = lia.is_upper()? floor(lia.get_value(j)) : ceil(lia.get_value(j));        
     }
         
     TRACE("int_solver",
           lia.display_column(tout << "branching v" << j << " = " << lia.get_value(j) << "\n", j);
-          tout << "k = " << lia.m_k << std::endl;);
+          tout << "k = " << lia.offset() << std::endl;);
     return lia_move::branch;        
 }
 
@@ -86,7 +86,7 @@ int int_branch::find_inf_int_base_column() {
             result = j;
             prev_usage = usage;
             n = 1;
-        } else if (usage == prev_usage && (lia.random() % (++n) == 0)) {
+        } else if (usage == prev_usage && (lia.settings().random_next() % (++n) == 0)) {
             result = j;
         }
     }
@@ -103,7 +103,7 @@ int int_branch::find_inf_int_base_column() {
             n = 1;
             result = j;
             range = new_range;
-        } else if (new_range == range && (lia.random() % (++n) == 0)) {
+        } else if (new_range == range && (lia.settings().random_next() % (++n) == 0)) {
             result = j;                    
         }
     }

src/math/lp/int_gcd_test.cpp

@@ -252,7 +252,7 @@ namespace lp {
     void int_gcd_test::add_to_explanation_from_fixed_or_boxed_column(unsigned j) {
         auto* deps = lra.get_bound_constraint_witnesses_for_column(j);
         for (auto d : lra.flatten(deps))
-            lia.m_ex->push_back(d);
+            lia.explanation()->push_back(d);
     }
 
     bool int_gcd_test::accumulate_parity(const row_strip<mpq> & row, unsigned least_idx) {

src/math/lp/int_solver.h

@@ -31,7 +31,7 @@ Revision History:
 namespace lp {
 class lar_solver;
 class lar_core_solver;
-class imp;
+struct imp;
 class int_solver {
     friend struct create_cut;
     friend class gomory;
@@ -39,31 +39,23 @@ class int_solver {
     friend class int_branch;
     friend class int_gcd_test;
     friend class hnf_cutter;
-    friend class imp;
+    friend struct imp;
 
     lar_solver&         lra;
     lar_core_solver&    lrac;
-    int_gcd_test        m_gcd;
+    imp*                m_imp; 
-    imp                 *m_imp;
-    unsigned            m_number_of_calls;
-    lar_term            m_t;               // the term to return in the cut
-    mpq                 m_k;               // the right side of the cut
-    bool                m_upper;           // cut is an upper bound
-    explanation         *m_ex;             // the conflict explanation
-    hnf_cutter          m_hnf_cutter;
-    unsigned            m_hnf_cut_period;
-    unsigned_vector     m_cut_vars;        // variables that should not be selected for cuts
-    
     vector<equality>       m_equalities;
 public:
     int_solver(lar_solver& lp);
     ~int_solver();
-    // main function to check that the solution provided by lar_solver is valid for integral values,
+    // the function that doing the main job
-    // or provide a way of how it can be adjusted.
     lia_move check(explanation *);
-    lar_term const& get_term() const { return m_t; }
+    lar_term const& get_term() const;
-    mpq const& get_offset() const { return m_k; }
+    lar_term & get_term();
-    bool is_upper() const { return m_upper; }
+    mpq const& offset() const;
+    mpq & offset();
+    bool is_upper() const;
+    bool& is_upper();
     bool is_base(unsigned j) const;
     bool is_real(unsigned j) const;
     const impq & lower_bound(unsigned j) const;
@@ -84,17 +76,14 @@ private:
     bool is_feasible() const;
     bool column_is_int_inf(unsigned j) const;
     std::ostream& display_inf_rows(std::ostream&) const;
-    bool should_find_cube();
+   
-    bool should_gomory_cut();
-    bool should_hnf_cut();
-
     lp_settings& settings();
     const lp_settings& settings() const;
     bool at_bound(unsigned j) const;
     bool has_lower(unsigned j) const;
     bool has_upper(unsigned j) const;
     unsigned row_of_basic_column(unsigned j) const;
-    bool cut_indices_are_columns() const;
+   
         
 public:
     bool is_fixed(unsigned j) const;
@@ -107,15 +96,10 @@ public:
     std::ostream&  display_row_info(std::ostream & out, unsigned row_index) const;
     std::ostream & display_row(std::ostream & out, vector<row_cell<rational>> const & row) const;
 
-private:
-    unsigned random();
-    bool has_inf_int() const;
 public:
     bool is_term(unsigned j) const;
     unsigned column_count() const;
-    lia_move hnf_cut();
-
     int select_int_infeasible_var();
-    
+    explanation * explanation();
 };
 }

src/math/lp/lp_settings.h

@@ -217,6 +217,7 @@ public:
     unsigned         column_number_threshold_for_using_lu_in_lar_solver = 4000;
     unsigned         m_int_gomory_cut_period = 4;
     unsigned         m_int_find_cube_period = 4;
+    unsigned         m_dioph_eq_period = 4;
 private:
     unsigned         m_hnf_cut_period = 4;
     bool             m_int_run_gcd_test = true;

src/sat/smt/arith_solver.cpp

@@ -1176,7 +1176,7 @@ namespace arith {
             TRACE("arith", tout << "branch\n";);
             app_ref b(m);
             bool u = m_lia->is_upper();
-            auto const& k = m_lia->get_offset();
+            auto const& k = m_lia->offset();
             rational offset;
             expr_ref t(m);
             b = mk_bound(m_lia->get_term(), k, !u, offset, t);
@@ -1199,7 +1199,7 @@ namespace arith {
                 set_evidence(ev.ci());
             // The call mk_bound() can set the m_infeasible_column in lar_solver
             // so the explanation is safer to take before this call.
-            app_ref b = mk_bound(m_lia->get_term(), m_lia->get_offset(), !m_lia->is_upper());
+            app_ref b = mk_bound(m_lia->get_term(), m_lia->offset(), !m_lia->is_upper());
             IF_VERBOSE(4, verbose_stream() << "cut " << b << "\n");
             literal lit = expr2literal(b);
             assign(lit, m_core, m_eqs, explain(hint_type::cut_h, lit));

src/smt/theory_lra.cpp

@@ -1888,7 +1888,7 @@ public:
         case lp::lia_move::branch: {
             TRACE("arith", tout << "branch\n";);
             bool u = m_lia->is_upper();
-            auto const & k = m_lia->get_offset();
+            auto const & k = m_lia->offset();
             rational offset;
             expr_ref t(m);
             expr_ref b = mk_bound(m_lia->get_term(), k, !u, offset, t);
@@ -1919,13 +1919,13 @@ public:
             }
             // The call mk_bound() can set the m_infeasible_column in lar_solver
             // so the explanation is safer to take before this call.
-            expr_ref b = mk_bound(m_lia->get_term(), m_lia->get_offset(), !m_lia->is_upper());
+            expr_ref b = mk_bound(m_lia->get_term(), m_lia->offset(), !m_lia->is_upper());
             if (m.has_trace_stream()) {
                 th.log_axiom_instantiation(b);
                 m.trace_stream() << "[end-of-instance]\n";
             }
             IF_VERBOSE(4, verbose_stream() << "cut " << b << "\n");
-            TRACE("arith", dump_cut_lemma(tout, m_lia->get_term(), m_lia->get_offset(), m_explanation, m_lia->is_upper()););
+            TRACE("arith", dump_cut_lemma(tout, m_lia->get_term(), m_lia->offset(), m_explanation, m_lia->is_upper()););
             literal lit(ctx().get_bool_var(b), false);
             TRACE("arith", 
                   ctx().display_lemma_as_smt_problem(tout << "new cut:\n", m_core.size(), m_core.data(), m_eqs.size(), m_eqs.data(), lit);