The conclusions of an experimental study of algorithms are only as good as the instances they are run on. Benchmark libraries for well-studied problems took decades to curate, while evaluations of new problems often fall back on random instances, which are known to be misleading: they may say more about the random generator than about the algorithmic question at hand. We treat instance generation as an optimization problem: parameterize the instance space, take the solver's running time as the objective, and let a black-box optimizer search for hard instances. We develop a widely applicable workflow built on the Nevergrad optimization platform and demonstrate it on four NP-hard problems: satisfiability, traveling salesperson, Hamiltonian cycle, and non-permutation flow-shop scheduling. The search needs only the solver, an instance encoder, and a compute budget. Our evolved instances beat the hardest instance of a budget-matched random draw in all four case studies, by an order of magnitude or more in three. They are often competitive with long-curated benchmark sets: our SAT champion is harder (for a three-solver portfolio) than 78% of the 498 SAT Competition formulas in its size class; our 20-city TSP champions take several times longer than the hardest measured classical TSPLIB instance (229 cities); and our flow-shop champion takes 238.6 seconds of CP Optimizer time to solve to proven optimality (versus 4.5 seconds for the hardest of 100,000 random draws) while denying CP-SAT an optimality proof. The optimizer even recovers known structure from running time alone: it locates a SAT clause/variable ratio near the phase transition and finds structurally different champions for the two scheduling engines.
Figures & tables
Figure 2.1: The evaluation pipeline. Bottom: one evaluation – the optimizer asks for a genome, the encoding decodes it into an instance, the solver solves it k times, the aggregated time is transformed into a loss and told back to the optimizer. Top: the screening stage (Stage 1) runs this loop for every optimizer with budget B and several independent runs per configuration (task, encoding, loss transform F ).
Case
Champion train/held-out
Random control train/held-out
Context: external benchmarks and properties
SAT portfolio
12.0
0.47
phase-transition random 0.94; van der Waerden >60 ; SAT Comp: only expert-designed families harder
TSP, Shiwa U=103
13.5 / 7.99
0.70 / 0.79
gr229 2.34 / 2.24; Hard-TSPLIB >60
HAM
1.12 / 0.48
0.35 / 0.28
density-matched random G(20,0.22) : 0.26 / 0.17; FHCP is stronger at larger sizes
NPFS, CP-Opt 10×5
238.6 / 235.3
4.50
proven optimal on all 30 seeds; CP-SAT finds no proof within 600 s; hardest official VRF 10×5 under NPFS: 3.8 s; hardest official Taillard 20×5 : 4.5 s (seeds 1–7)
NPFS, CP-Opt 8×4
7.24 / 7.03
0.67 / 0.65
bred on CP-Opt , exceeds CP-SAT ’s cap; Taillard starts at 20×5 , Demirkol at 20×15
Table 3.1: Primary results in seconds on the reference machine. A slash separates train from held-out; single entries have no held-out value. The TSP control is the conservative best-held-out RandomSearch result.
family
n
m
minisat
BID+cdc
CMS
kissat
march
random, ratio 4.27
200
854
0.94
1.06
6.31
1.18
0.12
PHP 1112
132
738
> 60
0.009
> 60
36.2
59.6
Tseitin expander
150
400
> 60
0.008
0.80
10.4
> 60
W(2;3,13)
160
7308
> 60
> 60
> 60
> 60
> 60
RS (kcnf)
200
1000
0.07
0.10
0.16
0.19
0.02
RS (mprefix)
200
852
0.47
0.62
2.45
0.59
0.08
Table 3.2: SAT: per-solver times in seconds on the reference machine, cap 60 s; each entry is the median of five sequential evaluations. The portfolio objective is the minimum over the first three solvers (bold); kissat and march are context only. All listed instances are unsatisfiable. The first row (phase-transition) is one measured random formula; the RS rows are the hardest instances found by budget-matched RandomSearch . The Tseitin row is a fresh formula of the same size class from the Global Benchmark Database.
family
N
train
held-out
random Euclidean, hardest of draw
20
0.08
0.07
TSPLIB, median
≤ 300
0.097
–
TSPLIB, hardest (gr229)
229
2.34
2.24
clustered Euclidean (our generator), median
50–200
0.17
–
Hard-TSPLIB, hardest solved
20
33.8
28.7
Hard-TSPLIB (23 of 40)
10–76
> 60
–
Table 3.3: TSP: median Concorde process time in seconds on the reference machine, cap 60 s. Train = breeding seeds 1–7; held-out = unseen seeds 8–30. Generated instances and the two fixed comparators (gr229, hardest solved Hard-TSPLIB) use three repetitions per seed; the broad TSPLIB, clustered, and Hard-TSPLIB scans use one solve per seed. Random draws use budget 100,000 , matching the U=1000 setup and twice the DiagonalCMA budget.
family
N
train
held-out
random G(20,0.22)
20
0.26
0.17
random cubic
20
0.04
0.01
FHCP, hardest solved on all seeds
108
7.88
–
FHCP, 6 of 11 scanned members
90–150
> 60
–
RandomSearch , best of three encodings
20
0.35
0.28
champion TwoPointsDE (scores + threshold)
20
0.61
0.27
Table 3.4: HAM: median Concorde process time in seconds, cap 60 s. Train = breeding seeds 1–7, held-out = seeds 8–30. Generated instances use three repetitions per seed; the FHCP scan uses one solve per seed.
family
n×m
CP-SAT
CP-Opt
held-out
champion, CP-SAT arm
6×4
18.2
0.33
16.3
RandomSearch , same arm
6×4
0.21
0.02
0.25
champion, CP-Opt arm
6×4
0.78
0.54
0.52
RandomSearch , same arm
6×4
0.14
0.18
0.18
RandomSearch , uniform
8×4
–
0.67
0.65
champion (DiagonalCMA)
8×4
> 60
7.24
7.03
Table 3.5: Non-permutation flow shop: median process time in seconds per engine, cap 60 s except 600 s for 10×5 . Engine columns use evaluation seeds 1–7; the last column uses the champion’s own engine on seeds 8–30. Random rows are the hardest of 100,000 fresh draws (for the CP-SAT arm this exceeds the search budget, a conservative comparison). In the > -entries, CP-SAT found a feasible schedule but no optimality proof within the cap.
encoding / optimizer
−t
−logt
−t2
HAM, adjacency matrix (triv)
NGOptRW
1.14
0.82
–
NgIohMLn
0.83
1.05
0.63
RecombiningDiscreteLenglerOnePlusOne
0.56
0.99
0.80
HAM, edge scores + edge count (pint)
NgIohRS
0.89
0.87
0.86
Table A.1: Screening (budget 15,000, 2 runs): best instance hardness in seconds after the screening campaign’s own clean rebench (not the final reference machine of section B ), per loss transform. Only rankings and relative magnitudes are used from this table. Three best optimizers per encoding; “–” = combination not sampled.
Neural combinatorial optimization solvers generate many candidate solutions per instance and report the best one found, using the same sample budget for every instance regardless of difficulty. A companion study showed that reallocating a fixed budget toward harder instances can improve solution quality, but that the standard way of measuring this improvement is biased: deciding an allocation and evaluating it on the same data can manufacture an apparent gain even when none exists. This left open what property of a workload determines whether reallocation is worth doing, and whether a policy that spends part of the budget to decide how to allocate the rest still pays once that cost is counted. This paper answers both questions through pre-registered confirmatory experiments -- analysis and verdict criteria fixed before data collection -- across three independently trained solvers and two ways of constructing harder workloads on the traveling salesman problem. Within the workloads we study, the deciding property is how varied the instances within a workload are in difficulty, not how difficult the workload is on average: a uniformly easy or uniformly hard workload offers little room for reallocation, while a mixed workload offers substantial room. A budget-aware policy that pays for its own information about instance difficulty recovers most, though not all, of the improvement available when that information is assumed free. Every experiment was independently recomputed from its written specification, and every correction to an earlier version -- including two that weakened the paper's own claims -- is reported with the direction it moved the conclusion. The paper offers a specific empirical answer and a template for verifying that answer is not an artifact of how it was measured.
Jinhyung Bae
Department of Industrial and Management Engineering / AI Data Convergence, Hankuk University of Foreign Studies, Yongin, Republic of Korea.
Generating optimization instances that are both feasible and computationally challenging is crucial for benchmarking solvers and training learning-based optimization algorithms. Existing non-LLM generators rely on seed instances or parameter tuning, resulting in high test-time computational cost, while existing LLM generators lack explicit hardness measures. Recent reinforcement learning methods with verifier feedback evaluate only binary correctness, which is misaligned with generating challenging problems. We note that an optimization solver reports the cost of solving at several stages of its pipeline, and leverage this to design a reward that scores both the solvability and the hardness of generated problems, measured by branch-and-bound nodes and post-cut relaxation gaps. Our key idea is a challenger-solver asymmetric self-play approach, where an LLM challenger generates progressively harder instances and the solver verifies feasibility and hardness, so no seed or training MILP instances are required. We fine-tune Gemma-4-12B and Qwen3.5-4B with GRPO and a size curriculum into OptiScribe-12B and OptiScribe-4B, which generate feasible yet challenging MILP problems from natural language instructions. On capacitated facility location and max-cut, OptiScribe-12B raises median SCIP search nodes by 1.7-5x and post-cut gaps by 1.1-1.7x over its base model and improves the feasibility rate on facility location by 9-19 points, while OptiScribe-4B raises median nodes by up to 15.6x. The problems cover a wider difficulty range than public benchmarks of the same size, follow instructions on density and difficulty, and can tune solver settings for families that public libraries lack. These results indicate that optimization-specific rewards, used in self-play mode, can teach LLMs to generate high-difficulty optimization benchmarks. We will release our code and models publicly on acceptance.
Hard combinatorial optimization problems, many of which are NP-hard, present fundamental algorithmic challenges. Average-case analysis on random instances has emerged as a powerful framework for understanding typical algorithmic performance beyond worst-case guarantees. A substantial body of work has established negative results: for sufficiently hard instances (often controlled by the underlying graph connectivity/constraints density), no known polynomial-time algorithm can significantly outperform naive heuristics in the double asymptotic limit where both problem size and constraints density tend to infinity. We revisit this picture by studying the finite-size behavior of some optimization algorithms across easy, intermediate, and hard regimes. Through rigorous analysis of large-graph asymptotics combined with numerical experiments on canonical problems (maximum independent set and maximum K-SAT), we demonstrate that while algorithms do eventually converge to theoretically predicted bounds, this convergence can be remarkably slow. In the intermediate regime where instances are already highly constrained, local algorithms achieve solutions substantially better than their predicted performance in the high-constraint-density limit. This gap between finite-regime and asymptotic behavior has important practical implications: sophisticated algorithmic design remains crucial even when asymptotic theory predicts inevitable failure.
Ali Hussaini Umar, Jean Barbier, Matthieu Jonckheere +1
SISSA, Trieste, Italy. · International Center for Theoretical Physics, Trieste, Italy. · LAAS–CNRS, Toulouse, France. +1