BCR 2023, Lemma 12 — chunk systems of ratio at every level
OpenKServer.bcr_level_familyBubeck--Coester--Rabani, Lemma 12: the recursive family of chunk systems.
Small set chasing (metrical service systems) asks a single server -- the evader -- to move into each of a sequence of requested subsets of a metric space, paying the distance travelled. Bubeck, Coester and Rabani build, by recursion on a level parameter , a family of finite metric spaces with marked points carrying random request sequences against which every online evader must pay times the offline optimum. The bookkeeping device for the recursion is a chunk system.
A chunk system ChunkSystemB X s t cLo cHi T price M between two marked points of a metric space consists of a finitely supported random sequence of chunks of set requests, adapted to an explicit filtration, together with adapted sizes lying in , such that the last request is , an offline server starting at serves the whole sequence for at most , the expected total of the sizes is at least , and, conditionally on the history, every deterministic online evader pays at least the size of the current chunk while serving that chunk -- even if it is allowed to escape the chunk for a one-time price.
The statement asserts that there are a constant and a base such that for every level there is a finite metric space with
carrying a chunk system between and , with size floor , nonnegative escape price and trivial initial history, whose expected total obeys
The two numerical constraints are exactly those of the paper's construction: each level replaces the space by a theta gluing of two three-copy chains, which multiplies the number of points by at most and the distance between the marked points by exactly . The ratio therefore grows like the square of the level, i.e. like the square of the logarithm of the number of points.
Role. Together with the level-to-cardinality packaging already verified on the platform, this yields KServer.bcr_chunk_system_family (chunk systems of ratio on at most points), hence KServer.bcr_hard_chunk_system, hence the small set chasing lower bound KServer.mss_randomized_lower_bound, and finally the randomized -server lower bound. All of those derivations are machine-checked, so this statement is what remains of the refutation of the randomized -server conjecture.
Formalization note. The carrier is existentially quantified as a bare Type with its MetricSpace and Fintype instances, and the cardinality and distance constraints are stated separately, so a construction is free to produce whatever space the recursion builds -- for instance the platform's bcrLevel2 family, whose cardinality and distance bounds are already proved. The size ceiling, escape price and number of chunks are existential, since only the ratio between the expected total and matters downstream. Triviality of the initial history is required because the platform's level-step and mapping combinators both assume and preserve it.
import Mathlib import Definitions.Def_KServer_model import Definitions.Def_KServer_evader import Definitions.Def_KServer_evader_bail import Definitions.Def_KServer_chunk_system_b
namespace KServer
theorem bcr_level_family :
∃ α : ℝ, 0 < α ∧ ∃ β : ℕ, 0 < β ∧ ∀ w : ℕ,
∃ (X : Type) (mX : MetricSpace X) (fX : Fintype X) (s t : X),
@Fintype.card X fX ≤ (β + 1) * 6 ^ w ∧
@dist X mX.toDist s t = (β : ℝ) * 3 ^ w ∧
∃ (cHi price : ℝ) (M : ℕ)
(C : @ChunkSystemB X mX s t 0 cHi
(α * (w : ℝ) ^ 2 * ((β : ℝ) * 3 ^ w)) price M),
0 ≤ price ∧ (∀ ω₁ ω₂ : C.Ω, C.hist 0 ω₁ = C.hist 0 ω₂) := by sorry
end KServer