test2 in lp-feasibility-relaxation depends on value of x; updated documentation

Author: jajhall

check/TestIis.cpp

@@ -570,15 +570,20 @@ TEST_CASE("lp-feasibility-relaxation", "[iis]") {
     std::vector<double> local_rhs_penalty = {1, -1, 10};
     h.feasibilityRelaxation(1, 1, 0, nullptr, nullptr,
                             local_rhs_penalty.data());
-    // AMPL says: Should get slacks (-3, 4, 0) corresponding to x = 1;
-    // y = 0, giving objective = 4 + 3 = 7
+    // AMPL says: Should get slacks (-3, 4, 0) corresponding to (x, y)
+    // = (1, 0), giving objective = 4 + 3 = 7
     //
-    // However, x = 0; y = 0, gives slacks (-2, 1, 20) and also
+    // However, (x, y) = (0, 0) gives slacks (-2, 1, 20) and also
     // objective = 5 + 2 = 7
     //
-    double r0_slack = -2;  // -3;
-    double r1_slack = 1;   // 4;
-    double r2_slack = 20;  // 0;
+    // The 64-bit integer build (11/11/25) gives (x, y) = (1, 0), and
+    // the 32-bit integer build gives (x, y) = (0, 0). Since this may
+    // vary randomly in future, the test below is dependent on whether
+    // x = 0 or x = 1
+    const bool solution0 = solution.col_value[0] == 0;
+    double r0_slack = solution0 ? -2 : -3;
+    double r1_slack = solution0 ? 1 : 4;
+    double r2_slack = solution0 ? 20 : 0;
     h.writeSolution("", 1);
     REQUIRE(solution.row_value[0] == lp.row_lower_[0] + r0_slack);
     REQUIRE(solution.row_value[1] == lp.row_upper_[1] - r1_slack);

docs/src/guide/advanced.md

@@ -42,15 +42,19 @@ only be used for LPs. The full IIS calculation is expensive, since it
 requires the solution of multiple LPs. Although there is a prototype
 implementation, it is not as robust or efficient as it will
 be. Otherwise, there is a simple, cheap test that looks for
-infeasibility due to incompatible variable oe constraint bounds, or
+infeasibility due to incompatible variable or constraint bounds, or
 constraint bounds that cannot be satisfied given the range of values
 on the constraint activity implied by bounds on variables.
 
-The choice of IIS strategy is defined by the [iis_strategy](@id option-iis-strategy) option, which can take the value
+The choice of IIS strategy is defined by the [iis_strategy](@ref option-iis-strategy) option. This a bit map
 
-- `kIisStrategyLight` = 0: The cheap test
-- `kIisStrategyFromLpRowPriority` = 1: The full IIS calculation, aiming to have a minimal number of rows in the IIS
-- `kIisStrategyFromLpColPriority` = 2: The full IIS calculation, aiming to have a minimal number of columns in the IIS
+- 0 => "light strategy", which is always performed when Highs::getIis is called
+- 1 => From dual ray, which is currently unavailable
+- 2 => From the whole LP (solving an elasticity LP repeatedly (fixing positive elastic variables at zero) until no more elastic variables are positive, and using the fixed elastic variables to determine a set of infeasible rows, for which there is a corresponding set of columns with nonzeros in those rows that form an infeasibility set (IS)
+- 4 => Attempt to reduce the IS to an ISS
+- 8 => Prioritize low numbers of columns (rather than low numbers of rows) when reducing the IS
+
+Hence, by just setting the 2-bit, an IS is formed reliably, and at no great expense (for an LP)
 
 ### IIS-related methods in the `Highs` class