Consider objective function integrality when pruning + bug fixes

ci/validate_wheel.sh

@@ -22,11 +22,11 @@ PYDISTCHECK_ARGS=(
 if [[ "${package_dir}" == "python/libcuopt" ]]; then
     if [[ "${RAPIDS_CUDA_MAJOR}" == "12" ]]; then
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '635Mi'
+            --max-allowed-size-compressed '645Mi'
         )
     else
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '475Mi'
+            --max-allowed-size-compressed '485Mi'
         )
     fi
 elif [[ "${package_dir}" != "python/cuopt" ]] && \

cpp/src/branch_and_bound/branch_and_bound.cpp

@@ -489,7 +489,7 @@ void branch_and_bound_t<i_t, f_t>::set_new_solution(const std::vector<f_t>& solu
   if (is_feasible) { report_heuristic(obj); }
   if (attempt_repair) {
     mutex_repair_.lock();
-    repair_queue_.push_back(crushed_solution);
+    repair_queue_.push_back(solution);
     mutex_repair_.unlock();
   }
 }
@@ -522,9 +522,11 @@ void branch_and_bound_t<i_t, f_t>::queue_external_solution_deterministic(
   mutex_original_lp_.unlock();
 
   if (!is_feasible) {
-    // Queue for repair
+    // Queue the uncrushed solution for repair; it will be crushed at
+    // consumption time so that the crush reflects the current LP state
+    // (which may have gained slack columns from cuts added after this point).
     mutex_repair_.lock();
-    repair_queue_.push_back(crushed_solution);
+    repair_queue_.push_back(solution);
     mutex_repair_.unlock();
     return;
   }
@@ -613,11 +615,14 @@ void branch_and_bound_t<i_t, f_t>::repair_heuristic_solutions()
 
   if (to_repair.size() > 0) {
     settings_.log.debug("Attempting to repair %ld injected solutions\n", to_repair.size());
-    for (const std::vector<f_t>& potential_solution : to_repair) {
+    for (const std::vector<f_t>& uncrushed_solution : to_repair) {
+      std::vector<f_t> crushed_solution;
+      crush_primal_solution<i_t, f_t>(
+        original_problem_, original_lp_, uncrushed_solution, new_slacks_, crushed_solution);
       std::vector<f_t> repaired_solution;
       f_t repaired_obj;
       bool is_feasible =
-        repair_solution(edge_norms_, potential_solution, repaired_obj, repaired_solution);
+        repair_solution(edge_norms_, crushed_solution, repaired_obj, repaired_solution);
       if (is_feasible) {
         mutex_upper_.lock();
 
@@ -1195,6 +1200,9 @@ std::pair<node_status_t, rounding_direction_t> branch_and_bound_t<i_t, f_t>::upd
     policy.graphviz(search_tree, node_ptr, "lower bound", leaf_obj);
     policy.update_pseudo_costs(node_ptr, leaf_obj);
     node_ptr->lower_bound = leaf_obj;
+    if (original_lp_.objective_is_integral) {
+      node_ptr->lower_bound = std::ceil(leaf_obj - settings_.integer_tol);
+    }
     policy.on_optimal_callback(leaf_solution.x, leaf_obj);
 
     if (num_frac == 0) {
@@ -1308,7 +1316,11 @@ dual::status_t branch_and_bound_t<i_t, f_t>::solve_node_lp(
 
   simplex_solver_settings_t lp_settings = settings_;
   lp_settings.set_log(false);
-  lp_settings.cut_off       = upper_bound_ + settings_.dual_tol;
+  if (original_lp_.objective_is_integral) {
+    lp_settings.cut_off = std::ceil(upper_bound_ - settings_.integer_tol) - 1 + settings_.dual_tol;
+  } else {
+    lp_settings.cut_off = upper_bound_ + settings_.dual_tol;
+  }
   lp_settings.inside_mip    = 2;
   lp_settings.time_limit    = settings_.time_limit - toc(exploration_stats_.start_time);
   lp_settings.scale_columns = false;
@@ -3158,11 +3170,14 @@ void branch_and_bound_t<i_t, f_t>::deterministic_sort_replay_events(
     if (to_repair.size() > 0) {
       settings_.log.debug("Deterministic sync: Attempting to repair %ld injected solutions\n",
                           to_repair.size());
-      for (const std::vector<f_t>& potential_solution : to_repair) {
+      for (const std::vector<f_t>& uncrushed_solution : to_repair) {
+        std::vector<f_t> crushed_solution;
+        crush_primal_solution<i_t, f_t>(
+          original_problem_, original_lp_, uncrushed_solution, new_slacks_, crushed_solution);
         std::vector<f_t> repaired_solution;
         f_t repaired_obj;
         bool success =
-          repair_solution(edge_norms_, potential_solution, repaired_obj, repaired_solution);
+          repair_solution(edge_norms_, crushed_solution, repaired_obj, repaired_solution);
         if (success) {
           // Queue repaired solution with work unit timestamp (...workstamp?)
           mutex_heuristic_queue_.lock();

cpp/src/dual_simplex/presolve.cpp

@@ -569,15 +569,16 @@ void convert_user_problem(const user_problem_t<i_t, f_t>& user_problem,
   }
 
   // Copy info from user_problem to problem
-  problem.num_rows     = user_problem.num_rows;
-  problem.num_cols     = user_problem.num_cols;
-  problem.A            = user_problem.A;
-  problem.objective    = user_problem.objective;
-  problem.obj_scale    = user_problem.obj_scale;
-  problem.obj_constant = user_problem.obj_constant;
-  problem.rhs          = user_problem.rhs;
-  problem.lower        = user_problem.lower;
-  problem.upper        = user_problem.upper;
+  problem.num_rows              = user_problem.num_rows;
+  problem.num_cols              = user_problem.num_cols;
+  problem.A                     = user_problem.A;
+  problem.objective             = user_problem.objective;
+  problem.obj_scale             = user_problem.obj_scale;
+  problem.obj_constant          = user_problem.obj_constant;
+  problem.objective_is_integral = user_problem.objective_is_integral;
+  problem.rhs                   = user_problem.rhs;
+  problem.lower                 = user_problem.lower;
+  problem.upper                 = user_problem.upper;
 
   // Make a copy of row_sense so we can modify it
   std::vector<char> row_sense = user_problem.row_sense;

cpp/src/dual_simplex/presolve.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -41,6 +41,7 @@ struct lp_problem_t {
   std::vector<f_t> upper;
   f_t obj_constant;
   f_t obj_scale;  // 1.0 for min, -1.0 for max
+  bool objective_is_integral{false};
 };
 
 template <typename i_t, typename f_t>

cpp/src/dual_simplex/user_problem.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -47,6 +47,7 @@ struct user_problem_t {
   std::vector<std::string> col_names;
   f_t obj_constant;
   f_t obj_scale;  // 1.0 for min, -1.0 for max
+  bool objective_is_integral{false};
   std::vector<variable_type_t> var_types;
   std::vector<i_t> Q_offsets;
   std::vector<i_t> Q_indices;

cpp/src/mip_heuristics/feasibility_jump/fj_cpu.cu

@@ -39,15 +39,14 @@
 namespace cuopt::linear_programming::detail {
 
 template <typename i_t, typename f_t, typename ArrayType>
-HDI thrust::tuple<f_t, f_t> get_mtm_for_bound(
-  const typename fj_t<i_t, f_t>::climber_data_t::view_t& fj,
-  i_t var_idx,
-  i_t cstr_idx,
-  f_t cstr_coeff,
-  f_t bound,
-  f_t sign,
-  const ArrayType& assignment,
-  const ArrayType& lhs_vector)
+thrust::tuple<f_t, f_t> get_mtm_for_bound(const typename fj_t<i_t, f_t>::climber_data_t::view_t& fj,
+                                          i_t var_idx,
+                                          i_t cstr_idx,
+                                          f_t cstr_coeff,
+                                          f_t bound,
+                                          f_t sign,
+                                          const ArrayType& assignment,
+                                          const ArrayType& lhs_vector)
 {
   f_t delta_ij = 0;
   f_t slack    = 0;
@@ -63,7 +62,7 @@ HDI thrust::tuple<f_t, f_t> get_mtm_for_bound(
 }
 
 template <typename i_t, typename f_t, MTMMoveType move_type, typename ArrayType>
-HDI thrust::tuple<f_t, f_t, f_t, f_t> get_mtm_for_constraint(
+thrust::tuple<f_t, f_t, f_t, f_t> get_mtm_for_constraint(
   const typename fj_t<i_t, f_t>::climber_data_t::view_t& fj,
   i_t var_idx,
   i_t cstr_idx,
@@ -109,17 +108,16 @@ HDI thrust::tuple<f_t, f_t, f_t, f_t> get_mtm_for_constraint(
 }
 
 template <typename i_t, typename f_t>
-HDI std::pair<f_t, f_t> feas_score_constraint(
-  const typename fj_t<i_t, f_t>::climber_data_t::view_t& fj,
-  i_t var_idx,
-  f_t delta,
-  i_t cstr_idx,
-  f_t cstr_coeff,
-  f_t c_lb,
-  f_t c_ub,
-  f_t current_lhs,
-  f_t left_weight,
-  f_t right_weight)
+std::pair<f_t, f_t> feas_score_constraint(const typename fj_t<i_t, f_t>::climber_data_t::view_t& fj,
+                                          i_t var_idx,
+                                          f_t delta,
+                                          i_t cstr_idx,
+                                          f_t cstr_coeff,
+                                          f_t c_lb,
+                                          f_t c_ub,
+                                          f_t current_lhs,
+                                          f_t left_weight,
+                                          f_t right_weight)
 {
   cuopt_assert(isfinite(delta), "invalid delta");
   cuopt_assert(cstr_coeff != 0 && isfinite(cstr_coeff), "invalid coefficient");