mip: presolve forcing-row removal for redundant continuous rows (#18)

CBC's CglPreProcess drops rows that can never bind (min activity >= lb,
max activity <= ub) after bound tightening. cbcgo's presolve tightened
bounds and coefficients but kept every row.

This adds dropRedundantContinuousRows: after presolve+probe, remove rows
that are both (a) inert under the current column bounds and (b) free of
any integer column. Condition (a) makes removal exact for the LP;
condition (b) keeps it clear of the GMI/MIR cut suite, which derives only
from integer structure -- so the relaxation, cuts and branch tree are
unchanged, only inert continuous rows leave. Dropping integer-bearing
rows was tried and regressed (it re-rolls the cut/vertex lottery on the
demand-rate cases); restricting to continuous rows avoids that.

Exact postsolve (expandRows) rebuilds the dropped rows' activity (a.x)
and dual (0) so row-indexed outputs stay in the original row space.

Golden suite (../optimizer): case 018 1.07s -> 0.55s (-48%, 103 -> 29
nodes); 020/021 unchanged (their redundant rows are integer big-M);
suite -5%, all cases proven optimal, no regressions.

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

Author: andig

mip/eliminate.go

@@ -167,6 +167,105 @@ func eliminateSingletons(p *problem.Problem) (*problem.Problem, *reduction) {
 	return q, &reduction{orig: p, records: records, colMap: colMap}
 }
 
+// dropRedundantContinuousRows removes rows that (a) can never bind under the
+// current column bounds (min activity >= lb and max activity <= ub) and (b)
+// contain no integer column. Condition (a) makes removal exact for the LP;
+// condition (b) keeps it clear of the GMI/MIR cut suite, which only derives
+// from integer structure — so the relaxation, cuts and branch tree are all
+// unchanged, only inert continuous rows leave (CBC forcing-row removal).
+// Returns (nil,nil) when nothing qualifies; keep[origRow]=false when dropped.
+func dropRedundantContinuousRows(p *problem.Problem) (*problem.Problem, []bool) {
+	inf := problem.Inf
+	keep := make([]bool, len(p.Rows))
+	nkeep := 0
+	for ri := range p.Rows {
+		r := &p.Rows[ri]
+		rlb, rub := r.Bounds()
+		var mn, mx float64
+		var mni, mxi int
+		hasInt := false
+		for k, j := range r.Idx {
+			if p.Cols[j].Integer {
+				hasInt = true
+			}
+			a := r.Coef[k]
+			c := &p.Cols[j]
+			lb, ub := c.LB, c.UB
+			loInf := (a > 0 && lb <= -inf) || (a < 0 && ub >= inf)
+			hiInf := (a > 0 && ub >= inf) || (a < 0 && lb <= -inf)
+			if loInf {
+				mni++
+			} else if a >= 0 {
+				mn += a * lb
+			} else {
+				mn += a * ub
+			}
+			if hiInf {
+				mxi++
+			} else if a >= 0 {
+				mx += a * ub
+			} else {
+				mx += a * lb
+			}
+		}
+		redundant := !hasInt && mni == 0 && mxi == 0 && mn >= rlb-1e-7 && mx <= rub+1e-7
+		keep[ri] = !redundant
+		if keep[ri] {
+			nkeep++
+		}
+	}
+	if nkeep == len(p.Rows) {
+		return nil, nil
+	}
+	q := problem.New()
+	q.Name, q.ObjSense, q.SOSs = p.Name, p.ObjSense, p.SOSs
+	for j := range p.Cols {
+		c := &p.Cols[j]
+		q.AddCol(c.Name, c.LB, c.UB, c.Obj, c.Integer, nil, nil)
+	}
+	for ri := range p.Rows {
+		if !keep[ri] {
+			continue
+		}
+		r := &p.Rows[ri]
+		nri := q.AddRow(r.Name, r.Idx, r.Coef, r.Sense, r.RHS)
+		q.Rows[nri].HasRange, q.Rows[nri].Range = r.HasRange, r.Range
+	}
+	debugf("presolve: dropped %d/%d redundant continuous rows", len(p.Rows)-nkeep, len(p.Rows))
+	return q, keep
+}
+
+// expandRows restores full-length row outputs after a continuous-row drop:
+// kept rows copy through in order, dropped inert rows get activity a·x and a
+// zero dual (they never bind). orig is the pre-drop row set.
+func expandRows(res *Result, keep []bool, orig []problem.Row) {
+	if res.X == nil {
+		return
+	}
+	act := make([]float64, len(keep))
+	price := make([]float64, len(keep))
+	ri := 0
+	for i, k := range keep {
+		if k {
+			if ri < len(res.RowActivity) {
+				act[i] = res.RowActivity[ri]
+			}
+			if ri < len(res.RowPrice) {
+				price[i] = res.RowPrice[ri]
+			}
+			ri++
+			continue
+		}
+		r := &orig[i]
+		a := 0.0
+		for kk, j := range r.Idx {
+			a += r.Coef[kk] * res.X[j]
+		}
+		act[i] = a // price stays 0: an inert row never binds
+	}
+	res.RowActivity, res.RowPrice = act, price
+}
+
 // setRowBounds rewrites a row's sense/rhs/range to represent [lb, ub].
 func setRowBounds(r *problem.Row, lb, ub float64) {
 	inf := problem.Inf

mip/mip.go

@@ -102,6 +102,10 @@ type Model struct {
 	// per-column pseudocosts: observed bound gain per unit fraction
 	psUp, psDn   []float64
 	psUpN, psDnN []int
+
+	// continuous-row drop postsolve: keep mask + pre-drop rows for a·x
+	rrKeep []bool
+	rrRows []problem.Row
 }
 
 // psRecord accumulates one observed branching gain for column j.
@@ -205,6 +209,12 @@ func (m *Model) Solve() Result {
 		}
 		probe(m.P, probeDeadline)
 		presolve(m.P)
+		// forcing-row removal: drop redundant continuous rows (inert AND
+		// clear of the integer cut suite). Postsolve rebuilds their outputs.
+		if q, keep := dropRedundantContinuousRows(m.P); q != nil {
+			m.rrKeep, m.rrRows = keep, m.P.Rows
+			m.P = q
+		}
 		if q, red := eliminateSingletons(m.P); red != nil {
 			m.P, m.red = q, red
 			if len(m.MIPStart) == len(red.orig.Cols) {
@@ -677,6 +687,9 @@ func (m *Model) Solve() Result {
 	if m.red != nil {
 		m.red.expand(&res)
 	}
+	if m.rrKeep != nil {
+		expandRows(&res, m.rrKeep, m.rrRows)
+	}
 	return res
 }