Better and Simpler Learning-Augmented Online Caching

Alexander Wei Harvard University weia@college.harvard.edu

Abstract.

Lykouris and Vassilvitskii (ICML 2018) introduce a model of online caching with machine-learned advice, where each page request additionally comes with a prediction of when that page will next be requested. In this model, a natural goal is to design algorithms that (1) perform well when the advice is accurate and (2) remain robust in the worst case a la traditional competitive analysis. Lykouris and Vassilvitskii give such an algorithm by adapting the Marker algorithm to the learning-augmented setting. In a recent work, Rohatgi (SODA 2020) improves on their result with an approach also inspired by randomized marking. We continue the study of this problem, but with a somewhat different approach: We consider combining the BlindOracle algorithm, which just naïvely follows the predictions, with an optimal competitive algorithm for online caching in a black-box manner. The resulting algorithm outperforms all existing approaches while being significantly simpler. Moreover, we show that combining BlindOracle with LRU is in fact optimal among deterministic algorithms for this problem.

1. Introduction

Traditionally, the study of online algorithms focuses on worst-case robustness, with algorithms providing the same competitive guarantee against the offline optimal over all inputs. In recent years, however, there has been a surge of interest in studying online algorithms in the presence of structured inputs [MV17, LV18, PSK18, GP19, KPS+19, KPS+20, Roh20, LLM+20, Mit20]. A principal motivation for these works is the philosophy of beyond worst-case analysis [KP00, Rou19]: Many practical settings have inputs that follow restricted patterns, making classical worst-case competitive analysis too pessimistic to inform practice. In particular, the worst-case examples classical competitive analyses guard against often do not materialize. Furthermore, algorithms designed with the worst case in mind can be hamstrung by these considerations, ending up unnatural and losing performance on “nice” inputs.

Learning-augmented online algorithms, introduced by [LV18, PSK18], is a beyond worst-case framework motivated by the powerful predictive abilities of modern machine learning. The structure of the input is assumed to come in the form of a machine-learned predictor that provides predictions of future inputs. A concern with this setup may be that machine learning models typically have few worst-case guarantees. Nonetheless, with learning-augmented algorithms, we want the best of both worlds: Given a predictor, the objective is to design algorithms that (1) perform well in the optimistic scenario, where the predictor has low error, and (2) remain robust in the classical worst-case sense, when the predictor can be arbitrarily bad. That is, we would like our algorithm to be $c(\eta)$ -competitive against the offline optimal on all inputs, where $c$ is a function of the predictor error $\eta$ such that $\max_{\eta}c(\eta)\leq\gamma$ for some $\gamma\geq 1$ . Such an algorithm is said to be $\gamma$ -robust.

The focus of our work is learning-augmented online caching [LV18, Roh20]. In the online caching (a.k.a. online paging) problem, one seeks to maintain a cache of size $k$ online while serving requests for pages that may or may not be in the cache. For simplicity, we assume that pages must always be served from the cache and that bringing a page into the cache has unit cost. (In particular, if the cache is full, bringing a page into the cache requires also evicting a page already in the cache.) Thus, we seek to minimize the number of requests for which the page is not already in the cache, i.e., the number of cache misses. This is a classical online problem that has been the subject of extensive study over the past several decades (see [BE98] for an overview). From the worst-case perspective, this problem is well-understood for not only the version stated above [ST85, FKL+91, ACN00], but also for weighted generalizations [BBN12, BBN12a].

Online caching in the learning-augmented context was first considered by [LV18]. They introduce a model of prediction where the predictor, upon the arrival of each page, predicts the next time that this page will be requested. They show that the BlindOracle algorithm, which follows the predictor naïvely and evicts the page with the latest predicted arrival time, can have unbounded competitive ratio (i.e., is non-robust). They then give a different algorithm, PredictiveMarker, based on the Marker algorithm of [FKL+91], that achieves a competitive ratio of

2+O\left\lparen\min\left\lparen\sqrt{\frac{\eta}{\mathsf{OPT}}},\log k\right\rparen\right\rparen,

where $\eta$ is the $\ell_{1}$ error of the predictor and $\mathsf{OPT}$ is the cost of the offline optimal. (See Section 2.1 for precise definitions.) In [Roh20], Rohatgi introduces the LNonMarker algorithm, which is also based on randomized marking (but eschews the framework somewhat), and shows that this algorithm obtains a competitive ratio of

O\left\lparen 1+\min\left\lparen\frac{\log k}{k}\frac{\eta}{\mathsf{OPT}},\log k\right\rparen\right\rparen.

This bound is obtained by first constructing a non-robust algorithm and then using a black-box combination technique discussed in [LV18] to combine this non-robust algorithm with the Marker algorithm. Rohatgi also provides a lower bound of

\Omega\left\lparen\min\left\lparen\log\left\lparen\frac{1}{k\log k}\frac{\eta}{\mathsf{OPT}}\right\rparen,\log k\right\rparen\right\rparen

for the competitive ratio of any learning-augmented online algorithm for caching in terms of $k$ , $\mathsf{OPT}$ , and $\eta$ .

1.1. Our Contribution

We show that the strikingly simple approach of combining BlindOracle with an $O(\log k)$ -competitive online caching algorithm (e.g., Marker) in a black-box fashion obtains a competitive ratio bound of

O\left\lparen 1+\min\left\lparen\frac{1}{k}\frac{\eta}{\mathsf{OPT}},\log k\right\rparen\right\rparen,

improving on that of LNonMarker. Thus, although BlindOracle is non-robust [LV18], we show that it should not be abandoned entirely. In fact, it has excellent performance when $\eta/\mathsf{OPT}$ is small. So when this algorithm is combined with a $O(\log k)$ -competitive algorithm, we start seeing performance improvement over the robust algorithm starting at $\eta/\mathsf{OPT}=O(k\log k)$ .

And although our improvement in the competitive ratio is slight, previous approaches for learning-augmented online caching [LV18, Roh20] have relied on much more intricate constructions based on randomized marking. We therefore believe that our simple approach may yield better practical performance and may generalize more readily to other learning-augmented settings. (Indeed, we note that the deterministic combining algorithm is particularly simple: Just “follow” the algorithm with the better performance thus far.)

We also give precise bounds on the constant factors in the competitive ratios that we obtain. [FKL+91, BB00] provide optimal bounds for combining online algorithms online in a black-box manner, with better constants than the approach discussed in [LV18] and applied in [Roh20]. By composing a careful competitive analysis of BlindOracle with these “combiners,” we obtain constants in the competitive ratio that are lower than those of previous work.

Finally, we show that combining BlindOracle with a $k$ -competitive deterministic algorithm (e.g., LRU [ST85]) is the best one could hope to do among deterministic algorithms for learning-augmented online caching. In particular, we show that a linear dependence on $\eta/(k\cdot\mathsf{OPT})$ in the competitive ratio is necessary. Therefore, if a logarithmic dependence on $\eta/(k\cdot\mathsf{OPT})$ is to be achieved, as in Rohatgi’s lower bound, then randomization is needed, (perhaps surprisingly) even in the regime where $\eta/(k\cdot\mathsf{OPT})$ is bounded.

Stated formally, our main result analyzing BlindOracle is the following:

Theorem 1.1 (restate=maintheorem,label=theorem:main).

For learning-augmented online caching, BlindOracle obtains a competitive ratio of

\min\left\lparen 1+2\frac{\eta}{\mathsf{OPT}},2+\frac{4}{k-1}\frac{\eta}{\mathsf{OPT}}\right\rparen,

where $\eta$ is the $\ell_{1}$ loss incurred by the predictor and $\mathsf{OPT}$ is the offline optimal cost. (For precise definitions, see Section 2.1.)

Plugging this bound into the results of [FKL+91, BB00] for competitively combining online algorithms online (see Section 2.2) yields the following corollaries:

Corollary 1.2 (restate=firstcorollary,label=corollary:det).

There exists a deterministic algorithm for learning-augmented online caching that achieves a competitive ratio of

2\min\left\lparen\min\left\lparen 1+2\frac{\eta}{\mathsf{OPT}},2+\frac{4}{k-1}\frac{\eta}{\mathsf{OPT}}\right\rparen,k\right\rparen.

Corollary 1.3 (restate=secondcorollary,label=corollary:rand).

There exists a randomized algorithm for learning-augmented online caching that achieves a competitive ratio of

(1+\varepsilon)\min\left\lparen\min\left\lparen 1+2\frac{\eta}{\mathsf{OPT}},2+\frac{4}{k-1}\frac{\eta}{\mathsf{OPT}}\right\rparen,H_{k}\right\rparen

for any $\varepsilon\in(0,1/4)$ .¹¹1The trade-off in $\varepsilon$ and the additional cost is additive; thus, it does not factor into the competitive ratio. (Here, $H_{k}=1+\frac{1}{2}+\frac{1}{3}+\cdots+\frac{1}{k}=\ln(k)+O(1)$ is the $k$ -th harmonic number.)

Finally, we state our matching lower bound for LABEL:corollary:det on deterministic algorithms for learning-augmented online caching:

Theorem 1.4 (restate=lowerboundtheorem,label=theorem:lower).

The competitive ratio bound for any deterministic learning-augmented online caching algorithm must be at least

1+\Omega\left\lparen\min\left\lparen\frac{1}{k}\frac{\eta}{\mathsf{OPT}},k\right\rparen\right\rparen.

1.2. Related Work

In addition to the predecessor works by [LV18, Roh20] on learning-augmented online caching, there have been several other recent papers in the space of learning-augmented online algorithms: [MV17] study repeated posted-price auctions, [PSK18, GP19] study the ski rental problem, and [PSK18, LLM+20, Mit20] study online scheduling. Of these, the scheduling algorithm of [PSK18] is the most similar in spirit to this present work: Both algorithms are based on combining a naïve and optimistic algorithm with a robust algorithm.

Other threads of research falling under beyond worst-case online algorithms include work on combining multiple algorithms with different performance characteristics [FKL+91, BB00, MNS12, GP19], designing online algorithms with distributional assumptions (e.g., stochasticity) on the input [KP00, BS12, MGZ12], and semi-online algorithms, where the input is assumed to have a predictable offline component and an adversarial online component [KPS+19, KPS+20].

The idea of learning-augmentation has also been explored in many other algorithmic and data structural settings in recent years. These include learned indices [KBC+18], bloom filters [Mit18], frequency estimation in streams [HIK+19], and nearest neighbor search [DIR+19], among others.

Finally, advice for online algorithms has also been considered with a more complexity theoretic spirit through the study of advice complexity of online algorithms; see the survey of [BFK+17].

1.3. Recent Developments

Recently, in work done independently of and concurrently with this paper, [ACE+20] also study a BlindOracle-like algorithm, which they term FollowThePrediction, in the more general setting of learning-augmented metrical task systems; they also use the “combiner” of [BB00] to make this algorithm robust. However, their prediction model, when specialized to online caching, is incomparable to that of [LV18] (which we follow).²²2Namely, their algorithms expect predictions to be in a different form: They expect predictions to be cache states (i.e., the set of pages in the cache at time $t$ ) rather than next arrival times of pages. Moreover, there exist sequences of “corresponding” inputs for each of these two models such that the predictor error approaches infinity in one model while remaining constant in the other. Thus, the theoretical results proved in these two models do not imply each other.

2. Preliminaries

2.1. Setup and Notation

In the online caching problem, we receive a sequence $\sigma=(\sigma_{1},\ldots,\sigma_{n})$ of page requests online, and our goal is to serve these requests using a cache of size $k$ while minimizing cost. In this problem, pages must be served from the cache and can be served at no cost; however, evicting a page from the cache has unit cost.³³3Note that this is equivalent to the “standard” version, where each cache miss has unit cost, up to a constant of $k$ .

We will establish competitive bounds comparing the performance of two online caching algorithms $\mathcal{A}$ and $\mathcal{B}$ . More precisely, we will show bounds of the form

\mathsf{ALG}_{\mathcal{B}}(\sigma)\leq\gamma\cdot\mathsf{ALG}_{\mathcal{A}}(\sigma)+O(1),

where $\mathsf{ALG}_{\mathcal{A}}(\sigma)$ and $\mathsf{ALG}_{\mathcal{B}}(\sigma)$ are the costs of $\mathcal{A}$ and $\mathcal{B}$ , respectively, as measured in number of evictions made while serving a sequence $\sigma$ of page requests. We will also compare our costs to the offline optimal algorithm $\mathsf{OPT}$ , whose cost $\mathsf{OPT}(\sigma)$ is the minimum possible cost of serving request sequence $\sigma$ . We will omit the argument $\sigma$ when the context is clear (i.e., just writing $\mathsf{ALG}_{\mathcal{A}}$ to represent $\mathsf{ALG}_{\mathcal{A}}(\sigma)$ ).

In our analysis, we use $A_{t}$ and $B_{t}$ to denote the cache states of $\mathcal{A}$ and $\mathcal{B}$ , respectively, just before the $t$ -th request. Formally, $A_{t}$ and $B_{t}$ are subsets of $\{1,\ldots,t-1\}$ of size at most $k$ , containing for each cached page the index at which it was last served. That is, when serving the $t$ -th request, we remove some old request index $t^{\prime}$ from the cache and insert $t$ . Thus, if $t^{\prime}$ is such that $\sigma_{t}=\sigma_{t^{\prime}}$ , this operation is free; otherwise, it has unit cost. In the sequel, we will also refer to these indices $t$ as page requests.

In the learning-augmented online caching problem, the $t$ -th page request comes with a prediction $h_{t}$ for the next time page $\sigma_{t}$ is requested. That is, at the time of the $t$ -th request, our algorithm receives the pair $(\sigma_{t},h_{t})$ . Let $h=(h_{1},\ldots,h_{n})$ be the tuple of all $n$ predictions. To define a notion of loss, let $y_{t}$ denote for each $t$ the next time page $t$ is actually requested, with $y_{t}=n+1$ if page $\sigma_{t}$ is never requested again. The $\ell_{1}$ loss is then defined to be

\eta(\sigma,h)=\sum_{t}|h_{t}-y_{t}|.

We will omit arguments to $\eta$ if the context is clear. Note that if $\eta(\sigma,h)=0$ , then the offline optimal can be obtained, as the optimal algorithm always evicts the page that is next requested furthest into the future.

In stating our bounds, the essential quantity is often $\eta/\mathsf{OPT}$ . To make this clear, we take $\varepsilon=\eta/\mathsf{OPT}$ and state our bounds in terms of $\varepsilon$ in the sequel.

2.1.1. Inversions

Call a pair $(i,j)$ of page requests an inversion if $y_{i}<y_{j}$ but $h_{i}\geq h_{j}$ . Let $M(\sigma,h)$ denote the total number of inversions between the pair of sequences $\sigma$ and $h$ . And as above, we will omit the arguments to $M$ when the context is clear.

2.1.2. BlindOracle

We now formally define the BlindOracle algorithm as follows: For each page request, if the requested page is already in the cache, do nothing. Otherwise, evict the page request $p$ whose predicted next arrival time $h_{p}$ is furthest away among all $p\in A_{t}$ , with ties broken consistently (e.g., by always evicting the least recently used page with maximal $h_{p}$ ).

2.2. Combining Online Algorithms Competitively

In this section, we state some classical bounds on competitively combining online algorithms, due to [FKL+91] and [BB00]. This type of “black-box” combination was also considered by [LV18], but their approach has a worst constant than that of [FKL+91]. We also note that results of a similar flavor are proven by [PSK18, MNS12], but for other online problems.

The question of combining multiple online algorithms while remaining competitive against each was first considered in the seminal paper of [FKL+91]. They consider combining $n$ online algorithms $\mathcal{A}_{1},\ldots,\mathcal{A}_{n}$ for the online caching problem into a single algorithm $\mathcal{A}$ such that $\mathcal{A}$ is $C_{i}$ -competitive against $\mathcal{A}_{i}$ for each $i$ . They show that such an $\mathcal{A}$ is achievable if and only if

\sum_{i=1}^{n}\frac{1}{C_{i}}\leq 1.

We will need only the special case of $n=2$ and $C_{1}=C_{2}=2$ , which we state below:

Theorem 2.1 ([FKL+91], special case).

Given any two algorithms $\mathcal{A}$ and $\mathcal{B}$ for the online caching problem, there exists an algorithm $\mathcal{C}$ such that

\mathsf{ALG}_{\mathcal{C}}(\sigma)\leq 2\min(\mathsf{ALG}_{\mathcal{A}}(\sigma),\mathsf{ALG}_{\mathcal{B}}(\sigma))+O(1).

Moreover, if $\mathcal{A}$ and $\mathcal{B}$ are deterministic, so is $\mathcal{C}$ .

Indeed, we note that that this can be done deterministically with a “follow-the-leader” approach, in which we simulate both algorithms and at each step evict any page that is not in the cache of the better performing algorithm (as measured by total number of evictions after serving the current request).

[BB00] show that one can obtain a better approximation factor using a randomized scheme, namely multiplicative weights.⁴⁴4The result of [BB00] in fact holds for general metrical task systems. That is, at each point in time, the probability that the combined algorithm is following one of the $n$ algorithms is given by a probability distribution over the $n$ algorithms governed by the multiplicative weights update rule. For $n=2$ , their result can be stated as follows:

Theorem 2.2 ([BB00], special case).

Given any two algorithms $\mathcal{A}$ and $\mathcal{B}$ for the online caching problem and any $\varepsilon$ , $0<\varepsilon<1/4$ , there exists an algorithm $\mathcal{C}$ such that

\mathsf{ALG}_{\mathcal{C}}(\sigma)\leq(1+\varepsilon)\min(\mathsf{ALG}_{\mathcal{A}}(\sigma),\mathsf{ALG}_{\mathcal{B}}(\sigma))+O(\varepsilon^{-1}k).

Remark.

Although we do not state the versions of these results for $n>2$ , one could imagine that they can be useful wishes to combine multiple machine-learned predictors.

2.3. From $\ell_{1}$ Loss to Inversions

We now state a lemma of [Roh20] that relates $\ell_{1}$ loss to the number of inversions, letting us lower bound the $\ell_{1}$ loss $\eta(\sigma,h)$ by lower bounding the number of inversions $M(\sigma,h)$ . Thus, instead of reasoning in terms of $\ell_{1}$ loss, we will reason in terms of inversions.

Lemma 2.3 ([Roh20]).

For any $\sigma$ and $h$ , $\eta(\sigma,h)\geq\frac{1}{2}M(\sigma,h)$ .

With this lemma, it suffices (up to a factor of $2$ ) to give our competitive ratio upper bounds in terms of the number of inversions $M$ .

3. A First Analysis of BlindOracle

In this section, we give a first analysis of BlindOracle, showing that it gets very good performance when the ratio $\varepsilon=\eta/\mathsf{OPT}$ is very small. In particular, our analysis shows that as $\varepsilon\to 0$ , the competitive ratio achieved approaches $1$ .

Let $\mathcal{A}$ be the offline optimal algorithm (i.e., such that $\mathsf{ALG}_{\mathcal{A}}=\mathsf{OPT}$ ). Let $\mathcal{B}$ be BlindOracle. Note that we can think of each of $\mathsf{ALG}_{\mathcal{A}}$ , $\mathsf{ALG}_{\mathcal{B}}$ , and $M$ as functions of the time $t$ , i.e., they are the cost of $\mathcal{A}$ , the cost of $\mathcal{B}$ , and the number of inversions, respectively, on the prefix consisting of the first $t-1$ requests.⁵⁵5This indexing is to be consistent with the definitions of $A_{t}$ and $B_{t}$ . We use the $\Delta$ operator to denote the change (in a function of $t$ ) from time $t$ to time $t+1$ . For example, $\Delta\mathsf{ALG}_{\mathcal{A}}=1$ if $\mathsf{ALG}_{\mathcal{A}}$ evicts an element upon the $t$ -th request.

In our analysis, we maintain a matching $X_{t}$ between $A_{t}$ and $B_{t}$ at all times $t$ . Call a matching valid if it consists only of pairs $(a,b)\in A_{t}\times B_{t}$ such that the next arrival of $b$ is no later than the next arrival of $a$ . Indeed, our matching $X_{t}\subseteq A_{t}\times B_{t}$ will be valid throughout the execution of the algorithm.

We now proceed with a potential function analysis, taking our potential $\Phi$ (as a function of $A_{t}$ , $B_{t}$ , and $X_{t}$ ) to be the number of unmatched pages in $B_{t}$ . For notational simplicity, we will simply denote $\Phi(A_{t},B_{t},X_{t})$ by $\Phi(t)$ . Given this setup, we show:

Proposition 3.1.

There exists a valid matching $X_{n}$ such that

\mathsf{ALG}_{\mathcal{B}}+\Phi(n)\leq\mathsf{OPT}+M.

Proof.

We induct on the length $n$ of the input and perform a case analysis to show that we can maintain a valid matching $X_{t}$ such that at each time step, the right-hand side increases at least as much as the left-hand side, i.e., $\Delta\mathsf{ALG}_{\mathcal{B}}+\Delta\Phi\leq\Delta\mathsf{OPT}+\Delta M$ .

For our base case, note that $A_{1}=B_{1}$ , so we may take $X_{1}$ to be the identity matching.

Now, upon a request at time $t$ , we update $X_{t}$ according to the following cases (and with the consequences listed for each case):

(1)
The requested page $p$ is in both $A_{t}$ and $B_{t}$ .
1. (a)
  The cached pages are matched to each other.
  - •
    
    Do nothing.
2. (b)
  Otherwise:
  1. (i)
    
    Both cached pages are matched.
    
    •
    
    Remove the pairs $(c,p)$ and $(p,d)$ from $X_{t}$ .
    
    •
    
    Add the pairs $(p,p)$ and $(c,d)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\Phi=0$ .
  2. (ii)
    
    Otherwise:
    
    •
    
    Remove any pairs involving $p$ from $X_{t}$ . (There is at most one such pair.)
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\Phi\leq 0$ .
(2)
The requested page $p$ is in $B_{t}$ only.
- •
  
  Remove any pairs involving the evicted page $a$ from $X_{t}$ . (There is at most one such pair.)
- •
  
  Remove any pairs involving the requested page $p$ from $X_{t}$ . (There is at most one such pair.)
- •
  
  Add the pair $(p,p)$ to $X_{t}$ .
- •
  As a result:
  - –
    
    $\Delta\mathsf{OPT}=1$ .
  - –
    
    $\Delta\Phi\leq 1$ .
(3)
The requested page $p$ is in $A_{t}$ only.
1. (a)
  The evicted page $b\in B_{t}$ is unmatched.
  - •
    
    Add the pair $(p,p)$ to $X_{t}$ . (The arriving page $p\in A_{t}$ cannot be in any valid matching.)
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi=-1$ .
2. (b)
  The evicted page $b\in B_{t}$ is matched.
  1. (i)
    
    $b$ arrives later than all unmatched pages in $B_{t}$ .
    
    •
    
    Remove the pair $(c,b)$ involving the evicted page $b$ from $X_{t}$ .
    
    •
    
    Add the pair $(c,b^{\prime})$ to $X_{t}$ , where $b^{\prime}\in B_{t}$ is any unmatched page.
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ . (The arriving page $p\in A_{t}$ cannot be in any valid matching.)
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi=-1$ .
  2. (ii)
    
    There is an unmatched page $b^{\prime}\in B_{t}$ arriving later than $b$ .
    
    •
    
    Remove the pair $(c,b)$ involving the evicted page $b$ from $X_{t}$ .
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ . (The arriving page $p\in A_{t}$ cannot be in any valid matching.)
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi=0$ .
    
    –
    
    $\Delta M=1$ , as there is an inversion between $b$ and $b^{\prime}$ . (Note that we do not count this inversion ever again, as $b$ gets evicted.)
(4)
The requested page $p$ is in neither $A_{t}$ nor $B_{t}$ .
1. (a)
  $\mathcal{A}$ evicts an unmatched page $a\in A_{t}$ .
  1. (i)
    
    $\mathcal{B}$ evicts an unmatched page $b\in B_{t}$ .
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi=1$ .
  2. (ii)
    
    $\mathcal{B}$ evicts a matched page $b\in B_{t}$ .
    
    •
    
    Remove the pair $(c,b)$ involving $b$ from $X_{t}$ .
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
2. (b)
  $\mathcal{A}$ evicts a matched page $a\in A_{t}$ .
  1. (i)
    
    $\mathcal{B}$ evicts an unmatched page $b\in B_{t}$ .
    
    •
    
    Remove the pair $(a,d)$ involving $a$ from $X_{t}$ .
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
  2. (ii)
    
    $\mathcal{B}$ evicts a matched page $b\in B_{t}$ .
    
    •
    
    Remove the pair $(a,d)$ involving $a$ from $X_{t}$ .
    
    •
    
    Remove the pair $(c,b)$ involving $b$ from $X_{t}$ .
    
    •
    
    Add the pair $(p,p)$ to $X_{t}$ .
    
    •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    Note that either $b$ arrives after $d$ , in which case we can add $(c,d)$ to $X_{t}$ and $\Delta\Phi=0$ , or the pair $(b,d)$ forms an inversion, in which case $\Delta\Phi=1$ and $\Delta M=1$ . (As before, since $b$ is getting evicted, we will not count this pair twice.)

It is not hard to verify that the change in the left-hand side of the bound is no more than the change in the right-hand side in each of the cases listed above, from which the proposition follows. ∎

Proposition 3.2.

The competitive ratio of algorithm $\mathcal{B}$ is at most $1+2\varepsilon$ .

Proof.

Note that $2\eta$ is bounded below by the number of inversions $M$ of $(\sigma,h)$ by Lemma 2.3. By Proposition 3.1, $\mathsf{ALG}_{\mathcal{A}}\leq\mathsf{OPT}+M$ , so $\mathsf{ALG}_{\mathcal{A}}/\mathsf{OPT}\leq 1+M/\mathsf{OPT}\leq 1+2\varepsilon$ . ∎

4. A More Careful Analysis

In this section, we give an asymptotically better (in $k$ ) bound for the performance of BlindOracle. A more careful analysis is needed to show an upper bound with a $1/k$ coefficient on the ratio $\varepsilon=\eta/\mathsf{OPT}$ . We use the same high-level approach for the proof as before, but with a more complicated potential function. Again, $\mathcal{A}$ is the offline optimal algorithm and $\mathcal{B}$ is the BlindOracle algorithm, and also as before, we use $\Delta$ to denote change (in functions of $t$ ) from request $t$ to request $t+1$ .

We maintain in this proof a matching $X_{t}$ over pairs of page requests $(a,b)\in A_{t}\times B_{t}$ such that $h_{a}\geq h_{b}$ for each time step $t$ . Our potential function $\Phi$ will be a function of $A_{t}$ , $B_{t}$ , and $X_{t}$ . For notational simplicity, we will simply denote $\Phi(A_{t},B_{t},X_{t})$ by $\Phi(t)$ .

Given $A_{t}$ , $B_{t}$ , and $X_{t}$ at time $t$ , define $\Phi_{0}(t)$ to be the number of $b\in B_{t}$ that are unmatched. Define $\Phi_{1}(t)$ to be the number of $b\in B_{t}$ such that $(b,b)\not\in X_{t}$ . In other words, $\Phi_{1}$ counts how many page requests in $B_{t}$ are not matched to the same page request in $A_{t}$ . Let $z_{a}(t)$ be the number of pages in $B_{t}$ predicted to appear no later than $h_{a}$ , with tie-breaking done in a consistent manner (e.g., by the last time the page was requested). Next, define

\Phi_{2}(t)=\sum_{(a,b)\in X_{t}}(z_{b}(t)-z_{a}(t))=\sum_{(a,b)\in X_{t}}\big{\lparen}\varphi^{A}_{a}(t)+\varphi^{B}_{b}(t)\big{\rparen},

where $\varphi^{A}_{a}(t)=(k-1)-z_{a}(t)$ and $\varphi^{B}_{b}(t)=z_{b}(t)-(k-1)$ . Finally, we take

\Phi(t)=(k-1)\Phi_{0}(t)+(k-1)\Phi_{1}(t)+\Phi_{2}(t)

as our overall potential function.

Proposition 4.1.

For any input $(\sigma,h)$ , there exists a matching $X_{n}\subseteq A_{n}\times B_{n}$ consisting only of pairs $(a,b)$ satisfying $h_{a}\geq h_{b}$ such that

(k-1)\mathsf{ALG}_{\mathcal{B}}+\Phi(n)\leq 2(k-1)\mathsf{OPT}+2M.

Proof.

We again induct on the length $n$ of the input, and we again perform a case analysis to show that we can maintain a matching $X_{t}$ consisting only of pairs $(a,b)$ satisfying $h_{a}\geq h_{b}$ such that at each time step, the right-hand side increases at least as much as the left-hand side.

For our analysis, we split the serving of each page request into two phases:

(1)

Matching. Update $X_{t}$ so that the page requests in $A_{t}$ and $B_{t}$ that are to be removed are unmatched. (Note that page requests are removed either because the corresponding page was requested again or because the corresponding page was evicted.)
(2)

Updating. Replace a page request from each of $A_{t}$ and $B_{t}$ with the new request and insert the new page request pair $(t,t)$ into $X_{t}$ .

We first analyze how updating affects the potential $\Phi$ . This operation always decreases $\Phi_{0}$ and $\Phi_{1}$ each by $1$ , since we remove an unmatched pair. Next, for $\Phi_{2}$ , observe that for a matched pair $(a,b)$ , the difference $z_{b}-z_{a}$ increases on the $t$ -th request only if there exists a $p\in B_{t}$ such that $\sigma_{p}=\sigma_{t}$ and $h_{b}<h_{p}\leq h_{a}$ . In this case, the pair $(p,b)$ also forms an inversion. Any inversion $(p,b)$ is counted at most once this way because $p$ is evicted from $b$ . Thus, we have $\Delta\Phi_{2}\leq\Delta M$ .

We now analyze the matching phase with a case analysis:

(1)
The requested page is in both $A_{t}$ and $B_{t}$ .
- •
  
  The previous page requests for $\sigma_{t}$ in $A_{t}$ and $B_{t}$ are matched to each other, so we can just unmatch them.
- •
  As a result:
  - –
    
    $\Delta\Phi_{0}=1$ .
  - –
    
    $\Delta\Phi_{1}=1$ .
  - –
    
    $\Delta\Phi_{2}=0$ , since the pages were matched to each other.
(2)
The requested page is in $A_{t}$ only.
1. (a)
  The previous request $p\in A_{t}$ for the requested page is matched as $(p,d)$ and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is matched as $(c,b)$ .
  - •
    
    Unmatch $(p,d)$ and $(c,b)$ and then match $(c,d)$ . The latter is okay since $h_{c}\geq h_{b}\geq h_{d}$ . Note that $p\neq d$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    $\Delta\Phi_{1}\leq 1$ .
    
    –
    
    $\Delta\Phi_{2}=z_{p}-(k-1)$ , since $\varphi^{B}_{b}=0$ and $\varphi^{A}_{p}=(k-1)-z_{p}$ .
    
    –
    
    $\Delta M\geq z_{p}$ , since the arrival of $\sigma_{p}$ also generates $z_{p}$ inversions of the form $(p,b^{\prime})$ for all $b^{\prime}\in B_{t}$ such that $h_{p}\geq h_{b^{\prime}}$ .
2. (b)
  The previous request $p\in A_{t}$ for the requested page is matched as $(p,d)$ and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is unmatched.
  - •
    
    Unmatch $(p,d)$ . Note that $p\neq d$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    $\Delta\Phi_{1}=0$ .
    
    –
    
    $\Delta\Phi_{2}\leq z_{p}$ , since $\varphi^{A}_{p}=(k-1)-z_{p}$ and $\varphi^{B}_{d}=z_{d}-(k-1)\geq-(k-1)$ .
    
    –
    
    $\Delta M\geq z_{p}$ , since the arrival of $\sigma_{p}$ also generates $z_{p}$ inversions of the form $(p,b^{\prime})$ for all $b^{\prime}\in B_{t}$ such that $h_{p}\geq h_{b^{\prime}}$ .
3. (c)
  The previous request $p\in A_{t}$ for the requested page is unmatched and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is matched as $(c,b)$ .
  - •
    
    Unmatch $(c,b)$ and match $(c,d)$ for an arbitrary unmatched $d\in B_{t}\setminus\{b\}$ . Doing so is okay because $h_{c}\geq h_{b}\geq h_{d}$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\Phi_{0}=0$ .
    
    –
    
    $\Delta\Phi_{1}\leq 1$ .
    
    –
    
    $\Delta\Phi_{2}\leq 0$ , since $\varphi^{B}_{b}=0$ and $-\varphi^{B}_{d}=(k-1)-z_{d}\geq 0$ .
4. (d)
  The previous request $p\in A_{t}$ for the requested page is unmatched and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is unmatched.
  - •
    
    Do nothing.
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
(3)
The requested page is in $B_{t}$ only.
1. (a)
  The previous request $p\in B_{t}$ for the requested page is matched as $(c,p)$ and the page request $a\in A_{t}$ evicted by $\mathcal{A}$ is matched as $(a,d)$ .
  - •
    
    Unmatch $(c,p)$ and $(a,d)$ . Note that $c\neq p$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=2$ .
    
    –
    
    If $a=d$ , then $\Delta\Phi_{1}=1$ and $\varphi^{A}_{a}+\varphi^{B}_{d}=0$ ; otherwise, $a\neq d$ , in which case $\Delta\Phi_{1}=0$ and $\varphi^{A}_{a}+\varphi^{B}_{d}\geq-(k-1)$ .
    
    –
    
    Moreover, $\varphi^{A}_{c}+\varphi^{B}_{p}\geq-(k-1)$ .
2. (b)
  The previous request $p\in B_{t}$ for the requested page is matched as $(c,p)$ and the page request $a\in A_{t}$ evicted by $\mathcal{A}$ is unmatched.
  - •
    
    Unmatch $(c,p)$ . Note that $c\neq p$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    $\Delta\Phi_{1}=0$ .
    
    –
    
    $\Delta\Phi_{2}\leq k-1$ , since $\varphi^{A}_{c}+\varphi^{B}_{p}\geq-(k-1)$ .
3. (c)
  The previous request $p\in B_{t}$ for the requested page is unmatched and the page request $a\in A_{t}$ evicted by $\mathcal{A}$ is matched as $(a,d)$ .
  - •
    
    Unmatch $(a,d)$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    If $a=d$ , then $\Delta\Phi_{1}=1$ and $\varphi^{A}_{a}+\varphi^{B}_{d}=0$ ; otherwise, $a\neq d$ , in which case $\Delta\Phi_{1}=0$ and $\varphi^{A}_{a}+\varphi^{B}_{d}\geq-(k-1)$ .
4. (d)
  The previous request $p\in B_{t}$ for the requested page is unmatched and the page request $a\in A_{t}$ evicted by $\mathcal{A}$ is unmatched.
  - •
    
    Do nothing.
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
(4)
The requested page is in neither $A_{t}$ nor $B_{t}$ .
1. (a)
  The previous request $a\in A_{t}$ evicted by $\mathcal{A}$ is matched as $(a,d)$ and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is matched as $(c,b)$ .
  - •
    
    Unmatch $(a,d)$ and $(c,b)$ and then match $(c,d)$ . The latter is okay because $h_{c}\geq h_{b}\geq h_{d}$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    $\Delta\Phi_{1}\leq 2$ .
    
    –
    
    $\Delta\Phi_{2}\leq 0$ , since $\varphi^{A}_{a}\geq 0$ and $\varphi^{B}_{b}=0$ .
2. (b)
  The previous request $a\in A_{t}$ evicted by $\mathcal{A}$ is matched as $(a,d)$ and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is unmatched.
  - •
    
    Unmatch $(a,d)$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=1$ .
    
    –
    
    If $a=d$ , then $\Delta\Phi_{1}=1$ and $\varphi^{A}_{a}+\varphi^{B}_{d}=0$ ; otherwise, $a\neq d$ , in which case $\Delta\Phi_{1}=0$ and $\varphi^{A}_{a}+\varphi^{B}_{d}\geq-(k-1)$ .
3. (c)
  The previous request $a\in A_{t}$ evicted by $\mathcal{A}$ is unmatched and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is matched as $(c,b)$ .
  - •
    
    Unmatch $(c,b)$ and match $(c,d)$ .
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\mathsf{OPT}=1$ .
    
    –
    
    $\Delta\Phi_{0}=0$ .
    
    –
    
    $\Delta\Phi_{1}\leq 1$ .
    
    –
    
    $\Delta\Phi_{2}\leq 0$ , since $\varphi^{B}_{b}=0$ and $-\varphi^{B}_{d}=(k-1)-z_{d}\geq 0$ .
4. (d)
  The previous request $a\in A_{t}$ evicted by $\mathcal{A}$ is unmatched and the page request $b\in B_{t}$ evicted by $\mathcal{B}$ is unmatched.
  - •
    
    Do nothing.
  - •
    
    As a result:
    
    –
    
    $\Delta\mathsf{ALG}_{\mathcal{B}}=1$ .
    
    –
    
    $\Delta\mathsf{OPT}=1$ .

Since $\Phi_{1}$ and $\Phi_{2}$ each decrease by $1$ in the updating phase, we have $2(k-1)$ in extra potential that we can use to pay for costs in the matching phase. Indeed, one can verify that this is sufficient for all of the cases described above—the tight cases are 2(a), 2(b), 2(c), 3(a), and 4(a). Thus, the proposition follows. ∎

Proposition 4.2.

The competitive ratio of algorithm $\mathcal{B}$ is at most $2+4\varepsilon/(k-1)$ .

Proof.

Compose Proposition 4.1 with Lemma 2.3. ∎

Remark.

This analysis of BlindOracle is tight in the constant term—we can make $\varepsilon/(k-1)$ arbitrarily small while having a competitive ratio of $2$ . (However, for very small $\varepsilon$ , the bound of the previous section is better—in particular, if $\varepsilon<\frac{1}{2}+\frac{1}{k-3}$ .)

5. Proofs of Upper Bounds

We are now ready to prove the results stated in Section 1: \maintheorem*

Proof.

From the analysis of the previous two sections, the desired bound immediately follows from taking the minimum of the bounds in Propositions 3.2, LABEL: and 4.2. ∎

\firstcorollary

Proof.

Combine BlindOracle with LRU using the “combiner” from Theorem 2.1, with the performance of BlindOracle being bounded by LABEL:theorem:main. ∎

\secondcorollary

Proof.

Like in the proof above, combine BlindOracle with algorithm Equitable of [ACN00]⁶⁶6We use Equitable because it achieves the optimal worst-case competitive ratio of $H_{k}$ for online caching; Marker has a competitive ratio of $2H_{k}-1$ [ACN00]., this time using the “combiner” from Theorem 2.2. ∎

6. Deterministic Lower Bound

We now show that combining BlindOracle with LRU gets an optimal competitive ratio bound (in terms of $\eta$ , $\mathsf{OPT}$ , and $k$ ) among all deterministic algorithms for learning-augmented online caching by proving LABEL:theorem:lower:

\lowerboundtheorem

Proof.

Let $\mathcal{A}$ be any deterministic algorithm for learning-augmented online caching.

We show there exists a family of inputs $(\sigma,h)$ with $\varepsilon/k$ ranging from $0$ to $k$ and $\mathsf{OPT}$ arbitrarily large such $\mathsf{ALG}_{\mathcal{A}}\geq\mathsf{OPT}+C\eta/k$ , for some constant $C>0$ . That is, for $\varepsilon/k$ ranging from $0$ to $k$ , we will show that we can make this inequality hold as $\mathsf{OPT}\to\infty$ with $\varepsilon/k$ fixed. Dividing through by $\mathsf{OPT}$ then implies the theorem.

We now construct such inputs $(\sigma,h)$ . First, fix $j<k$ . Let $P_{1},\ldots,P_{k},Q_{0}$ be $k+1$ distinct pages. We make the following sequence of requests, which we call a phase:

(1)
Repeat $k$ times the following:
1. (a)
  
  Make requests to $P_{1},\ldots,P_{k}$ in order, predicting each page to next appear $k$ requests from now except during the last iteration, where we predict each page to next appear $k+j+1$ requests from now.
(2)

Make a request to $Q_{0}$ and predict that it will next appear $k^{2}+j+1$ pages from now.
(3)
For $i=1,\ldots,j$ :
1. (a)
  
  Request the page evicted by in $\mathcal{A}$ during the previous request, if it exists. Otherwise, request an arbitrary page. For each page, provide the same prediction as the last time this page was requested.

We repeat the above as many times as needed.

In a single phase, observe that $\mathsf{OPT}$ makes at most two evictions—once to evict $Q_{0}$ and once upon the arrival of $Q_{0}$ . On the other hand, I claim $\mathcal{A}$ makes at least $j+1$ evictions. First, if the cache of $\mathcal{A}$ after (1) does not consist of $P_{1},\ldots,P_{k}$ , then $\mathcal{A}$ must have incurred cost at least $k\geq j+1$ during (1). Thus, we may assume that $\mathcal{A}$ ’s cache consists of $P_{1},\ldots,P_{k}$ after (1). If so, $\mathcal{A}$ has to evict a page for each of the remaining $j+1$ requests in the phase, as the arrival of $Q_{0}$ forces an eviction and by induction, each arrival of (3) forces an eviction. Finally, observe that all the predictions are accurate except those for pages arriving in (3), in which case they are off by at most $k+j+1\leq 2k$ . Thus, over a single phase, $\eta\leq 2jk$ . Putting all of these observations together, we get $\mathsf{ALG}_{\mathcal{A}}\geq j+1\geq\mathsf{OPT}+j-1$ , with $j-1=\Omega(\eta/k)$ .

To make $\mathsf{OPT}$ arbitrarily large, note that we can simply repeat the above phase multiple times in sequence; the same analysis holds, with all the values scaling linearly. Hence we have $\mathsf{ALG}_{\mathcal{A}}\geq\mathsf{OPT}+\Omega(\eta/k)$ for arbitrarily large $\mathsf{OPT}$ over the desired range of $\varepsilon/k$ , so the theorem follows. ∎

Acknowledgments

I would like to thank Jelani Nelson for advising this project and Bailey Flanigan for providing many helpful references.

References

[ACE+20] Antonios Antoniadis et al. “Online metric algorithms with untrusted predictions” In CoRR abs/2003.02144, 2020
[ACN00] Dimitris Achlioptas, Marek Chrobak and John Noga “Competitive analysis of randomized paging algorithms” In Theor. Comput. Sci. 234.1-2, 2000, pp. 203–218
[BB00] Avrim Blum and Carl Burch “On-line Learning and the Metrical Task System Problem” In Mach. Learn. 39.1, 2000, pp. 35–58
[BBN12] Nikhil Bansal, Niv Buchbinder and Joseph Naor “A Primal-Dual Randomized Algorithm for Weighted Paging” In J. ACM 59.4, 2012, pp. 19:1–19:24
[BBN12a] Nikhil Bansal, Niv Buchbinder and Joseph Naor “Randomized Competitive Algorithms for Generalized Caching” In SIAM J. Comput. 41.2, 2012, pp. 391–414
[BE98] Allan Borodin and Ran El-Yaniv “Online computation and competitive analysis” Cambridge University Press, 1998
[BFK+17] Joan Boyar et al. “Online Algorithms with Advice: A Survey” In ACM Comput. Surv. 50.2, 2017, pp. 19:1–19:34
[BS12] Sébastien Bubeck and Aleksandrs Slivkins “The Best of Both Worlds: Stochastic and Adversarial Bandits” In COLT 2012 - The 25th Annual Conference on Learning Theory, June 25-27, 2012, Edinburgh, Scotland, 2012, pp. 42.1–42.23
[DIR+19] Yihe Dong, Piotr Indyk, Ilya P. Razenshteyn and Tal Wagner “Learning Sublinear-Time Indexing for Nearest Neighbor Search” In CoRR abs/1901.08544, 2019
[FKL+91] Amos Fiat et al. “Competitive Paging Algorithms” In J. Algorithms 12.4, 1991, pp. 685–699
[GP19] Sreenivas Gollapudi and Debmalya Panigrahi “Online Algorithms for Rent-Or-Buy with Expert Advice” In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, 2019, pp. 2319–2327
[HIK+19] Chen-Yu Hsu, Piotr Indyk, Dina Katabi and Ali Vakilian “Learning-Based Frequency Estimation Algorithms” In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019
[KBC+18] Tim Kraska et al. “The Case for Learned Index Structures” In Proceedings of the 2018 International Conference on Management of Data, SIGMOD Conference 2018, Houston, TX, USA, June 10-15, 2018, 2018, pp. 489–504
[KP00] Elias Koutsoupias and Christos H. Papadimitriou “Beyond Competitive Analysis” In SIAM J. Comput. 30.1, 2000, pp. 300–317
[KPS+19] Ravi Kumar et al. “Semi-Online Bipartite Matching” In 10th Innovations in Theoretical Computer Science Conference, ITCS 2019, January 10-12, 2019, San Diego, California, USA, 2019, pp. 50:1–50:20
[KPS+20] Ravi Kumar, Manish Purohit, Zoya Svitkina and Erik Vee “Interleaved Caching with Access Graphs” In Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, 2020, pp. 1846–1858
[LLM+20] Silvio Lattanzi, Thomas Lavastida, Benjamin Moseley and Sergei Vassilvitskii “Online Scheduling via Learned Weights” In Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, 2020, pp. 1859–1877
[LV18] Thodoris Lykouris and Sergei Vassilvitskii “Competitive Caching with Machine Learned Advice” In Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmässan, Stockholm, Sweden, July 10-15, 2018, 2018, pp. 3302–3311
[MGZ12] Vahab S. Mirrokni, Shayan Oveis Gharan and Morteza Zadimoghaddam “Simultaneous approximations for adversarial and stochastic online budgeted allocation” In Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2012, Kyoto, Japan, January 17-19, 2012, 2012, pp. 1690–1701
[Mit18] Michael Mitzenmacher “A Model for Learned Bloom Filters and Optimizing by Sandwiching” In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montréal, Canada, 2018, pp. 462–471
[Mit20] Michael Mitzenmacher “Scheduling with Predictions and the Price of Misprediction” In 11th Innovations in Theoretical Computer Science Conference, ITCS 2020, January 12-14, 2020, Seattle, Washington, USA, 2020, pp. 14:1–14:18
[MNS12] Mohammad Mahdian, Hamid Nazerzadeh and Amin Saberi “Online Optimization with Uncertain Information” In ACM Trans. Algorithms 8.1, 2012, pp. 2:1–2:29
[MV17] Andres Muñoz Medina and Sergei Vassilvitskii “Revenue Optimization with Approximate Bid Predictions” In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, 2017, pp. 1858–1866
[PSK18] Manish Purohit, Zoya Svitkina and Ravi Kumar “Improving Online Algorithms via ML Predictions” In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS 2018, 3-8 December 2018, Montréal, Canada, 2018, pp. 9684–9693
[Roh20] Dhruv Rohatgi “Near-Optimal Bounds for Online Caching with Machine Learned Advice” In Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, 2020, pp. 1834–1845
[Rou19] Tim Roughgarden “Beyond worst-case analysis” In Commun. ACM 62.3, 2019, pp. 88–96
[ST85] Daniel Dominic Sleator and Robert Endre Tarjan “Amortized Efficiency of List Update and Paging Rules” In Commun. ACM 28.2, 1985, pp. 202–208

Better and Simpler Learning-Augmented Online Caching

Abstract.

1. Introduction

1.1. Our Contribution

Theorem 1.1 (restate=maintheorem,label=theorem:main).

Corollary 1.2 (restate=firstcorollary,label=corollary:det).

Corollary 1.3 (restate=secondcorollary,label=corollary:rand).

Theorem 1.4 (restate=lowerboundtheorem,label=theorem:lower).

1.2. Related Work

1.3. Recent Developments

2. Preliminaries

2.1. Setup and Notation

2.1.1. Inversions

2.1.2. BlindOracle

2.2. Combining Online Algorithms Competitively

Theorem 2.1 ([FKL+91], special case).

Theorem 2.2 ([BB00], special case).

Remark.

2.3. From ℓ1\ell_{1} Loss to Inversions

Lemma 2.3 ([Roh20]).

3. A First Analysis of BlindOracle

Proposition 3.1.

Proof.

Proposition 3.2.

Proof.

4. A More Careful Analysis

Proposition 4.1.

Proof.

Proposition 4.2.

Proof.

Remark.

5. Proofs of Upper Bounds

Proof.

Proof.

Proof.

6. Deterministic Lower Bound

Proof.

Acknowledgments

References

2.3. From $\ell_{1}$ Loss to Inversions