Papers for

operations research practitioners

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Optimization finds much harder problem instances for testing algorithms

Hard Instances on Demand

Abstract: 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.

Thu 15 OctData Structures and AlgorithmsArtificial Intelligence
The gist
Testing how well computer programs solve hard problems depends a lot on the examples they try. The authors treat finding these tricky examples like a puzzle, using a tool that tweaks problem details to make the program run slower. They showed this works on four tough problems, creating examples that challenge solvers more than typical random ones or some famous benchmarks. This helps better test and improve problem-solving software.
Open → 2610.22637v1

Solving large asset selling problems with precise optimization methods

Non-convex integer programming: a deterministic solution method of the large block sale problem

Abstract: We study a non-convex, nonlinear integer mathematical program with a linear constraint. This problem originates in finance and consists of selling a large predetermined quantity of a financial asset over a fixed time horizon, while maximizing the total proceeds. The selling price is modeled using a deterministic penalty function capturing the market's adverse reaction to the selling flow. From a complexity perspective, the problem is in NP. We first solve the problem exactly using dynamic programming and propose several heuristics that yield tight numerical lower bounds. We then reformulate the problem into an equivalent factorable form and derive a tight convex relaxation using McCormick inequalities. This relaxation is embedded within an adapted Branch & Bound algorithm to find the global optimum in finite time. Numerical experiments show that our methods outperform several widely used generic solvers (LocalSolver, Scip, Baron, Couenne, and Bonmin) for selected instances, but do not yield tight upper bounds, beyond small instances.

Sat 10 OctDiscrete Mathematics
The gist
Selling a large amount of a financial asset over time can lower the price you get because the market reacts to big sales. The authors studied how to figure out the best way to sell that asset to make the most money. They developed exact and approximate methods to solve this problem, using ideas from math and computer science. Their methods work better than some existing software for certain cases, though they struggle on bigger problems.
Open → 2610.14962v1

Efficient algorithms achieve optimal rates for nonsmooth convex optimization

Stable Movement for Nondual Lipschitz Convex Optimization: Efficiency and Nearly Optimal Oracle Rates

Abstract: We study efficient algorithms for realizing the first-order oracle complexity of optimization of $G$-Lipschitz convex functions with respect to the $\ell_{q}$-norm over an $\ell_{p}$-ball of radius $R$, where $1\leq p,q\leq \infty$. For $p<q$, we obtain error $\widetilde{O}_{p,q}(GR/T^{1/p-(1/q-1/2)_{+}})$ after $T$ oracle queries, efficiently realizing the nearly optimal rates of (MBG+26), thereby resolving the nonsmooth end of the COLT 2015 open problem (Guz15b). In particular, the rate is $\widetilde{O}(GR/T)$ for Euclidean Lipschitzness over an $\ell_1$-ball of radius $R$ ($p=1,q=2$). Our solution consists of reducing convex Lipschitz optimization to the chasing nested convex sets problem in sublevel sets of an evolving bundle (LNN95; BBE+20): at each query we either find a point with low function value or we produce a deep cut in the current sublevel of the bundle, that we chase. The dichotomy between stability of selectors and forced movement by deep cuts bounds the number of iterations of the algorithm near optimally. For nested subsets of $R B_{p}^{d}$, we introduce a novel notion of stable center whose movement is bounded by $\widetilde{O}_{p,q}(RT^{1-1/p+(1/q-1/2)_{+}})$ in the $\ell_{q}$-norm after $T$ steps, which we show is nearly optimal in high dimensions. A Monte Carlo average of the proposed selector achieves near-optimal rates with high probability and can be implemented in polynomial time for our optimization algorithm in the real-arithmetic model.

Thu 17 SeptMachine Learning
The gist
Optimization methods often try to find the best solution with limited information about a problem. This paper tackles optimizing certain convex functions that change smoothly within some limits, called Lipschitz conditions. The authors present new algorithms that nearly reach the best theoretical speed for finding solutions relying on limited queries. They achieve this by framing the problem as a sequence of nested sets to chase, balancing finding promising points and cutting bad regions efficiently. Their approach also controls how much the solution moves, ensuring stable and efficient progress.
Open → 2609.20701v1

Simulated annealing method optimizes partition function estimation efficiently

Optimal Simulated Annealing for Partition Function Estimation

Abstract: In this note, we give a simple analysis of a non-adaptive simulated annealing algorithm for estimating the partition function of Gibbs distributions. This yields the most efficient reduction of this kind so far. We also establish lower bounds for both general and non-adaptive algorithms, showing that our algorithm is optimal over a broad range of parameters.

Thu 17 SeptData Structures and Algorithms
The gist
Estimating the partition function is important in many areas like physics and machine learning but can be very hard to do quickly and accurately. The authors analyzed a specific version of simulated annealing, a method inspired by cooling metal slowly, to estimate these partition functions more efficiently without needing to adapt as they run. They also proved that their approach is as good as possible for a wide range of cases, meaning it can’t be improved much further. This helps make some complex calculations faster and more predictable.
Open → 2609.20337v1