Do not discard a MIP solution when its repair LP fails to solve

When a solution is feasible for the presolved model but violates the original
model by more than mip_feasibility_tolerance, HighsMipSolverData repairs it by
fixing the integer columns and re-solving the LP in the original space. The
repaired solution is accepted only if that LP returns a feasible primal
solution, so a failure of the solver is treated exactly like a solution that is
genuinely bad: the solution is discarded and kHighsInf is returned, so it is not
used for bounding. When the discarded solution is the optimum, the search
reports a worse incumbent as optimal at a zero gap.

The repair LP is solved in the original space with the dual simplex, which on a
badly scaled model can fail the ratio test with "excessive dual values" (or its
primal counterpart) and return kSolveError. On a 12710 x 23091 MIP with an
objective coefficient range of 2.4e13, 17 of 34 repair LPs failed this way and
the optimum was among the solutions discarded, leaving an objective 20.67 worse
reported as optimal.

Retry such a solve once without presolve; the same LP then solves to optimality,
as it also does with the primal simplex or with IPM.

Also recompute the row activities from the repaired column values. The
feasibility test is given solution.row_value and trusts it, but the values
returned by the LP solver need only satisfy the LP to its own tolerance, so they
can differ from the quad-precision recomputation used by the check that is later
applied to the returned solution. Without this a repaired solution can pass here
and then fail that check, turning a reported optimum into a solve error.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: EamonHetherton

highs/mip/HighsMipSolverData.cpp

@@ -11,6 +11,7 @@
 #include <sstream>
 
 #include "../extern/pdqsort/pdqsort.h"
+#include "lp_data/HighsLpUtils.h"
 #include "lp_data/HighsModelUtils.h"
 #include "mip/HighsPseudocost.h"
 #include "mip/HighsRedcostFixing.h"
@@ -1239,11 +1240,28 @@ double HighsMipSolverData::transformNewIntegerFeasibleSolution(
     // HiPO or IPX to solve an LP without a basis, use simplex
     tmpSolver.setOptionValue("solver", kSimplexString);
     tmpSolver.optimizeLp();
+    // The repair LP is solved in the original space, which for a badly scaled
+    // model can defeat the dual simplex ratio test ("excessive dual values")
+    // or its primal counterpart. That is a failure of the solver, not a
+    // statement about the solution, so retry once without presolve rather than
+    // discarding a solution that may be the incumbent - or the optimum.
+    if (tmpSolver.getModelStatus() == HighsModelStatus::kSolveError) {
+      tmpSolver.setOptionValue("presolve", kHighsOffString);
+      tmpSolver.optimizeLp();
+    }
     this->total_repair_lp_iterations +=
         tmpSolver.getInfo().simplex_iteration_count;
     if (tmpSolver.getInfo().primal_solution_status == kSolutionStatusFeasible) {
       this->total_repair_lp_feasible++;
       solution = tmpSolver.getSolution();
+      // Recompute the row activities from the repaired column values. The
+      // feasibility test below is given solution.row_value and trusts it, but
+      // the values returned by the LP solver need only satisfy the LP to its
+      // own tolerance, so they can differ from a quad-precision recomputation -
+      // which is what the check applied to the returned solution uses. Without
+      // this, a repaired solution can pass here and fail that later check.
+      calculateRowValuesQuad(*mipsolver.orig_model_, solution.col_value,
+                             solution.row_value);
       allow_try_again = false;
       goto try_again;
     }