Exploit dual degeneracy to reduce the number of integer infeasibilities

cpp/include/cuopt/mathematical_optimization/constants.h

@@ -85,6 +85,9 @@
 #define CUOPT_MIP_ZERO_HALF_CUTS                    "mip_zero_half_cuts"
 #define CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS        "mip_strong_chvatal_gomory_cuts"
 #define CUOPT_MIP_REDUCED_COST_STRENGTHENING        "mip_reduced_cost_strengthening"
+#define CUOPT_MIP_DUAL_DEGENERATE_FEASIBILITY_PUMP  "mip_dual_degenerate_feasibility_pump"
+#define CUOPT_MIP_PRIMAL_DEGENERATE_PIVOTS          "mip_primal_degenerate_pivots"
+#define CUOPT_MIP_DUAL_DEGENERATE_PIVOTS            "mip_dual_degenerate_pivots"
 #define CUOPT_MIP_RINS                              "mip_rins"
 #define CUOPT_MIP_RENS                              "mip_rens"
 #define CUOPT_MIP_OBJECTIVE_STEP                    "mip_objective_step"

cpp/include/cuopt/mathematical_optimization/mip/solver_settings.hpp

@@ -135,11 +135,14 @@ class mip_solver_settings_t {
   i_t clique_cuts               = -1;
   i_t zero_half_cuts            = -1;
   i_t implied_bound_cuts        = -1;
-  i_t strong_chvatal_gomory_cuts = -1;
-  i_t reduced_cost_strengthening = -1;
-  i_t objective_step             = 1;  // 0 = disable objective step tightening, 1 = enable
-  f_t cut_change_threshold       = -1.0;
-  f_t cut_min_orthogonality      = 0.5;
+  i_t strong_chvatal_gomory_cuts       = -1;
+  i_t reduced_cost_strengthening       = -1;
+  i_t dual_degenerate_feasibility_pump = -1;  // -1 = automatic (on), 0 = off, 1 = on
+  i_t primal_degenerate_pivots         = -1;  // -1 = automatic (on), 0 = off, 1 = on
+  i_t dual_degenerate_pivots           = -1;  // -1 = automatic (on), 0 = off, 1 = on
+  i_t objective_step                   = 1;   // 0 = disable objective step tightening, 1 = enable
+  f_t cut_change_threshold             = -1.0;
+  f_t cut_min_orthogonality            = 0.5;
   i_t mip_batch_pdlp_strong_branching{
     0};  // 0 = DS only, 1 = cooperative DS + PDLP, 2 = batch PDLP only
   i_t mip_batch_pdlp_reliability_branching{

cpp/src/branch_and_bound/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 set(BRANCH_AND_BOUND_SRC_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/branch_and_bound.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/degenerate_pivots.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/pseudo_costs.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/diving_heuristics.cpp
   )

cpp/src/branch_and_bound/branch_and_bound.hpp

@@ -12,6 +12,7 @@
 #include <branch_and_bound/mip_node.hpp>
 #include <branch_and_bound/node_queue.hpp>
 #include <branch_and_bound/pseudo_costs.hpp>
+#include <branch_and_bound/reduced_cost_bounds.hpp>
 #include <branch_and_bound/worker.hpp>
 #include <branch_and_bound/worker_pool.hpp>
 
@@ -41,6 +42,7 @@
 #include <atomic>
 #include <functional>
 #include <future>
+#include <limits>
 #include <list>
 #include <memory>
 #include <vector>
@@ -175,8 +177,13 @@ class branch_and_bound_t {
     simplex::basis_update_mpf_t<i_t, f_t>& basis_update,
     std::vector<i_t>& basic_list,
     std::vector<i_t>& nonbasic_list,
-    std::vector<f_t>& edge_norms);
+    std::vector<f_t>& edge_norms,
+    f_t& work_estimate);
 
+  void update_reduced_cost_bounds(f_t relaxation_objective,
+                                  const std::vector<f_t>& reduced_costs,
+                                  const std::vector<simplex::variable_status_t>& var_status,
+                                  reduced_cost_bounds_t<i_t, f_t>& reduced_cost_bounds);
   i_t find_reduced_cost_fixings(f_t upper_bound,
                                 std::vector<f_t>& lower_bounds,
                                 std::vector<f_t>& upper_bounds);
@@ -246,6 +253,7 @@ class branch_and_bound_t {
   simplex::lp_solution_t<i_t, f_t> root_relax_soln_;
   simplex::lp_solution_t<i_t, f_t> root_crossover_soln_;
   method_t root_relax_solved_by{Unset};
+  f_t root_relax_work_estimate_;
   std::vector<f_t> edge_norms_;
   std::atomic<bool> root_crossover_solution_set_{false};
   omp_atomic_t<f_t> root_lp_current_lower_bound_;
@@ -326,6 +334,7 @@ class branch_and_bound_t {
                                 f_t& last_upper_bound,
                                 f_t& last_objective,
                                 f_t root_relax_objective,
+                                reduced_cost_bounds_t<i_t, f_t>& reduced_cost_bounds,
                                 i_t& cut_pool_size,
                                 const std::vector<f_t>& saved_solution);
 
@@ -345,6 +354,8 @@ class branch_and_bound_t {
                              i_t leaf_depth,
                              search_strategy_t thread_type);
 
+  omp_atomic_t<i_t> integer_pivots_{0};
+
   // Repairs low-quality solutions from the heuristics, if it is applicable.
   void repair_heuristic_solutions();
 
@@ -405,6 +416,7 @@ class branch_and_bound_t {
 
   // Solve the LP relaxation of a leaf node
   simplex::dual_status_t solve_node_lp(mip_node_t<i_t, f_t>* node_ptr,
+                                       const simplex::simplex_solver_settings_t<i_t, f_t>& settings,
                                        branch_and_bound_worker_t<i_t, f_t>* worker,
                                        branch_and_bound_stats_t<i_t, f_t>& stats,
                                        simplex::logger_t& log,