BCR Claim 13: the subchunk system of one level, at the tight escape price
OpenKServer.bcr_claim13_tight_subchunksClaim 13 of Bubeck--Coester--Rabani, in the form the regrouping of Lemma 15 consumes.
Let be the level- space of the recursive BCR family, with marked points at distance , and let be the level invariant KServer.BCRInductiveChunksTight: a chunk system with online escapes on with sizes in , expected total at least , escape price , exactly chunks, constant initial information and no empty chunk.
Statement. Fix constants and an integer subject to the smallness relation , and let be a level with . If holds, then on the next level's space there are reals with
and a chunk system with online escapes between and whose
- size floor is and whose size ceiling is ;
- escape price is , unchanged from level ;
- Doob martingale of the total mass has one-step jumps at most ;
- expected total mass is exactly ;
- initial information is constant, and no chunk is empty.
Content. This is the first half of one level of BCR's Lemma 12, namely Claim 13: the three-stage construction of subchunks on the six-copy next-level space --- stage 1, the stage-2a race with its anti-concentration gain, stage 2b and stage 3. Stages 1, 2b and 3 contribute three copies of the level- mass, so the mass triples while the distance triples too; the race must contribute the further chunk masses that raise the competitive ratio from to . That is what the smallness relation is for: the anti-concentration gain of a race of steps with chunk masses of order is of order , which dominates the required increment exactly when is small enough.
Two features of the conclusion are normalisations rather than content. Fixing the expected total exactly at the level- target is free once at least that much mass has been produced, because the sizes of a chunk system may always be scaled down: every hypothesis of KServer.ChunkSystemB is monotone in the sizes. And bounding the ceiling plus the Doob jump by is precisely the budget that the regrouping needs: the level- window is centred at with half-width , and a regrouping into chunks of mean mass spends of that half-width on each side, plus a further for the integrality of the chunk count; leaves both affordable as soon as .
Why this formulation. Together with the zero-floor regrouping KServer.chunk_combining_zero_floor this statement gives one full level of the induction: regrouping the subchunk system into chunks of mean mass puts the sizes inside the level- window, raises the escape price from to at most , and preserves the total, the constant initial information and the nonemptiness of the chunks --- which is exactly .
What remains for a prover. The parameter schedule of the race inside Claim 13: the number of coin steps , the tie-break scale , the floor used in the anti-concentration bound and the depth of the sturdiness invariant, subject to the gain of KServer.level_step_sturdy exceeding the losses it charges. Note that the level invariant supplies the sturdiness, Doob-jump and variance hypotheses of that step only through the crude window bounds of KServer.chunk_window_invariants and KServer.chunk_window_variance, whose defect is of the same order as the whole mass; sharpening that, or carrying a regularity invariant through the construction, is the substance of the claim.
import Mathlib import Definitions.Def_KServer_bcr_induction_tight import Definitions.Def_KServer_chunk_cond
namespace KServer
theorem bcr_claim13_tight_subchunks (α : ℝ) (hα : 0 < α) (hα1 : α ≤ 1)
(β : ℕ) (hβ : 0 < β) (hβ2 : 2 ≤ β) (hsmall : α * (β : ℝ) ≤ 1 / 10 ^ 6)
(w : ℕ) (hw : 1 < α * ((w + 1 : ℕ) : ℝ) ^ 2)
(hC : BCRInductiveChunksTight α β hβ w) :
∃ cB jbS : ℝ, 0 ≤ cB ∧ 0 ≤ jbS ∧ cB + jbS ≤ 11 / 8 * (3 : ℝ) ^ w ∧
∃ C : @ChunkSystemB (bcrLevel2 β hβ (w + 1)).carrier
(bcrLevel2 β hβ (w + 1)).metric
(bcrLevel2 β hβ (w + 1)).s (bcrLevel2 β hβ (w + 1)).t
0 cB ((α * β * ((w + 1 : ℕ) : ℝ) ^ 2) * 3 ^ (w + 1)) ((β : ℝ) * 3 ^ w) 0,
(∑ ω, C.P ω * ∑ i, C.size ω i)
= (α * β * ((w + 1 : ℕ) : ℝ) ^ 2) * 3 ^ (w + 1) ∧
(∀ ω₁ ω₂ : C.Ω, C.hist 0 ω₁ = C.hist 0 ω₂) ∧
(∀ (ω : C.Ω) (i : Fin C.m), C.chunk ω i ≠ []) ∧
C.DoobJumpBound jbS := by sorry
end KServer