mip: cheap dual-only strong-branch probes (CBC-style limited iteration) (#19)

Strong branching re-solved each probe child to full optimality (warm
primal, 80ms deadline), which grinds on the degenerate LPs these
scheduling models produce. CBC instead runs a few dual-simplex
iterations per probe and reads off the bound: the dual stays
dual-feasible throughout, so its objective is a valid lower bound
(a conservative branch-gain) at any iteration.

This adds an LP probe mode: SetProbe(cap) makes a warm re-solve stop
after the dual repair with an IterCap on the dual pivots, returning the
dual bound and skipping the primal phase. strongBranch enables it around
its candidate probes. The bound is a lower estimate, so branch scores,
pseudocosts and cutoff-fathoming all stay sound (conservative).

Golden suite (../optimizer): case 018 0.57s -> 0.34s (-40%), case 020
5.51s -> 4.99s (-9%); suite -10%. Case 021 (cut-loop bound, not
branching bound) is unchanged within noise. All cases proven optimal.

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

Author: andig

mip/mip.go

@@ -1216,6 +1216,10 @@ func (m *Model) nodeBound(nd *node, j int) (float64, float64) {
 	return lb, ub
 }
 
+// strongProbeCap bounds dual pivots per strong-branch probe: enough for a
+// useful bound, cheap enough that probing all shallow nodes stays affordable.
+const strongProbeCap = 100
+
 // strongBranch (CBC-style) probes both children of the top candidates and
 // returns the column whose worse child moves the bound most; -1 if none do.
 // strongBranch probes both sides of the most fractional candidates. A side
@@ -1248,6 +1252,11 @@ func (m *Model) strongBranch(nd *node, x []float64, endState *simplex.State, obj
 	// short per-probe deadline: strong branching must never eat the budget
 	saved := m.LP.Deadline
 	defer func() { m.LP.Deadline = saved }()
+	// cheap strong-branch probes: a capped dual-only re-solve returns a valid
+	// lower bound (CBC limited-iteration strong branching) instead of a full
+	// node solve, at a fraction of the pivots
+	m.LP.SetProbe(strongProbeCap)
+	defer m.LP.ClearProbe()
 
 	bestCol, bestScore := -1, math.Inf(-1)
 	var fixed []boundOverride

simplex/simplex.go

@@ -79,6 +79,13 @@ type LP struct {
 	// (checked periodically inside the pivot loop).
 	Deadline time.Time
 
+	// IterCap >0 bounds total pivots per solve; probeMode returns the
+	// dual-feasible bound after dual repair without a primal phase. Together
+	// they make strong-branch probes cheap: a capped dual-only re-solve
+	// yields a valid lower bound (CBC-style limited-iteration strong branching).
+	IterCap   int
+	probeMode bool
+
 	// pricingWindow >0 makes chooseEntering scan a rotating column window
 	// (partial pricing) instead of all n+m every pivot; 0 means full scan.
 	pricingWindow int
@@ -308,9 +315,19 @@ func (lp *LP) warmSolve(st *State, touched []int, preserve bool) (Status, *State
 	} else if !noDualRepair {
 		lp.dualRun(st)
 	}
+	if lp.probeMode {
+		// dual repair leaves a dual-feasible basis: its objective is a valid
+		// lower bound (a conservative strong-branch gain) without a primal solve
+		return Optimal, st, lp.objective(st)
+	}
 	return lp.solveFrom(st)
 }
 
+// SetProbe enables cheap dual-only strong-branch probing (a valid bound
+// after at most `cap` dual pivots); ClearProbe restores normal solving.
+func (lp *LP) SetProbe(cap int) { lp.probeMode, lp.IterCap = true, cap }
+func (lp *LP) ClearProbe()      { lp.probeMode, lp.IterCap = false, 0 }
+
 // dualPivotCap bounds dual pivots per re-solve; a degenerate dual bails to
 // the primal run instead of grinding forever.
 const dualPivotCap = 1024
@@ -358,6 +375,10 @@ func (lp *LP) dualRun(st *State) {
 		if !lp.Deadline.IsZero() && time.Now().After(lp.Deadline) {
 			return
 		}
+		if lp.IterCap > 0 && iter >= lp.IterCap {
+			lp.Stats.DualCap++
+			return
+		}
 		if iter == dualPivotCap {
 			lp.Stats.DualCap++
 			return