mip: extend big-M coefficient strengthening to >= rows (large models) (#17)

presolve already tightened binary big-M coefficients CglProbing-style,
but only on pure <= rows. This adds the exact >= mirror (both sub-cases
preserve the integer feasible set), matching CBC's Cgl0003 strengthening.

Gated to len(p.Rows) > 3000: on large root-heavy models the shrink lets
faceWalk reach the incumbent in far fewer pivots, but on smaller
proof-tree cases the perturbed cut set regresses the branch tree. The
row-count gate mirrors the existing NumRows() > 1500 sbDepth gate.

Golden suite (../optimizer): case 021 faceWalk pivots 16908 -> 6732
(-60%), 3.09s -> 2.30s (-26%); case 020 unchanged (185 nodes, proven);
suite -12%, all cases proven optimal, no regressions.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: andig

mip/presolve.go

@@ -126,8 +126,12 @@ func presolvePass(p *problem.Problem) (changed bool) {
 			}
 		}
 
-		// coefficient tightening: binaries in pure <= rows
-		if !(rub < inf && rlb == -inf) {
+		// coefficient tightening: binaries in pure one-sided big-M rows.
+		// The >= mirror is gated to large models: on small proof-tree
+		// cases it perturbs the cut set for no gain (see perf notes).
+		pureLE := rub < inf && rlb == -inf
+		pureGE := rlb > -inf && rub == inf && len(p.Rows) > 3000
+		if !pureLE && !pureGE {
 			continue
 		}
 		for k, j := range r.Idx {
@@ -136,24 +140,43 @@ func presolvePass(p *problem.Problem) (changed bool) {
 			if !c.Integer || c.LB != 0 || c.UB != 1 {
 				continue
 			}
-			_, omax := others(k)
-			if math.IsInf(omax, 1) {
-				continue
-			}
-			switch {
-			case a < 0 && omax > rub && omax+a < rub:
-				// y=1 side is slack: shrink |a| so it just reaches
-				setCoef(p, ri, k, rub-omax)
-				changed = true
-				recompute()
-			case a > 0 && omax < rub && omax+a > rub:
-				// y=0 side is slack: shift a and the rhs down together
-				delta := rub - omax
-				setCoef(p, ri, k, a-delta)
-				r.RHS -= delta
-				rub = r.RHS
-				changed = true
-				recompute()
+			omin, omax := others(k)
+			if pureLE {
+				if math.IsInf(omax, 1) {
+					continue
+				}
+				switch {
+				case a < 0 && omax > rub && omax+a < rub:
+					// y=1 side is slack: shrink |a| so it just reaches
+					setCoef(p, ri, k, rub-omax)
+					changed = true
+					recompute()
+				case a > 0 && omax < rub && omax+a > rub:
+					// y=0 side is slack: shift a and the rhs down together
+					delta := rub - omax
+					setCoef(p, ri, k, a-delta)
+					r.RHS -= delta
+					rub = r.RHS
+					changed = true
+					recompute()
+				}
+			} else { // pureGE: mirror of pureLE under negation
+				if math.IsInf(omin, -1) {
+					continue
+				}
+				switch {
+				case a > 0 && omin < rlb && omin+a > rlb:
+					setCoef(p, ri, k, rlb-omin)
+					changed = true
+					recompute()
+				case a < 0 && omin > rlb && omin+a < rlb:
+					delta := omin - rlb
+					setCoef(p, ri, k, a+delta)
+					r.RHS += delta
+					rlb = r.RHS
+					changed = true
+					recompute()
+				}
 			}
 		}
 	}