BCR 2023, Lemma 12 — a chunk system on points with expected total
OpenKServer.bcr_hard_chunk_systemA hard chunk system on points: the recursive core of the Bubeck--Coester--Rabani lower bound.
Small set chasing (metrical service systems, MSS) asks a single server -- the evader -- to move into each of a sequence of requested subsets of a metric space, paying the distance travelled. The Bubeck--Coester--Rabani refutation of the randomized -server conjecture builds, for every , a -point metric space on which small set chasing has randomized competitive ratio .
The engine of that construction is their Lemma 12: a chunk system. Given a metric space with two marked points , a chunk system is a finitely supported random sequence of chunks of set requests, adapted to an explicit filtration, together with adapted sizes such that
- the last request of the last chunk is , and an offline server can serve the whole sequence from for cost at most ;
- conditionally on the history before chunk , every deterministic online evader pays at least on chunk in expectation, even when an escape price is available on that chunk;
- the sizes lie in the prescribed window, and the expected total is at least .
This is the structure ChunkSystemB X s t cLo cHi T price M of the platform's definition file.
The statement asserts that there are a constant and a threshold such that for every one can put a metric on the -point set, choose two points in it, and construct a chunk system between them (with size floor , some ceiling, some nonnegative escape price and some number of chunks) whose expected total satisfies
In other words: a single run of the instance forces every online evader to pay times what the offline optimum pays, on a space of only points.
Why this is the remaining gap. Together with the standard repetition argument -- concatenating independent runs, each followed by a request that forces the evader back to the start -- this lemma yields the full distributional (Yao-form) statement of BCR's Theorem 11, KServer.mss_randomized_lower_bound, and hence the randomized -server lower bound. That derivation is already machine-checked on the platform; what remains is the construction stated here.
Formalization note. The metric is existentially quantified as a MetricSpace (Fin (k+1)) instance, so the carrier has exactly points; a construction on fewer points must be padded (for instance by clones at a tiny distance) to reach exactly . The size floor is fixed to while the ceiling, the escape price and the number of chunks are existential, since only the expected total matters downstream. Distances are unnormalized: the bound is the scale-invariant ratio .
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_hard_chunk_system :
∃ c : ℝ, 0 < c ∧ ∃ k₀ : ℕ, ∀ k : ℕ, k₀ ≤ k →
∃ (m : MetricSpace (Fin (k + 1))) (s t : Fin (k + 1)) (cHi T price : ℝ) (M : ℕ),
0 ≤ price ∧
0 < @dist (Fin (k + 1)) m.toDist s t ∧
c * Real.log k ^ 2 * @dist (Fin (k + 1)) m.toDist s t ≤ T ∧
Nonempty (@ChunkSystemB (Fin (k + 1)) m s t 0 cHi T price M) := by sorry
end KServer