Block Bounded Value Elimination presolving pass for binary problems

ci/validate_wheel.sh

@@ -22,7 +22,7 @@ PYDISTCHECK_ARGS=(
 if [[ "${package_dir}" == "python/libcuopt" ]]; then
     if [[ "${RAPIDS_CUDA_MAJOR}" == "12" ]]; then
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '690Mi'
+            --max-allowed-size-compressed '695Mi'
         )
     else
         PYDISTCHECK_ARGS+=(

cpp/include/cuopt/mathematical_optimization/constants.h

@@ -146,6 +146,9 @@
 #define CUOPT_MIP_HYPER_SUBMIP_ITERATION_LIMIT_RATIO "mip_hyper_submip_iteration_limit_ratio"
 #define CUOPT_MIP_HYPER_SUBMIP_ENABLE_CPUFJ          "mip_hyper_submip_enable_cpufj"
 
+/* @brief Block bounded-variable-elimination step of cuOpt's internal MIP presolve */
+#define CUOPT_MIP_HYPER_BLOCK_BVE "mip_hyper_block_bve"
+
 /* @brief QCQP (barrier) scaling hyper-parameters */
 #define CUOPT_QCQP_HYPER_RUIZ_EQUILIBRATION "qcqp_hyper_ruiz_equilibration"
 

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

@@ -162,6 +162,15 @@ class mip_solver_settings_t {
    * When this is `false`, probing is skipped even if presolve is otherwise on.
    */
   bool probing{true};
+  /**
+   * @brief Enable the block bounded-variable-elimination step of cuOpt's MIP presolve.
+   *
+   * Runs after trivial_presolve and eliminates blocks of functionally-determined binary auxiliary
+   * variables discovered via the probing-cache implication closure, re-encoding each block's
+   * projected relation as certified prime-implicate clauses. Requires the probing-cache step; a
+   * no-op when no certified reduction exists.
+   */
+  bool block_bve{true};
   /**
    * @brief Determinism mode for MIP solver.
    *

cpp/src/io/mps_writer.cpp

@@ -229,8 +229,8 @@ void mps_writer_t<i_t, f_t>::write(const std::string& mps_file_path)
   // save coefficients with full precision
   mps_file << std::setprecision(std::numeric_limits<f_t>::max_digits10);
 
-  // NAME section
-  mps_file << "NAME          " << problem_.get_problem_name() << "\n";
+  const std::string& pname = problem_.get_problem_name();
+  mps_file << "NAME          " << (pname.empty() ? "cuopt" : pname) << "\n";
 
   if (problem_.get_sense()) { mps_file << "OBJSENSE\n MAXIMIZE\n"; }
 

cpp/src/math_optimization/solver_settings.cu

@@ -213,6 +213,7 @@ solver_settings_t<i_t, f_t>::solver_settings_t() : pdlp_settings(), mip_settings
     {CUOPT_MIP_HYPER_DIVING_SHOW_TYPE, &mip_settings.diving_params.show_type, false, "log diving heuristic type when it finds a new incumbent"},
     // Recursive sub-MIP (RINS) hyper-parameters (hidden from default --help: name contains "hyper_")
     {CUOPT_MIP_HYPER_SUBMIP_ENABLE_CPUFJ, &mip_settings.submip_params.enable_cpufj, true, "run CPU FJ over the sub-MIP"},
+    {CUOPT_MIP_HYPER_BLOCK_BVE, &mip_settings.block_bve, true, "eliminate blocks of binaries in cuOpt's MIP presolve (needs " CUOPT_MIP_PROBING ")"},
   };
   // String parameters
   string_parameters = {

cpp/src/mip_heuristics/CMakeLists.txt

@@ -33,6 +33,7 @@ set(MIP_NON_LP_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/local_search/rounding/simple_rounding.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/local_search/feasibility_pump/feasibility_pump.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/local_search/line_segment_search/line_segment_search.cu
+  ${CMAKE_CURRENT_SOURCE_DIR}/presolve/block_bve.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/bounds_presolve.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/bounds_update_data.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/presolve/semi_continuous.cu

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -11,13 +11,15 @@
 #include <mip_heuristics/mip_constants.hpp>
 #include <mip_heuristics/presolve/third_party_presolve.hpp>
 
+#include <mip_heuristics/presolve/block_bve.cuh>
 #include <mip_heuristics/presolve/conflict_graph/clique_table.cuh>
 #include <mip_heuristics/presolve/probing_cache.cuh>
 #include <mip_heuristics/presolve/trivial_presolve.cuh>
 #include <mip_heuristics/problem/problem_helpers.cuh>
 
 #include <pdlp/solve.cuh>
 
+#include <utilities/copy_helpers.hpp>
 #include <utilities/scope_guard.hpp>
 
 #include <chrono>
@@ -307,7 +309,10 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
     CUOPT_LOG_INFO("Probing-cache step disabled via %s=false", CUOPT_MIP_PROBING);
     run_probing_cache = false;
   }
-  if (run_probing_cache) {
+  const bool remap_cache_ids           = true;
+  problem_ptr->related_vars_time_limit = context.settings.heuristic_params.related_vars_time_limit;
+
+  if (run_probing_cache && !global_timer.check_time_limit() && !presolve_timer.check_time_limit()) {
     log_presolve_budget("PROBING", probing_features, probing_budget);
     f_t time_for_probing_cache = std::min(time_limit, (f_t)global_timer.remaining_time());
     timer_t probing_timer{time_for_probing_cache};
@@ -324,9 +329,17 @@ bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_
       std::chrono::duration<double>(std::chrono::steady_clock::now() - probing_t0).count());
     if (problem_is_infeasible) { return false; }
   }
-  const bool remap_cache_ids           = true;
-  problem_ptr->related_vars_time_limit = context.settings.heuristic_params.related_vars_time_limit;
+
   if (!global_timer.check_time_limit()) { trivial_presolve(*problem_ptr, remap_cache_ids); }
+
+  if (context.settings.block_bve && run_probing_cache) {
+    timer_t bve_deadline(std::min(global_timer.remaining_time(), presolve_timer.remaining_time()));
+    if (!block_bve_phase(ls.constraint_prop.bounds_update, *problem_ptr, bve_deadline)) {
+      stats.presolve_time = timer.elapsed_time();
+      return false;
+    }
+  }
+
   if (!problem_ptr->empty && !check_bounds_sanity(*problem_ptr)) { return false; }
   // if (!presolve_timer.check_time_limit() && !context.settings.heuristics_only &&
   //     !problem_ptr->empty) {

cpp/src/mip_heuristics/diversity/population.cu

@@ -233,6 +233,12 @@ std::vector<solution_t<i_t, f_t>> population_t<i_t, f_t>::get_external_solutions
           sol.compute_number_of_integers(),
           problem_ptr->n_integer_vars);
       }
+      if (std::abs(sol.get_objective() - h_entry.objective) > OBJECTIVE_EPSILON) {
+        CUOPT_LOG_DEBUG(
+          "External solution objective mismatch: sol.get_objective() = %g, h_entry.objective = %g",
+          sol.get_objective(),
+          h_entry.objective);
+      }
       sol.handle_ptr->sync_stream();
       return_vector.emplace_back(std::move(sol));
       counter++;