acceptodds
Under review as a conference paper at ICLR 2027

MILP-Evo: Closed-Loop Fully Automatic Design of MILP Solvers

Abstract

Machine learning methods have shown that data-driven policies can accelerate mixed-integer linear programming (MILP) solvers, but many such approaches remain difficult to inspect, adapt, and deploy because the learned policy is represented as an external predictor or other opaque model. By contrast, explicit solver logic is easier to understand and integrate, but is usually hand-designed rather than learned from solver feedback. We study the automatic design of executable white-box components for MILP solvers, using their end-to-end behavior on MILP instances to guide iterative refinement. To this end, we introduce MILP-Evo, a framework implemented through PySCIPOpt, and instantiate it on the joint design of a cut selector and a branching rule. Candidate implementations are executed directly within SCIP and refined using their runtime outcomes and search-process diagnostics. The resulting solver components can be inspected, modified, and deployed within standard solver workflows. Across four families, MILP-Evo performs strongly on independent set, combinatorial auctions, and set cover, and remains competitive on facility location.

Primary area:
optimization
Keywords:
Mixed-Integer Linear Programming, Automated Algorithm Design, Large Language Models

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_gdsUOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

MILP-Evo uses LLM-driven evolutionary program search (Gemini 3 Flash) to write a PySCIPOpt module that implements a cut selector and a branching rule together.

  • Search machinery. Islands, a MAP-Elites archive whose two descriptors are rated by the LLM, reflection prompts, mutation, and crossover.
  • Validity. A "contract-preserving" repair operator fixes candidates that break PySCIPOpt callback contracts.
  • Fitness. Mean SCIP process time over 10 Easy training instances, with invalid or unsolved candidates assigned infinite fitness.
  • Evaluation. On four learn2branch families (set cover, combinatorial auctions, facility location, independent set), the exported module is tested on Easy, Medium and Hard scales: 10 instances × 5 seeds per scale. It has the best mean time in 7 of the 9 independent-set, auction, and set-cover settings.
  • Analysis. Ablations on independent set compare joint search with single-component search and with search without repair. Repair statistics and a lineage analysis are also reported.
Critical strengths
  1. Inspectable, deployable output. The result is a readable callback module. The paper prints the full independent-set program and candidly analyzes which of its terms actually affect decisions (Appendix B.1).
  2. A sensible target for joint search. Searching for cut selection and branching together is well-motivated. On the independent set, the joint module clearly outperforms the post hoc combination of separately found components at the Hard scale (806 s vs 2,299 s).
  3. Appropriate statistics. Seeds are averaged per instance before exact Wilcoxon tests with Holm correction (Table 7), and the non-significant settings are reported openly.
  4. The repair operator is measured. Valid-candidate rate rises from 79.96% to 95.64% (Table 3).
Critical weaknesses
  1. Methodological novelty over existing LLM program search is limited. Islands, MAP-Elites archives, reflection, and LLM mutation and crossover are established in FunSearch, EoH, ReEvo, and AlphaEvolve. The new parts are callback-contract checking and repair, which are engineering contributions. Please state what is methodologically new. Please also compare against at least one existing framework (for example, an EoH- or ReEvo-style loop) on the same callback space, with the same LLM and the same evaluation budget.

  2. The most relevant baseline, algorithm configuration, is missing. Tuning solver parameters per problem family is a mature approach (SMAC, irace, ParamILS applied to SCIP or CPLEX). The evolved independent-set cut selector mainly limits how many cuts are added: it keeps cuts that score at least 85% of the best, capped at one-third of the pool. A similar effect may be reachable by tuning SCIP's separation and cut-selection parameters (maximum cuts per round, cut-selector weights, separation emphasis) together with branching parameters, under the same budget (400 iterations × 10 instances). In addition, every learned baseline modifies only branching, whereas MILP-Evo also changes cut selection, so the comparison conflates the two effects. A learned cut-selection baseline, or a branching-only MILP-Evo in the main table, is needed.

  3. The baseline setup may not be consistent.

    • The paper says all baselines use "the fixed defaults of their cited implementations", and the software versions it lists describe only "the main MILP-Evo environment". Please confirm that every method (FSB, RPB, GNN, Hybrid, GS4CO, SCIP) runs on the same SCIP 10.0.2 build, with the same parameter settings (for example, cuts at the root only and restarts disabled, as in learn2branch, versus SCIP defaults), on the same machines and thread counts.
    • Some numbers suggest a mismatch. On an independent set at the Medium scale, GNN takes 1,673 s and Hybrid 1,502 s, compared to 194.74 s for RPB, roughly an 8× gap. The original learn2branch study found the GNN policy competitive with RPB at comparable scales.
    • Please also explain how "RPB" and "SCIP" differ, since SCIP's default branching rule is reliability pseudo-cost branching.
  4. The best result may rely on an instance-generator artifact. Appendix B.1 shows that the effective independent-set branching rule is (n_up(v), −i(v)): pick the variable with the most up-locks, then the smallest variable index. The learn2branch independent-set instances come from Barabási–Albert graphs. In that model, low-index nodes are the earliest added and tend to have the highest degree, so the index probably stands in for degree. That is a property of the generator's ordering, not of the problem. Please evaluate on instances whose variables and constraints are randomly permuted. If performance drops, the independent-set results, the paper's strongest, partly reflect ordering leakage. This also bears on the interpretability claim.

  5. The evaluation is small and rests on one search run.

    • Each scale uses only 10 test instances (× 5 seeds), fewer than the usual learn2branch protocol.
    • Search uses 10 training instances and a single SCIP seed.
    • Only one evolutionary run per family is reported. LLM-driven search is highly stochastic, so please report several independent runs (3–5) and the spread of their final test performance.
    • Please report the total cost of search: input and output tokens (or dollars), plus CPU-hours of SCIP evaluation. Figure 2 shows about 600k output tokens for independent set, but the full cost is not given.
  6. The ablations are under-specified. They are run only on independent set. It is unclear whether the cut-only and branch-only searches had the same 400-iteration budget, or whether NoRepair reached a comparable number of valid evaluations. Please clarify, and repeat the ablations on at least one more family.

  7. Results are mixed, and the claims are broader than the evidence.

    • MILP-Evo does not have the best mean time at the Hard scale of auctions (381.90 s vs 271.44 s for RPB) or set cover (2,641.34 s vs 2,401.92 s for RPB).
    • It trails on facility location at the Hard scale (761.88 s vs 607.57 s).
    • 5 of the 12 settings are not statistically significant.
    • All evaluation is within a single synthetic family, transferring only from Easy to Medium and Hard; nothing is tested on heterogeneous benchmarks such as MIPLIB. The title, "Closed-Loop Fully Automatic Design of MILP Solvers", is therefore much broader than the evidence, which covers two callbacks, four synthetic families, and hand-written, family-specific prompts.
  8. Presentation issues.

    • The abstract gives no quantitative results.
    • The formalization in Section 3.2 adds little.
    • Table 1 is dense; mean ± std should be in the main text rather than only in Appendix C.1.
    • The interpretability claim rests on one example, in which several terms turn out to be inactive.
    • The overhead of Python callbacks (the share of time spent inside them) is not reported.
Questions for authors
  1. Do all baselines run on the same SCIP build, with the same parameter settings, on the same hardware? What explains GNN and Hybrid being so slow on independent set at the Medium scale?
  2. How does the independent-set module perform on instances with randomly permuted variables and constraints?
  3. How does MILP-Evo compare with SCIP parameter tuning (e.g., SMAC or irace) under a matched compute budget?
  4. What is the spread of results over several independent search runs, and what is the total search cost (tokens and CPU-hours)?
  5. Were the single-component and NoRepair ablations given the same budget as the full method?
  6. How does MILP-Evo compare with an existing LLM program-search framework (EoH, ReEvo, or FunSearch-style) on the same callback space?
  7. What fraction of solve time is spent inside the Python callbacks?
9 comments

Thank you for the constructive review. We address the concerns below.

1. Contribution and search baselines (Q3, Q6)

Our contribution is joint synthesis of executable cut-selection and branching callbacks with solver-feedback validation and contract-preserving repair. The underlying LLM search operators are established.

ReEvo uses the same Gemini 3 Flash backbone and callback space as MILP-Evo, while SMAC tunes SCIP parameters. ReEvo is matched by total token budget and SMAC by solver-evaluation time, with each cap set to the corresponding MILP-Evo search budget. Tokens consumed by repair are included in the token budget.

Evaluation now covers 20 instances per scale and five runs per instance: 1,200 runs per method. Mean runtime includes every run, charging 3,600 s for unsuccessful runs.

Table 1. Aggregate results on the expanded benchmark.

MethodMean runtime (s)Solved / 1,200
MILP-Evo403.741150
ReEvo531.401125
SMAC680.951068
SCIP618.701104
COPT358.671143

MILP-Evo has lower mean runtime than ReEvo in all 12 settings and reduces aggregate mean runtime by 40.7% versus SMAC. COPT remains faster overall.

The following breakdown reports all 12 settings, each with 20 instances and five runs per instance. Unsuccessful runs contribute 3,600 s.

Family / scaleMILP-Evo (s)ReEvo (s)SMAC (s)SCIP (s)
Independent set / Easy3.004.094.0312.79
Independent set / Medium61.67129.60587.60325.34
Independent set / Hard773.591767.913285.332766.13
Auctions / Easy0.742.620.944.47
Auctions / Medium17.2936.9422.1652.24
Auctions / Hard362.22385.05433.07274.08
Set cover / Easy3.1910.283.0713.37
Set cover / Medium73.06174.0075.96211.54
Set cover / Hard2419.152580.452485.922645.52
Facility location / Easy70.3376.23218.1773.78
Facility location / Medium331.24406.91323.24337.54
Facility location / Hard729.40802.76731.91707.57

MILP-Evo improves mean runtime over ReEvo in every setting. The gains are particularly large on independent-set Hard (773.59 vs. 1767.91 s) and set-cover Medium (73.06 vs. 174.00 s). Against SMAC, MILP-Evo has lower mean runtime in 10 of 12 settings, while SMAC is faster on set-cover Easy and facility-location Medium. This breakdown shows where the aggregate 40.7% reduction over SMAC arises.

2. Baseline training and compatibility (Q1)

GNN/Hybrid followed official stopping criteria; independent-set training took 1h19m (67 epochs)/6h14m (61 epochs). GS4CO uses official pretrained expressions. All methods used the same hardware platform. Unrelated parameters were matched where possible; otherwise, version-specific defaults were retained.

MILP-Evo/ReEvo/SMAC/SCIP/FSB use SCIP 10.0.2, GNN 7.0.3, and Hybrid/GS4CO/RPB 6.0.1. RPB is relpscost in the GS4CO pipeline. MILP-Evo relies on the cut-selector plugin introduced in SCIP 8.0, so it cannot run unchanged on standard SCIP 6/7. Upgrading legacy baselines requires adapting PySCIPOpt/feature-extraction interfaces, including Ecole where used, and validating model/expression outputs and parameter mappings.

These constraints do not eliminate version effects. The same-version SCIP, ReEvo, and SMAC comparisons support our conclusions independently of the neural baselines. We will report parameter overrides and thread counts.

We additionally checked the independent-set Medium results on the new instances, pairing runs by instance and solver seed and retaining pairs solved to optimality by both methods.

Comparison (A / B)Paired runsMean nodes (A / B)Mean runtime (s, A / B)
GNN-GPU / SCIP4522352 / 1216389.76 / 149.99
GNN-CPU / GNN-GPU4315013 / 14918474.99 / 267.06
Hybrid / RPB3924994 / 3519823.02 / 148.66

The GNN CPU and GPU runs produce similar mean tree sizes, while GPU evaluation reduces runtime from 474.99 to 267.06 s. However, the GNN-GPU tree remains much larger than SCIP's on their jointly solved pairs. Hybrid also explores more nodes than RPB. Thus, the observed gap includes a search-tree difference and is not explained solely by neural inference overhead. Each row uses its own jointly solved subset.

3. Ordering sensitivity (Q2)

We tested the fixed exported independent-set policy without retraining or further LLM calls. Variable names, coefficients, bounds, objective, and variable types were preserved; only the input order was changed. Mathematical equivalence was verified after SCIP loaded each permuted instance.

For each scale, we used 10 instances, three permutation seeds (1101-1103), and five solver seeds (0-4), giving 150 runs per method with simultaneous variable/constraint permutations. MILP-Evo and SCIP used identical instances, permutations, and solver seeds, with one CPU core per run. We first averaged the three permutations within each instance/solver-seed pair, then calculated the permuted/original mean-time ratio across 50 matched pairs.

ScaleMILP-Evo original (s)MILP-Evo permuted (s)RatioSCIP permuted (s)Solved: MILP-Evo / SCIP
Easy3.053.231.0568.88150/150 / 150/150
Medium68.4662.750.917244.16150/150 / 150/150
Hard879.03869.400.9892838.35147/150 / 68/150

Times are CPU-PAR1, assigning 3,600 s to unsuccessful runs. The largest increase is 5.6% on Easy; Medium and Hard are 8.3% and 1.1% faster after permutation. On permuted Hard instances, MILP-Evo remains 3.26 times faster than SCIP and solves 147 rather than 68 runs. These results show that its advantage persists when the original input ordering is disrupted.

We also tested variable-only and constraint-only permutations on Easy instances with solver seed 0. Their permuted/original ratios are 1.094 and 1.028, respectively, providing separate checks of the two input orders.

4. Independent searches and cost (Q4)

Three 400-iteration searches yield best training fitness values (s) of 3.10/6.83/2.82 for independent set, 1.59/0.80/7.44 for auctions, 4.67/4.26/5.74 for set cover, and 25.43/23.31/24.72 for facility location.

Each search uses 3.14-3.75M recorded tokens and 8.90-36.87 evaluation CPU-hours, including invalid candidates; estimated elapsed time is 2.50-10.09 h.

The following ledger summarizes the three existing 400-iteration searches for each family. Token totals include input, output, and reasoning tokens; evaluation CPU time includes invalid candidates.

Family / seedTokens (M)Evaluation CPU (h)Estimated elapsed time (h)
Independent set / 10013.2310.513.15
Independent set / 10023.3112.433.71
Independent set / 10033.148.922.56
Auctions / 10013.4211.023.02
Auctions / 10023.758.902.50
Auctions / 10033.6214.934.08
Set cover / 10013.3724.886.93
Set cover / 10023.4118.914.95
Set cover / 10033.4430.167.78
Facility location / 10013.3636.829.68
Facility location / 10023.6936.2210.09
Facility location / 10033.6036.879.77

CPU-hours measure accumulated solver-evaluation work; elapsed estimates describe the duration reported by the search ledger. These are offline costs. Once exported, the policy runs as solver callbacks without further LLM calls.

5. Ablation budgets (Q5)

Joint, Cut-only, Branch-only, and NoRepair each use 400 iterations. Separate-best is constructed by selecting the best individual from the Cut-only search and the best individual from the Branch-only search, then combining their cut-selection and branching components. Each component search uses 400 iterations, giving 800 iterations in total.

Table 2. Ablation mean process time (s), Easy/Medium/Hard; 50 runs per setting.

MethodIndependent setAuctionsSet coverFacility location
Joint2.57/59.20/806.170.81/11.79/381.903.14/89.36/2641.3435.66/266.21/761.88
Cut-only6.33/179.96/2522.533.50/26.63/259.9610.44/185.67/2827.0340.20/305.36/820.06
Branch-only4.85/166.36/2452.773.04/26.40/239.2610.18/205.81/2899.1243.60/313.20/746.37
Separate-best3.95/124.48/2299.232.40/16.52/227.428.80/192.48/2892.5634.75/309.41/704.18
NoRepair6.34/200.81/2615.153.07/28.14/248.149.37/215.65/2960.6343.23/295.90/636.27

Joint leads nine settings, but Separate-best wins on Hard auctions and NoRepair on Hard facility location.

6. Statistics, overhead, and scope (Q7)

Across 120 Holm-corrected Wilcoxon comparisons using 20 instance means, MILP-Evo is significantly faster in 74, nonsignificant in 41, and slower in five. Losses are against COPT and GNN-GPU.

We profiled the fixed exported policies on five instances in each of the 12 family/scale settings, using solver seed 0: 60 runs in total, including 57 optimal completions and three timeouts. The numerator is cumulative wall time inside the cut-selection and branching callbacks, including their native API calls; nested callbacks are not double-counted. The denominator is wall time inside Model.optimize, excluding instance reading and model construction. Each setting-level percentage is the sum of callback times divided by the sum of optimize times.

FamilyCut selection (%) E/M/HBranching (%) E/M/HTotal (%) E/M/H
Independent set0.132/0.040/0.0190.374/0.490/0.7200.506/0.530/0.739
Auctions0.115/0.046/0.0311.353/1.272/1.5501.467/1.318/1.581
Set cover0.396/0.143/0.0571.010/1.547/0.7981.406/1.690/0.854
Facility location0.027/0.004/0.0010.034/0.016/0.0040.061/0.019/0.005

Total callback time accounts for 0.005%-1.69% of optimize time across the 12 setting-level aggregates, showing that the deployed callbacks consume a small fraction of solving time. The table separates cut-selection and branching costs and includes native operations invoked inside the callbacks.

We will narrow the title and claims to family-specific co-design of two callbacks and within-family scale transfer. Cross-family/MIPLIB transfer remains untested. We will highlight Hard losses, add abstract numbers and main-table mean ± standard deviation, shorten Section 3.2, and qualify interpretability claims.

Reviewer_pY8wOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes MILP-Evo, an LLM-driven framework for automatically designing executable MILP solver components. It jointly evolves cut-selection and branching rules through PySCIPOpt, using SCIP execution feedback, contract-preserving repair, and evolutionary search. Experiments on four MILP problem families show substantial improvements on independent set, combinatorial auctions, and set cover, with mixed results on facility location.

Critical strengths
  1. The paper addresses a meaningful problem by automatically generating interpretable, executable solver components rather than relying on black-box predictors.
  2. Jointly evolving cut selection and branching is well motivated, and the ablation results demonstrate benefits over independently optimized components.
  3. The framework incorporates callback validation and repair, improving the reliability of generated solver programs.
  4. Experiments across four MILP families demonstrate substantial runtime improvements on several benchmarks, particularly independent set.
Critical weaknesses
  1. The methodological novelty is somewhat limited. The evolutionary framework builds on established LLM-based program search techniques, while its distinctive algorithmic contributions beyond solver-specific integration remain unclear.
  2. The experimental comparisons are not fully balanced. MILP-Evo receives 400 evolutionary search iterations per problem family, whereas the baselines use fixed configurations without comparable tuning budgets.
  3. The generalization evidence is limited to different instance sizes within the same problem families. Transfer to unseen problem distributions or real-world MILPs remains untested.
  4. The ablation study focuses on independent set, leaving the benefits of joint evolution and repair across other problem families insufficiently established.
  5. The computational cost of LLM-based evolution is not adequately quantified, making it difficult to assess the overall cost-effectiveness of the framework.
Questions for authors
  1. How does MILP-Evo compare with simpler automated search methods under the same candidate-evaluation budget?
  2. What are the total LLM token consumption, computational cost, and wall-clock time required to discover each final policy?
  3. Does joint evolution consistently outperform separate optimization on the other three problem families?
  4. How well do the discovered policies generalize to unseen MILP distributions beyond the learn2branch benchmarks?
  5. How sensitive are the results to the LLM backbone and evolutionary search randomness?
2 comments

Thank you for the constructive review. We added search baselines, cost accounting, independent searches, and ablations across all four families.

1. Contribution and search budgets (Q1)

LLM mutation/crossover, islands, and archives are established components. Our contribution is joint synthesis of executable cut-selection and branching callbacks, with solver-feedback validation and contract-preserving repair.

ReEvo uses the same Gemini 3 Flash backbone and callback space as MILP-Evo, while SMAC tunes SCIP parameters. ReEvo is matched by total token budget and SMAC by solver-evaluation time, with each cap set to the corresponding MILP-Evo search budget. Tokens consumed by repair are included in the token budget.

Evaluation now covers 20 instances per scale and five runs per instance: 100 runs per setting and 1,200 per method. Mean runtime includes every run, charging 3,600 s for unsuccessful runs.

Table 1. Aggregate results on the expanded benchmark.

MethodMean runtime (s)Solved / 1,200
MILP-Evo403.741150
ReEvo531.401125
SMAC680.951068
SCIP618.701104
COPT358.671143

MILP-Evo has lower mean runtime than ReEvo in all 12 settings and reduces aggregate mean runtime by 40.7% versus SMAC. COPT remains faster overall.

The following breakdown reports all 12 settings, each with 20 instances and five runs per instance. Unsuccessful runs contribute 3,600 s.

Family / scaleMILP-Evo (s)ReEvo (s)SMAC (s)SCIP (s)
Independent set / Easy3.004.094.0312.79
Independent set / Medium61.67129.60587.60325.34
Independent set / Hard773.591767.913285.332766.13
Auctions / Easy0.742.620.944.47
Auctions / Medium17.2936.9422.1652.24
Auctions / Hard362.22385.05433.07274.08
Set cover / Easy3.1910.283.0713.37
Set cover / Medium73.06174.0075.96211.54
Set cover / Hard2419.152580.452485.922645.52
Facility location / Easy70.3376.23218.1773.78
Facility location / Medium331.24406.91323.24337.54
Facility location / Hard729.40802.76731.91707.57

MILP-Evo improves mean runtime over ReEvo in every setting. The gains are particularly large on independent-set Hard (773.59 vs. 1767.91 s) and set-cover Medium (73.06 vs. 174.00 s). Against SMAC, MILP-Evo has lower mean runtime in 10 of 12 settings, while SMAC is faster on set-cover Easy and facility-location Medium. This breakdown shows where the aggregate 40.7% reduction over SMAC arises.

All methods used the same hardware platform. Unrelated solver parameters were matched where possible; otherwise, version-specific defaults were retained. MILP-Evo/ReEvo/SMAC/SCIP/FSB use SCIP 10.0.2, GNN uses 7.0.3, and Hybrid/GS4CO/RPB use 6.0.1. The same-version search comparisons therefore support the gains independently of the cross-version neural comparisons.

GNN and Hybrid followed their official stopping criteria; GS4CO uses its official pretrained expressions without local retraining. Across independent set, auctions, set cover, and facility location, GNN training took 1h19m/1h59m/26h30m/28h38m; Hybrid took 6h14m/4h25m/15h58m/49h41m. These training times provide context, rather than a matched-compute comparison.

2. Search cost (Q2)

Across three 400-iteration searches per family, each search uses 3.14-3.75M recorded tokens: 2.18-2.64M input, 0.32-0.43M output, and 0.61-0.73M reasoning tokens.

Evaluation costs, including invalid candidates, range from 8.90 to 36.87 CPU-hours per search. The per-family ranges are 8.92-12.43 h for independent set, 8.90-14.93 h for auctions, 18.91-30.16 h for set cover, and 36.22-36.87 h for facility location. Estimated elapsed search times are 2.56-3.71, 2.50-4.08, 4.95-7.78, and 9.68-10.09 h, respectively. These are offline search costs; deployed callbacks require no further LLM calls.

The following ledger summarizes the three existing 400-iteration searches for each family. Token totals include input, output, and reasoning tokens; evaluation CPU time includes invalid candidates.

Family / seedTokens (M)Evaluation CPU (h)Estimated elapsed time (h)
Independent set / 10013.2310.513.15
Independent set / 10023.3112.433.71
Independent set / 10033.148.922.56
Auctions / 10013.4211.023.02
Auctions / 10023.758.902.50
Auctions / 10033.6214.934.08
Set cover / 10013.3724.886.93
Set cover / 10023.4118.914.95
Set cover / 10033.4430.167.78
Facility location / 10013.3636.829.68
Facility location / 10023.6936.2210.09
Facility location / 10033.6036.879.77

CPU-hours measure accumulated solver-evaluation work; elapsed estimates describe the duration reported by the search ledger. These are offline costs. Once exported, the policy runs as solver callbacks without further LLM calls.

3. Joint evolution across four families (Q3)

Joint, Cut-only, Branch-only, and NoRepair each use 400 iterations.

Separate-best is constructed by selecting the best individual from the Cut-only search and the best individual from the Branch-only search, then combining their cut-selection and branching components. Each component search uses 400 iterations, giving 800 iterations in total.

Table 2. Ablation mean process time (s), Easy/Medium/Hard; 50 runs per setting.

MethodIndependent setAuctionsSet coverFacility location
Joint2.57/59.20/806.170.81/11.79/381.903.14/89.36/2641.3435.66/266.21/761.88
Cut-only6.33/179.96/2522.533.50/26.63/259.9610.44/185.67/2827.0340.20/305.36/820.06
Branch-only4.85/166.36/2452.773.04/26.40/239.2610.18/205.81/2899.1243.60/313.20/746.37
Separate-best3.95/124.48/2299.232.40/16.52/227.428.80/192.48/2892.5634.75/309.41/704.18
NoRepair6.34/200.81/2615.153.07/28.14/248.149.37/215.65/2960.6343.23/295.90/636.27

Joint leads all scales of independent set and set cover, Easy/Medium auctions, and Medium facility location. Separate-best is faster on Hard auctions (227.42 vs. 381.90 s), and NoRepair is faster on Hard facility location (636.27 vs. 761.88 s).

4. Generalization scope (Q4)

Our evaluation concerns family-specific co-design of two callbacks and transfer from Easy to larger instances within each family. Cross-family and MIPLIB transfer remain untested. We will make this scope explicit in the title, abstract, and conclusions.

5. Search randomness and LLM backbone (Q5)

Across three search seeds, best training fitness values (s) are 3.10/6.83/2.82 for independent set, 1.59/0.80/7.44 for auctions, 4.67/4.26/5.74 for set cover, and 25.43/23.31/24.72 for facility location. Valid-evaluation rates range from 82.3% to 98.8%.

Reviewer_HktTOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper studies the automatic design of executable white-box components for mixed-integer linear programming solvers. The authors introduce MILP-Evo, a framework implemented through PySCIPOpt. They use it to jointly design a cut selector and a branching rule. The main contribution is an automatic design framework that produces explicit, solver-integrated PySCIPOpt modules. The learned object is explicit algorithmic logic rather than a black-box policy. The authors evaluate the resulting family-specific modules on independent set, combinatorial auctions, set cover, and capacitated facility location. MILP-Evo performs strongly on the first three families.

Critical strengths

The paper evolves cut selection and branching together as interacting components. The resulting modules perform well on the evaluated benchmarks, particularly on independent set, combinatorial auctions, and set cover. In the independent-set ablation, joint search clearly outperforms separately searching for the two components and combining the best ones afterward. This provides some evidence for the value of joint search.

The method produces PySCIPOpt modules that can be integrated directly into SCIP, rather than evaluating an external predictor through a surrogate interface. As the paper notes, the resulting solver components can be inspected, modified, and deployed within standard solver workflows.

Critical weaknesses

The evidence for search-level stability is limited. The full ablation is reported only on independent set, and each family appears to use one exported artifact from a single search run. The five SCIP seeds measure solver-run variability rather than variation across independent evolutionary searches. Multiple search runs are needed to determine whether the method reliably finds strong callbacks.

The primary comparison protocol is not fully justified. Although COPT and GNN-GPU are included in the result tables, they are treated only as external references and are excluded from the primary win counts and Wilcoxon tests. Both are competitive or substantially faster than MILP-Evo in several settings, particularly on some Hard settings and facility location. The paper should justify this exclusion more clearly and qualify its performance claims accordingly.

Questions for authors
  1. Can the authors rerun the complete MILP-Evo search with multiple independent LLM/random seeds and report the variability of the final performance? Could the authors also extend the full ablation study beyond independent set to the other three benchmark families?

  2. Can MILP-Evo generalize across different problem families? The current evaluation evolves a separate family-specific module for each benchmark and tests it only across Easy, Medium, and Hard instances from the same family. Please clarify whether cross-family generalization is within the intended scope and, if so, provide corresponding experiments.

  3. Why are COPT and GNN-GPU excluded from the primary win counts and Wilcoxon comparisons? In addition, could the authors clarify how mean runtime and W/S are computed when some runs time out, including the denominator and the use of the 3600-second penalty?

2 comments

Thank you for the constructive review. We added independent searches, four-family ablations, and statistical comparisons that include COPT and GNN-GPU.

1. Search variability and ablations (Q1)

We ran three independent 400-iteration searches per family with Gemini 3 Flash, using seeds 1001-1003. Best training fitness values (s) are 3.10/6.83/2.82 for independent set, 1.59/0.80/7.44 for auctions, 4.67/4.26/5.74 for set cover, and 25.43/23.31/24.72 for facility location.

Valid-evaluation rates range from 82.3% to 98.8%, with 3.14-3.75M recorded tokens per search. Training-fitness variability is smaller for set cover and facility location, but full test-set distributions across independent searches remain unavailable. These runs measure search variability separately from the five solver runs per instance.

Joint, Cut-only, Branch-only, and NoRepair each use 400 iterations. Separate-best is constructed by selecting the best individual from the Cut-only search and the best individual from the Branch-only search, then combining their cut-selection and branching components. Each component search uses 400 iterations, giving 800 iterations in total.

Table 1. Ablation mean process time (s), Easy/Medium/Hard; 50 runs per setting.

MethodIndependent setAuctionsSet coverFacility location
Joint2.57/59.20/806.170.81/11.79/381.903.14/89.36/2641.3435.66/266.21/761.88
Cut-only6.33/179.96/2522.533.50/26.63/259.9610.44/185.67/2827.0340.20/305.36/820.06
Branch-only4.85/166.36/2452.773.04/26.40/239.2610.18/205.81/2899.1243.60/313.20/746.37
Separate-best3.95/124.48/2299.232.40/16.52/227.428.80/192.48/2892.5634.75/309.41/704.18
NoRepair6.34/200.81/2615.153.07/28.14/248.149.37/215.65/2960.6343.23/295.90/636.27

Joint leads all scales of independent set and set cover, Easy/Medium auctions, and Medium facility location. Separate-best is faster on Hard auctions (227.42 vs. 381.90 s), and NoRepair is faster on Hard facility location (636.27 vs. 761.88 s). These losses limit the claim of a universal benefit; the experiments do not isolate their cause. On Hard set cover, Joint, Cut-only, Separate-best, and NoRepair each solve 25/50 runs, Branch-only solves 24/50, and SCIP solves 20/50.

2. Generalization scope (Q2)

Our evaluation concerns family-specific co-design of two callbacks and transfer from Easy to larger instances within each family. Cross-family and MIPLIB transfer remain untested. We will make this scope explicit in the title, abstract, and conclusions.

3. COPT and GNN-GPU comparisons (Q3)

COPT is commercial and closed-source, with different presolve, LP, and branching components. GNN-GPU uses an additional A100 GPU. We therefore treated both as external references outside the primary CPU-based SCIP comparison, excluding them from primary wins/tests. Both are now included in the expanded statistical analysis.

The expanded benchmark contains 20 instances per setting, with five runs per instance. We first average the runs within each instance, then apply two-sided exact Wilcoxon signed-rank tests to 20 paired instance means. Holm correction covers all 10 baselines within each setting at alpha = 0.05.

Table 2. Holm-corrected results, Easy/Medium/Hard. F means MILP-Evo is significantly faster, S significantly slower, and ns no significant difference.

Familyvs. COPT (E/M/H)vs. GNN-GPU (E/M/H)
Independent setns/ns/FF/F/F
AuctionsF/ns/SF/ns/S
Set coverF/F/nsF/F/ns
Facility locationS/S/Sns/ns/ns

Across 120 comparisons, MILP-Evo is significantly faster in 74, not significantly different in 41, and significantly slower in five. The five losses are against COPT on Hard auctions and all three facility-location scales, and against GNN-GPU on Hard auctions. Against the fastest baseline in each setting, the counts are 2 faster, 6 nonsignificant, and 4 slower. These are distinct summaries; neither supports a claim of universal superiority.

On Hard auctions, mean runtimes are 362.22 s for MILP-Evo, 159.42 s for COPT, and 192.12 s for GNN-GPU. COPT also remains faster overall (358.67 vs. 403.74 s). We will report these losses and include the full per-baseline tests in the appendix.

Comparison with COPT. Each row contains 20 paired instance means; W/T/L counts instances where MILP-Evo is faster/tied/slower. The p values retain Holm correction over all 10 baselines within each setting.

Family / scaleMILP-Evo (s)COPT (s)W/T/LHolm p
Independent set / Easy3.003.199/0/111
Independent set / Medium61.6778.3810/0/100.277
Independent set / Hard773.591376.9318/1/13.81e-05
Auctions / Easy0.742.1520/0/01.91e-05
Auctions / Medium17.2918.0615/0/50.123
Auctions / Hard362.22159.422/0/186.68e-05
Set cover / Easy3.197.2520/0/01.91e-05
Set cover / Medium73.0680.4115/0/50.00814
Set cover / Hard2419.152455.738/9/30.24
Facility location / Easy70.3312.540/0/201.91e-05
Facility location / Medium331.2437.210/0/201.91e-05
Facility location / Hard729.4072.780/0/201.91e-05

Comparison with GNN-GPU. Each row contains 20 paired instance means; W/T/L counts instances where MILP-Evo is faster/tied/slower. The p values retain Holm correction over all 10 baselines within each setting.

Family / scaleMILP-Evo (s)GNN-GPU (s)W/T/LHolm p
Independent set / Easy3.005.2820/0/01.91e-05
Independent set / Medium61.67789.5420/0/01.91e-05
Independent set / Hard773.593551.3619/1/03.81e-05
Auctions / Easy0.741.6420/0/01.91e-05
Auctions / Medium17.2914.229/0/110.106
Auctions / Hard362.22192.120/0/201.91e-05
Set cover / Easy3.195.5220/0/01.91e-05
Set cover / Medium73.0682.6215/0/50.0214
Set cover / Hard2419.152372.031/9/100.161
Facility location / Easy70.3366.067/0/131
Facility location / Medium331.24332.534/0/160.707
Facility location / Hard729.40730.127/0/131

MILP-Evo is significantly faster than GNN-GPU in six settings and COPT in four. For example, on independent-set Hard it takes 773.59 s versus COPT's 1376.93 s (Holm p = 3.81e-5). On set-cover Medium, the comparisons with COPT and GNN-GPU have Holm p = 0.00814 and 0.0214, respectively.

4. Runtime, solved counts, and wins (Q3)

Mean runtime divides the total penalized runtime by all N runs, with 3,600 s assigned to each unsuccessful run. N is 50 in the submitted table and 100 in the expanded benchmark; unsuccessful runs are never omitted.

In W/S, S counts runs solved to optimality within the time limit. W counts those solved runs that are strictly fastest within the stated comparison set; an unsolved run cannot win. The original win counts used the primary comparison set. We will label that set explicitly and distinguish these run-level counts from the instance-level statistical tests above. The revised main table will report mean ± standard deviation alongside solved counts.

Comments on the paper

1 comment

We thank the Area Chair and all three reviewers for their time and constructive feedback.

The reviews highlighted three strengths of MILP-Evo.

  • Inspectable, deployable solver components. Users can inspect and modify the evolved callbacks and run them directly in SCIP without further LLM calls.
  • Joint search for cut selection and branching. MILP-Evo evolves the cut selector and branching rule as a pair, using their combined effect on SCIP’s solve time to guide the search.
  • Callback validation and repair. MILP-Evo checks generated callbacks against SCIP’s interface requirements and uses execution feedback to repair invalid candidates.

During the discussion, we addressed most of the concerns raised across the three reviews through additional experiments and clarifications. Reviewer gdsU confirmed that the permutation experiment resolved their concern about ordering leakage and subsequently raised their score. We summarize the main revisions below.

  • Search baselines. Under matched token and solver-evaluation CPU-time budgets, respectively, MILP-Evo was faster on average than ReEvo in all 12 settings and reduced aggregate mean runtime by 40.7% relative to SMAC.
  • Joint optimization. Keeping both evolved callbacks yielded lower mean runtime than either single-callback replacement in 10 of 12 settings (Table 29).
  • Solver comparisons. We added a reliability pseudocost branching baseline on SCIP 10.0.2 and report Holm-corrected comparisons against all ten baselines.

We respectfully note the following points regarding the remaining concerns.

  • Search stability. Table 24 reports held-out runtimes across search runs for all four families, including the three-run comparison of Joint and Separate-best on independent set and auctions that we promised in our reply to gdsU.
  • Generalization. The revision clarifies our original evaluation scope. We train a separate policy for each of four synthetic families and evaluate transfer to larger instances within that family. Transfer to unseen families and industrial MILPs remains open.
  • COPT comparison. COPT was faster in aggregate (358.67 vs. 403.74 s). On Medium facility location, COPT solved the LP relaxations 7.71× faster than SCIP/SoPlex. Since branch-and-cut repeatedly solves LP relaxations, LP performance may contribute to this gap. Within SCIP 10.0.2, evolving cut selection and branching reduced aggregate mean runtime by 34.7%.

We have also added all feedback to the final version.

Thanks again for your time and effort in improving our work.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.