How Asymmetry Helps Buffer Management: Achieving Optimal Tail Size in Cup Games

TL;DR

This paper introduces a randomized algorithm for the cup game that significantly reduces tail size to near logarithmic levels, demonstrating tight bounds and extending results to multi-processor scenarios.

Contribution

The paper presents the first randomized algorithm achieving near-logarithmic tail size in polynomial steps and extends the analysis to multi-processor settings, with tight bounds and resource augmentation insights.

Findings

Achieves tail size O(log n) with high probability in polynomial steps.

Extends results to multi-processor cup game with tail size O(log n + p).

Shows monotone memoryless algorithms cannot guarantee unending tail size bounds without resource augmentation.

Abstract

The cup game on $n$ cups is a multi-step game with two players, a filler and an emptier. At each step, the filler distributes $1$ unit of water among the cups, and then the emptier selects a single cup to remove (up to) $1$ unit of water from. There are several objective functions that the emptier might wish to minimize. One of the strongest guarantees would be to minimize tail size, which is defined to be the number of cups with fill $2$ or greater. A simple lower-bound construction shows that the optimal tail size for deterministic emptying algorithms is $\Theta(n)$, however. We present a simple randomized emptying algorithm that achieves tail size $\tilde{O}(\log n)$ with high probability in $n$ for $\operatorname{poly} n$ steps. Moreover, we show that this is tight up to doubly logarithmic factors. We also extend our results to the multi-processor cup game, achieving tail size $\tilde{O}(\log n + p)$ on $p$ processors with high probability in $n$. We show that the dependence on $p$ is near optimal for any emptying algorithm that achieves polynomial-bounded backlog. A natural question is whether our results can be extended to give unending guarantees, which apply to arbitrarily long games. We give a lower bound construction showing that no monotone memoryless emptying algorithm can achieve an unending guarantee on either tail size or the related objective function of backlog. On the other hand, we show that even a very small (i.e., $1 / \operatorname{poly} n$) amount of resource augmentation is sufficient to overcome this barrier.