fix seeding the initial population before properly handling the free variables. added a guard to check if the variables are fixed to infinite or NaN bounds.

Signed-off-by: Nicolas L. Guidotti <nguidotti@nvidia.com>

Author: nguidotti

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -240,6 +240,16 @@ void diversity_manager_t<i_t, f_t>::add_user_given_solutions(
     }
 
     if (problem_ptr->pre_process_assignment(init_sol_assignment)) {
+      // Seed the solution with the provided assignment BEFORE fixing integers and running the
+      // completion LP. Otherwise the fix uses the solution_t constructor's default assignment
+      // (the variable lower bounds), which is -inf for free variables; fixing such a variable
+      // makes fix_given_variables compute a NaN constraint bound (inf - inf) and trips the
+      // problem-representation validation. Seeding first also lets us keep the LP's repaired
+      // continuous values (previously overwritten by a post-LP copy).
+      raft::copy(sol.assignment.data(),
+                 init_sol_assignment.data(),
+                 init_sol_assignment.size(),
+                 sol.handle_ptr->get_stream());
       relaxed_lp_settings_t lp_settings;
       lp_settings.time_limit            = std::min(60., timer.remaining_time() / 2);
       lp_settings.tolerance             = problem_ptr->tolerances.absolute_tolerance;
@@ -250,10 +260,6 @@ void diversity_manager_t<i_t, f_t>::add_user_given_solutions(
                              problem_ptr->integer_indices,
                              lp_settings,
                              static_cast<bound_presolve_t<i_t, f_t>*>(nullptr));
-      raft::copy(sol.assignment.data(),
-                 init_sol_assignment.data(),
-                 init_sol_assignment.size(),
-                 sol.handle_ptr->get_stream());
       bool is_feasible = sol.compute_feasibility();
       cuopt_func_call(sol.test_variable_bounds(true));
       CUOPT_LOG_DEBUG("Adding initial solution success! feas %d objective %f excess %f",

cpp/src/mip_heuristics/problem/problem.cu

@@ -1706,6 +1706,18 @@ void problem_t<i_t, f_t>::fix_given_variables(problem_t<i_t, f_t>& original_prob
                    variables_to_fix.end(),
                    [variable_fix_mask = make_span(fixing_helpers.variable_fix_mask)] __device__(
                      i_t x) { variable_fix_mask[x] = 1; });
+  // Guard: fixing a variable to a non-finite value corrupts the constraint RHS below
+  // (coeff * floor(+-inf) = +-inf, then original_bound - inf can be inf - inf = NaN), which
+  // otherwise surfaces much later as an opaque "Constraints bounds are invalid" validation
+  // error. Fail loudly at the source instead. Callers must seed a finite assignment before
+  // fixing (e.g. free variables must not be left at their -inf lower-bound default).
+  cuopt_func_call(thrust::for_each(handle_ptr->get_thrust_policy(),
+                                   variables_to_fix.begin(),
+                                   variables_to_fix.end(),
+                                   [assignment = make_span(assignment)] __device__(i_t x) {
+                                     cuopt_assert(isfinite(assignment[x]),
+                                                  "Fixing a variable to a non-finite value");
+                                   }));
   const i_t num_segments = original_problem.n_constraints;
   f_t initial_value{0.};