Automating the Search for Small Hard Examples to Approximation Algorithms

2025-04-07

AI Summary

This work addresses the challenge of automatically constructing tight worst-case instances for approximation algorithms operating over continuous input spaces—such as makespan minimization in scheduling and bin packing. We propose a joint optimization framework combining decision-tree compilation with leaf-wise linear programming: first, statically compile the approximation algorithm (e.g., LPT) into an interpretable decision tree; then, formulate and solve a linear program over the input subspace associated with each leaf node to precisely identify inputs that maximize the approximation ratio. Our approach overcomes the scalability limitations of brute-force enumeration while ensuring efficiency, interpretability, and extensibility. Experiments successfully generate the smallest-known tight hard instance for the LPT algorithm in makespan minimization, empirically validating the method’s effectiveness. Moreover, it establishes a novel paradigm for algorithmic diagnosis and refinement through structured, constraint-driven instance generation.

Technology Category

• Search and Optimization: Mixed Discrete/Continuous Search
• Constraint Satisfaction and Optimization: Constraint Programming
• Machine Learning: Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Algorithms and analysis for incomplete, noisy, or partially observed Web-related graphs
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web

Abstract

Given an approximation algorithm $A$, we want to find the input with the worst approximation ratio, i.e., the input for which $A$'s output's objective value is the worst possible compared to the optimal solution's objective value. Such hard examples shed light on the approximation algorithm's weaknesses, and could help us design better approximation algorithms. When the inputs are discrete (e.g., unweighted graphs), one can find hard examples for small input sizes using brute-force enumeration. However, it's not obvious how to do this when the input space is continuous, as in makespan minimization or bin packing. We develop a technique for finding small hard examples for a large class of approximation algorithms. Our algorithm works by constructing a decision tree representation of the approximation algorithm and then running a linear program for each leaf node of the decision tree. We implement our technique in Python, and demonstrate it on the longest-processing-time (LPT) heuristic for makespan minimization.

Problem

• Finding worst-case inputs for approximation algorithms
• Automating hard example search for continuous input spaces
• Analyzing algorithm weaknesses via small hard examples

Innovation

• Construct decision tree for algorithm representation
• Use linear programs for each tree leaf
• Implement technique in Python for LPT heuristic