Fix root LP solution copy in diversity_manager_t (#685)

This PR fixes a missing copy in diversity_manager_t after the root node solve, which caused uninitialized data to remain in the lp_optimal_solution vector and causing errors later down the line.


## Summary by CodeRabbit

* **Refactor**
  * Streamlined solution handling to copy LP primal/dual results directly and avoid redundant temporary allocations; preserved synchronization behavior.  
  * Adjusted feasibility validation to operate on a separate scaled copy to prevent unintended mutation.

* **Bug Fixes**
  * Added size and finiteness checks to validate solutions before use.

* **User-facing**
  * Deterministic fallback names for unnamed variables so every column has a label.

* **Tests**
  * Relaxed numerical tolerances in some objective and variable checks.

<sub>✏️ Tip: You can customize this high-level summary in your review settings.</sub>

Authors:
  - Alice Boucher (https://github.com/aliceb-nv)

Approvers:
  - Nicolas L. Guidotti (https://github.com/nguidotti)
  - Ramakrishnap (https://github.com/rgsl888prabhu)
  - Hugo Linsenmaier (https://github.com/hlinsen)

URL: #685

Author: aliceb-nv

cpp/src/linear_programming/translate.hpp

@@ -82,7 +82,11 @@ static dual_simplex::user_problem_t<i_t, f_t> cuopt_problem_to_simplex_problem(
   if (model.var_names.size() > 0) {
     user_problem.col_names.resize(n);
     for (int j = 0; j < n; ++j) {
-      user_problem.col_names[j] = model.var_names[j];
+      if (j < (int)model.var_names.size()) {
+        user_problem.col_names[j] = model.var_names[j];
+      } else {
+        user_problem.col_names[j] = "_CUOPT_x" + std::to_string(j);
+      }
     }
   }
   user_problem.obj_constant = model.presolve_data.objective_offset;

cpp/src/mip/diversity/diversity_manager.cu

@@ -357,18 +357,24 @@ solution_t<i_t, f_t> diversity_manager_t<i_t, f_t>::run_solver()
     pdlp_settings.pdlp_solver_mode                     = pdlp_solver_mode_t::Stable2;
     pdlp_settings.num_gpus                             = context.settings.num_gpus;
 
-    rmm::device_uvector<f_t> lp_optimal_solution_copy(lp_optimal_solution.size(),
-                                                      problem_ptr->handle_ptr->get_stream());
     timer_t lp_timer(lp_time_limit);
     auto lp_result = solve_lp_with_method<i_t, f_t>(*problem_ptr, pdlp_settings, lp_timer);
 
     {
       std::lock_guard<std::mutex> guard(relaxed_solution_mutex);
       if (!simplex_solution_exists.load()) {
+        cuopt_assert(lp_result.get_primal_solution().size() == lp_optimal_solution.size(),
+                     "LP optimal solution size mismatch");
+        cuopt_assert(lp_result.get_dual_solution().size() == lp_dual_optimal_solution.size(),
+                     "LP dual optimal solution size mismatch");
         raft::copy(lp_optimal_solution.data(),
-                   lp_optimal_solution_copy.data(),
+                   lp_result.get_primal_solution().data(),
                    lp_optimal_solution.size(),
                    problem_ptr->handle_ptr->get_stream());
+        raft::copy(lp_dual_optimal_solution.data(),
+                   lp_result.get_dual_solution().data(),
+                   lp_dual_optimal_solution.size(),
+                   problem_ptr->handle_ptr->get_stream());
       } else {
         // copy the lp state
         raft::copy(lp_state.prev_primal.data(),
@@ -382,6 +388,11 @@ solution_t<i_t, f_t> diversity_manager_t<i_t, f_t>::run_solver()
       }
       problem_ptr->handle_ptr->sync_stream();
     }
+    cuopt_assert(thrust::all_of(problem_ptr->handle_ptr->get_thrust_policy(),
+                                lp_optimal_solution.begin(),
+                                lp_optimal_solution.end(),
+                                [] __host__ __device__(f_t val) { return std::isfinite(val); }),
+                 "LP optimal solution contains non-finite values");
     ls.lp_optimal_exists = true;
     if (lp_result.get_termination_status() == pdlp_termination_status_t::Optimal) {
       set_new_user_bound(lp_result.get_objective_value());

cpp/src/mip/diversity/population.cu

@@ -283,10 +283,11 @@ void population_t<i_t, f_t>::run_solution_callbacks(solution_t<i_t, f_t>& sol)
           context.scaling.unscale_solutions(temp_sol.assignment, dummy);
           // Need to get unscaled problem as well
           problem_t<i_t, f_t> n_problem(*sol.problem_ptr->original_problem_ptr);
-          temp_sol.problem_ptr = &n_problem;
-          temp_sol.resize_to_original_problem();
-          temp_sol.compute_feasibility();
-          if (!temp_sol.get_feasible()) {
+          auto scaled_sol(temp_sol);
+          scaled_sol.problem_ptr = &n_problem;
+          scaled_sol.resize_to_original_problem();
+          scaled_sol.compute_feasibility();
+          if (!scaled_sol.get_feasible()) {
             CUOPT_LOG_DEBUG("Discard infeasible after unscaling");
             return;
           }

python/cuopt/cuopt/tests/linear_programming/test_python_API.py

@@ -809,7 +809,7 @@ def test_quadratic_objective_2():
     problem.solve()
 
     assert problem.Status.name == "Optimal"
-    assert x1.getValue() == pytest.approx(0.2295081)
+    assert x1.getValue() == pytest.approx(0.2295081, abs=1e-3)
     assert x2.getValue() == pytest.approx(0.0000000, abs=0.000001)
-    assert x3.getValue() == pytest.approx(0.1092896)
-    assert problem.ObjValue == pytest.approx(-0.284153)
+    assert x3.getValue() == pytest.approx(0.1092896, abs=1e-3)
+    assert problem.ObjValue == pytest.approx(-0.284153, abs=1e-3)