Competitive Paging Algorithms III: No Randomized Paging Algorithm Is Better than H_k-CompetitiveResearch Paper
Motivation
Paging is the problem of managing a two-level memory: a cache holds of the pages a program uses, every request must find its page in the cache, and a request to a page outside the cache (a page fault) forces the algorithm to bring the page in and evict another. An on-line algorithm chooses what to evict without seeing future requests. Sleator and Tarjan (CACM 1985) measured on-line paging algorithms against the optimal off-line algorithm, which knows the whole request sequence, and showed that no deterministic on-line algorithm can be within a factor smaller than of it.
Randomization changes that picture. Fiat, Karp, Luby, McGeoch, Sleator and Young (J. Algorithms 1991; arXiv:cs/0205038) gave a randomized algorithm, the marking algorithm, whose expected number of faults is within of the optimum, where . This mission formalizes the other half of their paper's picture: no randomized paging algorithm can do better than . The bound says that the logarithmic behaviour is not an artefact of one algorithm but a property of the problem.
Timeline:
- 1985 — Sleator and Tarjan: deterministic paging algorithms have competitive factor at least ; LRU and FIFO achieve .
- 1988 — Karlin, Manasse, Rudolph and Sleator (Algorithmica 3, 1988) introduce the term competitive; Manasse, McGeoch and Sleator (STOC 1988; J. Algorithms 1990) extend it to randomized algorithms and pose the -server problem, of which paging is the uniform-metric case.
- 1991 — Fiat et al.: the marking algorithm is -competitive, and no randomized algorithm is better than -competitive (Theorem 4 and Corollary 5 of the paper). Raghavan gave an alternative proof of the lower bound through Yao's minimax principle.
- 1991 — McGeoch and Sleator give an -competitive randomized paging algorithm (Algorithmica 6, 1991), so the lower bound is tight.
Setting
Let be a set of vertices with the uniform metric: any two distinct vertices are at distance . A configuration of servers is a map ; server sits at , and a vertex is covered when some server sits on it. A request sequence is a finite list of vertices. A deterministic on-line algorithm assigns to every prefix of requests the configuration after serving it, in such a way that the vertex just requested is covered; its cost on is the total distance travelled by its servers, which on the uniform metric is the number of server moves. Paging with cache slots and pages is exactly this -server problem on uniform vertices.
The optimal off-line cost is the least cost of any schedule of configurations that starts at and covers each request of in turn.
A randomized on-line algorithm is a probability space of coin outcomes together with a deterministic on-line algorithm for each outcome . Its expected cost is the average of the cost of on over . The request sequence is fixed in advance and does not depend on the coins (an oblivious adversary). Following the paper, is -competitive from the initial configuration if there is a constant such that
For the lower-bound argument, the probability vector after a prefix has equal to the probability, over , that vertex is not covered by after serving . A set of marked vertices and the number of unmarked vertices are bookkeeping of the adversary, updated as the marking algorithm would update them.
Formalization targets
Goal: Corollary 5
For , every randomized on-line algorithm with servers on uniform vertices, every initial configuration and every real ,
Theorem 4 (milestone)
The case : no randomized algorithm for the uniform -server problem on vertices is -competitive with .
Claims of the proof of Theorem 4 (milestones)
With the probability vector, the marked set, and :
Significance
The result. Together with the marking algorithm's upper bound, the corollary pins the randomized competitive ratio of paging to , an exponential improvement over the deterministic ratio that no randomized algorithm can push below . For the marking algorithm itself is -competitive, so Theorem 4 makes it optimal there. The bound is the benchmark every later randomized paging algorithm is measured against, including the -competitive algorithm of McGeoch and Sleator, and it is the uniform-metric base case of the randomized -server conjecture.
Formalizing it. The theorem is proved and classical; no machine-checked proof is known to exist. The platform already has the deterministic bound (KServer.uniform_not_competitive_below_k, ratio ) and a formal Yao averaging principle for randomized -server algorithms (KServer.randomized_yao_averaging), but no randomized paging lower bound. This mission produces the first formal lower bound, stated against the published randomized -server model, and a formal version of the paper's adversary argument. Either route — the paper's adaptive construction of a nemesis sequence from the probability vector, or Raghavan's distributional argument through Yao's principle — is welcome.
Difficulty
The adversary may not look at the coins, yet it must build one fixed sequence against which the expected cost is high in every phase. Requesting an uncovered vertex is not available, since which vertex is uncovered depends on the coins; requesting the vertex with the largest uncovered probability gives only per request and loses the harmonic sum. Lifting the per-phase bound to the asymptotic statement also requires handling the additive constant , the initial configuration of the off-line algorithm, and, for Corollary 5, the reduction from vertices to of them for an algorithm that may still place servers on the others.
Formalization scope
The Lean development reuses the published definitions KServer_model (configurations Fin k → M, deterministic on-line algorithms as functions of the request prefix, offlineCost) and KServer_randomized (RandomizedAlgorithm: a probability measure on coin outcomes, a deterministic algorithm per outcome, measurable costs; expCost as a lower Lebesgue integral in ; IsCompetitiveFrom C₀ c: every drawn algorithm starts at and there is one constant , fixed before the sequence, with expCost σ ≤ ENNReal.ofReal (c * offlineCost C₀ σ + a)). The clamp at in ENNReal.ofReal only weakens the property the goal refutes. The vertex set is an abstract type with an equivalence Fin n ≃ M and the uniform metric as a hypothesis, never the line metric of Fin n. is Mathlib's harmonic k cast to . The goal quantifies over every algorithm and every initial configuration, with no laziness or distinct-positions assumption, and over every real , including .
A formalization in which competitiveness is vacuous (a model with no algorithms, or a cost that is always infinite), in which the adversary may choose the sequence after seeing the coins, or which fixes or the additive constant, would be a different statement and is ruled out by the published definitions used here.
The probability vector is the one new definition, uncoveredProb A σ i. Milestones about it assume the uncovered events measurable, the standing convention that is a probability; the model itself only guarantees measurable costs. The milestone assumes the servers occupy distinct vertices, as in the paper; in general . The arithmetic milestones are stated for an arbitrary probability vector on a finite set. Reusable pieces: the probability vector and the cost lemma apply to any randomized -server algorithm on a uniform metric, and a restriction lemma (from vertices to ) would serve other paging lower bounds.
Selected references
- A. Fiat, R. M. Karp, M. Luby, L. A. McGeoch, D. D. Sleator, N. E. Young, Competitive Paging Algorithms, J. Algorithms 12(4):685–699, 1991. https://doi.org/10.1016/0196-6774(91)90041-V ; preprint arXiv:cs/0205038v1 (cited version). https://arxiv.org/abs/cs/0205038
- D. D. Sleator, R. E. Tarjan, Amortized Efficiency of List Update and Paging Rules, Comm. ACM 28(2):202–208, 1985. https://doi.org/10.1145/2786.2793
- M. S. Manasse, L. A. McGeoch, D. D. Sleator, Competitive Algorithms for Server Problems, J. Algorithms 11(2):208–230, 1990. https://doi.org/10.1016/0196-6774(90)90003-W
- L. A. McGeoch, D. D. Sleator, A Strongly Competitive Randomized Paging Algorithm, Algorithmica 6:816–825, 1991.
- P. Raghavan, Lecture Notes on Randomized Algorithms, IBM Research Report, Yorktown Heights, 1990 (the alternative proof of the lower bound, pp. 118–119).