Sparsity-driven Aggregation of Mixed Integer Programs

Gioni Mexi; Ksenia Bestuzheva; Liding Xu

REVIEW 3 major objections 4 minor 39 references

Sparsity-driven Aggregation of Mixed Integer Programs

T0 review · 3 major / 4 minor · reviewed 2026-08-09 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Sparse LP aggregation drops bad variables and shrinks MIP search trees.

desk verdict A solid, honest heuristic paper with a genuinely new lasso-based aggregation idea, but the iterative reweighting step is mis-specified and the headline speedup is weaker than it looks. read the letter →

arxiv 2502.01192 v2 pith:RJJ3MOXM submitted 2025-02-03 math.OC

Liding Xu , Gioni Mexi , Ksenia Bestuzheva This is my paper · ORCID

classification math.OC MSC 90C1190C1090C2790C05

keywords mixedintegerprogrammingcuttingplanesc-MIRcutsrowaggregationlassol0-normminimizationiterativereweightingbranch-and-cut

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that the quality of a MIP row aggregation is an $\ell_0$-norm minimization problem: choose nonnegative row multipliers so that the aggregated row keeps as few "bad" continuous variables as possible, where badness is measured by bound distance. It solves a lasso LP relaxation of this problem, then applies iterative reweighting LPs when the row is not sparse enough, and it shows that the standard greedy aggregation heuristic is a stepwise selection method for the same $\ell_0$ problem. On the MIPLIB 2017 benchmark, the new method yields much sparser aggregated rows and, for hard instances, reduces mean solve time and branch-and-bound nodes, while easy instances slow down. The contribution is a systematic optimization-based replacement for a greedy heuristic in the generation of complemented mixed-integer rounding cuts.

What carries the argument

The central object is the lasso approximation of the $\ell_0$ aggregation problem: minimize $\|W\lambda^\top A_{I,J}\|_1 + \sum_{i\in I}\lambda_i(b_i - A_i^\top\tilde{x})$ over $\lambda\in\mathbb{R}^I_+$ with $\lambda_{i0}\ge 1$, where $W$ carries bound distances of bad continuous variables and the sum is the slack of the aggregated row. This LP simultaneously promotes sparsity in the transformed coefficients and tightness of the base inequality. When the bad-variable density exceeds a threshold, the algorithm restricts to the positive-support rows and minimizes $\|W\lambda^\top A_{I',J}\|_1$ with weights updated as $w_i\leftarrow w_i/(\epsilon+\lambda_i)$, iterating until the row is sparse enough.

What would settle it

One could take a family of MIP instances where the new LP finds aggregations with zero remaining bad variables but large aggregated-row slack, and compare the bound improvement of the resulting c-MIR cuts against cuts from aggregations with one bad variable but near-zero slack; if the latter consistently gives stronger bounds, the proxy objective is wrong. A direct check on the reported benchmark would be to disable all cut separators except c-MIR from aggregated rows and see whether the node reductions persist.

Watch

Extended reading notes

Core claim

The paper establishes that the problem of choosing row multipliers for cut-generating aggregation is a weighted cardinality minimization problem over the bad continuous variables left in the aggregated row. The standard greedy heuristic is shown to be a forward stepwise selection method for this $\ell_0$ problem, and a three-row example exhibits a multiplier vector $(1,1,2)$ that eliminates all bad variables though no greedy path reaches it. The proposed algorithm instead solves a lasso LP that minimizes the weighted $\ell_1$ norm of the bad-variable coefficients plus the slack of the aggregated row, then runs iterative reweighted $\ell_1$ problems on the active rows when needed. In the computational setup reported, this produces aggregated rows with 0.37 bad columns on average versus 2.45 for the greedy heuristic, smaller branch-and-bound trees, and a mean runtime reduction of about 5% on instances taking at least 100 seconds, with slowdowns on easy instances.

Load-bearing premise

The load-bearing premise is that minimizing the weighted count of bad continuous variables and the slack of the aggregated row is the right proxy: sparse aggregations chosen this way produce c-MIR cuts that actually strengthen the LP relaxation and speed up the solver.

Editorial extensions

If this is right

Aggregated rows produced by the new algorithm retain 0.37 bad continuous variables on average, versus 2.45 for the greedy heuristic, meaning c-MIR cuts are derived from much sparser single-row relaxations.
On MIPLIB 2017 instances that take over 100 seconds, mean solver time falls by about 5% and branch-and-bound nodes by about 9%, so the cuts help most where the solver struggles.
On easy instances solved under 100 seconds by both settings, runtime rises about 17-18% while nodes still fall about 15%, so the extra LP work is not repaid.
The greedy heuristic is exactly a forward stepwise selection method for the same $\ell_0$ problem, so known drawbacks of stepwise selection carry over to it, and the explicit example shows a gap that the LP closes.
The new configuration solves two additional MIPLIB 2017 instances overall compared with the default solver setting.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural extension the paper leaves implicit is a difficulty-aware switch: run the cheap greedy heuristic on easy nodes and invoke the LP-based aggregation only on hard ones, which would recover most of the observed gains without the easy-instance slowdown.
The cosparsity formulation suggests that compressed-sensing style conditions on the constraint matrix could give provable guarantees for when the lasso LP recovers the true minimum-support aggregation; the paper does not attempt such a theorem.
One could test the proxy directly by comparing bound improvements from sparse aggregations produced by the LP against equally sparse but deliberately non-optimal aggregations on the same instances.
The iterative reweighting stage is a candidate for first-order convex solvers or warm-started simplex variants, since the active set is already small after the first LP.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

The paper does something real: it casts row aggregation for c-MIR cuts as an l0 cardinality problem and shows that the MW heuristic is forward stepwise selection. That is a useful reframing. The lasso LP is a sensible relaxation, and Example 1 convincingly shows that MW can fail where the LP succeeds. The experiments are honest and reasonably large: MIPLIB 2017, 1200 instance-seed runs, and the node reduction is supported by a Wilcoxon test.

The main soft spots are two reproducibility gaps. Equation (15) updates weights with indices on rows, but the objective in (14) puts weights on bad columns. As written, the iterative reweighting stage is undefined; you cannot execute Algorithm 3. I suspect it is a typo, but it means the Table 1 and Table 2 numbers are tied to an unspecified variant. Also, the density threshold eta in Algorithm 3 is never reported in Section 6.1, so the number of reweighting rounds is unknown. These are fixable, but they need to be fixed.

The performance claims are modest and appropriately so. The 5% time improvement on the 'solved-over-100s' subset is post-hoc (the subset is defined by runtime), no significance test is given for time, and the whole-picture mean time is flat. The sparsity improvement in Table 2 is real but partly by construction, since the objective minimizes sparse bad columns. That is fine as a diagnostic, but it does not independently establish that the cuts are stronger.

The central proxy assumption—that sparser, tighter aggregations yield better c-MIR cuts—is supported by the split-cut illustration and the node reduction, but not by a theorem. For a heuristic paper, that is acceptable.

Who is this for? People working on cutting-plane separators inside MIP solvers. It is a subfield-relevant contribution, not a broad breakthrough. With the typos and missing threshold fixed, I would be happy to see it in a good optimization journal. As it stands, it deserves a serious referee but needs revision before acceptance.

Recommendation: send to peer review, but flag the Eq. (15) issue and the missing eta as mandatory before publication.

Referee Report

3 major / 4 minor

Summary. The paper proposes a sparsity-driven approach to row aggregation for generating c-MIR cutting planes in mixed-integer programming. The aggregation problem is formulated as a weighted ell_0 minimization over row factors, and the authors propose solving a sequence of linear programs: a lasso approximation (13) followed by an iterative reweighting stage (14)--(15). The paper shows that the Marchand--Wolsey heuristic is a forward stepwise selection method for the same cardinality problem, gives an example where the heuristic fails but the LP approach succeeds, and reports computational experiments on MIPLIB 2017 with SCIP. The experiments show roughly equal overall performance, a slowdown on easy instances, a modest speedup and node reduction on harder instances, and a large reduction in the number of bad continuous columns left in aggregated rows.

Significance. If the algorithm is fully specified, the paper makes a useful contribution: it provides a unifying optimization-based perspective on aggregation, replaces a greedy heuristic by a convex (LP) surrogate, and gives an external benchmark study showing that the resulting c-MIR cuts can reduce branch-and-bound tree sizes on challenging instances. The Wilcoxon test on node counts is a positive feature, and the use of the MIPLIB 2017 benchmark with multiple seeds is appropriate. The authors are appropriately cautious about slowdowns on easy instances. A caveat is that the sparsity comparison in Table 2 is partly by construction, because the algorithm minimizes the weighted ell_1 norm of the bad-column coefficients; the meaningful evidence for usefulness is therefore the external performance data, not the sparsity statistics alone. The conceptual link between the surrogate objective and cut strength is heuristic and is only illustrated, not proved, which is acceptable for an algorithmic paper but should be stated as a limitation.

major comments (3)

[Section 5, Eq. (15)] The iterative reweighting update is dimensionally inconsistent. In Eq. (14), the weight matrix W is diagonal over bad columns j in J, so the objective is ||W lambda_{I'}^T A_{I',J}||_1 = sum_j w_j |(lambda^T A)_j|. Eq. (15), however, updates quantities indexed by rows i in I': w_i = w_i/(epsilon + lambda_i) when lambda_i != 0 and w_i = 0 when lambda_i = 0. There are no row-indexed weights in Eq. (14) to update, and setting a weight to zero when lambda_i = 0 would drop penalties on bad columns rather than on rows. As written, Algorithm 3 cannot be executed. Please state the intended update explicitly, presumably w_j <- w_j/(epsilon + |(lambda_{I'}^T A_{I',J})_j|) for nonzero coefficients (or a variant on row weights with a correspondingly modified objective), and confirm that the implemented code matches the corrected formula.
[Section 6.1 and Algorithm 3, line 8] The density threshold eta is never given, and the stabilizer epsilon in Eq. (15) is also unspecified. Algorithm 3 uses eta to decide whether to run another reweighting round, and the number of reweighting rounds actually performed in the experiments is therefore unknown. The parameter list in Section 6.1 reports SEPA FREQ and MAXAGGR but omits eta, epsilon, and the maximum number of reweighting iterations (or the criterion for stopping before MAXAGGR is reached). Without these values, the computational results in Tables 1 and 2 are not reproducible. Please report all parameter values and describe how often the reweighting stage was triggered in practice.
[Section 6.2, Table 1] The paper's headline claim of decreased mean runtime on challenging instances is not supported by a statistical test. The only paired significance test reported is a Wilcoxon signed-rank test on node counts for instances solved by both configurations. The 5% reduction in shifted geometric mean time on the 'solved-over-100s' subset is reported without a confidence interval or paired test, and the 'solved-by-one' subset contains only 18 instances. Given the known performance variability of MIP solvers and the use of only five seeds, the runtime improvement may be within noise. Please provide paired tests or confidence intervals for the time comparisons, or soften the abstract's runtime claim to reflect that only the node reduction is statistically significant.

minor comments (4)

[Section 5, before Eq. (14)] The text says the new LP 'has only the second term in its objective,' but Eq. (14) contains only the first term of Eq. (13), namely ||W lambda_{I'}^T A_{I',J}||_1; the slack term is dropped. Please correct this wording.
[Section 3, title] 'We next revise the MW heuristic' should be 'review' or 'describe', since the section gives a high-level restatement rather than a revision.
[Algorithm 3, line 8] If the set J of bad variables is empty, the density expression |{j in J : a_j != 0}|/|J| is undefined. Please state the intended handling of the case J = empty.
[Section 4, Eq. (8)] Since W is a positive diagonal matrix, the weights w_j do not affect the sparsity pattern minimized by the ell_0 formulation; they only influence the ell_1 relaxation. The authors may wish to clarify that the bound-distance weighting is an artifact of the lasso surrogate rather than of the cardinality model.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the aggregation objective is explicitly optimized, and the paper's performance claims rest on external MIPLIB benchmarks rather than on the in-sample sparsity table.

full rationale

The derivation chain is self-contained. The aggregation problem is formulated as minimizing ||W λ^T A_{I,J}||_0 plus row sparsity (Eqs. 8-11), then relaxed to the lasso LP (13) and reweighted LP (14). The sparsity comparison in Table 2 reports the very quantity these LPs are designed to reduce, so it is an in-sample diagnostic rather than an independent prediction; the paper does not use Table 2 as evidence for solver gains. The central performance claims (runtimes and branch-and-bound nodes on MIPLIB 2017, Table 1) are measured against the external SCIP-default baseline with multiple random seeds, and no parameter is fitted to those outcomes. The MW heuristic is cited from Marchand and Wolsey, and reweighted l1 minimization from Candes-Wakin-Boyd are external, parameter-free methodological references; self-citations (SCIP suite, cut-based conflict analysis) are implementation context, not load-bearing. The apparent index mismatch in Eq. (15) is a technical reproducibility issue, not a circularity. Overall, no load-bearing step reduces to its own inputs.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The algorithm's effectiveness rests on heuristic assumptions from the sparse-optimization and cutting-plane literature: that l1 relaxation finds good l0 aggregations, that bound-distance-weighted projection of continuous variables correlates with cut strength, and that reweighted l1 helps here. No new entities are introduced.

free parameters (2)

density threshold eta = not reported
Stops iterative reweighting when the fraction of nonzero bad-variable coefficients falls below eta; without its value, re-implementation may differ from the tested configuration.
reweighting stabilizer epsilon = not reported
Small positive constant in Eq. (15) to avoid division by zero; the value is not given.

assumptions (3)

domain assumption l1 minimization is a valid surrogate for the l0 aggregation problem
The paper assumes lasso solutions yield good aggregations that project out bad variables; no recovery guarantee for this specific cosparsity problem is provided. This enters in Section 4.
domain assumption Eliminating bad continuous variables with large bound distance and small slack yields stronger c-MIR cuts
Justified by the split-cut example in Section 3, but not proven. This supports the objective chosen in Eq. (13).
domain assumption Iterative reweighted l1 improves sparsity in the aggregation context
Transferred from Candes et al. [12] without re-establishing it for the MIP aggregation setting. This enters in Section 5.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Sparsity-driven Aggregation of Mixed Integer Programs." pith.science (2026). https://pith.science/paper/RJJ3MOXM

@misc{pith2026250201192,
  author       = {Pith},
  title        = {Pith review of: Sparsity-driven Aggregation of Mixed Integer Programs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RJJ3MOXM}},
  note         = {Machine review of arXiv:2502.01192}
}

abstract

Cutting planes are crucial for the performance of branch-and-cut algorithms for solving mixed-integer programming (MIP) problems, and linear row aggregation has been successfully applied to better leverage the potential of several major families of MIP cutting planes. This paper formulates the problem of finding good quality aggregations as an $\ell_0$-norm minimization problem and employs a combination of the lasso method and iterative reweighting to efficiently find sparse solutions corresponding to good aggregations. A comparative analysis of the proposed algorithm and the state-of-the-art greedy heuristic approach is presented, showing that the greedy heuristic implements a stepwise selection algorithm for the $\ell_0$-norm minimization problem. Further, we present an example where our approach succeeds, whereas the standard heuristic fails to find an aggregation with desired properties. The algorithm is implemented within the constraint integer programming solver SCIP, and computational experiments on the MIPLIB 2017 benchmark show that although the algorithm leads to slowdowns on relatively ``easier'' instances, our aggregation approach decreases the mean running time on a subset of challenging instances and leads to smaller branch-and-bound trees.

Figures

Figures reproduced from arXiv: 2502.01192 by the authors.

**Figure 1.** Example of a split cut The MW heuristic differentiates between normal constraints and variable bound constraints. However, the second bound substitution step can be interpreted as a specialized constraint aggregation procedure applied to variable bound constraints, where the absolute values of the corresponding factors are restricted to either zero or one by the MW heuristic. We will show that, in Sect. 5, our aggre… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

39 extracted references · 34 canonical work pages

[1]

Constraint integer programming

Tobias Achterberg. Constraint integer programming. 2007

work page 2007
[2]

The MCF-separator: detecting and exploiting multi-commodity flow structures in MIPs

Tobias Achterberg and Christian Raack. The MCF-separator: detecting and exploiting multi-commodity flow structures in MIPs. Mathematical Program- ming Computation , 2(2):125–165, 2010

work page 2010
[3]

On capacitated network design cut–set polyhedra

Alper Atamt¨ urk. On capacitated network design cut–set polyhedra. Mathe- matical Programming, 92:425–437, 2002

work page 2002
[4]

Disjunctive programming

Egon Balas. Disjunctive programming. Annals of discrete mathematics, 5:3–51, 1979

work page 1979
[5]

Partitioning procedures for solving mixed-variables pro- gramming problems

Jacques F Benders. Partitioning procedures for solving mixed-variables pro- gramming problems. Numer. Math , 4(1):238–252, 1962

work page 1962
[6]

Heuristic algorithms in global MINLP solvers

Timo Berthold. Heuristic algorithms in global MINLP solvers . Verlag Dr. Hut, 2015

work page 2015
[7]

Capacitated network design—polyhedral structure and computation

Daniel Bienstock and Oktay G¨ unl¨ uk. Capacitated network design—polyhedral structure and computation. Informs journal on Computing, 8(3):243–259, 1996

work page 1996
[8]

Pfetsch, Franziska Schl¨ osser, Felipe Serrano, Yuji Shi- nano, Mark Turner, Stefan Vigerske, Dieter Weninger, and Liding Xu

Suresh Bolusani, Mathieu Besan¸ con, Ksenia Bestuzheva, Antonia Chmiela, Jo˜ ao Dion ´ ısio, Tim Donkiewicz, Jasper van Doornmalen, Leon Eifler, Mo- hammed Ghannam, Ambros Gleixner, Christoph Graczyk, Katrin Halbig, Ivo 14 Hedtke, Alexander Hoen, Christopher Hojny, Rolf van der Hulst, Dominik Kamp, Thorsten Koch, Kevin Kofler, Jurgen Lentz, Julian Manns, ...

arXiv 2024

Show all 39 references

[9]

Projected Chv´ atal–Gomory cuts for mixed integer linear programs

Pierre Bonami, G´ erard Cornu´ ejols, Sanjeeb Dash, Matteo Fischetti, and An- drea Lodi. Projected Chv´ atal–Gomory cuts for mixed integer linear programs. Mathematical Programming, 113(2):241–257, 2008

2008
[10]

Robust uncertainty principles: Exact signal reconstruction from highly incomplete frequency infor- mation

Emmanuel J Cand` es, Justin Romberg, and Terence Tao. Robust uncertainty principles: Exact signal reconstruction from highly incomplete frequency infor- mation. IEEE Transactions on information theory , 52(2):489–509, 2006

2006
[11]

Decoding by linear programming

Emmanuel J Candes and Terence Tao. Decoding by linear programming. IEEE transactions on information theory , 51(12):4203–4215, 2005

2005
[12]

Enhancing sparsity by reweighted ℓ1 minimization

Emmanuel J Candes, Michael B Wakin, and Stephen P Boyd. Enhancing sparsity by reweighted ℓ1 minimization. Journal of Fourier analysis and appli- cations, 14:877–905, 2008

2008
[13]

{0, 1/2}-Chv´ atal-Gomory cuts.Math- ematical Programming, 74:221–235, 1996

Alberto Caprara and Matteo Fischetti. {0, 1/2}-Chv´ atal-Gomory cuts.Math- ematical Programming, 74:221–235, 1996

1996
[14]

On the separation of maximally violated mod-k cuts

Alberto Caprara, Matteo Fischetti, and Adam N Letchford. On the separation of maximally violated mod-k cuts. Mathematical Programming, 87:37–56, 2000

2000
[15]

A first-order primal-dual algorithm for convex problems with applications to imaging.Journal of mathematical imaging and vision , 40:120–145, 2011

Antonin Chambolle and Thomas Pock. A first-order primal-dual algorithm for convex problems with applications to imaging.Journal of mathematical imaging and vision , 40:120–145, 2011

2011
[16]

Atomic decomposition by basis pursuit

Scott Shaobing Chen, David L Donoho, and Michael A Saunders. Atomic decomposition by basis pursuit. SIAM review, 43(1):129–159, 2001

2001
[17]

Separation algorithms for cutting planes based on mixed integer row relaxations

Philipp M Christophel. Separation algorithms for cutting planes based on mixed integer row relaxations. PhD thesis, Paderborn, Univ., Diss., 2009, 2009

2009
[18]

Edmonds polytopes and a hierarchy of combinatorial problems

Vasek Chv´ atal. Edmonds polytopes and a hierarchy of combinatorial problems. Discrete mathematics, 4(4):305–337, 1973

1973
[19]

Chv´ atal clo- sures for mixed integer programming problems

William Cook, Ravindran Kannan, and Alexander Schrijver. Chv´ atal clo- sures for mixed integer programming problems. Mathematical Programming, 47(1):155–174, 1990

1990
[20]

Valid inequalities for mixed integer linear programs.Math- ematical programming, 112(1):3–44, 2008

G´ erard Cornu´ ejols. Valid inequalities for mixed integer linear programs.Math- ematical programming, 112(1):3–44, 2008

2008
[21]

Applied regression analysis

Norman R Draper and Harry Smith. Applied regression analysis. McGraw-Hill. Inc, 1998

1998
[22]

Optimizing over the first Chv´ atal closure

Matteo Fischetti and Andrea Lodi. Optimizing over the first Chv´ atal closure. Mathematical Programming, 110(1):3–20, 2007. 15

2007
[23]

MIPLIB 2017: data-driven compilation of the 6th mixed-integer programming library

Ambros Gleixner, Gregor Hendel, Gerald Gamrath, Tobias Achterberg, Michael Bastubbe, Timo Berthold, Philipp Christophel, Kati Jarck, Thorsten Koch, Jeff Linderoth, et al. MIPLIB 2017: data-driven compilation of the 6th mixed-integer programming library. Mathematical Programmin...

2017
[24]

An algorithm for the mixed integer problem

Ralph Edward Gomory. An algorithm for the mixed integer problem. Report No. P-1885, The Rand Corporation, Santa Monica, CA. , 1960

1960
[25]

An implementation of a separation procedure for mixed integer rounding inequalities

Joao PM Gon¸ calves and Laszlo Ladanyi. An implementation of a separation procedure for mixed integer rounding inequalities. IBM Res. Report RC23686 (W0508-022), IBM , 2005

2005
[26]

Lifted flow cover inequalities for mixed 0-1 integer programs

Zonghao Gu, George L Nemhauser, and Martin WP Savelsbergh. Lifted flow cover inequalities for mixed 0-1 integer programs. Mathematical Programming, 85:439–467, 1999

1999
[27]

Extended compar- isons of best subset selection, forward stepwise selection, and the lasso

Trevor Hastie, Robert Tibshirani, and Ryan J Tibshirani. Extended compar- isons of best subset selection, forward stepwise selection, and the lasso. arXiv preprint arXiv:1707.08692, 2017

2017 arXiv
[28]

The impact of model selection on inference in linear regression

Clifford M Hurvich and Chih—Ling Tsai. The impact of model selection on inference in linear regression. The American Statistician , 44(3):214–217, 1990

1990
[29]

On lifted cover inequalities: A new lifting procedure with unusual properties

Adam N Letchford and Georgia Souli. On lifted cover inequalities: A new lifting procedure with unusual properties. Operations Research Letters, 47(2):83–87, 2019

2019
[30]

Performance variability in mixed-integer programming

Andrea Lodi and Andrea Tramontani. Performance variability in mixed-integer programming. In Theory driven by influential applications , pages 1–12. IN- FORMS, 2013

2013
[31]

The 0-1 knapsack problem with a single continuous variable

Hugues Marchand and Laurence A Wolsey. The 0-1 knapsack problem with a single continuous variable. Mathematical Programming, 85:15–33, 1999

1999
[32]

Aggregation and mixed integer rounding to solve MIPs

Hugues Marchand and Laurence A Wolsey. Aggregation and mixed integer rounding to solve MIPs. Operations research, 49(3):363–371, 2001

2001
[33]

Cut-based conflict analysis in mixed integer programming

Gioni Mexi, Felipe Serrano, Timo Berthold, Ambros Gleixner, and Jakob Nord- str¨ om. Cut-based conflict analysis in mixed integer programming. arXiv preprint arXiv:2410.15110, 2024

2024
[34]

The cosparse analysis model and algorithms

Sangnam Nam, Mike E Davies, Michael Elad, and R´ emi Gribonval. The cosparse analysis model and algorithms. Applied and Computational Harmonic Analysis, 34(1):30–56, 2013

2013
[35]

A recursive procedure to generate all cuts for 0–1 mixed integer programs.Mathematical Programming, 46(1):379– 390, 1990

George L Nemhauser and Laurence A Wolsey. A recursive procedure to generate all cuts for 0–1 mixed integer programs.Mathematical Programming, 46(1):379– 390, 1990

1990
[36]

Prediction error and its estimation for subset-selected models

Ellen B Roecker. Prediction error and its estimation for subset-selected models. Technometrics, 33(4):459–468, 1991. 16

1991
[37]

Regression shrinkage and selection via the lasso

Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society Series B: Statistical Methodology , 58(1):267–288, 1996

1996
[38]

Cardinality minimization, constraints, and regularization: a survey

Andreas M Tillmann, Daniel Bienstock, Andrea Lodi, and Alexandra Schwartz. Cardinality minimization, constraints, and regularization: a survey. SIAM Review, 66(3):403–477, 2024

2024
[39]

Implementation of cutting plane separators for mixed integer programs

Kati Wolter. Implementation of cutting plane separators for mixed integer programs. Dipolma thesis, Technische Universit¨ at Berlin, 2006. 17

2006

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.

[1] [1]

Constraint integer programming

Tobias Achterberg. Constraint integer programming. 2007

work page 2007

[2] [2]

The MCF-separator: detecting and exploiting multi-commodity flow structures in MIPs

Tobias Achterberg and Christian Raack. The MCF-separator: detecting and exploiting multi-commodity flow structures in MIPs. Mathematical Program- ming Computation , 2(2):125–165, 2010

work page 2010

[3] [3]

On capacitated network design cut–set polyhedra

Alper Atamt¨ urk. On capacitated network design cut–set polyhedra. Mathe- matical Programming, 92:425–437, 2002

work page 2002

[4] [4]

Disjunctive programming

Egon Balas. Disjunctive programming. Annals of discrete mathematics, 5:3–51, 1979

work page 1979

[5] [5]

Partitioning procedures for solving mixed-variables pro- gramming problems

Jacques F Benders. Partitioning procedures for solving mixed-variables pro- gramming problems. Numer. Math , 4(1):238–252, 1962

work page 1962

[6] [6]

Heuristic algorithms in global MINLP solvers

Timo Berthold. Heuristic algorithms in global MINLP solvers . Verlag Dr. Hut, 2015

work page 2015

[7] [7]

Capacitated network design—polyhedral structure and computation

Daniel Bienstock and Oktay G¨ unl¨ uk. Capacitated network design—polyhedral structure and computation. Informs journal on Computing, 8(3):243–259, 1996

work page 1996

[8] [8]

Pfetsch, Franziska Schl¨ osser, Felipe Serrano, Yuji Shi- nano, Mark Turner, Stefan Vigerske, Dieter Weninger, and Liding Xu

Suresh Bolusani, Mathieu Besan¸ con, Ksenia Bestuzheva, Antonia Chmiela, Jo˜ ao Dion ´ ısio, Tim Donkiewicz, Jasper van Doornmalen, Leon Eifler, Mo- hammed Ghannam, Ambros Gleixner, Christoph Graczyk, Katrin Halbig, Ivo 14 Hedtke, Alexander Hoen, Christopher Hojny, Rolf van der Hulst, Dominik Kamp, Thorsten Koch, Kevin Kofler, Jurgen Lentz, Julian Manns, ...

arXiv 2024