EvoCut: Strengthening Integer Programs via Evolution-Guided Language Models

TL;DR

EvoCut tackles the challenge of manually designing acceleration cuts for MILPs by learning a reusable set of symbolically formulated cuts via an LLM-guided evolutionary process over a symbolic MILP model and a small problem description. It splits data into a verification set and an evaluation set, uses an initializer to propose cuts, and iteratively refines them with mutation and crossover agents, scoring cuts by empirical performance on $D_e$ while ensuring feasibility on $D_v$. Across seven NP-hard MILP benchmarks, EvoCut yields substantial improvements in optimality gaps and reduces time to target gaps, with robustness across LLM backends and across solvers. The method offers a practical pre-solve accelerator for custom MILPs, especially when problem formulations are new or not heavily engineered with tailored cuts.

Abstract

Integer programming (IP) is central to many combinatorial optimization tasks but remains challenging due to its NP-hard nature. A practical way to improve IP solvers is to manually design acceleration cuts, i.e., inequalities that speed up solving. However, this creative process requires deep expertise and has been difficult to automate. Our proposed framework, EvoCut, automates the generation of acceleration cuts at the symbolic modeling level: it reasons over a symbolic MILP model and a natural language description of the problem to discover a reusable set of acceleration cuts that can be used for each concrete instance of the model. EvoCut (i) initializes a population of candidate cuts via an initializer agent that uses an LLM, (ii) empirically screens candidates on a small verification set by checking that reference solutions remain feasible and that at least one stored LP relaxation solution is cut off, and (iii) iteratively refines the population through evolutionary crossover and mutation agents. Compared to baseline MILP formulations solved with a fixed time budget, EvoCut reduces optimality gaps by up to $76\%$ and reaches target gaps up to $7.2$ times faster (shifted geometric mean speedup). Ablations show its robustness across different LLM backends and across solvers/cut settings. Code: https://github.com/milad1378yz/EvoCut.

Figures (11)

• Figure 1: View of EvoCut in two stages: during development, EvoCut learns a reusable set of acceleration cuts for a symbolic model using a natural language description. During deployment, the cuts are instantiated for a concrete instance and appended to its MILP before solving.
• Figure 2: EvoCut workflow: an initializer agent proposes a population of candidate acceleration cuts. Each candidate is screened for code validity, verification set optimal solution screening (OSS) on $D_v$, and usefulness via LP separation, then evaluated on $D_e$ to obtain a fitness score based on the optimality gap. Tournament/elite selection and crossover/mutation driven by LLM agents generate the next population.
• Figure 3: EvoCut verifier: candidate cut code must compile (code check), pass OSS check on verification set $D_v$ (i.e., not cut off the recorded reference solution), and cut off at least one stored fractional LP optimum (usefulness check). Failures trigger feedback and regeneration.
• Figure 4: Steps in the development of the best cut for the JSSP. Blue panel: baseline formulation. Green panels: candidate cuts with annotated fitness. Yellow panels: agent instructions that produced each offspring.
• Figure 5: Best (blue, dashed) and mean (orange, dash dotted) fitness across 20 generations for the TSP, MCND, CWLP, JSSP, IMO6, PDPTW, and SHUC benchmarks. Shaded regions show one standard deviation.

Theorems & Definitions (1)

• Definition 3.1: Acceleration cut