Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Automating the Search for Small Hard Examples to Approximation Algorithms

Eklavya Sharma

TL;DR

This work tackles finding hard inputs for approximation algorithms when the input space is continuous. It introduces a fully automatic approach that represents an algorithm as a decision tree and, for each leaf, solves a linear program to identify worst-case inputs and the corresponding worst-case ratio $\alpha_n(A)$. The method is demonstrated by recovering known hard inputs for the longest-processing-time (LPT) heuristic in makespan minimization and by exploring extensions to other problems via gray-box circuit extraction and conditional-structure recovery. While the technique is powerful for linear, piecewise-affine settings, it faces scalability challenges due to exponential growth in the decision tree, motivating future improvements such as branch-and-bound or reinforcement learning-guided search. Overall, the paper provides a valuable automated toolkit for diagnosing approximation algorithm weaknesses and guiding design of better algorithms in continuous-input domains.

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.

Automating the Search for Small Hard Examples to Approximation Algorithms

TL;DR

This work tackles finding hard inputs for approximation algorithms when the input space is continuous. It introduces a fully automatic approach that represents an algorithm as a decision tree and, for each leaf, solves a linear program to identify worst-case inputs and the corresponding worst-case ratio . The method is demonstrated by recovering known hard inputs for the longest-processing-time (LPT) heuristic in makespan minimization and by exploring extensions to other problems via gray-box circuit extraction and conditional-structure recovery. While the technique is powerful for linear, piecewise-affine settings, it faces scalability challenges due to exponential growth in the decision tree, motivating future improvements such as branch-and-bound or reinforcement learning-guided search. Overall, the paper provides a valuable automated toolkit for diagnosing approximation algorithm weaknesses and guiding design of better algorithms in continuous-input domains.

Abstract

Given an approximation algorithm , we want to find the input with the worst approximation ratio, i.e., the input for which '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.

Paper Structure

This paper contains 18 sections, 4 theorems, 8 equations, 2 figures, 1 algorithm.

Table of Contents

  1. Introduction
  2. Preliminaries
  3. Division by 0:
  4. Suprema and Infima
  5. Halfspaces and Polyhedra
  6. Optimization Problems and Algorithms
  7. Makespan Minimization
  8. Decision Tree
  9. Computing Hard Examples
  10. Computing Decision Trees
  11. Recovering Circuits
  12. Recovering Decision Trees
  13. Implementation for LPT
  14. Conclusion
  15. Acknowledgements.
  16. ...and 3 more sections

Key Result

Theorem 1

Given a (closed) polyhedron $P \subseteq \mathbb{R}^n$ and a vector $c \in \mathbb{R}^n$, there is an efficient algorithm that outputs a pair $(x, d)$, where $x \in P \cup \{\mathtt{null}\}$ and $d \in \mathbb{R}^n$ such that

Figures (2)

  • Figure 1: Decision tree for the LPT algorithm when $m=2$ and $n=5$ (with appropriate tie-breaking rules).
  • Figure 2: Examples of circuits represented as DAGs. Variable nodes are rectangles. Output nodes have a double border.

Theorems & Definitions (6)

  • Theorem 1: Linear programming, bazaraa2010linear
  • Lemma 2: bazaraa2010linear
  • Lemma 3
  • proof
  • Lemma 4
  • proof