Achieving Optimal Backlog in Multi-Processor Cup Games

TL;DR

This paper improves backlog bounds in multi-processor cup games using randomization, showing near-optimal performance with high probability and extending results to larger backlogs, relevant for processor scheduling and buffer management.

Contribution

It introduces randomized algorithms that significantly reduce backlog in multi-processor cup games, achieving high-probability bounds and extending known single-processor results.

Findings

Greedy algorithm achieves backlog O(ε^{-1} log n) for multi-processor games.

Randomized algorithms can bound backlog by 3 with high probability when p is large.

Backlog bounds extend to larger backlog sizes with probabilistic guarantees.

Abstract

The single- and multi- processor cup games can be used to model natural problems in areas such as processor scheduling, deamortization, and buffer management. At the beginning of the single-processor cup game, $n$ cups are initially empty. In each step of the game, a filler distributes $1$ unit of water among the cups, and then an emptier selects a cup and removes $1 + \epsilon$ units from that cup. The goal of the emptier is to minimize the amount of water in the fullest cup, also known as the backlog. It is known that the greedy algorithm (i.e., empty the fullest cup) achieves backlog $O(\log n)$, and that no deterministic algorithm can do better. We show that the performance of the greedy algorithm can be greatly improved with a small amount of randomization: After any step $i$, and for any $k \ge \Omega(\log \epsilon^{-1})$, the emptier achieves backlog at most $O(k)$ with probability at least $1 -O(2^{-2^k})$. Whereas bounds for the single-processor cup game have been known for more than fifteen years, proving nontrivial bounds on backlog for the multi-processor extension has remained open. We present a simple analysis of the greedy algorithm for the multi-processor cup game, establishing a backlog of $O(\epsilon^{-1} \log n)$, as long as $\delta$, the game's other speed-augmentation constant, is at least $1/poly(n)$. Turning to randomized algorithms, we encounter an unexpected phenomenon: When the number of processors $p$ is large, the backlog after each step drops to \emph{constant} with large probability. Specifically, we show that if $\delta$ and $\epsilon$ satisfy reasonable constraints, then there exists an algorithm that bounds the backlog after a given step by three or less with probability at least $1 - O(\exp(-\Omega(\epsilon^2 p))$. We further extend the guarantees of our randomized algorithm to consider larger backlogs.

Equations

$$r_j+\sum _{t=1}^i{c}_j(t)(\mathrm{mod}1),$$

$$\varphi (i)=\sum _{i=1}^n(1+\epsilon {)}^{f_j(i)}.$$

$$\frac{d}{dx}\left((1+\epsilon {)}^x\right)=(1+\epsilon )\cdot \frac{d}{dx}\left((1+\epsilon {)}^{x-1}\right),$$

$$\mathrm{Pr}[Y\ge \mathbb{E}[Y]+R]\le e^{-2R^2/(c^{2}t)}.$$

$$p\cdot (1-\epsilon )\cdot \left(\frac{1}{m}+\frac{1}{m-p}+\frac{1}{m-2p}+\cdots \right)$$

$$=\Theta \left(\frac{1}{m/p}+\frac{1}{m/p-1}+\frac{1}{m/p-2}+\cdots \right)=\Theta \left(\log \frac{m}{p}\right).$$

$$O\left(\frac{1}{2^{2^{\Omega (k)}}}\right).$$

$$\lfloor r_j+a_j+b_j\rfloor -\lfloor r_j+a_j\rfloor .$$

$$\lfloor r_j+a_j+\overline{b_j}\rfloor >\lfloor r_j+a_j\rfloor .$$

$$X_1+X_2+\cdots +X_{\lfloor b_j\rfloor }+Y,$$

$$\mathrm{Pr}[S_t\ge \mathbb{E}[S_t]+\delta \mathbb{E}[S_t]]\le e^{-{\delta }^2\mathbb{E}[S_t]/3},$$

$$\mathrm{Pr}[S_t\ge \mathbb{E}[S_t]+\delta \mathbb{E}[S_t]]\le e^{-\delta \mathbb{E}[S_t]/3},$$

$$\mathrm{Pr}[S_t\ge t+k]\le \mathrm{Pr}[S_t\ge \mathbb{E}[S_t]+k]\le e^{-k/3}.$$

$$\mathrm{Pr}[S_t\ge t+k]\le \mathrm{Pr}[S_t\ge \mathbb{E}[S_t]+\epsilon t]\le e^{-{\epsilon }^2\mathbb{E}[S_t]/3}\le e^{-{\epsilon }^{2}t/6},$$

$$\mathrm{Pr}[S_t\ge t+k\text{ for some }t]$$

$$\le k\cdot e^{-k/3}+\sum _{t\ge k}{e}^{-{\epsilon }^{2}t/6}$$

$$=k\cdot e^{-k/3}+e^{-{\epsilon }^{2}k/6}\cdot \sum _{t\ge 0}{\left(e^{-{\epsilon }^2/6}\right)}^t$$

$$=k\cdot e^{-k/3}+e^{-{\epsilon }^{2}k/6}\frac{1}{1-e^{-{\epsilon }^2/6}}.$$

$$\le k\cdot e^{-k/3}+e^{-{\epsilon }^{2}k/6}O(1/{\epsilon }^2).$$

$$\le O\left(e^{-{\epsilon }^{2}k/6}/\epsilon \right).$$

$$\varphi (i)=\sum _{j=1}^n(1.1{)}^{f_j(i)},$$

$$\varphi (i)=\sum _{j=1}^n{\int }_{x=0}^{f_j(i)}1.1^{\lceil x\rceil }dx.$$

$$1.1^{\lfloor t\rfloor }+1.1^{\lfloor t\rfloor -1}\ge 1.1^{\lceil t\rceil }.$$

$$\varphi (i)=\sum _{j=1}^n{\int }_{x=0}^{f_j(i)}(1+\epsilon {)}^{\lceil x\rceil }dx.$$

$$l\cdot (1+\epsilon {)}^{\lceil h\rceil }.$$

$$(l+\epsilon p)(1+\epsilon {)}^{\lceil h\rceil -1}\ge (1+\epsilon )\cdot l\cdot (1+\epsilon {)}^{\lceil h\rceil -1}\ge l\cdot (1+\epsilon {)}^{\lceil h\rceil }.$$

$$(1+\epsilon {)}^{\lfloor t\rfloor }\cdot \delta .$$

$$n\cdot {\int }_{x=0}^t(1+\epsilon {)}^{\lceil x\rceil }dx\le \text{mbox}poly(n).$$

$$\mathrm{Pr}[T>p]\le e^{-{\epsilon }^2(1-\epsilon )p/3}\le e^{-{\epsilon }^{2}p/6}.$$

$$m\cdot e^{-{\epsilon }^{2}p/6}\le e^{-{\epsilon }^2(1-\epsilon )p/12}.$$

$$l_1\cdot (1+\delta )=k_1$$

$$k_2-2\le l_2\cdot (1+\delta )\le k_2+1=k_2+k_0$$

$$k_1+k_2-2\le l\cdot (1+\delta )\le k_0+k_1+k_2,$$

Full text

1 Introduction

A cup game [16, 33, 17, 1, 26, 11, 32, 14] is a multi-round game in which there there are $n$ cups, each initially empty, and two players. In each round, the filler distributes water to cups subject to some constraints, and then the emptier removes water from the cups subject to other constraints. For example, the filler may be constrained to add a total of at most one unit of water per round, while the emptier may be constrained to remove water from at most one cup.

The high-water mark after a given round is the maximum amount of water in any cup. The emptier’s goal is to minimize the high-water mark after each round and the filler acts as an adversary. In a cup game where the emptier uses a randomized strategy, the filler is oblivious; that is, the filler does not know the random choices made by emptier (and thus does not know the state of the cups).

In this paper, we focus on two cup games that naturally arise in the study of processor scheduling [1, 26, 17]. These games (and their relaxations) have also appeared in a variety of other applications, ranging from deamortization [3, 17, 16, 4, 31, 23, 18, 24], to buffer management in network switches [22, 5, 32, 20], to quality of service in real-time scheduling [8, 1, 26].

The single-processor cup game.

Consider $n$ threads, and suppose that at each time step they receive an aggregate of one new unit of work to do. The scheduler must then pick a thread to execute for that time step. The thread can then make $(1+\varepsilon)$ units of progress; here $\varepsilon$ is a speed-augmentation constant. Rephrasing the problem as a cup game, at each step the filler may distribute up to one unit of water among all of the cups, and the emptier may then select a cup and remove up to $1+\varepsilon$ units of water from it. In this context, the high-water mark is often referred to as the backlog.

The single-processor cup game and its variants have been studied extensively [1, 17, 16, 8, 28]. Notably, if the emptier follows the greedy algorithm, and always removes water from the fullest cup, then the backlog will never exceed $O(\log n)$ [1]. In fact, this remains true even when the speed-augmentation constant $\varepsilon$ is zero. It is further known that no matter the value of $\varepsilon$, no deterministic algorithm can do better, even by an additive constant factor (see the variant of the lower bound presented in [11] and [17]).111The fact that the bounds are unaffected by the choice of $\varepsilon$ has led past authors to implicitly either take $\varepsilon$ to be zero [1, 28, 8] or to be very large [16, 17, 11]. Combining the lower bound for the latter case with the upper bound for the former, one obtains the result for all values of $\varepsilon$ with no additional work.

Our single-processor results. We show that the performance of the greedy emptying algorithm for the single-processor cup game can be greatly improved with a small amount of randomization: After any step $i$, and for any $k\geq\Omega(\log\varepsilon^{-1})$, the emptier achieves backlog at most $O(k)$ with probability at least $1-O(2^{-2^{k}})$. An important consequence is that with high probability in $n$ (i.e., probability $1-1/\mbox{poly}(n)$), the backlog will not exceed $O(\log\log n)$, as long as $\varepsilon\geq O(1/\log n)$. Moreover, we show that these bounds are optimal, meaning that no algorithm can obtain the same probabilistic bounds for asymptotically smaller backlogs $k$.

The algorithm, which we call the smoothed greedy algorithm, works as follows: The emptier begins the game by artificially inserting into each cup $j$ a random quantity $r_{j}\in[0,1]$. Then at the end of each step, the emptier follows the deterministic greedy algorithm, except with a small but critical modification: If the fullest cup contains less than one unit of water, then the emptier does not remove any water at all.

This simple algorithm gives an explanation, in the form of a smoothed analysis, for why real-world systems should be expected to exhibit good behavior when following greedy strategies. Indeed, by randomly perturbing the start-state of the cups, a deterministic algorithm can suddenly obtain the guarantees of the (optimal) randomized algorithm. In this sense, our randomized algorithm can be interpreted as a one-shot smoothed analysis of the standard greedy algorithm.

The small amount of resource augmentation used by the smoothed greedy algorithm makes it robust to the setting in which cups begin in a bad initial starting state. In particular, we show that if $b$ units of water are maliciously placed into cups at the beginning of the game, then for steps $i>\frac{b}{\varepsilon}$, the $b$ units of water have no affect on the guarantees given by the algorithm.

The multi-processor cup game.

The multi-processor version of the same scheduling question has proven to be much harder. In each step of the multi-processor cup game, the filler distributes some amount of water proportional to $p$, the number of processors, among the cups (i.e., threads), and the emptier picks $p$ cups and removes a unit of water from each. If the filler is unrestricted in their placement of the water, then they can ensure an arbitrarily large backlog by placing all of the water in the same cup at each step; the emptier will then only be able to remove a single unit from that cup. A natural restriction, therefore, is to bound the amount of water placed in each cup at each step by some quantity $1-\delta$, where $\delta$ is, like $\varepsilon$, a speed-augmentation constant

The difficulty of the multi-processor version of the question stems from the fact that the emptier can remove at most one unit of water from each cup. In the scheduling problem, this corresponds with the fact that distinct processors cannot make progress on the same thread simultaneously, even if that thread has a vastly greater backlog of work than its peers. As noted by Liu [28], and subsequently reiterated by later authors [26, 8], this adds a “surprising amount of difficulty” to the scheduling problem.

Litman and Moran-Schein [26] showed that if the emptier has speed-augmentation constant $\delta$ and is permitted to be semi-clairvoyant, with knowledge of the schedule for when the next $1+\delta^{-1}$ units of water will arrive in each cup, then the emptier can follow a simple deadline-based algorithm to achieve backlog $O(1+\delta^{-1})$. Providing provable guarantees for a fully non-clairvoyant emptier has been a long-standing open problem [26, 1, 8]. It has been unknown, for example, whether a sufficiently clever filler might be able to achieve a backlog as a function of $p$.

Our multi-processor results. We present the first provable results for the multi-processor cup game without the use of clairvoyance. Specifically, we consider the game in which at each step, the filler places $(1-\varepsilon)p$ units of water among the cups, putting no more than $1-\delta$ units of water into any particular cup; the emptier then removes up to one unit of water from each of $p$ cups of their choice. We prove that the greedy Empty-Fullest-Cups algorithm achieves a backlog of $O\left(\frac{1}{\varepsilon}\log n\right)$ for any $0<\varepsilon<1$ and $\delta\geq\frac{1}{\mbox{poly}(n)}$. When $\varepsilon$ is constant, we show that this is provably optimal up to constant factors.

Turning to randomized algorithms, we encounter an unexpected phenomenon: When the number of processors $p$ is sufficiently large, the backlog after each step drops to constant with large probability. Specifically, we show that, if $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$, then there exists an algorithm that guarantees a backlog of three or less after each step with probability at least $1-O\left(e^{-\Omega(\varepsilon^{2}p)}\right)$.

We further extend the guarantees of our randomized algorithm to consider arbitrary backlogs. Namely, if we add the restriction that $\delta\geq\frac{1}{\mbox{poly}(p)}$, then our algorithm achieves backlog $O(k/\varepsilon)$ after each step with probability at least $1-O\left(e^{-e^{k}}\right)$. Additionally, in the case where $\varepsilon$ is constant, we prove lower bounds establishing that our probabilistic guarantees give optimal bounds up to constant factors in the backlog $k$ and in $p$.

As in the single-processor case, we show that the smoothed greedy algorithm is robust to the setting in which cups begin in a bad initial starting state. In particular, suppose $b$ units of water are maliciously placed into cups at the beginning of the game. Then the above guarantees for the multi-processor smoothed greedy algorithm continue to hold after any step $i\geq 2b/\delta$, except with an additional failure probability of $O\left(e^{-\Omega(i^{1/6})}\right)$.

A relaxed game for deamortization: the cup-flushing game.

A common application of cup games is to the deamortization of data structures [3, 17, 16, 4, 31, 23, 18, 24]. In this setting, a relaxation of the single-processor cup game, also known as the cup-flushing game, is often used. In the cup-flushing game, the emptier is permitted to remove all of the water from a cup at each step, rather than just a single unit. This is sometimes referred to as flushing a cup.

As in the single-processor cup game, a greedy emptier—who always flushes a fullest cup—can keep the backlog to $O(\log n)$ [16]. Using a more sophisticated randomized algorithm, the emptier can maintain the backlog at $O(\log\log n)$ with high probability in $n$ after any given round of the game [17].

Relationship with our results. The complicatedness of the randomized algorithm prompted the authors to pose finding a simpler algorithm as an open problem [17]. Since the cup-flushing game is a relaxation of the single-processor cup game, our randomized algorithm for the latter provides a resolution to this open problem. Our algorithm additionally improves on the prior work by offering probability bounds against any backlog $k$, rather than applying only to $k=\log\log n$.

In should be noted that, in general, the cup-flushing game can offer substantially more power to the emptier than do the scheduling games. Consider, for example, the “multi-processor” version of the cup-flushing game, in which the filler places $p$ units of water among cups and then the emptier flushes the water from $p$ cups. A solution to the “multi-processor” version follows trivially from the solution to the “single-processor” version, since the emptier can simply simulate the water poured by the filler as appearing in chunks of size one over the course of $p$ steps, and then perform the corresponding $p$ cup flushes (some of which may be to the same cup as each other). In contrast, the standard techniques for analyzing the single-processor cup game do not seem to generalize to the multi-processor case, and indeed the latter has remained open until now.

Other related work.

Adler et al. [1], who proved the $O(\log n)$ bound on the backlog in the single-processor cup game, also considered a relaxation of the multi-processor cup game in which the $p$ units of water removed by the emptier need not be from distinct cups, establishing a tight bound of $\Theta(\log n)$ backlog for this problem (without the use of clairvoyance or speed augmentation). As noted by [8], however, this relaxed version of the problem can be reduced to the single-processor version of the same question, and is thus primarily interesting from the perspective of lower bounds rather than upper bounds. Litman and Moran-Schein [26] proved a formal separation between the relaxed version and the non-relaxed versions, establishing that a deadline-based algorithm (which is completely clairvoyant) does provably worse in the multi-processor setting when it is not permitted to run the same thread on multiple processors concurrently.

In the context of packet-switching, Bar-Noy et al. [6] considered a variant of the single-processor cup game in which the filler is unconstrained as to how much water can be placed in the cups at each step, but must always place water in integer amounts. Rather than providing absolute bounds on backlog, which would be impossible in this scenario, they show that the greedy algorithm achieves an $O(\log n)$ competitive ratio with the optimal offline emptying algorithm. Moreover, they show that no online algorithm, including randomized algorithms, can do better. Several of the same results were also discovered concurrently by Fleischer and Koga [19]. Subsequent work has extended this to consider competitive ratios against other weaker adversaries [15].

Extensive work has also focused on variants of the cup games in which the rates of arrival are fixed [8, 21, 9, 27, 25, 30, 7]. That is, each cup $j$ receives the same amount $c_{j}$ from the emptier at each step $i$. Even in this simplified setting, constructing fast algorithms is highly non-trivial. Notably, by exploiting certain results from network flow theory, Baruah et al. [8] present a polynomial-time algorithm (per step of the game) that the emptier can follow in order to guarantee a maximum backlog of $O(1)$ in the single-processor cup game with fixed rates.

Additionally, a number of papers have explored variants of the multi-processor cup game in which the cups form the nodes of a graph, and the constraints on the emptier are a function of the graph structure [12, 11, 13, 14]. This is important, for example, in the study of multiprocessor scheduling with conflicts between tasks [13, 14], and in the study of sensor radio networks [11].

Recently, cup emptying games have also found applications to modeling memory-access heuristics in databases [10]. Here, whenever the emptier removes the water from a cup, the water is then redistributed according to some fixed probability distribution. The emptier’s goal is ensure that, on average, the amount of water in the cup being emptied is large.

2 Preliminaries

We describe formally the conventions that we will follow in discussing the cup games.

The single-processor cup game. A sequence of $n$ cups sit in a line, initially empty. At each step in the game, a filler distributes (up to) $(1-\varepsilon)$ units of water across the cups. Then an emptier selects one cup and removes (up to) one unit of water from the cup. The goal of the emptier is to minimize the amount of water in the fullest cup after each step, also known as the backlog.222Note that one could just as reasonably follow the convention that the filler places $1$ unit at each step, and the emptier removes $1+\varepsilon$ units (as was the case in Section 1). For $\varepsilon\leq 1/2$, the distinction between the conventions is aesthetic only, up to constant-factor changes in $\varepsilon$.

The following notation will be useful for analyzing the single-processor cup game. For each $i\in\mathbb{N}$, and for each cup-number $j\in[n]$, define $c_{j}(i)$ to be the amount poured into cup $j$ during the $i$-th step. The quantities $c_{j}(i)$ are predetermined by the filler at the start of the game (i.e., the filler is an oblivious adversary), and are constrained to satisfy $\sum_{j\in[n]}c_{j}(i)\leq 1-\varepsilon$. Let $f_{j}(i)$ denote the amount of water in cup $j$ after step $i$. The backlog of the system after step $i$ can be expressed as $\max_{j}f_{j}(i)$, the amount of water in the fullest cup.

The multi-processor cup game. As in the single-processor cup game, a sequence of $n$ cups sit in a line, initially empty.

At each step in the game, the filler distributes (up to) $(1-\varepsilon)p$ units of water among the cups, with no cup receiving more than $1-\delta$ units of water at a time. The emptier then removes (up to) one unit of water from (up to) $p$ distinct cups. As before, the goal of the emptier is to minimize the amount of water in the fullest cup at any given step, also known as the backlog. As in the single-processor cup game, the filler is an oblivious adversary.

We define the quantities $f_{j}(i)$ and $c_{j}(i)$ as in the single-processor cup game. The restrictions on the emptier translate to the constraint that, for a given step $i$, we have $c_{j}(i)\leq 1-\delta$ for each cup $j$, and $\sum_{j}c_{j}(i)\leq(1-\varepsilon)p$.

The renormalized multi-processor cup game. It is sometimes useful to use an (aesthetic) variation on the multi-processor cup game, which we refer to as the renormalized multi-processor cup game, in which the filler distributes $(1-\varepsilon)p$ units of water among the cups, placing no more than one unit in any cup (rather than $1-\delta$); and the emptier then selects up to $p+1$ (rather than $p$) distinct cups and removes up to $1+2\delta$ from each (rather than $1$).

For convenience of algorithm analysis, we use the renormalized multi-processor cup game when designing randomized algorithms for the multi-processor cup game, and we use the (non-renormalized) multi-processor cup game when analyzing deterministic algorithms. All of our results are portable between two versions of the game, with changes in $\varepsilon$ and $\delta$ by constant factors. See Appendix A for more details.

Bounding the number of random bits. Many of our algorithms assume the ability to select random real thresholds in the range $[0,1]$. In Appendix B we describe how to use low-precision thresholds in order to achieve the same guarantees, thereby reducing the number of random bits to $\Theta(\log n)$ per threshold.

3 Technical Overview

A randomized algorithm for the single-processor cup game.

In Section 4, we present a randomized algorithm for the single-processor cup game with the following guarantee: After any step $i$, and for any $k\geq\Omega(\log\varepsilon^{-1})$, the emptier achieves backlog at most $O(k)$ with probability, i.e., probability at least $1-O(2^{-2^{k}})$. When $\varepsilon\geq O(1/\log n)$, it follows that with high probability in $n$, the backlog will not exceed $O(\log\log n)$.

The algorithm, which we call the smoothed greedy algorithm, works as follows: The emptier begins the game by artificially inserting into each cup $j$ a random quantity $r_{j}\in[0,1]$. Then at the end of each step, the emptier follows the deterministic greedy algorithm of emptying from the fullest cup, except with a small but critical modification: If the fullest cup contains less than one unit of water, then the emptier does not remove any water at all. This modification ensures that the actions of the emptier do not affect the amount of water modulo one in each cup, a property which will play a critical role in the analysis of the algorithm.

To analyze the smoothed greedy algorithm, we begin by revisiting the deterministic greedy algorithm in a new setting in which the number of cups can change dynamically: arbitrarily many new empty cups may be added by the filler at the beginning of each step, and cups are removed at the end of a step if they are empty. We call this the dynamic single-processor cup game. We prove that if $n_{i}$ is the number of cups present at the end of a step $i$, then the backlog does not exceed $O(\log n_{i})$.

The analysis of the smoothed greedy algorithm reduces the game on $n$ cups to a dynamic game on far fewer cups. Call a cup active if it contains one or more units of water. The smoothed greedy algorithm can be seen as playing a virtual dynamic game on the active cups in which the virtual fill of each cup is the true fill minus one. In particular, cups enter and and leave the dynamic game based on whether they have positive virtual fill, and the emptier always removes water from the fullest cup. To bound the backlog by $O(k)$, it therefore suffices to bound the number of active cups by $2^{k}$.

The difficulty in bounding the number of active cups directly is that there may be a series of time steps during which the emptier removes water exclusively from cups containing more than two units of water, but during which the filler manages to increase the number of active cups significantly.

We instead bound a different quantity, which we call the integer fill. The integer fill after step $i$ is $\sum_{j=1}^{n}\lfloor f_{j}(i)\rfloor$, and can be thought of as the number of integer thresholds crossed within the cups. This gives an upper bound for the number of active cups, since each active cup contributes at least 1 to the integer fill. On the other hand, the integer fill also interacts nicely with the emptier, because whenever the emptier removes water from a cup, the emptier decreases the integer fill by exactly $1$.

This property ensures that, in order for the integer fill to exceed $2^{k}$ after a step $i$, the following must be true: There must be some $l>0$ so that in the $l$ steps leading up to $i$, at least $2^{k}+l$ integer thresholds were crossed by the filler. We call any $l$ satisfying the latter property a backlog witness.

To bound the probability that there exists a backlog witness $l>0$, we begin by considering the simpler problem of bounding the number of integer thresholds crossed in a single step. Recall that in the smoothed greedy algorithm, the emptier always removes water in integer quantities. Thus, the amount of water modulo 1 in a cup $j$ after step $i$ is

[TABLE]

regardless of the actions of the emptier.

Although the random quantity $r_{j}$ of water is inserted into the cup $j$ only once at the start of the game, it continues to randomize the amount of water modulo 1 at each step $i$. Remarkably, this makes the probability that cup $j$ crosses an integer threshold in step $i$ exactly $c_{j}(i)$. Moreover when one cup crosses thresholds is independent of when other cups do.

Naturally, the number of integer thresholds crossed in one step is not independent of previous steps; nonetheless, we can analyze $l$ consecutive steps together and express the number of integer thresholds crossed as a sum of independent indicator random variables. If $u_{j}$ water is placed in cup $j$ during the $l$ steps, then the cup simply contributes $\lfloor u_{j}\rfloor$ indicator random variables that are deterministically set to one, and one indicator random variable whose value is $1$ with probability equal to the fractional part of $u_{j}$.

The number of integer thresholds crossed by the filler in any sequence of $l$ consecutive steps is therefore a sum of independent indicator random variables with mean $(1-\varepsilon)l$. Applying a Chernoff bound and then summing over all $l>0$, we deduce that the probability of there existing a backlog witness is $O(2^{-2^{\Omega(k)}})$.

Analyzing the deterministic greedy algorithm in the multi-processor cup game.

Past analyses of the single-processor cup game—which have relied on showing that a collection of $n$ invariants remain simultaneously true at the end of each step [1, 16]—have so far failed to generalize to the multi-processor cup game. This difficulty has led authors to consider weaker variants of the game in which either the emptier is given clairvoyant abilities [26], or is permitted to remove as much water as it wants from individual cups [1]. The sparsity of results in the multi-processor setting is not for lack of trying; even the earliest papers on the subject [28, 8] explicitly acknowledge the difficulty of the problem.

In Section 5, we prove bounds for the multi-processor cup game using the parallel greedy algorithm. In particular, when $\varepsilon\geq\Omega(1)$ and $\delta\geq\frac{1}{\mbox{poly}(n)}$, we achieve a provably optimal bound of $O(\log n)$ on the backlog, matching the performance in the single-processor cup game. More generally, for any $\varepsilon>0$ and $\delta\geq\frac{1}{\mbox{poly}(n)}$, our algorithm achieves backlog $O(\varepsilon^{-1}\log n)$. In this discussion we will assume that $\varepsilon\geq 1/n$, so that $\delta\geq\varepsilon^{-1}/\mbox{poly}(n)$, although this requirement is removed in the full proof.

Rather than building on the invariants-based approach taken by past authors [1, 16], we show that a surprisingly simple potential function can be used to bound the backlog. Define,

[TABLE]

We show that $\phi(i)\leq\mbox{poly}(n)$ for all steps $i$. It follows that no $f_{j}(i)$ can ever exceed $O\left(\frac{1}{\varepsilon}\log n\right)$.

Fix $n^{c}$ to be a sufficiently large polynomial. To bound $\phi(i)$, there are three cases:

Case 1: The emptier removes a full unit of water from each of $p$ cups during step $i$: In this case, the water placed by the filler in step $i$ can be matched with the water removed by the emptier in a way so that each small amount of water poured is matched with at least $(1+\varepsilon)$ times as much water that is removed from a height no more than one smaller. Since

[TABLE]

it follows that the net change in potential during the step is non-positive.

Case 2: For all cups $j$, $f_{j}(i)\leq\log_{1+\varepsilon}n^{c-1}$. In this case, we trivially have that $\phi(i)\leq n^{c}$, since each cup contributes at most $n^{c-1}$ to $\phi(i)$.

Case 3: After step $i$, at least one cup contains $\log_{1+\varepsilon}n^{c-1}$ or more water, but during step $i$ there are never more than $p-1$ cups containing one or more units of water. This case is the most subtle. The key insight is that for each of the cups $c_{1},\ldots,c_{t}$ that contain more than one unit of water at the end of step $i$, all of the water that was placed into the cup during the step was subsequently removed. Moreover, at least $\delta$ additional water is successfully removed from each of the cups $c_{1},\ldots,c_{t}$, bringing their total contribution to the potential down by a factor of $(1+\varepsilon)^{\delta}=1+\Theta(\varepsilon\cdot\delta)$. Since at least one of the cups $c_{1},\ldots,c_{t}$ contains $\log_{1+\varepsilon}n^{c-1}$ units of water, this drop in potential is at least $n^{c-1}\cdot\Theta(\varepsilon\cdot\delta)$. Using that $\delta\geq\varepsilon^{-1}/\mbox{poly}(n)$, if $c$ large enough, the drop in potential is at least $2n$. On the other hand, the total contribution to $\phi(i)$ by all other cups at the end of the step is at most $(1+\varepsilon)\cdot n\leq 2n$. Thus, we get that $\phi(i)\leq\phi(i-1)$.

The simplicity of the potential-function argument makes Section 5 among the shortest in the paper. Nonetheless, due to the history of the problem, we consider it to be among our main results. It is also worth remarking that the analysis above can be used to reprove a number of classical results for cup games, such as the fact that the cup-flushing game achieves backlog $O(\log n)$. In fact, we can prove a stronger statement, which is that the backlog remains $O(\log n)$ even if the emptier’s approach is relaxed to always empty out of a cup that is within an additive constant of being fullest.

A randomized algorithm for the multi-processor cup game.

In Section 6, we present a randomized algorithm for the (renormalized) multi-processor cup game. Specifically, we show that, if $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$, then there exists an algorithm that guarantees the backlog is three or less after each step with probability at least $1-O\left(e^{-\Omega(\varepsilon^{2}p)}\right)$. In particular, when $\varepsilon$ is constant and the number of processors $p$ is relatively large, this brings the probability of super-constant backlog down to exponentially small in $p$. In contrast, in the single-processor case, no bounds on constant backlog can be achieved with better than constant probability.

Because this is the most technically difficult result in the paper, we give a somewhat higher level overview. As in the single-processor cup game, we once again apply our technique of using randomized threshold crossings as an accounting scheme to track the emptier’s progress. However, the interactions between multiple cups being emptied simultaneously makes both the instantiation of the thresholds and the analysis of the algorithm much more delicate.

The random thresholds are defined within the cups so that whenever $c_{j}(i)$ new units of water are placed in a cup $j$, at most one threshold is crossed, and the probability of a threshold being crossed is at most $c_{j}(i)$. Moreover, whenever a threshold is crossed, the cup $j$ is guaranteed to have enough water (i.e., $1+\delta$ units) that the emptier can make close to their maximum allowable withdrawal (of $1+2\delta$ units) from the cup. Whenever $p$ or fewer thresholds are crossed during a step, the emptier always has the option of removing water from the cups in which thresholds were crossed. When this happens, we regard the emptier as having been more successful during the step than was the filler.

On the other hand, if $k>p$ thresholds are crossed during a step $i$, then we define the number of surplus thresholds crossed as $T_{i}=k-p$. When the number of processors $p$ is large, the probability of there being any surplus threshold crossings for a given step $i$ becomes small. In particular, since the total amount of water $\sum_{j}c_{j}(i)$ placed by the filler at each step $i$ is at most $(1-\varepsilon)p$, and since threshold crossings are independent between cups, we can apply a Chernoff bound to bound $\Pr[T_{i}>0]\leq e^{-\Omega(\varepsilon^{2}p)}$.

The key to analyzing the algorithm after step $i$ is to show that with large probability, all $l>0$ satisfy the property that $\frac{\delta}{2}\cdot l$ or fewer surplus threshold crossings occurred in the $l$ steps leading up to step $i$. In particular, the emptier’s algorithm is designed to make progress roughly $\delta$ at each step towards undoing any damage caused by past surplus threshold crossings; if all $l>0$ satisfy the aforementioned property, then we are guaranteed after step $i$ that the emptier has successfully handled all surplus thresholds from the past.

The technical challenge becomes to prove a concentration bound on the number $\sum_{m=i-l+1}^{i}T_{m}$ of surplus threshold crossings within a sequence of $l$ steps. This is made difficult by the fact that there exists a complicated chain of dependencies between different $T_{m}$’s. In particular, the fact that a given $T_{m}$ is greater than zero cannot be attributed to any single cup. Rather, it requires that at least $p+1$ cups all have thresholds crossed simultaneously in step $m$. Which $p+1$ cups these are can then greatly impact for other steps $m^{\prime}$ the probability that $T_{m^{\prime}}$ is greater than zero.

To prove a concentration bound we use McDiarmid’s inequality (i.e., Azuma’s inequality applied to Doob Martingales) [29, 2]. McDiarmid’s inequality says that if a random variable $Y$ can be expressed as a function $F(X_{1},\ldots,X_{t})$ of independent random variables $X_{1},\ldots X_{t}$, and if each $X_{j}$’s value can affect $F(X_{1},\ldots,X_{t})$ by at most some bounded amount $c$, then a Chernoff-style concentration bound holds for $Y$:

[TABLE]

In order to make the algorithm more conducive to an application of McDiarmid’s inequality, a natural way to design the thresholds in our algorithm would be to have the thresholds be constantly changing within each cup $j$. In particular, one could select a random threshold $r_{j}^{s}\in[s,s+1]$ for each integer $s$, and say that a threshold is crossed within cup $j$ whenever the total amount of water ever poured into the cup passes a threshold $r_{j}^{s}$. Unfortunately, such a design would allow for two thresholds in a single cup to potentially be crossed in the same step, making it no longer be the case that the first $p$ threshold-crossings in each step are easily handled by the emptier.

To avoid this problem, we use a more nuanced layout of thresholds, in which gaps are placed between thresholds that differ in their values modulo 1. In order so that these gaps are not too frequent (which would then make it so that the threshold crossings no longer closely tracked the amount of water in the cups), thresholds are then placed in collections of size $1/\delta$, with each collection of thresholds using the same random offset modulo 1, and with consecutive collections being separated by a gap of size one. We define a threshold collection to be a set of thresholds that use the same random offset modulo 1, and we define the random value of the collection to be that random offset. We define the hitting capacity of a threshold collection in cup $j$ during steps $i-l+1,\ldots,i$ to be the expected number of thresholds (depending on the random value of the collection) that the water poured during those steps will have crossed in the collection.

With thresholds designed in this manner, a first attempt at applying McDiarmid’s inequality might go as follows: Notice that $Y=\sum_{m=i-l+1}^{i}T_{m}$ can be written as a function $F$ of the random values of each of the threshold collections with non-zero hitting capacities. As a loose bound, there are at most $n+lp$ such threshold collections, since in order for a cup $j$ to have $h>1$ such threshold collections, at least $(h-1)$ units of water must have been poured into the cup during the steps $i-l+1,\ldots,i$ (that way the water could cross the threshold-less gap between the collections). Moreover, the random value of each threshold collection can affect $Y$ by at most $\delta^{-1}$, since the random value controls in total when at most $\delta^{-1}$ different threshold crossings occur. Thus we can apply McDiarmid’s inequality with $c=\delta^{-1}$ and $t=n+lp$.

This naïve approach only gives a useful bound when $lp\geq n$. To handle smaller $l$, a more sophisticated argument is necessary. We express $Y$ as a function of random variables $X_{1},\ldots,X_{pl+1}$ where each $X_{s}$ corresponds with the random values of some set of threshold collections rather than with just a single random value. That is, we partition the threshold collections into a partition $Q_{1},\ldots,Q_{pl+1}$, and then define for each component $Q_{s}$ a random variable $X_{s}$ that reveals the random values of the threshold collections in the component $Q_{s}$. The key is to design the partition $Q_{1},\ldots,Q_{pl+1}$ so McDiarmid’s inequality can subsequently be applied. This is accomplished by assigning threshold collections that are likely to have substantial affect on $Y$ to their own components, and then grouping together large sets of threshold collections that are not expected to have substantial affect on $Y$ into other components. We show that with a large probability, no individual $X_{s}$ has substantial affect on the outcome of $Y$, allowing us to obtain the desired concentration bound via McDiarmid’s inequality.

The multi-processor smoothed greedy algorithm.

In the algorithm described above, whenever there are multiple cups containing super-constant amounts of water, the emptier may select which of them to empty out of arbitrarily. We define the multi-processor smoothed greedy algorithm to be the strategy in which, when deciding between cups of equal priority, the emptier always chooses the fullest cups.

Adding a new condition that $\delta\geq\frac{1}{\mbox{poly}(p)}$, we extend the analysis of the randomized algorithm for the multi-processor cup game to consider arbitrary backlogs. Specifically, in Section 7, we show that after any step $i$ and for any $k>1$, the multi-processor smoothed greedy algorithm achieves backlog $O(k/\varepsilon)$ with probability at least $1-O\left(e^{-e^{k}}\right)$.

The analysis combines ideas from each of the previous sections. We consider a dynamic version of the multi-processor cup game being played on the cups containing $4+\delta$ or more units of water. The number of cups involved in the game at the end of a step $i$ is upper bounded by the number of surplus threshold crossings that have been crossed in the past without being subsequently accounted for by the emptier. Concentration bounds for the number of cups in the dynamic game can thus be proven using extensions of the ideas from Section 6. Combining this with an analysis of the deterministic greedy algorithm for the dynamic multi-processor cup game, we obtain the desired bound on backlog.

Matching lower bounds.

In Section 8, we show that when $\varepsilon$ is constant, the bounds presented above for the smoothed greedy algorithm, the multi-processor greedy algorithm, and the multi-processor smoothed greedy algorithm are asymptotically optimal, in the sense that no algorithms can achieve better bounds, up to constant factors in the backlog and in $p$.

The strategy that the filler follows is a variant on the strategy used by past authors in the single-processor cup game [11, 17]. In particular, in the $p$-processor setting, the filler uses the following algorithm: First distribute $(1-\varepsilon)p$ units of water among some number $m$ of cups. Next attempt to guess which $p$ cups the emptier removes water from, and then distribute $(1-\varepsilon)p$ units of additional water among the remaining $m-p$ cups. Again attempt to guess which cups have water removed from them, and continue like this until there are $p$ or fewer cups remaining. In the event that the filler has made all their guesses correctly, the fullest cup will have

[TABLE]

Each of our lower bounds are proven simply by analyzing the success probabilities of variants of this strategy for various parameters $m$ and $p$.

Recovering from bad starting states.

In Section 9, we revisit both the smoothed greedy algorithm and the multi-processor smoothed greedy algorithm in the situation where the initial state of the cups is no longer empty. In particular, suppose that $b$ units of water have already been dispersed among the cups arbitrarily before the game begins. We show that in both games the system can quickly recover from such a starting state.

For the single-processor cup game, for $i>\frac{b}{\varepsilon}$, the smoothed greedy algorithm maintains the same guarantees as if the initial states of the cups were empty. The key insight is that there must be some step $i^{\prime}\leq i$ after which the integer fill is zero; using this fact, the analysis of the smoothed greedy algorithm at step $i$ can then be applied without modification. To prove the existence of such an $i^{\prime}$, notice that for each step, either the integer fill is zero at the end of the step, or the emptier must have successfully removed a full unit of water during the step. In the latter case, the total amount of water in the system will have decreased by at least $\delta$. This implies that the integer fill cannot be non-zero at the end of each of the steps $1,\ldots,i$ for any $i>\frac{b}{\varepsilon}$, as desired.

For the multi-processor cup game, the guarantees previously proven for the multi-processor smoothed greedy algorithm continue to hold after a step $i\geq 2b/\delta$ with an additional failure probability of $O\left(e^{-\Omega(i^{1/6})}\right)$. This corresponds with the probability that the emptier fails to achieve a state in which every cup is nearly empty during any of the steps $i^{\prime}\leq i$.

4 A Smoothed Algorithm for the Single-Processor Cup Game

In the greedy algorithm for the single-processor cup game, the emptier removes water from the fullest cup at each step. It was proven by Adler et al. [1] that the greedy algorithm achieves backlog $O(\log n)$ at all times, independently of $\varepsilon\leq 1/2$, and the lower bound [11, 17] shows that no deterministic algorithm can do better, regardless of the choice of $\varepsilon$. In this section, we consider the randomized version of the same problem, and present a randomized version of the greedy algorithm that achieves significantly better bounds.

The Algorithm. At the start of the game, the emptier selects random starting states $r_{1},\ldots,r_{n}\in(0,1]$, and places $r_{j}$ water in each cup $j$. (This can, of course, be simulated rather than actually performed.) Then, after each step of the algorithm, the emptier checks whether any cups have one or more units of water. If every cup has fill less than one, then the emptier does nothing. Otherwise, the emptier finds the fullest cup, and removes one unit of water from that cup.

We call our algorithm the smoothed greedy algorithm, because the algorithm can be seen as performing a variant of the deterministic greedy algorithm, except with the initial state of the cups smoothed so that each cup has a random quantity of water between zero and one. Surprisingly, this smoothing, which is only performed once at the beginning of the algorithm, results in significantly stronger bounds on the backlog at step $i$ for all $i\in\mathbb{N}$.

Theorem 1**.**

Suppose $\varepsilon\leq 1/2$. Fix $i\in\mathbb{N}$, and consider some value $k\geq 0$ such that $3\log\frac{1}{\varepsilon}\leq k$. Then the probability that the smoothed greedy algorithm has backlog $k$ or greater after step $i$ is at most

[TABLE]

By Theorem 1, for every step $i$, with high probability in $n$ the backlog does not exceed $O(\log\log n)$. Additionally, we will see that the smoothed greedy algorithm maintains the bound of the deterministic greedy algorithm, guaranteeing deterministically that the backlog never exceeds $O(\log n)$.

**Analysis of Algorithm. **In order to prove Theorem 1, we begin by analyzing the deterministic greedy algorithm in a new setting. Consider a variant of the problem in which cups can be added and removed at each step. In particular, at the beginning of any step, arbitrarily many new cups may be added to the system, each initially containing no water. During the step, the filler must then place a positive amount of water in each of the new cups. A cup is removed from the system whenever it is completely emptied by the emptier. We call this variant of the game the dynamic single-processor cup game. The following lemma extends the standard analysis of the deterministic greedy algorithm to this new game:

Lemma 1**.**

Consider the dynamic single-processor cup game, and suppose the emptier follows the greedy algorithm. If $m$ is the number of cups present after the $i$-th step in the game, then the fullest cup after the $i$-th step contains at most $O(\log m)$ water.

We defer the proof of Lemma 1 to Appendix C.

Call a cup active if the cup contains more than one unit of water, and inactive otherwise. The smoothed greedy algorithm essentially plays an instance of the dynamic single-processor cup game on the set of cups which are active. In particular, whenever a cup becomes active, it is because the filler has placed water overflowing the cup to contain more than one unit of water, and the only way a cup can become inactive is for the fill of the cup to be reduced to one or less. Since the smoothed greedy algorithm always removes one unit of water from the fullest active cup, this corresponds to an instance of the dynamic single-processor cup game, where the cups in the new game are the active cups in the original game, and the fill of each cup in the new game is one less than the fill of the cup in the original game. Applying Lemma 1, it follows that no cup contains more than $O(\log m)$ water, where $m$ is the number of active cups after a particular time step.

For the rest of the section, consider a fixed time step $i$. In order to bound the backlog after step $i$, it suffices to bound the number of active cups.

The difficulty in bounding the number of active cups directly is that there may be a series of time steps during which the emptier removes water exclusively from cups containing more than two units of water, thereby failing to make any active cups inactive, but the filler manages to increase the number of active cups significantly. In order to circumvent this issue, we instead bound a different quantity:

The integer fill of the cups after a step $k$ is given by $\sum_{j\in[n]}\lfloor f_{j}(k)\rfloor$. We may also refer to the integer fill as the number of integer thresholds passed after step $i$.

Since each active cup passes at least one integer threshold, the integer fill is always at least as large as the number of active cups. Moreover, the integer fill is easier to bound due to the fact that the emptier always reduces the integer fill by one at the end of each step, unless the integer fill was already zero. The filler, on the other hand, may get lucky on some time steps and manage to cross a large number of integer thresholds using the $1-\varepsilon$ units of water they pour. On average, though, the filler should not expect to cross more than $1-\varepsilon$ thresholds per time step.

In order to bound the integer fill after the $i$-th step, we begin by proving a concentration bound for the number of integer thresholds crossed in any given sequence of $t$ consecutive steps. Note that consecutive steps are not independent. For example, if the filler places $1/2$ a unit of water in cup $j$ during a step, and then another $1/2$ a unit of water in cup $j$ during the next step, then exactly one of the two steps will cross an integer threshold in cup $j$. Despite this, it turns out that the number of thresholds crossed during any $t$ consecutive steps can still be expressed as a sum of independent zero-one random variables:

Lemma 2**.**

Consider a sequence of $t$ consecutive steps in the cup game in which the emptier follows the smoothed greedy algorithm. Then the number of integer thresholds crossed during the $t$ steps can be expressed as a sum of independent zero-one random variables with total mean at most $(1-\varepsilon)t$.

Proof.

Let $l,l+1,\ldots,l+t-1$ be the indices of the steps being considered. For any cup $j$, let $a_{j}$ denote the total amount of water placed in the cup by the filler prior to the $l$-th step, and let $b_{j}$ denote the amount of the water placed in the cup during steps $l,\ldots,l+t-1$. That is, $a_{j}=\sum_{s<l}c_{j}(l)$ and $b_{j}=\sum_{l\leq s<l+t}c_{j}(l)$. Recalling that $r_{j}$ units of water are poured into each cup $j$ at the beginning of the game, the total amount of water ever placed in the cup prior to step $l$ is $r_{j}+a_{j}$, and the total amount of water ever placed in the cup prior to step $l+t$ is $r_{j}+a_{j}+b_{j}$. The emptier only ever removes integer amounts from a cup, meaning that the number of integer thresholds crossed in the steps $l,\ldots,l+t-1$ is independent of which steps the emptier targeted cup $j$. Indeed, the precise number of integer thresholds crossed in cup $j$ is given by

[TABLE]

The first $\lfloor b_{j}\rfloor$ units of water poured into the cup during the steps $l,l+1,\ldots,l+t-1$ will cross $\lfloor b_{j}\rfloor$ integer thresholds in total. Define $\overline{b_{j}}=b_{j}-\lfloor b_{j}\rfloor$ to be the fractional part of $b_{j}$. The final $\overline{b_{j}}$ units of water poured will cross an integer threshold if and only if

[TABLE]

This, in turn, occurs if and only if there exists positive $q\leq\overline{b_{j}}$ for which $r_{j}+a_{j}+q\equiv 0\mod 1.$ Because $r_{j}+a_{j}\pmod{1}$ is uniformly random (based on $r_{j}$), the probability of such a value $q$ existing is $\overline{a_{j}}$. Therefore, the number of integer thresholds crossed in cup $j$ can be written as a sum of indicator variables

[TABLE]

where each $X_{i}$ takes value $1$ with probability one, and where $Y$ is an indicator variable taking value $1$ with probability $\overline{a_{j}}$, depending on $r_{j}$. Because the $r_{j}$’s are independent between cups, the number of integer thresholds crossed is also independent between cups. Therefore, the total number of integer thresholds crossed during the steps $l,l+1,\ldots,l+t-1$ can be written as a sum of independent indicator variables, where the indicator variables for each individual cup have total expectation $a_{j}$, and thus the expected total sum of the indicator variables is $\sum_{j}a_{j}\leq(1-\varepsilon)t$. ∎

Applying Lemma 2, we can bound the probability for any $k$ that there are $k$ or more active cups after step $i$.

Lemma 3**.**

Consider $k\geq 1/\varepsilon^{3}$. With probability at least $1-e^{-\Omega(k^{1/3})},$ the integer fill after step $i$ is no more than $k$.

Proof.

Let $t\geq 0$ be the smallest $t$ such that at the end of step $i-t$, the integer fill was zero (i.e., there were no active cups). Then during each of the $t$ steps following step $i-t$, the emptier must have successfully removed one unit of water from some cup, thereby reducing the integer fill by one. Hence in order for the integer fill after step $i$ to be at least $k$, at least $t+k$ integer thresholds must have been crossed in the preceding $t$ steps.

Let $S_{t}$ denote the number of integer thresholds crossed in steps $i-t+1,\ldots,i$. In order to complete the proof, it suffices to bound the probability that $S_{t}\geq t+k$ for any $t$. By Lemma 2, $S_{t}$ can be expressed as a sum of independent indicator variables, and $\mathbb{E}[S_{t}]=(1-\varepsilon)t$. By a Chernoff bound, it follows that

[TABLE]

for $\delta\leq 1$, and

[TABLE]

for $\delta\geq 1$. Applying Eq. 4 in the case of $k\geq t$, we get

[TABLE]

Applying Eq. 3 in the case of $k\leq t$, we get

[TABLE]

where the final inequality uses the fact that $\mathbb{E}[S_{t}]=(1-\varepsilon)t\geq t/2$. Summing over all $t$, we get that

[TABLE]

Assuming $k\geq 1/\varepsilon^{3}$, this becomes $e^{-\Omega(k^{1/3})}.$ Therefore with probability at least $1-e^{-\Omega(k^{1/3})},$ the integer fill after step $i$ is no more than $k$. ∎

Putting the pieces together, we can complete the proof of Theorem 1.

Proof of Theorem 1.

Consider $k$ such that $3\log\frac{1}{\varepsilon}\leq k$, meaning that $1/\varepsilon^{3}\leq 2^{k}$. By Lemma 3, with probability at least $1-e^{-\Omega(2^{k/3})}$, the integer fill after step $i$ is at most $2^{k}$. Since the integer fill is at least as large as the number of active cups, it follows that there are at most $2^{k}$ active cups. Applying Lemma 1 to the active cups, we get that the backlog is at most $O(k)$, as desired. ∎

5 Deterministic Results for the Multi-Processor Cup Game

Recall that the multi-processor cup game works as follows. At each step the filler is allowed to distribute up to $(1-\varepsilon)p$ units of water among the cups, placing up to $1-\delta$ units in any individual cup; and then the emptier is permitted to remove up to one unit of water from each of up to $p$ distinct cups. As in the single-processor cup game, the emptier’s goal is to minimize backlog.

In this section we consider the multi-processor cup game in the deterministic setting, in which the emptier’s strategy is to simply always remove (up to) one unit of water from the $p$ fullest cups (also known as the greedy algorithm). Until now, no nontrivial upper bounds for the maximum backlog have been proven in this setting. We achieve a maximum backlog of $O(\log n)$, when the emptier is allowed to remove a constant-fraction more water in total than the filler pours, and at least a $1/\mbox{poly}(n)$ amount more from each individual cup (i.e., $\varepsilon\geq\Omega(1)$ and $\delta\geq 1/\mbox{poly}(n)$).

The goal of the section will be to prove Theorem 2:

Theorem 2**.**

Let $0<\varepsilon<1$ and $\delta\geq\frac{1}{\mbox{poly}(n)}$. Then the greedy algorithm will achieve maximum backlog $O(\frac{1}{\varepsilon}\log n)$ on a game with $n$ cups.

To introduce the approach for proving Theorem 2, we begin by revisiting the single-processor cup-flushing game [17].

5.1 Revisiting the Cup-Flushing Game

Recall that in each step of the cup-flushing game, the filler distributes one unit of water among the cups, and then the emptier removes all of the water from some cup. A result that has found numerous applications in deamortization is that, if the emptier follows the greedy algorithm, then no cup will ever have fill more than $O(\log n)$ [3, 17, 16, 4, 31, 23, 18, 24]. In this subsection, we present a new proof of the result. In additional to bringing new intuition to the problem, our proof has the interesting property that it can easily be adapted to work even if the emptier does not remove from the fullest cup at each step, but instead removes from a cup whose fill is within $O(1)$ of the maximum.

Define $f_{j}(i)$ to be the amount of water in cup $j$ after step $i$. The key insight in the proof is to examine the potential function,

[TABLE]

obtained by exponentiating the water in each cup, and then taking a sum. We will show that $\phi(i)$ never exceeds $O(n)$, by proving that at the end of each step $i$, either $\phi(i)<\phi(i-1)$, or no cup contains more than $2$ units of water (and thus $\phi(i)\leq O(n)$). The bound on $\phi(i)$ prevents any single cup from ever having fill greater than $O(\log n)$.

For convenience, we will actually use a slightly different potential function,

[TABLE]

Using this potential function, the proof proceeds as follows. Consider a given step $i$. Let $t$ be the fill of the fullest cup after the filler takes their turn. Assume that $t\geq 2$, since otherwise no cup contains more than $2$ units of water, and $\phi(i)$ cannot exceed $O(n)$. The water added to the cups can have increased the potential by at most $1.1^{\lceil t\rceil}$. On the other hand, the emptier will remove at least $2$ units of water from the fullest cup, thereby decreasing the potential by at least

[TABLE]

Thus the potential after step $i$ satisfies $\phi(i)\leq\phi(i-1)$.

Since either $\phi(i)\leq O(n)$ or $\phi(i)\leq\phi(i-1)$ for each $i>0$, and since $\phi(0)$ is trivially [math], the potential $\phi(i)$ must always remain in $O(n)$. This, in turn, implies that $f_{j}(i)\leq O(\log n)$ for all cups $j$ and steps $i$.

5.2 Proving Theorem 2

The proof of Theorem 2 generalizes the ideas from the previous section.

Proof of Theorem 2.

Define $f_{i}(j)$ to the fill in cup $j$ after step $i$, and define the potential function,

[TABLE]

We will prove that $\phi(i)\leq O(\mbox{poly}(n))$ for all $i$. This, in turn, bounds each $f_{i}(j)$ to be at most $O(\log_{1+\varepsilon}\mbox{poly}(n))\leq O(\frac{1}{\varepsilon}\log n)$.

For a given step $i$, we consider two cases separately:

**Case 1: The emptier removes a full unit of water from each of $p$ cups during step $i$. ** In this case, we break the emptying in step $i$ into three substeps, beginning after the filler has taken their turn: (1) The emptier identifies the $p$ fullest cups $r_{1},\ldots,r_{p}$; (2) The emptier removes from each of the cups $r_{i}$ any water that was poured into it during step $i$; (3) The emptier removes additional water so that a total of one unit has been removed from each of the cups $r_{1},\ldots,r_{p}$. Note that the case requirement ensures that each of the cups $r_{1},\ldots,r_{p}$ contains at least a unit of water during substep (1), and thus substep (3) is well defined.

Let $h$ denote the fill of the emptiest cup in the set $\{r_{1},\ldots,r_{p}\}$ at substep (1). Let $l$ be the number of units of water that the filler places in cups during step $i$ and that still remains after substep (2). (This corresponds with water placed in cups besides $r_{1},\ldots r_{p}$.) The total contribution of the $l$ units of water to the potential can be at most

[TABLE]

The amount of water removed in substep (2) is at most $p\cdot(1-\varepsilon)-l=p-(l+\varepsilon p)$. Thus at least $l+\varepsilon p$ further units of water are removed during substep (3). The removal of water that occurs in substep (3) decreases the potential by at least

[TABLE]

Thus the potential $\phi(i)$ at the end of step $i$ satisfies $\phi(i)\leq\phi(i-1)$.

Case 2: At no point during step $i$ do $p$ or more cups contain one or more units of water. Call the cups that contain more than one unit of water at the end of the step the heavy hitters. Taking a very loose bound, any water placed in non-heavy hitters during step $i$ can increase the potential by at most $2\cdot n$ in total. On the other hand, any water that is placed in a heavy hitter during step $i$ is then immediately removed by the emptier. Additionally, the emptier removes from each heavy hitter at least $\delta$ units of water that were present at the beginning of the step. If the fullest heavy hitter has fill $t$ at the beginning of the step, then this removal will reduce the potential by at least

[TABLE]

Recall that $\delta\geq\frac{1}{\mbox{poly}(n)}$. Thus if $t$ is sufficiently large in $\Omega(\log_{1+\varepsilon}n)$, then it follows that the $\delta$-unit removal of water will decrease the potential by at least $2n$. This forces the net change in potential $\phi(i)-\phi(i-1)$ in step $i$ to be negative.

If, on the other hand, $t\leq O(\log_{1+\varepsilon}n)$, then the total potential $\phi(i)$ at the end of step $i$ can be at most

[TABLE]

In both Case (1) and Case (2), at the end of each step $i$, the total potential is either bounded by $\mbox{poly}(n)$, or satisfies $\phi(i)\leq\phi(i-1)$. It follows that the potential $\phi(i)$ is always bounded by $\mbox{poly}(n)$, completing the proof. ∎

6 A Randomized Algorithm for the Multi-Processor Cup Game with Constant Backlog

In this section, we present the first evidence that the emptier in the multi-processor cup game is actually more powerful than the filler in the single-processor cup game. In particular, we design a randomized algorithm for the emptier which allows for them to guarantee with large probability (in $p$) at any given step that the backlog does not exceed $O(1)$. The techniques we introduce here will also play a critical role in Section 7 where we we extend the algorithm to provide probabilistic guarantees against any backlog $k$.

Throughout the section we use the renormalized multi-processor cup game, in which at each step the filler distributes $(1-\varepsilon)$ units of water among cups, placing no more than one unit in any cup; and the emptier then removes up to $(1+2\delta)$ units of water from each of up to $p+1$ cups. The goal of the section is to prove the following theorem:

Theorem 3**.**

Suppose $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$. Then there exists an algorithm for the (renormalized) multi-processor cup game that guarantees after any given step $i$ that with probability at least $1-O\left(e^{-\Omega(\varepsilon^{2}p)}\right)$ the backlog does not exceed $3$.

The design and analysis of the algorithm for Theorem 3 are somewhat more complex than in the single-processor case, and the analysis, in particular, invokes a concentration inequality for Doob martingales. We begin with an algorithm for a simpler version of the problem.

A Warmup: Games of Bounded Length We begin by proving Theorem 3 for the special case where the game terminates after $m$ steps for some $m\leq e^{\varepsilon^{2}p/12}$. The algorithm for this case is particularly simple, and motivates the algorithm for the general case. (Moreover, note that the algorithm in this case works even for $\delta=0$.)

At the start of the game, the emptier selects random starting states $r_{1},\ldots,r_{n}\in(0,1]$, and places $r_{j}$ water in each cup $j$. After each step, the emptier removes one unit of water from every cup containing one or more units, unless there are more than $p+1$ such cups, in which case the emptier selects $p+1$ of them arbitrarily.

Suppose that at the beginning of some step $i$, no cups have one or more units of water. Let $c_{j}(i)$ denote the amount of water which the filler places in each cup $j$. By the same reasoning as in the single-processor case, each cup will independently cross an integer threshold with probability $c_{j}(i)$. Consequently, the total number $T$ of cups that cross a threshold to contain one or more units of water will be a sum of indicator random variables with total mean at most $(1-\varepsilon)p$. By a Chernoff bound (applied to $\varepsilon<1/2$),

[TABLE]

Moreover, as long as $T\leq p+1$, then step $i$ will end with no cups having one or more units of water. Applying a union bound over the $m$ steps, the probability that there is any step $i$ after which some cup contains one or more units of water is at most

[TABLE]

Thus we have the following version of Theorem 3:

Theorem 4**.**

Suppose $\varepsilon\leq 1/2$, and suppose that the multi-processor cup game is played for $m\leq e^{\varepsilon^{2}p/12}$ steps. Then there exists an algorithm which guarantees with probability $1-e^{-\Omega(\varepsilon^{2}p)}$ that the backlog never exceeds $1$ at the end of any step.

Remark 1**.**

One can also consider the case where $\varepsilon>1/2$. Applying the same argument, except with the appropriately modified Chernoff bounds, the probability $\Pr[T>p]$ becomes bounded by $e^{-(1-\varepsilon)p/3}$. By a union bound, the probability that the backlog ever exceeds $1$ at the end of any of the first $m$ steps, becomes at most $e^{-(1-\varepsilon)p/3}/m$. Thus one can use larger $\varepsilon$ values in order to achieve better constants in the exponent of the probability bound, which may be useful for some applications where $p$ is small. Although we do not do it out explicitly, the use of larger values of $\varepsilon$ has the same effect on Theorem 3.

**Generalizing to Games of Unbounded Length ** The algorithm for the bounded-length case can be reframed as follows. For each cup $j$, a random value $s_{j}$ is selected (equal to $1-r_{j}$ in the original version of the algorithm). Additionally, the emptier maintains a counter $w_{j}$ for each cup. Whenever the total amount of water ever poured into a cup $j$ crosses a threshold of the form $k+s_{j}$ for some $k\in\mathbb{N}$, the counter $w_{j}$ is incremented. The emptier’s algorithm at each step is then to simply select (up to) $p+1$ cups with non-zero counters, to remove (up to) one unit of water from each of those cups, and then to decrement each of the corresponding counters.

If the filler never manages to cross thresholds in more than $p+1$ cups in any step, then all of the counters will be maintained at zero at the end of each step, and no cup will contain more than one unit of water. This is what happens in the bounded-length case. In the unbounded-length case, we must handle the fact that the filler may sometimes manage to make a large number of cups cross thresholds at the same time. Handling this requires not only a more sophisticated analysis, but also a noteworthy change to the algorithm design. In particular, the random value $s_{j}$ associated with cup $j$ changes over time, that way the filler cannot correctly guess $s_{j}$ at one point in time and then use it in order to make cup $j$ misbehave indefinitely by crossing thresholds at inconvenient times for the emptier. The generalized algorithm is presented next.

**The Algorithm ** We assume without loss of generality that $\frac{1}{\delta}$ is a natural number. Set the threshold $r_{j}(0)$ to be null in each cup $j$ (i.e., non-existent). Then for every $i\in\mathbb{N}$ such that $i\equiv 1\mod 1/\delta+1$, and for every cup $j$, set the threshold $r_{j}(i)$ to be null (i.e., non-existent), then select a random value $s_{j}(i)\in(0,1]$, and set the thresholds $r_{j}(i+1)=(i+1)+s_{j}(i),\ldots,r_{j}(i+1/\delta)=(i+1/\delta)+s_{j}(i)$. Let $a_{j}(i)$ denote the total amount of water poured into cup $j$ during the first $i$ steps. We say that cup $j$ crosses a threshold at step $i$ whenever there is some $r_{j}(t)$ such that $a_{j}(i-1)<r_{j}(t)\leq a_{j}(i)$.

Our definition of the thresholds $r_{j}(i)$ has three important properties: The first is that within a given cup, each threshold $r_{j}(i)$ is dependent on at most $1/\delta$ other thresholds $r_{j}(i^{\prime})$. This independence between far-apart thresholds will be important in the analysis when we wish to prove concentration bounds concerning threshold crossings. The second property is that no two thresholds $r_{j}(i)$ and $r_{j}(i^{\prime})$ are ever within less than one of each other. Consequently, no cup can ever cross more than a single threshold in a given step. The third property is that the threshold $r_{j}(i)$ is only null for one in every roughly $1/\delta$ values of $i$. This will ensure that as long as $1+\delta$ units of water are removed from a cup each time a threshold is crossed, then the cup will be kept at a steady state of containing only a constant fill after each step.

For every cup $j$, the algorithm maintains a threshold counter $w_{j}$, initially set to zero, which is incremented by $1+\delta$ every time the cup crosses a threshold. The counter is reduced by the emptier (but never below [math]) as follows: whenever the emptier empties from a cup $j$, they remove $t=\min(1+2\delta,w_{j})$ units of water from the cup and reset $w_{j}=w_{j}-t$.

We will show that the spacing of thresholds ensures the total quantity the filler has ever added to $w_{j}$ is at most the total amount of water that has been poured into cup $j$; since the emptier removes from $w_{j}$ the same amount as they remove water from the cup, it follows that there is always at least $w_{j}$ water in each cup. This means that the emptier’s strategy of removing $\min(1+2\delta,w_{j})$ units of water is well defined.

Using the threshold counters, the algorithm through which the emptier selects cups is simple. At each step the emptier may select an arbitrary set of $p+1$ cups to empty from, as long as priority is given to cups $j$ satisfying $w_{j}\geq 1+\delta$ (over all other cups) and to cups satisfying $w_{j}\neq 0$ (over cups satisfying $w_{j}=0$). The emptier then removes $\min(w+2\delta,w_{j})$ water from each of the selected cups $j$, and updates the threshold counters appropriately.

**Algorithm Analysis **We begin by showing that each of the counters $w_{j}$ closely tracks the backlog in the corresponding cup $j$. As a convention, we will often use $w_{j}(i)$ as a shorthand to denote the value of the counter $w_{j}$ after step $i$.

Lemma 4**.**

The amount of water $f_{j}(i)$ contained in cup $j$ after step $i$ satisfies $w_{j}(i)\leq f_{j}(i)\leq w_{j}(i)+3$.

Proof.

Let $l$ be the number of thresholds crossed in cup $j$ during the first $i$ steps. Let $b$ be the net amount of water removed by the emptier during those steps. Then $w_{j}(i)=l\cdot(1+\delta)-b$. It therefore suffices to compare $l\cdot(1+\delta)$ to the total amount of water $k$ poured into $w_{j}$ in the first $i$ steps. Namely, we wish to show that $l\cdot(1+\delta)\leq k\leq l\cdot(1+\delta)+3$.

The total amount of water poured into cup $j$ can be broken into the sum of three quantities $k=k_{0}+k_{1}+k_{2}$, where $k_{0}=1$, $k_{1}$ is some multiple of $\frac{1}{\delta}+1$, and $k_{2}<\frac{1}{\delta}+1$.333Note that the case in which less than one unit of water has been placed in cup $j$ is trivially handled on its own. Once $k_{0}+k_{1}$ units of water has been poured into the cups the number $l_{1}$ of thresholds crossed will exactly satisfy

[TABLE]

When $k_{2}$ additional units are added, the number $l_{2}$ of additional thresholds crossed will satisfy $k_{2}-2\leq l_{2}\leq k_{2}$. Since $l_{2}\cdot(1+\delta)\leq l_{2}+1$, it follows that

[TABLE]

Combining Eq. 8 and Eq. 9, we get that

[TABLE]

which in turn implies that $k-3\leq l\cdot(1+\delta)\leq k$. This rearranges to $l\cdot(1+\delta)\leq k\leq l\cdot(1+\delta)+3$, as desired. ∎

Lemma 4 tells us that, in order to bound the backlog by $3$ after step $i$, it suffices to demonstrate that $\sum_{j}w_{j}(i)=0$. Next we turn to the task of proving concentration bounds on $\sum_{j}w_{j}$. If $k$ thresholds are crossed by water poured during a given step $i$, we define the random variable $T_{i}=k-\min(k,p)$ to be the number of surplus thresholds crossed during the step. A key insight is that for any $t\geq 0$, we can express $\Pr[\sum_{j}w_{j}(i)>t]$ as a statement about sums of $T_{i}$’s. Namely, we can show that if $\sum_{j}w_{j}(i)$ is large, then there must be some $l$ such that the number of surplus thresholds crossed in the $l$ steps leading up to step $i$ was also large.

Lemma 5**.**

Call a positive integer $l$ a height-$t$ backlog witness for step $i$ if $2\sum_{m=i-l+1}^{i}T_{m}\geq\delta l+t.$ For any $t\geq 0$ and any step $i$, if $\sum_{j}w_{j}(i)>t$, then there exists a height-$t$ backlog witness for step $i$.

Proof.

Suppose $\sum_{j}w_{j}(i)>t$, and define $l>0$ to be the smallest $l\geq 0$ such that $\sum_{j}w_{j}(i-l)=0$. (Note that such an $l$ exists since $l=i$ will always work.)

We claim that during each step $m\in\{i-l+1,\ldots,i\}$, if $k$ is the number of thresholds crossed, then the emptier reduces the counters by at least

[TABLE]

In particular, during the step $m$, $k$ counters will be incremented by $1+\delta$. It follows that the emptier will be able to successfully be able to reduce at least $\min(k,p+1)$ counters by at least $1+\delta$ each.

If $k\geq p+1$, then the total reduction in the counters will therefore be at least

[TABLE]

If, on the other hand, $k\leq p$, then the emptier will have been able to successfully reduce $k$ counters by at least $1+\delta$ each. If this is the full extent to which the emptier is able to reduce the counters (i.e., the emptier reduces $\sum_{j}w_{j}$ by exactly $(1+\delta)k$ in this step), then all $k$ of the reduced counters must have had values $w_{j}$ exactly equal $1+\delta$ prior to the reduction, and all other counters $w_{j}$ must have already been zero. This cannot occur, however, since we know that $\sum_{j}w_{j}(m)$ is positive at the end of step $m$ (due to the fact that $m$ comes after step $i-l$). Thus we may conclude that during step $m$ the emptier reduces the $\sum w_{j}$ by more than $k\cdot(1+\delta)$. As an invariant, every counter always remains a multiple of $\delta$, meaning that the emptier must actually reduce $\sum_{j}w_{j}$ by at least $k\cdot(1+\delta)+\delta$.

We have seen that during step $m$, regardless of whether $k>p$ or $k\leq p$, the emptier reduces the counters by at least

[TABLE]

On the other hand, the filler increased the counters by

[TABLE]

Thus the net increase in $\sum_{j}w_{j}$ during step $m$ is at most

[TABLE]

Over the course of the $l$ steps $i-l+1,\ldots,i$, the sum $\sum_{j}w_{j}$ must increase in total by more than $t$. It follows that

[TABLE]

Hence

[TABLE]

which establishes that $l$ is a height-$t$ backlog witness. ∎

By Lemma 5, if we wish to bound $\Pr[\sum_{j}w_{j}>0]$ at a step $i$, then it suffices to instead bound the probability that there exists a height-0 backlog witness (which, for brevity, we will often refer to simply as a backlog witness). In order to do this, we begin by bounding the probability that $T_{k}>0$ for any given $k$.

Lemma 6**.**

For a given $k$, $\Pr[T_{k}>0]\leq e^{-\varepsilon^{2}p/6}$.

Proof.

For each cup $j$, if $c_{j}(k)$ units of water are poured into the cup during step $k$, then the probability of crossing a threshold in that cup is at most $c_{j}(k)$, depending on the value of the appropriate threshold. Since thresholds are independent between cups, the number of thresholds crossed in step $k$ is a sum of independent indicator variables with total mean at most $(1-\varepsilon)p$. By a Chernoff bound, the probability that $m$ or more thresholds are crossed is therefore at most

[TABLE]

where the final inequality uses that $\varepsilon\leq 1/2$. ∎

It will also be useful to have a bound for $\mathbb{E}[T_{k}]$.

Lemma 7**.**

$\mathbb{E}[T_{k}]\leq O(p\cdot e^{-\varepsilon^{2}p/6})$.

Proof.

Recalling that the number of thresholds crossed in step $k$ is a sum of independent indicator variables with total mean at most $(1-\varepsilon)p$,

[TABLE]

∎

Now we return to our task of bounding the probability of there existing a backlog witness $l>0$. Define $M=e^{\varepsilon^{2}p/12}$. By Lemma 6 and the union bound, with probability at least $1-1/M$ we have $T_{i},T_{i-1},\ldots,T_{i-M+1}=0$, and thus that $1,2,\ldots,M$ are not backlog witnesses.

Next we consider the probability that $l$ is a backlog witness for $l>M$. Unfortunately, $T_{i}+T_{i-1}+\cdots+T_{i-l+1}$ cannot easily be expressed as a sum of independent random variables. In particular, because each $T_{i}$ can only be made to be greater than zero by a combination of events in multiple cups, one cannot perform a per-cup analysis in the same way as for the single-processor case.

Instead, we will employ a more sophisticated analysis in order to prove the following proposition:

Proposition 1**.**

Suppose $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$. For any $l>0$, and any step $i$, the probability that $l$ is a height-$t$ backlog witness for step $i$ is at most

[TABLE]

Before presenting a proof of Proposition 1, we first use the proposition in order to complete the proof of Theorem 3.

Proof of Theorem 3.

By Lemma 4, it suffices to examine the probability that $\sum_{j}w_{j}(i)=0$. This is guaranteed to occur whenever there are no backlog witnesses $l\geq 1$ for step $i$.

We have already shown that the probability of any $l\leq M$ being a backlog witness is at most $1/M$. Now consider some $l\geq M$. By Proposition 1 the probability of $l$ being a backlog witness is at most

[TABLE]

Using the fact that $\delta$ is sufficiently large in $\Omega\left(e^{-O(\varepsilon^{2}p)}\right)$, we may assume that $\delta\geq e^{p^{1/3}/120}$. Using the fact that $l\geq M\geq e^{p^{1/3}/12}\geq\Omega(p^{10})$, and that $l\geq M\geq 1/\delta^{10}$, it follows that the probability of $l$ being a backlog witness is at most

[TABLE]

By the union bound, the probability of there being any any $l\geq M$ that is a backlog witness is at most

[TABLE]

Recall that with probability at least $1-1/M$, no value of $l\leq M$ is a backlog witness. It follows that with probability $1-O(1/M)$ there are no backlog witness values of $l$. Since $M=e^{\varepsilon^{2}p/12}$, this completes the proof. ∎

The remainder of the section is devoted to proving Proposition 1.

6.1 Proof of Proposition 1

An essential ingredient to the proof will be the use of McDiarmid’s Inequality.

Theorem 5** (McDiarmid’s Inequality [29]).**

Let $X_{1},\ldots,X_{m}$ be independent random variables over an arbitrary probability space. Let $F$ be a function mapping $X_{1},\ldots,X_{m}$ to $\mathbb{R}$, and suppose $F$ satisfies,

[TABLE]

for all $1\leq i\leq n$. That is, if $X_{1},X_{2},\ldots,X_{i-1},X_{i+1},\ldots,X_{n}$ are fixed, then the value of $X_{i}$ can affect the value of $F(X_{1},\ldots,X_{n})$ by at most $c$. Then for all $R>0$,

[TABLE]

and

[TABLE]

McDiarmid’s inequality can be viewed as a special case of Azuma’s inequality applied a Doob martingale [2]. In particular, one can obtain McDiarmid’s inequality by applying Azuma’s inequality to the martingale $(B_{0},\ldots,B_{n})$ with $B_{i}=\mathbb{E}[F(X_{1},\ldots,X_{n})\mid X_{1},\ldots,X_{i}]$. We will be using McDiarmid’s inequality directly, without explicitly constructing the corresponding martingale.

In our application of McDiarmid’s inequality, we will partition the values $s_{j}(k)$ (i.e., the random values used in our algorithm) into a partition $Q_{1},\ldots,Q_{pl+1}$. Roughly speaking, each random variable $X_{t}$ will represent the values of all the $s_{j}(k)$’s in the component $Q_{t}$ of the partition. The key technical difficulty is to design the partition $Q_{1},\ldots,Q_{pl+1}$ so that the condition for McDiarmid’s inequality is met, thereby allowing us to obtain a concentration inequality on the value of $T_{i}+T_{i-1}+\cdots+T_{i-l+1}$.

For a cup $j$, and a non-negative $k$ satisfying $k\equiv 1\mod 1/\delta+1$, define the threshold collection $(j,k)$ to be the set of thresholds $r_{j}(k+1),\ldots,r_{j}(k+1/\delta)$. In particular, these are the thresholds whose values are determined by $s_{j}(k)$. We say that step $t$ is hit by threshold collection $(j,k)$ if during step $t$, the total amount of water ever poured into cup $j$ crosses one of the thresholds in the collection $(j,k)$ (i.e., one of $r_{j}(k+1),\ldots,r_{j}(k+1/\varepsilon)$). For each step $t$, the number of thresholds crossed during that step is equal to the number of threshold collections $(j,k)$ which hit step $t$. (In particular, the step cannot cross more than one threshold in a single cup, and thus cannot cross more than two thresholds from the same collection.)

Let $a_{j}(i)$ denote the total amount of water poured into cup $j$ in the first $i$ steps. We say that a threshold collection $(j,k)$ has hitting capacity $s$ if $\min(a_{i},k+1/\delta+1)-\max(a_{i-l+1},k+1)=s$. In other words, during steps $i-l+1,\ldots,i$, a total of $s$ units of the poured water have the possibility of crossing one of the thresholds in the collection $(j,k)$. Notably, the sum of the hitting capacities of all threshold collections is at most $(1-\varepsilon)pl$, upper bounded by the total amount of water poured during the steps. Moreover, if a threshold collection $(j,k)$ has hitting capacity $s<1$, then at most one of the steps can be hit by the collection $(j,k)$, and the probability of any step being hit by the collection $(j,k)$ is $s$ (with the outcome depending on $s_{j}(k)$).

Using this notion of hitting capacity, we now define a partition $Q_{1},\ldots,Q_{pl+1}$ of all threshold collections $(j,k)$. If a threshold collection $(j,k)$ has hitting capacity $s\geq 1$, then we assign it to its own component of the partition. These components of the partition are called single-threshold components. The threshold collections $(j,k)$ with hitting capacity less than one are placed in components such that the sum of the hitting capacities within any component is between 1 and 2 (although one of the components may have hitting capacity less than one as an edge case). These components of the partition are called the multi-threshold components. Note that the resulting partition has at most $pl+1$ components since the sum of the hitting capacities in each component is at least $1$, with the exception of at most one component. Moreover, we may assume that the partition has exactly $pl+1$ components by adding empty components as necessary.

Define the random variables $X_{1},\ldots,X_{pl+1}$ so that $X_{t}$ is the set of pairs $((j,k),r)$ of threshold collections $(j,k)\in Q_{t}$ and steps $r\in\{i-l+1,\ldots,i\}$ such that step $r$ is hit by threshold collection $(j,k)$. Notice that the $X_{t}$’s are independent of one-another, since they depend on disjoint sets of threshold collections. Moreover, if $T$ is the sum of $T_{i}+T_{i-1}+\cdots+T_{i-l+1}$, then $T$ can be expressed as a deterministic function of the $X_{t}$’s, with

[TABLE]

Additionally, for a given value $A$ of $X_{t}$,

[TABLE]

since adding any element $((j,k),m)$ to $X_{t}$ can affect at most one of $T_{i},T_{i-1},\ldots,T_{i-l+1}$. Namely, it can only affect $T_{m}$, and will either increase $T_{m}$ by one, or not affect $T_{m}$ at all.

If each $|X_{t}|$ were guaranteed to be small, then Eq. 11 would allow us to apply McDiarmid’s inequality to $F(X_{1},\ldots,X_{pl+1})$. As a step in this direction, the following lemma gives a probabilistic bound on $|X_{t}|$.

Lemma 8**.**

For any component $Q_{t}$ and any $r\geq 0$, with high probability in $r$,

[TABLE]

Proof.

For single-threshold components $Q_{t}$, we are guaranteed that $|X_{t}|\leq 1/\delta$, since a single threshold collection can hit at most $1/\delta$ steps.

Now suppose $Q_{t}$ is a multi-threshold component. For each threshold collection $(j,k)\in Q_{t}$, let $Y_{j,k}$ be the random variable counting the number of steps in $\{i-r+1,\ldots,i\}$ that $(j,k)$ hits. Recall that because $Q_{t}$ is a multi-threshold component, the threshold collection $(j,k)$ must have some hitting capacity $s<1$, and will thus either hit exactly one of the steps with probability $s$, or will hit none of the steps with probability $(1-s)$ (with the outcome depending on the value of the random variable $s_{j}(k)$). Thus each $Y_{j,k}$ is an indicator variable which takes value $1$ with probability equal to the hitting capacity of $(j,k)$. Moreover, the random variables $Y_{j,k}$ are independent, since the random variables $s_{j}(k)$ are independent. Thus the size of $X_{t}$ can be expressed as the sum

[TABLE]

of independent indicator variables. Moreover, $\mathbb{E}[X_{t}]$ will be the sum of the hitting capacities of the threshold collections $(j,k)\in Q_{t}$, which is at most $2$. In order to apply a Chernoff bound to the summation Eq. 12, we must also note that there are only finitely many $(j,k)$ with hitting capacity $s>0$, so Eq. 12 can be regarded as a finite sum. Applying a Chernoff bound, we see that for any $c>1$,

[TABLE]

completing the proof. ∎

Let $r$ be a quantity that we will determine a value for later. Define random variables $X_{1}^{\prime},\ldots,X_{p+1}^{\prime}$ such that each $X_{t}^{\prime}$ is selected independently from the same distribution as $X_{t}$, except restricted to the case where $|X_{t}|\leq c(\log r+1/\delta)$, for some sufficiently large constant $c$. In particular, we select $c$ to be sufficiently large so that Lemma 8 guarantees that each $X_{t}$ satisfies $|X_{t}|\leq c(\log r+1/\delta)$ with probability at least $1-1/r$.

Consider the random variable

[TABLE]

By Eq. 11, we may apply McDiarmid’s inequality to get

[TABLE]

Recall that each $X_{t}$ satisfies $|X_{t}|\leq c(\log r+1/\delta)$ with probability at least $1-1/r$. Since there are $pl+1$ such $X_{t}$, it follows by the union bound that with probability at least $1-O(pl/r)$, $|X_{t}|\leq c(\log r+\delta^{-1})$ for all $t$. If we define the random variable $B=T_{i-l+1}+\cdots+T_{i}=F(X_{1},\ldots,X_{pl+1})$, then it follows from Eq. 13 that

[TABLE]

Plugging in $\ln r=\left(\frac{\delta^{2}R^{2}}{lp}\right)^{1/3}$, it follows that

[TABLE]

Note that Eq. 14 is only useful when $pl/r$ is small. When this is the case, we can bound $\mathbb{E}[A]$ to be no more than $\delta r/8$, thereby turning Eq. 14 into a statement about $B$ only.

Lemma 9**.**

Suppose that $pl/r<1/2$. Then,

[TABLE]

Proof.

Defining $B$ as above, we begin by considering $\mathbb{E}[B]=\mathbb{E}[T_{i}+T_{i-1}+\cdots+T_{i-l+1}]$. By Lemma 7, and by linearity of expectation,

[TABLE]

Since $\varepsilon\leq p^{-1/3}$, this is $l\cdot O(e^{-\Omega(\varepsilon^{2}p)})$. Using the fact that $\delta$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$, it follows that

[TABLE]

On the other hand, $\mathbb{E}[B]=\mathbb{E}[F(X_{1},\ldots,X_{pl+1})]$ can also be expressed as,

[TABLE]

where the final step uses that $pl/r\leq 1/2$. Applying Eq. 15, it follows that $\mathbb{E}[A]\geq\delta l/8,$ as desired.

∎

Applying Lemma 9 to Eq. 14, we get that when $pl/r<1/2$,

[TABLE]

On the other hand, when $pl/r=pl\cdot\exp\left(-\left(\frac{\delta^{2}R^{2}}{lp}\right)^{1/3}\right)\geq 1/2$, Eq. 16 is trivially true since the left side is upper-bounded by $1$. Thus the equation holds for any value of $pl/r$.

Recall that $l$ is a height-$t$ backlog witness for step $i$ if $2B=2\sum_{m=i-l+1}^{i}T_{m}\geq\delta l+t$. Thus, the probability that $l$ is a height-$t$ backlog witness for step $i$ is at most

[TABLE]

This completes the proof of Proposition 1.

Remark 1**.**

In later sections it will be useful note that we have proven a statement slightly stronger than Proposition 1. Namely, that

[TABLE]

7 Bounds for Non-Constant Backlogs

Recall that the algorithm given in Section 6 allows for the emptier to select cups in an arbitrary fashion, as long as preference is given to cups $j$ satisfying $w_{j}\geq 1+\delta$ (over all other cups) and to cups satisfying $w_{j}\neq 0$ (over cups satisfying $w_{j}=0$). If within each priority level, the emptier always selects the fullest cups possible to empty out of, then we call the resulting algorithm the multi-processor smoothed greedy algorithm.

In this section, we prove a probabilistic upper bound for the backlog using multi-processor smoothed greedy algorithm. In Section 8, we will see that when $\varepsilon$ is constant, our bound is tight.

As in Section 6, we continue to use the renormalized multi-processor cup game. The goal of the section is to prove the following theorem:

Theorem 6**.**

Suppose that $1/2\geq\varepsilon\geq p^{-1/3}$, $\delta\geq\frac{1}{\mbox{poly}(p)}$, and that $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$. Consider the multi-processor smoothed greedy algorithm on $n$ cups for the (renormalized) multi-processor cup game. Then for any value $k\geq\log p$ and for any step $i$, the backlog is $O(k/\varepsilon)$ after step $i$ with probability at least

[TABLE]

Remark 2**.**

Although Theorem 6 does not explicitly consider values of $k<\log p$, these values are already implicitly covered by Theorem 3. Indeed, assuming $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $e^{-O(\varepsilon^{2}p)}$, Theorem 3 bounds the probability of superconstant backlog by

[TABLE]

The proof of Theorem 6 considers a dynamic version of the multi-processor cup game being played on the cups containing $4+\delta$ or more units of water. Since each such cup $j$ must have a nonzero counter $w_{j}(i)$, the number of cups involved in the game at the end of a step $i$ is upper bounded by $\sum_{j}w_{j}(i)$. Building on the results from Section 6, we obtain a concentration inequality on the sum $\sum_{j}w_{j}(i)$, which then allows us to complete the proof of Theorem 6.

In Subsection 7.1 we present and analyze the dynamic multi-processor cup game. Then in Subsection 7.2 we combine this with techniques from Section 6 in order to prove Theorem 6.

7.1 The Dynamic Multi-Processor Cup Game

We define the dynamic multi-processor cup game as follows. As in the (non-renormalized) multi-processor cup game, at each step the filler is allowed to distribute up to $(1-\varepsilon)p$ units of water among the cups, placing up to $1-\delta$ units in any individual cup; the emptier is then allowed to remove up to one unit of water from up to $p$ distinct cups. In the dynamic version of the game, we have the additional caveat that the number of cups changes dynamically: at the beginning of any turn the filler may introduce arbitrarily many new cups (into which they must pour a non-zero amount of water); and at the end of each turn, any empty cups are removed. Theorem 7 provides a bound for the maximum backlog in terms of the number of active cups during any given step.

Note that for convenience, we are considering in this subsection the non-renormalized multi-processor cup game. When applying Theorem 7, we will therefore have to perform the (simple) task of transferring between the variants on parameters.

Theorem 7**.**

Consider an instance of the dynamic multi-processor cup game. Let $r$ be a sufficiently large constant. Let $n_{i}$ be the number of cups at the end of step $i$, or $p^{r}$ if the number of cups is less than $p^{r}$. Suppose that $0<\varepsilon<1$ and that $\delta$ is sufficiently large in $\Omega(\varepsilon/p^{r-1})$.

Then at the end of each step $i$, the greedy algorithm will achieve maximum backlog $O(\frac{1}{\varepsilon}\log n_{i})$.

Proof.

Define $f_{i}(j)$ to the fill in cup $j$ after step $i$, and define the potential function,

[TABLE]

We will prove that $\phi(i)\leq n_{i}^{2}$ for all $i$. This, in turn, bounds each $f_{i}(j)$ to be at most $O(\log_{1+\varepsilon}\mbox{poly}(n_{i}))\leq O(\frac{1}{\varepsilon}\log n_{i})$.

Assume by induction that $\phi(i-1)\leq n_{i-1}^{2}$ for the $i-1$-th step (note that the base case of $i=1$ is immediate). We will use this to prove that $\phi(i)\leq n_{i}^{2}$.

For a given step $i$, we consider two cases separately:

**Case 1: The emptier removes a full unit of water from each of $p$ cups during step $i$. ** In this case, the number of cups $n_{i}$ at the end of step $i$ satisfies $n_{i}\geq n_{i-1}$. Thus it suffices to show that $\phi(i)\leq\phi(i-1)$. This follows from Case 1 of the proof of Theorem 2.

Case 2: At no point during step $i$ do $p$ or more cups contain one or more units of water. Call the cups that contain more than one unit of water at the end of the step the heavy hitters. Any water placed in non-heavy hitters during step $i$ can increase their contribution to the potential, which is initially at most $O(n_{i})$, by at most $O(p)$. On the other hand, any water placed in heavy hitters is then immediately removed by the emptier. Additionally, the emptier removes from each heavy hitter at least $\delta$ units of water that were present at the beginning of the step.

Since

[TABLE]

this removal of $\delta$ units from each heavy hitter will reduce the contribution to $\phi(i)$ of each of the heavy hitters by a multiplicative factor of $1-\Omega(\varepsilon\delta)$.

Thus there is some $M\in\Omega(\varepsilon\delta)$ such that

[TABLE]

where the second term is to account for the fact that the contributions to $\phi(i)$ by non-heavy hitters are not necessarily decreased by the multiplicative factor of $1-M$, and the third term accounts for water added to non-heavy hitters during step $i$.

Note that $n_{i}\geq n_{i-1}-p$. If we recall the inductive hypothesis that $\phi(i-1)\leq n_{i-1}^{2}$, then

[TABLE]

Since $n_{i}\geq p^{r}$, it follows that

[TABLE]

Now using the assumption that $\delta$ is sufficiently large in $\Omega(\varepsilon^{-1}/p^{r-1})$ and that $M=\Omega(\varepsilon\delta)$, we get that $(1+4/p^{r-1})\cdot(1-M)\leq(1-M/2)$. Thus

[TABLE]

Using the fact that $n_{i}\geq p^{r}$ is sufficiently large in $\Omega(1)$, this gives

[TABLE]

Since $n_{i}\geq p^{r}$, the fact that $\delta$ is sufficiently large in $\Omega(\varepsilon^{-1}/p^{r-1})$ then implies that

[TABLE]

completing the proof. ∎

7.2 Proof of Theorem 6

Define $K=e^{k}$. We claim that, after a given step $i$, if $\sum_{j}w_{j}\leq\mbox{poly}(K)$, then the backlog is at most $O(k)$. In particular, consider at each step only the cups containing $4+\delta$ or more units of water. By Lemma 4, each such cup $j$ has counter $w_{j}\geq 1+\delta$, meaning that the multi-processor smoothed greedy algorithm will always empty out of the fullest of the cups containing $4+\delta$ or more units of water. If we consider just these cups, and subtract out $4+\delta$ from each of their fills, then we are playing a dynamic multi-processor cup game, and using the multi-processor smoothed greedy algorithm. By Theorem 7, if there are $r$ cups containing $4+\delta$ or more units of water, then the backlog is at most

[TABLE]

(Note that we are actually applying the theorem to $\varepsilon^{\prime}\geq\varepsilon$, $\delta^{\prime}=\frac{2\delta}{1+2\delta}=\Theta(\delta)$ and to $p^{\prime}=p+1$; moreover, the theorem requires that $\delta^{\prime}\geq\varepsilon^{-1}/\mbox{poly}(p^{\prime})$, which is true here because $\varepsilon\geq p^{-1/3}$ and $\delta\geq 1/\mbox{poly}(p)$ by assumption.) Since $\ln K=k\geq\log p$, it follows that if there are $\mbox{poly}(K)$ cups in the dynamic game, then the backlog is at most $O(\frac{1}{\varepsilon}\log K)=O\left(\frac{1}{\varepsilon}k\right)$. This, in turn, implies that if $\sum_{j}w_{j}(i)\leq\mbox{poly}(K)$, then the backlog is at most $O(\frac{1}{\varepsilon}k)$.

To complete the proof, it suffices to show that $\Pr[\sum_{j}w_{j}(i)>K^{c}]\leq O\left(e^{-e^{k}}\right)$ for some sufficiently large constant $c$. By Lemma 5, the probability that $\sum_{j}w_{j}(i)\geq K^{c}$ is at most the probability that there exists a height-$K^{c}$ backlog witness for the step $i$. The following lemma, which we will prove shortly, can be used to bound the probability of such a witness existing.

Lemma 10**.**

Suppose $1/2\geq\varepsilon\geq p^{-1/3}$ and $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$. Consider $t\geq\frac{\sqrt{p}}{\delta}$. Then the probability that any $l>0$ is a height-$t^{4}$ backlog witness for step $i$ is at most

[TABLE]

By Lemma 10, for $c$ a large enough constant, the probability that a height-$K^{c}$ backlog witness exists is at most $O(e^{-K})=O(e^{-e^{k}})$, as desired. (Note that Lemma 10 requires that $t=K^{c/4}$ satisfies $t\geq\sqrt{p}/\delta$; since $K=e^{k}\geq p$ and $\delta\geq\frac{1}{\mbox{poly}(p)}$, this will be true for $c$ a sufficiently large constant.)

In order to complete the proof of Theorem 6, it therefore suffices to prove Lemma 10.

Proof of Lemma 10.

By the union bound and Proposition 1, the probability that any $0<l\leq t^{3}$ is a height-$t^{4}$ backlog witness for step $i$ is at most

[TABLE]

where the last step uses the fact hat $pl\leq pt^{3}\leq t^{5}$.

The probability that any $l\geq t^{t}$ is a height-$t^{4}$ backlog witness for step $i$ is at most

[TABLE]

Combining the two probabilities, the probability of any height-$t^{4}$ backlog witness existing is at most $O\left(e^{-\Omega(t^{1/3})}\right)$. ∎

8 Lower Bounds

In this section we discuss strategies that the filler can follow in order to maximize backlog, regardless of the algorithm followed by the emptier. When $\varepsilon$ is a positive constant, the resulting bounds establish that the algorithms for the emptier given in the preceding sections are essentially optimal, at least up to constant-factor changes in the backlog and in $p$.

Consider a cup-emptying game on $n$ cups in which at each step, the filler is allowed to distribute $p/2$ units of water among the cups, and then the emptier is allowed to select $p$ cups and remove all of the water from each of them. We call this the universal emptying game on $p$ processors and $n$ cups. Lower bounds for universal emptying game easily port to lower bounds for single-processor cup game and multi-processor cup game (played with arbitrary $\varepsilon$ for the single-processor variant, and with arbitrary $\varepsilon\leq 1/2$ and $\delta$ for the multi-processor variant).

We begin with a lower bound for the universal emptying game in the case where the filler is an adaptive adversary.

Theorem 8**.**

Consider the universal emptying game on $p$ processors and $n$ cups, where $n$ is a multiple of $p$. There is an adaptive strategy for the filler that accomplishes a backlog of $\Theta\left(\log\frac{n}{p}\right)$ after step $\frac{n}{p}-1$.

Proof.

The strategy that the filler follows is a simple variant on the strategy used by past authors in the single-processor cup game [11, 17]. At the beginning of each step $i$, the emptier will have so far removed water from $p\cdot(i-1)$ cups. The filler ignores these cups, and distributes $p/2$ units of water among the $n-p\cdot(i-1)$ cups that have never had water removed from them. This continues until the end of the $\frac{n}{p}$-th step, at which point every cup has been emptied out of.

After the $i$-th step, there will be $n-p\cdot i$ cups each containing

[TABLE]

water. It follows that at the end of step $\frac{n}{p}-1$ some cup has fill at least

[TABLE]

∎

Theorem 8 implies that our backlog upper bound of $O\left(\frac{1}{\varepsilon}\log n\right)$ (given by Theorem 2) for the deterministic multi-processor cup game is optimal (up to constant factors in the backlog) when $\varepsilon\leq 1/2$ is a positive constant and $n\geq p^{2}$. This is captured formally in the following corollary.

Corollary 1**.**

For $n\geq p^{2}$, any deterministic emptying strategy for the multi-processor cup game played on $n$ cups must have worst-case backlog at least $\Omega(\log n)$.

Next, we generalize Theorem 8 to the case where the filler is an oblivious adversary, meaning the filler is unable to see which cups the emptier has or has not removed water from.

Theorem 9**.**

Consider the universal emptying game on $p$ processors and $n$ cups. For any $k$ such that $2p\leq k\leq n$ and such that $k$ is a multiple of $p$, there is an obvious strategy for the filler that accomplishes a backlog of $\Theta\left(\log\frac{k}{p}\right)$ after step $\frac{k}{p}-1$ with probability at least

[TABLE]

Proof.

In order to achieve a backlog of $\Theta\left(\log\frac{k}{p}\right)$, the filler considers only the cups $1,\ldots,k$ and attempts to follow the same construction as presented in the proof of Theorem 8. The caveat is that the filler must now guess during each step which $p$ cups the emptier selected in the previous step. Since the filler is concerned only about the first $k$ cups, it suffices for the filler to guess after each step $i$ a $p$-element subset $S_{i}\subseteq[k]$ such that during the $i$-th step, the emptier did not touch any of the cups in $[k]\setminus S_{i}$. The number of options for each $S_{i}$ is $\binom{k}{p}$. Thus the filler can successfully simulate the adaptive lower-bound construction with probability at least

[TABLE]

∎

For $k\geq p^{2}$, the oblivious filler in Theorem 9 achieves a backlog of $\Omega(\log k)$ with probability at least $\frac{1}{2^{k}}$. Substituting $k$ with $2^{j}$, it follows that for $j\geq 2\log p$, the oblivious filler achieves a backlog of $\Omega(j)$ with probability at least $2^{-2^{j}}$. This, in turn, implies that Theorems 1 and 6, which upper bound the backlog of the smoothed greedy algorithm and the multi-processor smoothed greedy algorithm, are optimal (up to constant factors in the backlog) when $\varepsilon\leq 1/2$ is a positive constant.The lower bound demonstrating the optimality of Theorems 1 and 6 is captured formally in the following corollary.

Corollary 2**.**

Consider the $p$-processor multi-processor cup game on $n$ cups with $\varepsilon\leq 1/2$. For any $k$ satisfying $\log p\leq k\leq\log n$, there is an oblivious pouring strategy that guarantees after some particular step that there is a backlog of at least $\Omega(k)$ with probability at least $2^{-2^{k}}$.

Finally, for arbitrary constants $c$, Theorem 9 can be used by the filler to achieve backlog $c$ with probability at least $e^{-O(p)}$. In particular, a backlog of $c$ corresponds with a backlog of $\log\frac{2^{c}\cdot p}{p}$, which by Theorem 9 can be achieved after some step $\lceil\frac{2^{O(c)}\cdot p}{p}\rceil-1$ with probability at least

[TABLE]

Since $c$ is constant, this probability is just $2^{-O(p)}$. Hence Theorem 3, which ensures in the multi-processor cup game a backlog of three or smaller with probability at least $1-O\left(e^{-\Omega(\varepsilon^{2}p)}\right)$, is optimal (up to constant factors in $p$) when $\varepsilon\leq 1/2$ is a positive constant. This is captured formally in the following corollary.

Corollary 3**.**

Consider the $p$-processor multi-processor cup game with $\varepsilon\leq 1/2$. For any constant $c$, there is an oblivious pouring strategy that guarantees after some particular step that there is a backlog of at least $c$ with probability at least $2^{-O(p)}$.

9 Recovery from Bad Starting States

In this section we revisit both the single-processor cup game and the multi-processor cup game in the situation in which the starting-state of the cups is non-empty. In particular, suppose that $b$ units of water have already been dispersed among the cups arbitrarily before the game begins. We wish to show that in both games the system can quickly recover from such a starting state.

We will prove the following two theorems:

Theorem 10**.**

Consider the single-processor cup game beginning from a starting state in which $b$ units of water have already been dispersed arbitrarily among the cups. Suppose $\varepsilon\leq 1/2$ and consider some value $k\geq 0$ such that $3\log\frac{1}{\varepsilon}\leq k$. Then for $i>\frac{b}{\varepsilon}$, the probability that the smoothed greedy algorithm has backlog $k$ or greater after step $i$ is at most

[TABLE]

Theorem 11**.**

Consider the (renormalized) multi-processor cup game beginning from a starting state in which $b$ units of water have already been dispersed arbitrarily among cups. Set each counter $w_{j}(0)$ initially to be the number of thresholds crossed by the $b$ units of water in each cup $j$.

Suppose that $1/2\geq\varepsilon\geq p^{-1/3}$ and that $\delta<1$ is sufficiently large in $\Omega(e^{-O(\varepsilon^{2}p)})$.

Then the multi-processor smoothed greedy algorithm guarantees after any given step $i$ satisfying $i\geq\delta^{-8}\cdot p^{2}$ and $i\geq 2b/\delta$, the following is true:

• •

The backlog is three or less with probability at least

[TABLE]

• •

If we further assume that $\delta\geq 1/\mbox{poly}(p)$, then for any $k\geq\log p$, the backlog is $O(k/\varepsilon)$ with probability at least

[TABLE]

The proof of Theorem 10 largely reuses the ideas from the analysis in the standard setting:

Proof of Theorem 10.

For a step $i$, we begin by considering the event $E_{i}$ that for each of the first $i$ steps $1,\ldots,i$, the integer fill at the end of each step has remained positive. Note that if the integer fill at the end of a step is positive, then the emptier must have successfully removed at least one full unit of water during that step. Thus, if event $E_{i}$ occurs, then the emptier must successfully remove a total of at least $i$ units of water in the first $i$ steps. Given that the cups contain $b$ units of water initially, and that the filler places at most $(1-\varepsilon)i$ units of water during the steps, it follows that

[TABLE]

Therefore, the event $E_{i}$ cannot occur for $i>b/\varepsilon$.

So far we have shown that, during the first $i$ steps, the integer fill must at some point hit zero. Using this, we can analyze the backlog in precisely the same way as we do for the single-processor cup game. In particular, starting at the point where the integer fill was zero, we consider an instance of the dynamic cup game being played on the cups that contain one or more units of water (with their fill in the dynamic game being one less than their actual fill). By Lemma 1, the backlog at any given step is at most logarithmic in the number of cups engaged in the dynamic game. This, in turn, is at most the integer fill. By the analysis in Lemma 3, with probability at least

[TABLE]

the integer fill at the end of step $j$ is no greater than $r$.444Notice that in order for this analysis to work, we require that there is some $t<j$ such that the integer fill was zero at step $j-t$; but fortunately we have already established this. Plugging in $r=2^{k}$, the backlog after step $j$ will be $O(k)$ with probability at least $1-O\left(e^{-e^{\Omega(k)}}\right)$. ∎

Next we prove Theorem 11.

Proof of Theorem 11.

Let $T_{0}$ be the number of thresholds crossed (using the multi-processor smoothed greedy algorithm’s definition of thresholds) by the initial $b$ units of water. For each $m>0$, define $T_{m}$ to be the number of surplus thresholds crossed during the $m$-th step.

Suppose there is some step $l\leq i$ such that after step $l$ the counters $w_{j}(l)$ are all zero. Then the proof of Theorems 3 and 6 apply without modification, since both proofs rely only on analysis of how the counters $w_{j}$ have changed since the last time they were all zero.

In order to complete the proof, it suffices to show that with probability at least

[TABLE]

there is some step $l\leq i$ at which the counters $w_{j}$ are all zero.

By the same analysis as in Lemma 5, for each step $m$ such that $\sum_{j}w_{j}(m)\geq 0$, the net increase in $\sum_{j}w_{j}$ during the step is at most $T_{m}\cdot(1+\delta)-\delta$. Thus if

[TABLE]

then we will be guaranteed that there is some step $l\leq i$ such that $\sum_{j}w_{j}(l)=0$, as desired.

We will consider $T_{0}$ and $\sum_{i=1}^{j}T_{j}$ separately, proving the bounds,

[TABLE]

and

[TABLE]

which together establish Eq. 17.

By Proposition 1 and Remark 1,

[TABLE]

Using the fact that $i\geq\delta^{-8}\cdot p^{2}$, it follows that

[TABLE]

thereby proving Eq. 18.

On the other hand, the number of thresholds crossed by the initial $b$ units of water (i.e., $T_{0}$) can be bounded as follows: If a cup $j$ received $r$ units of water, then it cannot have crossed more than $\lfloor r\rfloor$ thresholds, since the threshold $r_{j}(0)$ is null for each cup $j$ (meaning there is no threshold to cross between [math] and $1$). Therefore, $T_{0}$ is deterministically at most $b$, which in turn is less than $\delta i/2$. This implies Eq. 19, completing the proof. ∎

10 Acknowledgments

This work was supported in part by NSF Grants CCF 805476, CCF 822388, CNS 1408695, CNS 1755615, CCF 1439084, CCF 1725543, CSR 1763680, CCF 1716252, CCF 1617618, CCF 1314547 and CCF 1533644; and by an MIT Akamai Fellowship and a Fannie & John Hertz Foundation Fellowship.

Acknowledgments

This research was supported in part by NSF Grants 1314547 and 1533644.

Appendix A Porting Results Between Parameter Regimes

In this section, we describe how to transfer results for the renormalized multi-processor cup game to results for the (non-renormalized) multi-processor cup game.

Suppose $0\leq\delta\leq O(\varepsilon)$ and $\varepsilon\leq 1/2$. Then the corresponding $p^{\prime}$, $\varepsilon^{\prime}$, $\delta^{\prime}$ in the multi-processor cup game are

[TABLE]

since $1-\varepsilon^{\prime}$ is the ratio of water poured to water emptied;

[TABLE]

since $1-\delta^{\prime}$ is the ratio of the amount the filler is permitted to place in each cup to the amount the emptier is allowed to remove; and $p^{\prime}=p+1$. Moreover, $1$ unit of backlog in the renormalized multi-processor cup game corresponds with $1+2\delta$ units of backlog in the multi-processor cup game.

It follows that, whenever using the renormalized multi-processor cup game, one can always add the assumption that $0\leq\delta\leq O(\varepsilon)$ to obtain an analogous result for the multi-processor cup game for values of $\varepsilon$ and $\delta$ that differ by a constant factor from before; and in fact the assumption that $0\leq\delta\leq O(\varepsilon)$ is without loss of generality in each of our result statements, since no advantage in the guarantees is obtained by increasing $\delta$ beyond $O(\varepsilon)$. Thus all of our randomized results port over immediately to the (non-renormalized) multi-processor cup game (with the modification of $\varepsilon$ and $\delta$ by constant factors).

Appendix B Bounding the Number of Random Bits

In this section, we briefly explain how to limit the number of random bits used by our algorithms.

In all of our results, we may assume without loss of generality that $\varepsilon$ and $\delta$ are rational and use $O(\log n)$ bits in their denominators. Although the filler may place water in arbitrary real quantities into cups, we can assume without loss of generality that the filler always places multiples of $\frac{\varepsilon}{n^{2}}$ for the single-processor cup game and $\frac{\min(\varepsilon,\delta)}{n^{2}}$ for the multi-processor cup game. In particular, even if this is not the case, we may simulate it by always rounding up the quantity placed into each cup; this increases the total amount of water poured by no more than $\min(\varepsilon,\delta)/n$, a modification that can easily be absorbed by changing $\varepsilon$ and $\delta$ negligibly.

Many of our algorithms assume the ability to select random real thresholds in the range $[0,1]$. However, since we may assume without loss of generality (as described above) that the water in each cup is always a rational number with a $O(\log n)$-bit denominator $d$ determined by $\varepsilon,\delta,n$, we can select thresholds with precision only $\frac{1}{d}$ without changing the behavior of the algorithms.555However, to be careful about boundary conditions for when a threshold is crossed, one should avoid rounding thresholds to be exactly multiples of $\frac{1}{d}$; to select a random threshold in $[0,1]$, one can instead select a member of $\{\frac{1}{2d},\frac{3}{2d},\frac{5}{2d},\ldots,\frac{2d-1}{2d}\}$ at random. Thus at most $O(\log n)$ random bits are required for each threshold.

Appendix C Analysis of the Dynamic Single-Processor Cup Game

Here we present the proof of Lemma 1, analyzing the dynamic single-processor cup game. The analysis is a simple variation on the analysis presented by [1] for the greedy algorithm.

Proof of Lemma 1.

At the end of a given step $i$, we denote the number of cups in the system by $n_{i}$, and we denote the average amount of water in the fullest $j$ cups by $\operatorname{av}_{i}(j)$. (That is, $\operatorname{av}_{i}(j)$ is $1/j$ times the sum of the amounts of water in each of the fullest $j$ cups.)

We will prove by induction on $i$, that at the end of the $i$-th step, for all $j\geq 1$,

[TABLE]

For convenience, we will include cases where $j>n_{i}$ in our inductive hypothesis, even though Eq. 20 is trivially true for these cases. As a base case, note that Eq. 20 is immediate for $i=0$, since initially there are no cups. Suppose the inductive hypothesis holds for step $i-1$, and we wish to prove it for step $i$.

Consider some value $\operatorname{av}_{i}(j)$, and examine how it evolves over the course of step $i$, starting initially equal to $\operatorname{av}_{i-1}(j)$. At the beginning of step $i$, some number of new cups are added to the system. Because these cups are initially empty, $\operatorname{av}_{i}(j)$ is unchanged. The filler then distributes at most one unit of water among all the cups, thereby increasing each $\operatorname{av}_{i}(j)$ by at most $1/j$. There are then three cases to consider:

The fullest cup contains one or fewer units of water: In this case, the emptier will remove all of the water in the cup, thereby removing the cup from the system. However, because the fullest cup contained no more than one unit of water prior to the removal, it must be that no cup contains more than one unit of water. Thus Eq. 20 remains true. 2. 2.

*The fullest cup contains more than one unit of water, and after the removal of a unit, the cup is still among the $j$ fullest cups: *In this case, the initial addition of water to the cups may have increased $\operatorname{av}_{i}(j)$ by as much as $1/j$, but the subsequent removal of water will have then decreased $\operatorname{av}_{i}(j)$ by exactly $1/j$, resulting in $\operatorname{av}_{i}(j)\leq\operatorname{av}_{i-1}(j)$. Since $n_{i}\geq n_{i-1}$, it follows that Eq. 20 still holds. 3. 3.

*The fullest cup contains more than one unit of water, and after the removal of a unit, the cup is no longer among the $j$ fullest cups: *In this case, we turn our focus to $\operatorname{av}_{i}(j+1)$. The initial addition of water during the step may have increased $\operatorname{av}_{i}(j+1)$ by as much as $\frac{1}{j+1}$. Then, once water was removed from the fullest cup, the cups which were formerly in ranks $2,3,\ldots,j+1$ for fullness, become the new fullest $j$ cups. The average fill in these cups is at most what the average fill was in the fullest $j+1$ cups prior to the emptying. Thus the final value for $\operatorname{av}_{i}(j)$ is at most $\operatorname{av}_{i-1}(j+1)+\frac{1}{j+1}$. By the inductive hypothesis, this is at most

[TABLE]

as desired.

In each of the three cases, Eq. 20 continues to hold, implying by induction on $i$ that it will hold for all $i$ and $j$. Considering the case of $j=1$, we see that the amount of water in the fullest cup $\operatorname{av}_{i}(1)$ after the $i$-th step is no greater than $1+1/2+1/3+\cdots+1/n_{i}\leq O(\log n_{i})$. ∎