Zero Half(Odd-Cycle) cuts

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

@@ -129,6 +129,7 @@ class mip_solver_settings_t {
   i_t knapsack_cuts             = -1;
   i_t flow_cover_cuts           = -1;
   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;

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -2475,7 +2475,7 @@ mip_status_t branch_and_bound_t<i_t, f_t>::solve(mip_solution_t<i_t, f_t>& solut
 
   omp_atomic_t<bool>* clique_signal = &signal_extend_cliques_;
 
-  if (settings_.clique_cuts != 0 && clique_table_ == nullptr &&
+  if ((settings_.clique_cuts != 0 || settings_.zero_half_cuts != 0) && clique_table_ == nullptr &&
       omp_get_num_threads() >= CUOPT_MIP_CLIQUE_CUTS_REQUIRED_THREAD_COUNT) {
     signal_extend_cliques_.store(false, std::memory_order_release);
     typename mip_solver_settings_t<i_t, f_t>::tolerances_t tolerances_for_clique{};

cpp/src/cuts/cuts.hpp

@@ -41,8 +41,9 @@ enum cut_type_t : int8_t {
   CHVATAL_GOMORY         = 3,
   CLIQUE                 = 4,
   IMPLIED_BOUND          = 5,
-  FLOW_COVER             = 6,
-  MAX_CUT_TYPE           = 7
+  ZERO_HALF              = 6,
+  FLOW_COVER             = 7,
+  MAX_CUT_TYPE           = 8
 };
 
 template <typename f_t>
@@ -182,6 +183,7 @@ struct cut_info_t {
                                               "Strong CG     ",
                                               "Clique        ",
                                               "Implied Bounds",
+                                              "Zero-Half     ",
                                               "Flow Cover    "};
   std::array<i_t, MAX_CUT_TYPE> num_cuts   = {0};
 };
@@ -273,6 +275,16 @@ std::vector<std::vector<int>> find_maximal_cliques_for_test(
   int max_calls,
   double time_limit);
 
+// Test-only helper to run the production odd-cycle separator used by zero-half cuts.
+// adjacency_list must contain local vertex indices in [0, n_vertices). x_values gives
+// the LP value for each vertex. Returns simple odd cycles whose induced edge weight
+// sum is < 0.5 - min_violation.
+std::vector<std::vector<int>> find_violated_odd_cycles_for_test(
+  const std::vector<std::vector<int>>& adjacency_list,
+  const std::vector<double>& x_values,
+  double min_violation,
+  double time_limit);
+
 template <typename i_t, typename f_t>
 class cut_pool_t {
  public:
@@ -581,6 +593,34 @@ class knapsack_generation_t {
 template <typename i_t, typename f_t>
 class mixed_integer_rounding_cut_t;
 
+template <typename i_t, typename f_t>
+class variable_bounds_t;
+
+template <typename i_t, typename f_t>
+struct fractional_conflict_subgraph_t {
+  i_t num_vars{0};
+  std::vector<i_t> vertices;
+  std::vector<f_t> weights;
+  std::vector<i_t> vertex_to_local;
+  std::vector<char> in_subgraph;
+  std::vector<std::vector<i_t>> adj_local;
+  bool ready{false};
+
+  i_t num_local() const { return static_cast<i_t>(vertices.size()); }
+  bool empty_subgraph() const { return vertices.empty(); }
+
+  void clear()
+  {
+    num_vars = 0;
+    vertices.clear();
+    weights.clear();
+    vertex_to_local.clear();
+    in_subgraph.clear();
+    adj_local.clear();
+    ready = false;
+  }
+};
+
 template <typename i_t, typename f_t>
 class cut_generation_t {
  public:
@@ -666,20 +706,33 @@ class cut_generation_t {
                             const std::vector<f_t>& reduced_costs,
                             f_t start_time);
 
+  // Generate zero-half (odd-cycle / odd-wheel) cuts from the conflict graph
+  bool generate_zero_half_cuts(const lp_problem_t<i_t, f_t>& lp,
+                               const simplex_solver_settings_t<i_t, f_t>& settings,
+                               const std::vector<variable_type_t>& var_types,
+                               const std::vector<f_t>& xstar,
+                               const std::vector<f_t>& reduced_costs,
+                               f_t start_time);
+
   // Generate implied bounds cuts from probing implications
   void generate_implied_bound_cuts(const lp_problem_t<i_t, f_t>& lp,
                                    const simplex_solver_settings_t<i_t, f_t>& settings,
                                    const std::vector<variable_type_t>& var_types,
                                    const std::vector<f_t>& xstar,
                                    f_t start_time);
 
+  void prepare_fractional_sub_cg(const simplex_solver_settings_t<i_t, f_t>& settings,
+                                 const std::vector<f_t>& xstar,
+                                 f_t start_time);
+
   cut_pool_t<i_t, f_t>& cut_pool_;
   knapsack_generation_t<i_t, f_t> knapsack_generation_;
   flow_cover_generation_t<i_t, f_t> flow_cover_generation_;
   const user_problem_t<i_t, f_t>& user_problem_;
   const probing_implied_bound_t<i_t, f_t>& probing_implied_bound_;
   std::shared_ptr<detail::clique_table_t<i_t, f_t>> clique_table_;
   omp_atomic_t<bool>* signal_extend_{nullptr};
+  fractional_conflict_subgraph_t<i_t, f_t> sub_cg_;
 };
 
 template <typename i_t, typename f_t>

cpp/src/dual_simplex/simplex_solver_settings.hpp

@@ -88,6 +88,7 @@ struct simplex_solver_settings_t {
       flow_cover_cuts(-1),
       implied_bound_cuts(-1),
       clique_cuts(-1),
+      zero_half_cuts(-1),
       strong_chvatal_gomory_cuts(-1),
       symmetry(-1),
       reduced_cost_strengthening(-1),
@@ -179,6 +180,7 @@ struct simplex_solver_settings_t {
   i_t flow_cover_cuts;             // -1 automatic, 0 to disable, >0 to enable flow cover cuts
   i_t implied_bound_cuts;          // -1 automatic, 0 to disable, >0 to enable implied bound cuts
   i_t clique_cuts;                 // -1 automatic, 0 to disable, >0 to enable clique cuts
+  i_t zero_half_cuts;              // -1 automatic, 0 to disable, >0 to enable zero-half cuts
   i_t strong_chvatal_gomory_cuts;  // -1 automatic, 0 to disable, >0 to enable strong Chvatal Gomory
                                    // cuts
   i_t symmetry;  // -1 automatic, 0 to disable, >0 to enable different symmetry methods

cpp/src/mip_heuristics/diversity/lns/rins.cu

@@ -254,6 +254,7 @@ void rins_t<i_t, f_t>::run_rins()
   branch_and_bound_settings.reliability_branching                    = 0;
   branch_and_bound_settings.max_cut_passes                           = 0;
   branch_and_bound_settings.clique_cuts                              = 0;
+  branch_and_bound_settings.zero_half_cuts                           = 0;
   branch_and_bound_settings.sub_mip                                  = 1;
   branch_and_bound_settings.strong_branching_simplex_iteration_limit = 200;
   branch_and_bound_settings.log.log                                  = false;

cpp/src/mip_heuristics/diversity/recombiners/sub_mip.cuh

@@ -111,6 +111,7 @@ class sub_mip_recombiner_t : public recombiner_t<i_t, f_t> {
       branch_and_bound_settings.reliability_branching                    = 0;
       branch_and_bound_settings.max_cut_passes                           = 0;
       branch_and_bound_settings.clique_cuts                              = 0;
+      branch_and_bound_settings.zero_half_cuts                           = 0;
       branch_and_bound_settings.sub_mip                                  = 1;
       branch_and_bound_settings.strong_branching_simplex_iteration_limit = 200;
       branch_and_bound_settings.solution_callback = [this](std::vector<f_t>& solution,

cpp/src/mip_heuristics/solver.cu

@@ -24,6 +24,7 @@
 #define DETECT_SYMMETRY_AFTER_PRESOLVE
 
 #include <mip_heuristics/feasibility_jump/early_cpufj.cuh>
+#include <mip_heuristics/presolve/conflict_graph/clique_table.cuh>
 
 #include <raft/sparse/detail/cusparse_wrappers.h>
 #include <raft/core/cusparse_macros.hpp>
@@ -373,6 +374,7 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
     branch_and_bound_settings.flow_cover_cuts    = context.settings.flow_cover_cuts;
     branch_and_bound_settings.implied_bound_cuts = context.settings.implied_bound_cuts;
     branch_and_bound_settings.clique_cuts        = context.settings.clique_cuts;
+    branch_and_bound_settings.zero_half_cuts     = context.settings.zero_half_cuts;
     branch_and_bound_settings.strong_chvatal_gomory_cuts =
       context.settings.strong_chvatal_gomory_cuts;
     branch_and_bound_settings.cut_change_threshold  = context.settings.cut_change_threshold;
@@ -425,7 +427,6 @@ solution_t<i_t, f_t> mip_solver_t<i_t, f_t>::run_solver()
                   std::placeholders::_2);
     }
 
-    // Create the branch and bound object
     branch_and_bound = std::make_unique<dual_simplex::branch_and_bound_t<i_t, f_t>>(
       branch_and_bound_problem,
       branch_and_bound_settings,

cpp/src/utilities/omp_helpers.hpp

@@ -39,7 +39,6 @@ class omp_mutex_t {
 
   omp_mutex_t(omp_mutex_t&& other) { *this = std::move(other); }
 
-  omp_mutex_t(const omp_mutex_t&)            = delete;
   omp_mutex_t& operator=(const omp_mutex_t&) = delete;
 
   omp_mutex_t& operator=(omp_mutex_t&& other)