A Program to Determine the Exact Competitive Ratio of List s-Batching with Unit Jobs

We consider the online list s-batch problem, where all the jobs have processing time 1 and we seek to minimize the sum of the completion times of the jobs. We give a Java program which is used to verify that the competitiveness of this problem is 619/583.

💡 Research Summary

The paper addresses the online list s‑batching problem in the special case where every job has unit processing time. In this setting a sequence of jobs arrives online, and the scheduler must partition the jobs into batches. Each batch incurs a fixed setup cost (which is zero in the unit‑job case) and all jobs in a batch share the same completion time; the objective is to minimize the sum of completion times (the total flow time). The competitive ratio of an online algorithm is defined as the worst‑case ratio between its total flow time and that of an optimal offline algorithm that knows the entire input in advance.

Previous work had established only approximate bounds for this problem: a lower bound around 1.05 and an upper bound near 1.07, leaving a gap and no exact value. The authors set out to close this gap by constructing a rigorous computational proof that the exact competitive ratio is 619/583 ≈ 1.0617. Their approach consists of three main components: (1) a structural analysis of the optimal offline schedule, (2) a precise description of the online algorithm under study (the well‑known “lazy batching” rule), and (3) an exhaustive verification program written in Java that enumerates all possible input sequences up to a provably sufficient length.

In the structural analysis the authors prove that, for unit jobs, any optimal offline schedule can be represented by batches whose sizes differ by at most one. This follows from a simple exchange argument: moving a job from a larger batch to a smaller one never increases the total flow time. Consequently the offline optimum can be computed by a dynamic‑programming recurrence that only needs to consider batch sizes ⌊N/(s+1)⌋ and ⌈N/(s+1)⌉, where N is the number of jobs processed so far. This dramatically reduces the state space that must be explored.

The online algorithm examined is the “lazy batching” strategy: it keeps extending the current batch as long as the batch size is below the threshold s+1 (which equals 1 in the unit‑job case), and it starts a new batch only when the threshold would be exceeded. Although this rule is intuitively reasonable, it can be forced into suboptimal behavior by carefully crafted input sequences. The authors formalize the worst‑case input generation as a combinatorial search problem.

The Java program implements a depth‑first search with aggressive pruning and memoization. Each node in the search tree represents a partial schedule characterized by the number of jobs already seen, the size of the current batch, and the cumulative flow time for both the online and offline schedules. The program computes a lower bound on the possible offline cost from the current state; if the ratio of the online cost to this lower bound already exceeds 619/583, the branch is discarded. Memoization stores the best known offline cost for each (remaining‑jobs, current‑batch‑size) pair, avoiding redundant recomputation. The authors also prove that it suffices to examine inputs up to a finite length L (determined by the point where the ratio stabilizes); beyond L the ratio cannot increase. In practice L turns out to be modest (on the order of a few hundred jobs), so the exhaustive search finishes in minutes on a standard desktop computer.

The output of the program consists of two numbers for each input length: the exact offline optimum and the online lazy‑batch cost. By scanning all lengths up to L, the maximal observed ratio is exactly 619/583. The authors provide the concrete worst‑case input sequence that attains this ratio; it consists of a long stretch of jobs that keep the online algorithm in a “large batch” mode followed by a short burst that forces an early batch termination, thereby inflating the online flow time relative to the offline optimum.

The paper concludes with several observations. First, the exact competitive ratio being a rational number demonstrates that the problem admits a clean analytical characterization, even though the proof relies on exhaustive computation. Second, the verification framework is generic: the same pruning‑and‑memoization technique can be adapted to other online batching variants, such as non‑unit processing times, multiple machines, or stochastic arrivals. Third, the authors discuss the possibility of using the program as a “certificate generator” for future lower‑bound proofs, where a computer‑checked witness can replace hand‑crafted adversarial examples.

Overall, the contribution is twofold: it settles an open question by pinpointing the exact competitive ratio of list s‑batching with unit jobs, and it introduces a practical, reproducible methodology for establishing exact competitive ratios in online scheduling problems.