When Solvers Get Moody: Quantifying and Predicting Performance Variability in Mixed Integer Programming

arXiv:2610.12876 · math.OC, cs.LG · Submitted 2026-10-09 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "When Solvers Get Moody".

Jane: The Weighted Variability Score (WVS) is introduced as a robust, multi-component metric designed to aggregate dispersion in normalized runtime, final optimality gap, LP iterations,

Tom: First, who's behind it and why it matters.

Paper summary: Jane: We've been talking about the Weighted Variability Score, or WVS, and how it helps us quantify and predict performance variability in mixed-integer programming solvers. So to wrap up, what’s the big picture here?

Tom: The main point is that we have a robust metric that aggregates dispersion in runtime, gap, iterations, and nodes across repeated runs. This allows researchers to distinguish genuinely stable instances from those whose outcomes are just dependent on the random seed.

Lu: The paper shows this variability isn't just noise; it’s systematically driven by primal and dual inactivity indicators right at the root node.

Meng: For us in production, this means we can use these early features to triage instances and decide upfront if we need to spend more time or resources on a particular problem.

Jane: The WVS provides a tool for preemptive tuning and fairer evaluation of new algorithms by showing us what structural features cause solver instability.

Tom: It suggests that variability should be treated as an explicit tuning objective in solver development because the early-run information is quite predictive, with the gated tail uplift model achieving a mean absolute error of zero point zero five eight.

Lu: And the implication for future work is that we need to keep looking at these structural drivers and how they manifest across different problem types to build better predictors.

Conclusion: Tom: So we’ve been talking about this new paper by some folks who looked at how mixed integer programming solvers behave when they get moody across different runs.

Jane: Right, so we're looking at something called the Weighted Variability Score, or WVS. It sounds like a way to measure if a solver is just being lucky or if it’s actually unstable.

Tom: Exactly. The authors, they focused on quantifying this dispersion in things like runtime and the final gap when you run the same problem over and over.

Jane: I mean, for someone who isn't reading these papers, what does that variability actually *mean* for a solver? Is it just noise?

Tom: Not at all. The paper shows that this variability isn't random; it’s tied to specific structural features of the problem itself, like root degeneracy or matrix structure.

Jane: So if a solver has high WVS, what does that tell you about the problem we’re trying to solve? Does it mean we should just try a different solver?

Tom: Not necessarily. It means the instance itself has characteristics—like those zero dual values or zero reduced costs they mentioned—that make it inherently tricky for solvers to handle consistently.

Jane: That’s interesting, because if we can predict *why* it’s moody, instead of just guessing, what does that change for how we develop these mathematical tools?

Tom: It gives us a way to preemptively tune the problem setup or the solver settings before we even start running the full simulation.

Jane: So, in short, this paper moves us from just observing bad runs to understanding the underlying mechanics of why those bad runs happen.

Tom: And since they built a predictor for this score using early run features and static structure, it suggests we might actually be able to use these early indicators to decide if we should spend more time on an instance upfront.

Jane: That sounds like a practical step, moving the research from pure theory into something that could actually help us make solvers more reliable in the real world. (Sound of traffic and coffee swells slightly)

Mourchid Adegbindina, Brenda Dietrichb, Jamol Penderc, Andrea Lodid

Cornell University

math.OC, cs.LG

Submitted: 2026-10-09

Updated: 2026-10-09

Comments: 21 pages, including a 3-page electronic companion. An earlier conference version appeared in the IOS 2026 proceedings. https://doi.org/10.5281/zenodo.19478202

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

The gist: The Weighted Variability Score (WVS) is introduced as a robust, multi-component metric designed to aggregate dispersion in normalized runtime, final optimality gap, LP iterations, and

Key concepts

Weighted Variability Score (WVS)
A robust metric that aggregates dispersion across four performance indicators: normalized runtime, final optimality gap, LP iterations, and branch-and-bound nodes. It uses modified coefficients of variation to create a scale-free score that captures instability.
Modified Coefficient of Variation (MCV)
A formula used to calculate the dispersion in each component (like time or gap). It down-weights extreme deviations using weights that depend on the deviation's magnitude, ensuring the final score is robust against outliers and timeouts.
Root Degeneracy
A structural feature of a problem where many constraints are active at the root node, meaning they are binding. High root degeneracy is identified as a primary driver for high WVS scores, indicating that instability often stems from how the solver handles these specific structural configurations.
Predictive Modeling
A machine learning approach using static and early-run features to predict the WVS score before solving. A tree-based model with a gated tail uplift was used, achieving good accuracy on test data to triage instances for further investigation.

Summary

The Weighted Variability Score (WVS) is introduced as a robust, multi-component metric designed to aggregate dispersion in normalized runtime, final optimality gap, LP iterations, and branch-and-bound nodes across repeated runs to quantify performance variability in mixed integer programming solvers. This research matters because it provides a tool for preemptive tuning and fairer evaluation of new algorithms by identifying which structural features drive solver instability.

How it works

The core contribution is the Weighted Variability Score (WVS), which is defined as a weighted sum of four component modified coefficients of variation (MCV) for normalized time, final gap, LP iterations, and branch-and-bound nodes. The MCV down-weights extreme standardized deviations using the formula MCVc = vutÍN j=1 wj(x j − μ) 2 / μ 2 ÍN j=1 wj, where wj = 1/(1 + zj 2) and zj = (xj − μ)/s if s > 0 (otherwise zj = 0). This construction ensures the score is scale-free, and timeout-robust.

The WVS is calculated for each instance–solver pair (i, s) using a weight vector w = (wT, wG, wI, wB) summing to one. The weights are chosen by searching over a discrete grid on the simplex Δ = [w ∈ R 4 ≥0: wT + wG + wI + wB = 1]. For each candidate weight vector, the score is defined as WVSi,s (w) = wT MCVT i,s + wG MCVG i,s + wI MCVI i,s + wB MCVB i,s. The weights used in the final calculation are fixed at (0.65, 0.05, 0.20, 0.10) for the SCIP–Gurobi overlap set.

Experimental Design and Features

The study utilized a broad subset of MIPLIB 2017 instances (1,065 instances), running each instance 100 times under identical parameter settings and varying only the solver’s internal random seed. The analysis involves extracting two groups of features: static structural features and early-run dynamic features. Static features include numbers of variables, constraints, and nonzeros; variable-type ratios (binary, general-integer, continuous); simple measures of sparsity and row/column aspect ratio. Dynamic features capture early presolving and root-node behavior under the standardized run protocol.

Empirical Characterization of Variability

The empirical distribution of WVS reveals a right-skewed distribution with a substantial upper tail: many instances are essentially stable, but some exhibit large variability that is not explained by basic properties alone. The analysis shows that WVS behaves as an additional axis, complementary to size and baseline difficulty, as correlations between WVSi and simple proxies like log10 of the number of constraints are moderate rather than near one.

Component-level behavior analysis showed that LP-iteration dispersion tracks time dispersion closely (correlation about 0.86), as expected, but remains useful on instances where many runs hit the time limit and time is censored. The decomposition of WVS into its four components shows that time contribution grows sharply and becomes dominant on average, while iterations and nodes continue to contribute in an instance-dependent way.

Predictive Modeling

A tree-based predictor with a gated tail uplift was built using static descriptors and root-level features. This model achieved a mean absolute error of 0.058 and Spearman rank correlation of 0.65 on a sealed test split. The final predictor uses three tree experts—a base expert, a synthetic-tail expert trained with SMOTE-style synthetic oversampling, and a tail expert trained with a 0.90 quantile loss—combined via logistic gates to add nonnegative corrections.

Discussion and Drivers

Feature-importance analysis using SHAP attributions highlights that root degeneracy, matrix structure, coefficient ranges, and presolve reductions as the main drivers of high WVS. The most consistent signals of instability are indicators of primal and dual inactivity: the ratio of binding constraints with zero dual values and the fraction of non-basic variables with zero reduced costs. The results suggest that variability is a systematic property of the numerical and combinatorial structure exposed at the root node.

Implications

The findings imply that variability can be reported alongside standard aggregates, allowing researchers to distinguish genuinely stable instances from those whose outcomes depend strongly on the random seed. The early-stage predictor suggests a simple triage mechanism where high predicted WVS instances are natural targets for larger budgets or bet-and-run strategies. Furthermore, the drivers point toward solver development, indicating that variability should be treated as an explicit tuning objective. The final predictor achieves a mean absolute error of about 0.058 and a Spearman rank correlation of about 0.65 with WVS.

The gist

WVS reveals a strongly rightskewed distribution with a substantial upper tail: many instances are essentially stable, but some exhibit large run-to-run variability that is not a simple monotone function of instance scale or difficulty.

Improvements for AI systems

  1. Bold header: Incorporate Weighted Variability Score (WVS) into instance selection criteria. The WVS distinguishes genuinely stable instances from those whose outcomes depend strongly on the random seed, allowing researchers to report on performance robustness rather than just single-run metrics.

  2. Bold header: Implement a tree-based predictor for preemptive tuning. This model, trained using static descriptors and root-level features, can be used as a simple triage mechanism to determine if an instance requires a larger budget, extra seeds, or bet-and-run strategies.

  3. Bold header: Develop solver development targets based on feature importance. The analysis shows that variability is driven by factors like root degeneracy, matrix structure, coefficient ranges, and presolve reductions, indicating that parameter sets can be compared based on their impact on these specific instability drivers.

Related papers