import Mathlib
import OAI.Combinatorics.KServer.Tiers

namespace OAI

noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualRoster
open RosterLifetimes FiniteBallLaw PartitionProbabilities Chronological
attribute [local instance] Classical.propDecidable Classical.decEq

lemma final_survival {K a : ℕ} (hK : 2 ≤ K) (ha : a+1=K^2) :
    actualPresence K a=survive (1/(K:ℝ)) (K^2-K) := by
  have hkk : K+1 ≤ K^2 := by nlinarith
  have hak : ¬a<K := by omega
  have hac : a<K^2 := by omega
  have he : a-K+1=K^2-K := by omega
  simp only [actualPresence,ite_eq_right hak,ite_eq_left hac,he]

/-- Unconditional marginal death bound. The extra tail is never interpreted
as a conditional compulsory hazard. -/
lemma death_marginal {K a b : ℕ} (hK : 2 ≤ K) (hab : a ≤ b) (hba : b ≤ a+1) :
    (∑ d : Lifetime K, if alive K a d ∧ ¬alive K b d then lifetimeLaw K d else 0) ≤
      (1/(K:ℝ))*actualPresence K a+
        if a<K^2 then survive (1/(K:ℝ)) (K^2-K) else 0 := by
  have hk : 1≤K := by omega
  have hq := (rate_range hk).1
  have hs := (survival_range hk a).1
  have ht := (survive_range (rate_range hk) (K^2-K)).1
  by_cases he : b=a
  · subst b
    simp only [and_not_self,ite_false,sum_const_zero]
    exact add_nonneg (mul_nonneg hq hs) (by split_ifs <;> positivity)
  · have hb : b=a+1 := by omega
    subst b
    rw [death_probability hk]
    by_cases hac : a<K^2
    · rw [ite_eq_left hac]
      by_cases hbc : a+1<K^2
      · exact (ordinary_death_bound hk hbc).trans (le_add_of_nonneg_right ht)
      · have heq : a+1=K^2 := by omega
        rw [actual_cutoff (a:=a+1) (by omega),sub_zero,final_survival hK heq]
        exact le_add_of_nonneg_left (mul_nonneg hq ht)
    · rw [ite_eq_right hac,actual_cutoff (le_of_not_gt hac),actual_cutoff (by omega)]
      simp

/-- A literal finite lifetime-tape first-coverer estimate.  The `S` hypothesis
is only a deterministic candidate count, and is discharged by chronological
ages below. -/
theorem first_retirement_bound {H K : ℕ} (hK : 2 ≤ K)
    (a b : Fin H → ℕ) (inc : ∀ i, a i≤b i ∧ b i≤a i+1)
    (cover : Fin H → Prop) (S : Finset (Fin H))
    (hS : ∀ i, cover i → a i<K^2 → i∈S) (hcard : S.card ≤ K^2) :
    PartitionProbabilities.probability (fun _ : Fin H=>lifetimeLaw K)
      (firstSeparation (fun i d=>cover i ∧ alive K (a i) d)
        (fun i d=>cover i ∧ alive K (a i) d ∧ ¬alive K (b i) d)) ≤ 49/(K:ℝ) := by
  have hk : 1≤K := by omega
  have hkp : (0:ℝ)<K := by exact_mod_cast (show 0<K by omega)
  let T : ℝ := survive (1/(K:ℝ)) (K^2-K)
  have hT : 0≤T := (survive_range (rate_range hk) _).1
  let ε : Fin H → ℝ := fun i=>if i∈S then (K:ℝ)*T else 0
  have heps : ∑ i, ε i=(K:ℝ)*T*S.card := by simp [ε,sum_ite_mem,mul_comm]
  have hh := SparseFirstHit.sparse_bound (fun _ : Fin H=>lifetimeLaw K)
    (fun _=>lifetime_nonneg hk) (fun _=>lifetime_sum hk)
    (hit:=fun i d=>cover i ∧ alive K (a i) d)
    (sep:=fun i d=>cover i ∧ alive K (a i) d ∧ ¬alive K (b i) d)
    (fun _ _ h=>⟨h.1,h.2.1⟩) ε (rate_range hk).1
    (fun i=>by dsimp [ε]; split_ifs <;> positivity)
  have hm (i : Fin H) : (∑ d, if cover i ∧ alive K (a i) d ∧ ¬alive K (b i) d then lifetimeLaw K d else 0) ≤
      (1/(K:ℝ))*((∑ d, if cover i ∧ alive K (a i) d then lifetimeLaw K d else 0)+ε i) := by
    by_cases hc : cover i
    · simp only [hc,true_and]
      rw [alive_probability hk]
      have hd := death_marginal hK (inc i).1 (inc i).2
      refine hd.trans ?_
      by_cases hy : a i<K^2
      · simp only [ite_eq_left hy,ε,ite_eq_left (hS i hc hy)]
        dsimp [T]
        field_simp
        exact le_rfl
      · simp only [ite_eq_right hy,add_zero]
        exact mul_le_mul_of_nonneg_left (le_add_of_nonneg_right (by dsimp [ε]; split_ifs <;> positivity)) (rate_range hk).1
    · simp only [hc,false_and,ite_false,sum_const_zero,zero_add]
      exact mul_nonneg (rate_range hk).1 (by dsimp [ε]; split_ifs <;> positivity)
  have hb := hh (fun i=>by
    convert hm i using 1
    · apply sum_congr rfl
      intro d _
      by_cases h : cover i ∧ alive K (a i) d ∧ ¬alive K (b i) d <;> simp [h]
    · apply congrArg (fun z : ℝ=>(1/(K:ℝ))*(z+ε i))
      apply sum_congr rfl
      intro d _
      by_cases h : cover i ∧ alive K (a i) d <;> simp [h])
  rw [heps] at hb
  have hc : (S.card:ℝ)≤(K:ℝ)^2 := by exact_mod_cast hcard
  have hfin : (1/(K:ℝ))*(1+(K:ℝ)*T*S.card) ≤ 1/(K:ℝ)+(K:ℝ)^2*T := by
    calc _ ≤ (1/(K:ℝ))*(1+(K:ℝ)*T*(K:ℝ)^2) := by gcongr
         _ = _ := by field_simp
  exact (hb.trans hfin).trans (actual_retirement_bound K hK)

variable {Y : Type*} [MetricSpace Y] [Fintype Y] {H K : ℕ}

/-- The unconditional first-coverer retirement estimate for an actual fixed
chronological roster and arbitrary fixed radii. Increment bounds follow from
one chronological insertion, not from the realized random presences. -/
theorem chronological_retirement_bound (center : ℕ → Y) (I : Finset ℕ)
    {r : ℝ} (hr : 0 < r) (hK : 2≤K) (rad : Fin H → Outcome Y r) (p : Y)
    (b : Fin H → ℕ) (hinc : ∀ i : Fin H, age center I (20*r) i≤b i ∧ b i≤age center I (20*r) i+1) :
    PartitionProbabilities.probability (fun _ : Fin H=>lifetimeLaw K)
      (firstSeparation
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧ alive K (age center I (20*r) i) d)
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧
          alive K (age center I (20*r) i) d ∧ ¬alive K (b i) d)) ≤49/(K:ℝ) := by
  let a : Fin H → ℕ := fun i=>age center I (20*r) i
  let pres : Fin H → Prop := fun i=>(i:ℕ)∈I ∧ a i<K^2
  let S := SparseFirstHit.candidates r (fun i : Fin H=>center i) pres p p
  have hb := first_retirement_bound hK a b hinc
    (fun i=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i)) S
    (fun i hi ha=>by
      simp only [S,SparseFirstHit.candidates,mem_filter,mem_univ,true_and,min_self]
      exact ⟨⟨hi.1,ha⟩,hi.2.trans (radius_range hr _).2⟩)
    (SparseFirstHit.candidate_count hr.le center I pres (fun _ h=>h) p p (by simpa using hr.le))
  simpa only [a,and_assoc] using hb

end KServer.ActualRoster

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualRoster
open Chronological FiniteBallLaw PartitionProbabilities
attribute [local instance] Classical.propDecidable Classical.decEq

variable {Y : Type*} [MetricSpace Y] [Fintype Y] {H K : ℕ}

omit [Fintype Y] in
lemma age_insert_bounds (center : ℕ → Y) (I : Finset ℕ) (R : ℝ) (t i : ℕ) :
    age center I R i ≤ age center (insert t I) R i ∧
      age center (insert t I) R i ≤ age center I R i+1 := by
  refine ⟨age_mono center (subset_insert _ _) le_rfl i,?_⟩
  unfold age
  rw [filter_insert]
  split_ifs
  · exact card_insert_le _ _
  · omega

lemma old_covered_of_new (center : ℕ → Y) (I : Finset ℕ) (r : ℝ) (t : ℕ)
    (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r) (p : Y) (i : Fin H)
    (hit : (i:ℕ)≠t) (hi : covered center (insert t I) r life rad p i) :
    covered center I r life rad p i := by
  refine ⟨⟨(mem_insert.mp hi.1.1).resolve_left hit,?_⟩,hi.2⟩
  exact alive_antitone K _ (age_insert_bounds center I (20*r) t i).1 hi.1.2

lemma new_covered_of_persists (center : ℕ → Y) (I : Finset ℕ) (r : ℝ) (t : ℕ)
    (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r) (p : Y) (i : Fin H)
    (hi : covered center I r life rad p i) (hp : present center (insert t I) r life i) :
    covered center (insert t I) r life rad p i := ⟨hp,hi.2⟩

/-- Chronological appending cannot supersede a surviving first coverer. -/
lemma first_persists (center : ℕ → Y) (I : Finset ℕ) (r : ℝ) (t : ℕ)
    (hI : ∀ i∈I, i<t) (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r)
    (p : Y) (i : Fin H) (hfirst : first center I r life rad p=some i)
    (hp : present center (insert t I) r life i) :
    first center (insert t I) r life rad p=some i := by
  obtain ⟨hc,hbefore⟩ := (first_some_iff _ _ _ _ _ _ _).mp hfirst
  apply (first_some_iff _ _ _ _ _ _ _).mpr
  refine ⟨new_covered_of_persists center I r t life rad p i hc hp,?_⟩
  intro j hj hnew
  have hji : (j:ℕ) < i := hj
  have hit := hI i hc.1.1
  exact hbefore j hj (old_covered_of_new center I r t life rad p j (by omega) hnew)

def retired (center : ℕ → Y) (I J : Finset ℕ) (r : ℝ)
    (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r) (p : Y) : Prop :=
  ∃ i, first center I r life rad p=some i ∧ ¬present center J r life i

lemma retired_iff (center : ℕ → Y) (I J : Finset ℕ) (hIJ : I⊆J) (r : ℝ)
    (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r) (p : Y) :
    retired center I J r life rad p ↔
      firstSeparation
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧ alive K (age center I (20*r) i) d)
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧
          alive K (age center I (20*r) i) d ∧ ¬alive K (age center J (20*r) i) d) life := by
  constructor
  · rintro ⟨i,hf,hn⟩
    obtain ⟨hi,hbef⟩ := (first_some_iff _ _ _ _ _ _ _).mp hf
    refine ⟨i,⟨hi.1.1,hi.2,hi.1.2,fun h=>hn ⟨hIJ hi.1.1,h⟩⟩,?_⟩
    rintro j hj ⟨hm,hd,ha⟩
    exact hbef j hj ⟨⟨hm,ha⟩,hd⟩
  · rintro ⟨i,⟨hm,hd,ha,hn⟩,hbef⟩
    refine ⟨i,(first_some_iff _ _ _ _ _ _ _).mpr ⟨⟨⟨hm,ha⟩,hd⟩,?_⟩,fun h=>hn h.2⟩
    intro j hj hh
    exact hbef j hj ⟨hh.1.1,hh.2,hh.1.2⟩

/-- An actual insertion's exceptional first-coverer retirement row, under the
literal lifetime tape and with every radius held fixed. -/
theorem insertion_retirement (center : ℕ → Y) (I : Finset ℕ) {r : ℝ} (hr : 0<r)
    (hK : 2≤K) (t : ℕ) (rad : Fin H → Outcome Y r) (p : Y) :
    PartitionProbabilities.probability (fun _ : Fin H=>lifetimeLaw K)
      (fun life=>retired center I (insert t I) r life rad p) ≤49/(K:ℝ) := by
  have he : (fun life=>retired center I (insert t I) r life rad p)=
      firstSeparation
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧ alive K (age center I (20*r) i) d)
        (fun i d=>(i:ℕ)∈I ∧ dist (center i) p≤radius r (rad i) ∧
          alive K (age center I (20*r) i) d ∧ ¬alive K (age center (insert t I) (20*r) i) d) := by
    funext life
    exact propext (retired_iff center I _ (subset_insert _ _) r life rad p)
  rw [he]
  exact chronological_retirement_bound center I hr hK rad p _ (fun i=>age_insert_bounds center I (20*r) t i)

/-- The retirement error is supported inside the 22r neighbourhood. -/
lemma retired_near (center : ℕ → Y) (I : Finset ℕ) {r : ℝ} (hr : 0<r) (t : ℕ)
    (hI : ∀ i∈I, i<t) (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r)
    (p : Y) (h : retired center I (insert t I) r life rad p) : dist p (center t)≤22*r := by
  obtain ⟨i,hf,hn⟩ := h
  obtain ⟨hi,_⟩ := (first_some_iff _ _ _ _ _ _ _).mp hf
  have hit : (i:ℕ)<t := hI i hi.1.1
  have ht : t∉I := fun hh=>Nat.lt_irrefl _ (hI t hh)
  have hc : dist (center i) (center t)≤20*r := by
    by_contra hc
    have ha := age_insert center I (20*r) ht hit
    rw [ite_eq_right hc,add_zero] at ha
    apply hn
    exact ⟨mem_insert_of_mem hi.1.1,ha ▸ hi.1.2⟩
  have hp := hi.2.trans (radius_range hr _).2
  have htri := dist_triangle p (center i) (center t)
  rw [dist_comm p (center i)] at htri
  linarith

/-- A fresh appended ball covers every point within r, pathwise even on
zero-probability lifetime tape outcomes. -/
lemma inserted_covers (center : ℕ → Y) (I : Finset ℕ) {r : ℝ} (hr : 0<r) (hK : 0<K)
    (t : Fin H) (hI : ∀ i∈I, i<t) (life : Fin H → Lifetime K)
    (rad : Fin H → Outcome Y r) (p : Y) (hp : dist (center t) p≤r) :
    covered center (insert (t:ℕ) I) r life rad p t := by
  refine ⟨⟨mem_insert_self _ _,?_⟩,hp.trans (radius_range hr _).1⟩
  rw [age_new center I (20*r) hI]
  exact alive_certain hK _

def indicator (P : Prop) : ℝ := if P then 1 else 0

lemma indicator_nonneg (P : Prop) : 0 ≤ indicator P := by unfold indicator; split_ifs <;> norm_num at *
lemma indicator_le_one (P : Prop) : indicator P≤1 := by unfold indicator; split_ifs <;> norm_num at *

/-- Literal stationary noncoverage table. -/
theorem stationary_table (center : ℕ → Y) (I : Finset ℕ) (r : ℝ) (t : ℕ)
    (hI : ∀ i∈I, i<t) (life : Fin H → Lifetime K) (rad : Fin H → Outcome Y r) (p : Y) :
    indicator (first center I r life rad p≠first center (insert t I) r life rad p)+
      indicator (first center (insert t I) r life rad p=none)-
      indicator (first center I r life rad p=none) ≤
        2*indicator (retired center I (insert t I) r life rad p) := by
  cases ho : first center I r life rad p with
  | none =>
    cases hn : first center (insert t I) r life rad p with
    | none => simp only [indicator]; split_ifs <;> norm_num at *
    | some j => simp only [indicator]; split_ifs <;> norm_num at *
  | some i =>
    by_cases hr : retired center I (insert t I) r life rad p
    · rw [show indicator (retired center I (insert t I) r life rad p)=1 from ite_eq_left hr]
      cases hn : first center (insert t I) r life rad p with
      | none => unfold indicator; split_ifs <;> norm_num at *
      | some j => simp only [indicator]; split_ifs <;> norm_num at *
    · have hp : present center (insert t I) r life i := by
        by_contra hp; exact hr ⟨i,ho,hp⟩
      have hn := first_persists center I r t hI life rad p i ho hp
      simp [hn,indicator,hr]

/-- Mover row, using final guaranteed coverage instead of a stationary final
position. Its retirement coefficient is one instead of two. -/
theorem mover_table (center : ℕ → Y) (I : Finset ℕ) {r : ℝ} (hr : 0<r) (hK : 0<K)
    (t : Fin H) (hI : ∀ i∈I, i<t) (life : Fin H → Lifetime K)
    (rad : Fin H → Outcome Y r) (p : Y) :
    indicator (first center I r life rad p≠first center (insert (t:ℕ) I) r life rad p)+
      indicator (first center (insert (t:ℕ) I) r life rad (center t)=none)-
      indicator (first center I r life rad p=none) ≤
        indicator (retired center I (insert (t:ℕ) I) r life rad p) := by
  have hc := inserted_covers center I hr hK t hI life rad (center t) (by simpa using hr.le)
  have hn : first center (insert (t:ℕ) I) r life rad (center t)≠none :=
    fun h=>(first_none_iff _ _ _ _ _ _).mp h t hc
  rw [show indicator (first center (insert (t:ℕ) I) r life rad (center t)=none)=0 from ite_eq_right hn,add_zero]
  cases ho : first center I r life rad p with
  | none =>
    unfold indicator
    split_ifs <;> norm_num at *
  | some i =>
    by_cases he : retired center I (insert (t:ℕ) I) r life rad p
    · rw [show indicator (retired center I (insert (t:ℕ) I) r life rad p)=1 from ite_eq_left he]
      unfold indicator
      split_ifs <;> norm_num at *
    · have hp : present center (insert (t:ℕ) I) r life i := by
        by_contra hp; exact he ⟨i,ho,hp⟩
      have hnew := first_persists center I r t hI life rad p i ho hp
      simp [hnew,indicator,he]

end KServer.ActualRoster

end


/-! One-structure edits of the actual priority map. These lemmas keep earlier
structures fixed; in particular a covered heavy key suppresses all tier edits. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.PriorityKeys
attribute [local instance] Classical.propDecidable Classical.decEq
variable {I Y:Type*} [Fintype I] [LinearOrder I] {A:I→Type*}

lemma selected_congr_point (q₀ q₁:(i:I)→Y→Option (A i)) (x:Y)
    (h:∀ i,q₀ i x=q₁ i x) : selected q₀ x=selected q₁ x := by
  let u₀:(i:I)→Unit→Option (A i):=fun i _=>q₀ i x
  let u₁:(i:I)→Unit→Option (A i):=fun i _=>q₁ i x
  have hu:u₀=u₁:=funext fun i=>funext fun _=>h i
  change selected u₀ ()=selected u₁ ()
  rw [hu]

lemma key_congr_point (q₀ q₁:(i:I)→Y→Option (A i)) (x:Y)
    (h:∀ i,q₀ i x=q₁ i x) : key q₀ x=key q₁ x := by
  simp only [key,selected_congr_point q₀ q₁ x h]

lemma key_ne_single (q₀ q₁:(i:I)→Y→Option (A i)) (x:Y) (j:I)
    (h:∀ i,i≠j→q₀ i x=q₁ i x) (hn:key q₀ x≠key q₁ x) : q₀ j x≠q₁ j x := by
  intro he
  apply hn
  apply key_congr_point
  intro i
  by_cases hi:i=j
  · subst i; exact he
  · exact h i hi

lemma single_indicator (q₀ q₁:(i:I)→Y→Option (A i)) (x:Y) (j:I)
    (h:∀ i,i≠j→q₀ i x=q₁ i x) :
    ActualRoster.indicator (key q₀ x≠key q₁ x) ≤ ActualRoster.indicator (q₀ j x≠q₁ j x) := by
  unfold ActualRoster.indicator
  split_ifs with hn hj hj <;> try norm_num
  exact False.elim (hj (key_ne_single q₀ q₁ x j h hn))

/-- Before and after the elementary edit at structure j. -/
def stageBefore (q₀ q₁:(i:I)→Y→Option (A i)) (j:I) : (i:I)→Y→Option (A i) :=
  fun i=>if i<j then q₁ i else q₀ i

def stageAfter (q₀ q₁:(i:I)→Y→Option (A i)) (j:I) : (i:I)→Y→Option (A i) :=
  fun i=>if i≤j then q₁ i else q₀ i

omit [Fintype I] in
lemma stage_at (q₀ q₁:(i:I)→Y→Option (A i)) (j:I) :
    stageBefore q₀ q₁ j j=q₀ j ∧ stageAfter q₀ q₁ j j=q₁ j := by
  simp [stageBefore,stageAfter]

omit [Fintype I] in
lemma stage_outside (q₀ q₁:(i:I)→Y→Option (A i)) (j i:I) (hi:i≠j) :
    stageBefore q₀ q₁ j i=stageAfter q₀ q₁ j i := by
  simp only [stageBefore,stageAfter,le_iff_lt_or_eq,hi,or_false]

lemma stage_charge (q₀ q₁:(i:I)→Y→Option (A i)) (j:I) (x:Y) :
    ActualRoster.indicator (key (stageBefore q₀ q₁ j) x≠key (stageAfter q₀ q₁ j) x) ≤
      ActualRoster.indicator (q₀ j x≠q₁ j x) := by
  have h:=single_indicator (stageBefore q₀ q₁ j) (stageAfter q₀ q₁ j) x j
    (fun i hi=>congrFun (stage_outside q₀ q₁ j i hi) x)
  simpa only [(stage_at q₀ q₁ j).1,(stage_at q₀ q₁ j).2] using h

variable [OrderBot I]

lemma selected_bot (q:(i:I)→Y→Option (A i)) (x:Y) (a:A ⊥) (ha:q ⊥ x=some a) :
    selected q x=some ⟨⊥,a⟩ := by
  have hc:(covered q x).Nonempty:=⟨⊥,mem_filter.mpr ⟨mem_univ _,by rw [ha]; exact Option.some_ne_none _⟩⟩
  have he:(covered q x).min' hc=⊥:=bot_unique (min'_le (covered q x) ⊥ (mem_filter.mpr ⟨mem_univ _,by rw [ha]; exact Option.some_ne_none _⟩))
  unfold selected
  rw [dite_eq_left hc]
  change (q ((covered q x).min' hc) x).map (fun b=>(⟨(covered q x).min' hc,b⟩:Sigma A))=some ⟨⊥,a⟩
  rw [he,ha]
  rfl

lemma key_bot (q:(i:I)→Y→Option (A i)) (x:Y) (a:A ⊥) (ha:q ⊥ x=some a) :
    key q x=Sum.inl ⟨⊥,a⟩ := by simp only [key,selected_bot q x a ha]

lemma bot_shadow (q₀ q₁:(i:I)→Y→Option (A i)) (x:Y) (a:A ⊥)
    (h₀:q₀ ⊥ x=some a) (h₁:q₁ ⊥ x=some a) : key q₀ x=key q₁ x :=
  (key_bot q₀ x a h₀).trans (key_bot q₁ x a h₁).symm
lemma stage_shadow (q₀ q₁:(i:I)→Y→Option (A i)) {j:I} (hj:⊥<j)
    (x:Y) (a:A ⊥) (ha:q₁ ⊥ x=some a) :
    key (stageBefore q₀ q₁ j) x=key (stageAfter q₀ q₁ j) x := by
  apply bot_shadow _ _ x a
  · simpa only [stageBefore,ite_eq_left hj] using ha
  · simpa only [stageAfter,ite_eq_left hj.le] using ha
end KServer.PriorityKeys

end


/-! Literal finite-label tier edit tables. The old/new difference is bounded
through permanent chronological labels; no resampling or independence is
assumed at an observed surviving roster. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierEdits
open ActualRoster Chronological
attribute [local instance] Classical.propDecidable Classical.decEq

lemma indicator_mono {P Q:Prop} (h:P→Q) : indicator P≤ indicator Q := by
  unfold indicator
  split_ifs with hP hQ hQ <;> try norm_num
  exact False.elim (hQ (h hP))

lemma map_charge {A B:Type*} (f:A→B) (a b:Option A) :
    indicator (a.map f≠b.map f)≤ indicator (a≠b) :=
  indicator_mono (fun hn he=>hn (congrArg (Option.map f) he))

lemma map_none {A B:Type*} (f:A→B) (a:Option A) :
    indicator (a.map f=none)=indicator (a=none) := by
  cases a <;> simp [indicator]

variable {Y:Type*} [MetricSpace Y] [Fintype Y] {H K:ℕ}

lemma key_none (center:ℕ→Y) {r:ℝ} (hr:0≤r) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:ℕ) (p:Y) :
    indicator (TierKeys.key center hr K q life rad t p=none)=
      indicator (first center (schedule center r K q t) r life rad p=none) :=
  map_none _ _

lemma key_change (center:ℕ→Y) {r:ℝ} (hr:0≤r) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:ℕ) (p:Y) :
    indicator (TierKeys.key center hr K q life rad t p≠TierKeys.key center hr K q life rad (t+1) p)≤
      indicator (first center (schedule center r K q t) r life rad p≠
        first center (schedule center r K q (t+1)) r life rad p) :=
  map_charge _ _ _

lemma stationary (center:ℕ→Y) {r:ℝ} (hr:0≤r) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:ℕ) (p:Y)
    (hin:insertTest center (schedule center r K q t) r K t (q t)) :
    indicator (TierKeys.key center hr K q life rad t p≠TierKeys.key center hr K q life rad (t+1) p)+
      indicator (TierKeys.key center hr K q life rad (t+1) p=none)-
      indicator (TierKeys.key center hr K q life rad t p=none) ≤
        2*indicator (retired center (schedule center r K q t) (schedule center r K q (t+1)) r life rad p) := by
  have ht:=stationary_table center (schedule center r K q t) r t (schedule_before _ _ _ _ _) life rad p
  have hnew:schedule center r K q (t+1)=insert t (schedule center r K q t):=by
    simp only [schedule,ite_eq_left hin]
  have hc:=key_change center hr q life rad t p
  rw [key_none,key_none,hnew]
  rw [hnew] at hc
  linarith

lemma mover (center:ℕ→Y) {r:ℝ} (hr:0<r) (hK:0<K) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:Fin H) (p:Y)
    (hin:insertTest center (schedule center r K q t) r K t (q t)) :
    indicator (TierKeys.key center hr.le K q life rad t p≠TierKeys.key center hr.le K q life rad (t.val+1) p)+
      indicator (TierKeys.key center hr.le K q life rad (t.val+1) (center t)=none)-
      indicator (TierKeys.key center hr.le K q life rad t p=none) ≤
        indicator (retired center (schedule center r K q t) (schedule center r K q (t.val+1)) r life rad p) := by
  have ht:=mover_table center (schedule center r K q t) hr hK t (schedule_before _ _ _ _ _) life rad p
  have hnew:schedule center r K q (t.val+1)=insert (t:ℕ) (schedule center r K q t):=by
    simp only [schedule,ite_eq_left hin]
  have hc:=key_change center hr.le q life rad t p
  rw [key_none,key_none,hnew]
  rw [hnew] at hc
  linarith

lemma no_insert (center:ℕ→Y) {r:ℝ} (hr:0≤r) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:ℕ)
    (hin:¬insertTest center (schedule center r K q t) r K t (q t)) :
    TierKeys.key center hr K q life rad (t+1)=TierKeys.key center hr K q life rad t := by
  funext p
  simp only [TierKeys.key,schedule,ite_eq_right hin]

lemma covered_inner (center:ℕ→Y) {r:ℝ} (hr:0<r) (hK:0<K) (q:ℕ→Prop)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:Fin H)
    (hin:insertTest center (schedule center r K q t) r K t (q t)) (p:Y) (hp:dist (center t) p≤r) :
    indicator (TierKeys.key center hr.le K q life rad (t.val+1) p=none)=0 := by
  rw [key_none]
  have hnew:schedule center r K q (t.val+1)=insert (t:ℕ) (schedule center r K q t):=by
    simp only [schedule,ite_eq_left hin]
  rw [hnew]
  apply ite_eq_right
  intro hh
  exact (first_none_iff _ _ _ _ _ _).mp hh t
    (inserted_covers center _ hr hK t (schedule_before _ _ _ _ _) life rad p hp)

end KServer.TierEdits

end


/-! The literal chronological tier edits inside a complete level, including
heavy-priority shadowing. Noncoverage deliberately ignores earlier structures. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.LevelTierEdits
open LevelKeys LevelCoverage LevelLaw FiniteExperiment TierProcess Pilot
open ActualRoster Chronological
attribute [local instance] Classical.propDecidable Classical.decEq
local instance (priority := 2000) finDecEq (n:ℕ) : DecidableEq (Fin n) := Classical.decEq _
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def charge (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y) : ℝ :=
  indicator (PriorityKeys.key (PriorityKeys.stageBefore (keys s law hr σ a t)
    (keys s law hr σ a (t+1)) (i:Structure k)) p ≠
    PriorityKeys.key (PriorityKeys.stageAfter (keys s law hr σ a t)
    (keys s law hr σ a (t+1)) (i:Structure k)) p)

def uncovered (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y) : ℝ :=
  indicator (keys s law hr σ a t (i:Structure k) p=none)

def inserted (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (t:ℕ) (i:Tier k) : Prop :=
  insertTest (request s σ) (schedule (request s σ) r (tierK (height i))
    (tierQualifies s law r σ i) t) r (tierK (height i)) t (tierQualifies s law r σ i t)

def retirement (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y) : Prop :=
  retired (request s σ) (schedule (request s σ) r (tierK (height i))
    (tierQualifies s law r σ i) t) (schedule (request s σ) r (tierK (height i))
    (tierQualifies s law r σ i) (t+1)) r (a.2 i).1 (a.2 i).2 p

lemma charge_nonneg (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y) : 0 ≤ charge s law hr σ a t i p :=
  indicator_nonneg _

lemma charge_le (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y) :
    charge s law hr σ a t i p ≤ indicator (keys s law hr σ a t (i:Structure k) p≠
      keys s law hr σ a (t+1) (i:Structure k) p) :=
  PriorityKeys.stage_charge _ _ _ _

lemma stationary (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y)
    (hin:inserted s law r σ t i) :
    charge s law hr σ a t i p+uncovered s law hr σ a (t+1) i p-
      uncovered s law hr σ a t i p ≤ 2*indicator (retirement s law r σ a t i p) := by
  have ht:=TierEdits.stationary (request s σ) hr (tierQualifies s law r σ i)
    (a.2 i).1 (a.2 i).2 t p hin
  have hc:=charge_le s law hr σ a t i p
  dsimp only [uncovered,retirement,keys] at hc ⊢
  linarith

lemma mover (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k) (p:Y)
    (hin:inserted s law r σ t i) :
    charge s law hr.le σ a t i p+uncovered s law hr.le σ a (t.val+1) i (σ t)-
      uncovered s law hr.le σ a t i p ≤ indicator (retirement s law r σ a t i p) := by
  have ht:=TierEdits.mover (request s σ) hr
    (by have hh:=tierK_ge_two (height_ge i); omega) (tierQualifies s law r σ i)
    (a.2 i).1 (a.2 i).2 t p hin
  rw [request_fin] at ht
  have hc:=charge_le s law hr.le σ a t i p
  dsimp only [uncovered,retirement,keys] at hc ⊢
  linarith

lemma no_insert_charge (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y)
    (hin:¬inserted s law r σ t i) : charge s law hr σ a t i p=0 := by
  apply le_antisymm _ (charge_nonneg s law hr σ a t i p)
  have hc:=charge_le s law hr σ a t i p
  have he:=congrFun (TierEdits.no_insert (request s σ) hr
    (tierQualifies s law r σ i) (a.2 i).1 (a.2 i).2 t hin) p
  change keys s law hr σ a (t+1) (i:Structure k) p=keys s law hr σ a t (i:Structure k) p at he
  simpa only [he,ne_self_iff_false,indicator,ite_false] using hc

lemma no_insert_stationary (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:ℕ) (i:Tier k) (p:Y)
    (hin:¬inserted s law r σ t i) :
    charge s law hr σ a t i p+uncovered s law hr σ a (t+1) i p-
      uncovered s law hr σ a t i p=0 := by
  rw [no_insert_charge s law hr σ a t i p hin,zero_add]
  have he:=congrFun (TierEdits.no_insert (request s σ) hr
    (tierQualifies s law r σ i) (a.2 i).1 (a.2 i).2 t hin) p
  change keys s law hr σ a (t+1) (i:Structure k) p=keys s law hr σ a t (i:Structure k) p at he
  change indicator (_=none)-indicator (_=none)=0
  rw [he,sub_self]

lemma covered_qualified (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k)
    (hq:tierQualifies s law r σ i t) : uncovered s law hr.le σ a (t.val+1) i (σ t)=0 := by
  obtain ⟨b,hb⟩:=TierKeys.guaranteed_coverage (request s σ) hr
    (by have hh:=tierK_ge_two (height_ge i); omega) (tierQualifies s law r σ i)
    t t.isLt hq (a.2 i).1 (a.2 i).2
  rw [request_fin] at hb
  change keys s law hr.le σ a (t.val+1) (i:Structure k) (σ t)=some b at hb
  change indicator (_=none)=0
  rw [hb]
  exact ite_eq_right (Option.some_ne_none _)

lemma no_insert_mover (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k) (p:Y)
    (hin:¬inserted s law r σ t i) :
    charge s law hr.le σ a t i p+uncovered s law hr.le σ a (t.val+1) i (σ t)-
      uncovered s law hr.le σ a t i p ≤
        if tierQualifies s law r σ i t then 0 else
          indicator (keys s law hr.le σ a (t.val+1) (i:Structure k) (σ t)≠
            keys s law hr.le σ a (t.val+1) (i:Structure k) p) := by
  rw [no_insert_charge s law hr.le σ a t i p hin,zero_add]
  by_cases hq:tierQualifies s law r σ i t
  · rw [ite_eq_left hq,covered_qualified s law hr σ a t i hq]
    exact sub_nonpos.mpr (indicator_nonneg _)
  · rw [ite_eq_right hq]
    have he:=congrFun (TierEdits.no_insert (request s σ) hr.le
      (tierQualifies s law r σ i) (a.2 i).1 (a.2 i).2 t hin) p
    change keys s law hr.le σ a (t.val+1) (i:Structure k) p=keys s law hr.le σ a t (i:Structure k) p at he
    unfold uncovered
    rw [←he]
    unfold indicator
    split_ifs with hx hp hn hp hn hn <;> try norm_num
    all_goals simp_all

lemma heavy_inner_covers (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (p:Y)
    (hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)))
    (hp:dist (σ t) p ≤ heavyGamma*r) : ∃ b,keys s law hr.le σ a (t.val+1) (⊥:Structure k) p=some b := by
  obtain ⟨c,hc,hd⟩:=heavy_near_center s law σ t hr.le hh
  have hv:=HeavySchedule.run_valid s law hr heavyGamma heavyDelta σ a.1 (t.val+1)
  have hC:=HeavyCenters.centers_separated s law r heavyGamma heavyDelta σ (t.val+1)
  have hcp:dist c p ≤ (HeavySchedule.run s law r heavyGamma heavyDelta σ a.1 (t.val+1)).rad c:=by
    have hγ:heavyGamma ≤ 1:=by norm_num [heavyGamma]
    have hm:=mul_le_mul_of_nonneg_right hγ hr.le
    linarith [dist_triangle c (σ t) p,(hv.1 c hc).1]
  have he:=(HeavyKeys.centerKey_some hr hC (fun b hb=>(hv.1 b hb).2)).mpr ⟨hc,hcp⟩
  refine ⟨(HeavySchedule.run s law r heavyGamma heavyDelta σ a.1 (t.val+1)).label c,?_⟩
  change HeavyKeys.key _ _ _ _ _ _ _ _ _=some _
  simp only [HeavyKeys.key,he,Option.map_some]

lemma heavy_inner_charge (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k) (p:Y)
    (hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)))
    (hp:dist (σ t) p ≤ heavyGamma*r) : charge s law hr.le σ a t i p=0 := by
  obtain ⟨b,hb⟩:=heavy_inner_covers s law hr σ a t p hh hp
  have he:=PriorityKeys.stage_shadow (I:=Structure k) (keys s law hr.le σ a t)
    (keys s law hr.le σ a (t.val+1)) (j:=(i:Structure k)) (WithBot.bot_lt_coe i) p b hb
  exact ite_eq_right (not_not.mpr he)

lemma heavy_inner_stationary (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k) (p:Y)
    (hin:inserted s law r σ t i)
    (hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)))
    (hp:dist (σ t) p ≤ heavyGamma*r) :
    charge s law hr.le σ a t i p+uncovered s law hr.le σ a (t.val+1) i p-
      uncovered s law hr.le σ a t i p ≤ 0 := by
  rw [heavy_inner_charge s law hr σ a t i p hh hp,zero_add]
  have hcov:=TierEdits.covered_inner (request s σ) hr
    (by have hh:=tierK_ge_two (height_ge i); omega) (tierQualifies s law r σ i)
    (a.2 i).1 (a.2 i).2 t hin p
    (by rw [request_fin]; exact hp.trans (mul_le_of_le_one_left hr.le (by norm_num [heavyGamma])))
  change uncovered s law hr.le σ a (t.val+1) i p=0 at hcov
  rw [hcov]
  exact sub_nonpos.mpr (indicator_nonneg _)

end KServer.LevelTierEdits

end


/-! Average actual tier retirements over the full finite partition tape, not
conditionally on surviving entries. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.LevelRetirement
open LevelKeys LevelCoverage LevelLaw LevelTierEdits FiniteExperiment TierProcess Pilot
open ActualRoster Chronological FiniteTape PartitionProbabilities
attribute [local instance] Classical.propDecidable Classical.decEq
local instance (priority := 2000) finDecEq (n:ℕ) : DecidableEq (Fin n) := Classical.decEq _
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ}

lemma tier_lifetime_bound {r:ℝ} (hr:0 < r) (i:Tier k)
    (E:(Fin H→Lifetime (tierK (height i)))→(Fin H→FiniteBallLaw.Outcome Y r)→Prop)
    (c:ℝ) (hc:∀ rad,probability (fun _ : Fin H=>lifetimeLaw (tierK (height i)))
      (fun life=>E life rad)≤c) :
    (∑ a:Tape Y k H r,if E (a.2 i).1 (a.2 i).2 then weight r a else 0)≤c := by
  have he:=tier_event (H:=H) hr i (fun b=>E b.1 b.2)
  have heq : (∑ a:Tape Y k H r,if E (a.2 i).1 (a.2 i).2 then weight r a else 0)=
      ∑ b:(Fin H→Lifetime (tierK (height i))) × (Fin H→FiniteBallLaw.Outcome Y r),
        if E b.1 b.2 then tierWeight r i b else 0 := by
    refine Eq.trans ?_ (he.trans ?_) <;> apply sum_congr rfl <;> intro a _ <;> split_ifs <;> rfl
  rw [heq]
  simp only [Fintype.sum_prod_type,tierWeight,pair]
  rw [sum_comm]
  calc (∑ rad,∑ life,if E life rad then lifetimeWeight i life*radiusWeight r i rad else 0)=
        ∑ rad,radiusWeight r i rad*(∑ life,if E life rad then lifetimeWeight i life else 0) := by
          apply sum_congr rfl
          intro rad _
          rw [mul_sum]
          apply sum_congr rfl
          intro life _
          split_ifs <;> ring
       _ ≤ ∑ rad,radiusWeight r i rad*c := by
          apply sum_le_sum
          intro rad _
          apply mul_le_mul_of_nonneg_left _ (radius_nonneg hr i rad)
          exact hc rad
       _ = c := by rw [←sum_mul,radius_sum hr i,one_mul]

variable [NeZero k]

lemma retirement_bound (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (t:ℕ) (i:Tier k) (p:Y) (hin:inserted s law r σ t i) :
    (∑ a:Tape Y k H r,if retirement s law r σ a t i p then weight r a else 0) ≤
      49/(tierK (height i):ℝ) := by
  have hnew:schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) (t+1)=
      insert t (schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) t):=by
    change insertTest _ _ _ _ _ _ at hin
    simp only [schedule,ite_eq_left hin]
  unfold retirement
  rw [hnew]
  refine tier_lifetime_bound hr i (fun life rad => retired (request s σ)
    (schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) t)
    (insert t (schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) t))
    r life rad p) _ ?_
  intro rad
  exact insertion_retirement (request s σ) _ hr (tierK_ge_two (height_ge i)) t rad p

lemma retirement_far (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (i:Tier k) (p:Y)
    (hin:inserted s law r σ t i) (hp:22*r < dist (σ t) p) :
    ¬retirement s law r σ a t i p := by
  intro he
  have hnew:schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) (t.val+1)=
      insert (t:ℕ) (schedule (request s σ) r (tierK (height i)) (tierQualifies s law r σ i) t):=by
    change insertTest _ _ _ _ _ _ at hin
    simp only [schedule,ite_eq_left hin]
  unfold retirement at he
  rw [hnew] at he
  have hn:=retired_near (request s σ) _ hr t (schedule_before _ _ _ _ _) (a.2 i).1 (a.2 i).2 p he
  rw [request_fin,dist_comm] at hn
  exact not_lt_of_ge hn hp

def mean (r:ℝ) (f:Tape Y k H r→ℝ) : ℝ := ∑ a,weight r a*f a

omit [NeZero k] in
lemma mean_mono {r:ℝ} (hr:0<r) {f g:Tape Y k H r→ℝ} (h:∀ a,f a≤g a) : mean r f ≤ mean r g :=
  sum_le_sum (fun a _=>mul_le_mul_of_nonneg_left (h a) (weight_nonneg hr a))

omit [NeZero k] in
lemma mean_const {r:ℝ} (hr:0<r) (c:ℝ) : mean (Y:=Y) (k:=k) (H:=H) r (fun _=>c)=c := by
  unfold mean
  rw [←sum_mul,weight_sum hr,one_mul]

omit [NeZero k] in
lemma mean_indicator (r:ℝ) (E:Tape Y k H r→Prop) :
    mean r (fun a=>indicator (E a))=∑ a,if E a then weight r a else 0 := by
  unfold mean
  apply sum_congr rfl
  intro a _
  by_cases h:E a
  · simp only [indicator,ite_eq_left h,mul_one]
  · simp only [indicator,ite_eq_right h,mul_zero]

omit [NeZero k] in
lemma mean_scale (r:ℝ) (c:ℝ) (f:Tape Y k H r→ℝ) :
    mean r (fun a=>c*f a)=c*mean r f := by
  unfold mean
  rw [mul_sum]
  apply sum_congr rfl
  intro a _
  ring

lemma stationary_mean (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) (hin:inserted s law r σ t i) :
    mean r (fun a=>LevelTierEdits.charge s law hr.le σ a t i p+
      uncovered s law hr.le σ a (t.val+1) i p-uncovered s law hr.le σ a t i p) ≤
        if dist (σ t) p≤22*r ∧ ¬(mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
          (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)) ∧
          dist (σ t) p≤heavyGamma*r) then 98/(tierK (height i):ℝ) else 0 := by
  by_cases hp:dist (σ t) p≤22*r
  · by_cases hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
          (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)) ∧
          dist (σ t) p≤heavyGamma*r
    · rw [ite_eq_right (fun h=>h.2 hh)]
      exact (mean_mono hr (fun a=>heavy_inner_stationary s law hr σ a t i p hin hh.1 hh.2)).trans_eq (mean_const hr 0)
    · rw [ite_eq_left ⟨hp,hh⟩]
      have hb:=mean_mono hr (fun a=>LevelTierEdits.stationary s law hr.le σ a t i p hin)
      rw [mean_scale,mean_indicator] at hb
      have hc:=mul_le_mul_of_nonneg_left (retirement_bound s law hr σ t i p hin) (by norm_num : (0:ℝ)≤2)
      exact hb.trans (by convert hc using 1; ring)
  · rw [ite_eq_right (fun h=>hp h.1)]
    have hb:=mean_mono hr (fun a=>LevelTierEdits.stationary s law hr.le σ a t i p hin)
    have hz (a:Tape Y k H r):indicator (retirement s law r σ a t i p)=0:=
      ite_eq_right (retirement_far s law hr σ a t i p hin (lt_of_not_ge hp))
    simp only [hz,mul_zero,mean_const hr] at hb
    exact hb

lemma mover_mean (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) (hin:inserted s law r σ t i) :
    mean r (fun a=>LevelTierEdits.charge s law hr.le σ a t i p+
      uncovered s law hr.le σ a (t.val+1) i (σ t)-uncovered s law hr.le σ a t i p) ≤
        49/(tierK (height i):ℝ) := by
  have hb:=mean_mono hr (fun a=>LevelTierEdits.mover s law hr σ a t i p hin)
  rw [mean_indicator] at hb
  exact hb.trans (retirement_bound s law hr σ t i p hin)

end KServer.LevelRetirement

end


/-! Exact scale-log sums for the true post-request metric posterior. The same
absolute shift works for the heavy test and all dyadic tier tests. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.LevelScale
open FiniteExperiment Pilot LevelCoverage TierProcess
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [Fintype Y] [MetricSpace Y]

lemma log_ball_bounds (μ:Y→ℝ) (hμ:∀ y,0 ≤ μ y) (x:Y) (hx:1 ≤ μ x)
    {k r:ℝ} (hk:∑ y,μ y=k) (hr:0 ≤ r) :
    Real.log (mass μ (ball x r)) ∈ Set.Icc 0 (Real.log k) := by
  have hl:1 ≤ mass μ (ball x r):=hx.trans (single_le_sum (fun y _=>hμ y)
    (by simp only [ball,mem_filter,mem_univ,true_and,dist_self]; exact hr))
  have hu:mass μ (ball x r) ≤ k:=by simpa only [hk] using ball_mass_total μ hμ x r
  exact ⟨Real.log_nonneg hl,Real.log_le_log (by linarith) hu⟩

lemma mass_positive (μ:Y→ℝ) (hμ:∀ y,0 ≤ μ y) (x:Y) (hx:1 ≤ μ x)
    {r:ℝ} (hr:0 ≤ r) : 0 < mass μ (ball x r) := by
  have hl:1 ≤ mass μ (ball x r):=hx.trans (single_le_sum (fun y _=>hμ y)
    (by simp only [ball,mem_filter,mem_univ,true_and,dist_self]; exact hr))
  linarith

lemma logratio_sum (μ:Y→ℝ) (hμ:∀ y,0 ≤ μ y) (x:Y) (hx:1 ≤ μ x)
    {k r₀ τ γ D:ℝ} (hk:∑ y,μ y=k) (hr:0 ≤ r₀) (hτ:0 ≤ τ)
    (hγ:0 < γ) (hγD:γ ≤ D) (p n:ℕ) (hp:D ≤ γ*τ^p) :
    (∑ j∈range n,Real.log (mass μ (ball x (D*radius r₀ τ j))/
      mass μ (ball x (γ*radius r₀ τ j)))) ≤ p*Real.log k := by
  have hrad (j:ℕ):0 ≤ radius r₀ τ j:=mul_nonneg hr (pow_nonneg hτ _)
  have hm (j:ℕ):0 < mass μ (ball x (γ*radius r₀ τ j)):=
    mass_positive μ hμ x hx (mul_nonneg hγ.le (hrad j))
  have hM (j:ℕ):0 < mass μ (ball x (D*radius r₀ τ j)):=
    mass_positive μ hμ x hx (mul_nonneg (hγ.le.trans hγD) (hrad j))
  have hstep (j:ℕ):mass μ (ball x (D*radius r₀ τ j)) ≤
      mass μ (ball x (γ*radius r₀ τ (j+p))):=by
    apply ball_mass_mono μ hμ x
    rw [radius_add]
    nlinarith [mul_le_mul_of_nonneg_right hp (hrad j)]
  calc _ ≤ ∑ j∈range n,(Real.log (mass μ (ball x (γ*radius r₀ τ (j+p))))-
          Real.log (mass μ (ball x (γ*radius r₀ τ j)))) := by
        apply sum_le_sum
        intro j _
        rw [Real.log_div (hM j).ne' (hm j).ne']
        exact sub_le_sub_right (Real.log_le_log (hM j) (hstep j)) _
       _ ≤ _ := by
        simpa using ScaleMass.shifted_sum_le (fun j=>Real.log (mass μ (ball x (γ*radius r₀ τ j))))
          0 (Real.log k) (fun j=>log_ball_bounds μ hμ x hx hk (mul_nonneg hγ.le (hrad j))) n p

lemma nonheavy_count (μ:Y→ℝ) (hμ:∀ y,0 ≤ μ y) (x:Y) (hx:1 ≤ μ x)
    {k r₀ τ γ D δ:ℝ} (hk:∑ y,μ y=k) (hr:0 ≤ r₀) (hτ:0 ≤ τ)
    (hγ:0 < γ) (hγD:γ ≤ D) (hδ:0 < δ) (p n:ℕ) (hp:D ≤ γ*τ^p) :
    (∑ j∈range n,if mass μ (ball x (D*radius r₀ τ j)) ≤
      (1+δ)*mass μ (ball x (γ*radius r₀ τ j)) then (0:ℝ) else 1)
      ≤ (p*Real.log k)/Real.log (1+δ) := by
  have hlog:0 < Real.log (1+δ):=Real.log_pos (by linarith)
  apply (le_div_iff₀ hlog).mpr
  trans ∑ j∈range n,Real.log (mass μ (ball x (D*radius r₀ τ j))/
      mass μ (ball x (γ*radius r₀ τ j)))
  · rw [sum_mul]
    apply sum_le_sum
    intro j _
    have hrad:0 ≤ radius r₀ τ j:=mul_nonneg hr (pow_nonneg hτ _)
    have hm:=mass_positive μ hμ x hx (mul_nonneg hγ.le hrad)
    have hM:=mass_positive μ hμ x hx (mul_nonneg (hγ.le.trans hγD) hrad)
    have hab:=ball_mass_mono μ hμ x (mul_le_mul_of_nonneg_right hγD hrad)
    split_ifs with hh
    · rw [zero_mul]
      exact Real.log_nonneg ((le_div_iff₀ hm).mpr (by simpa using hab))
    · rw [one_mul]
      apply Real.log_le_log (by linarith : 0 < 1+δ)
      exact (le_div_iff₀ hm).mpr (le_of_lt (lt_of_not_ge hh))
  · exact logratio_sum μ hμ x hx hk hr hτ hγ hγD p n hp

lemma tier_shift {τ:ℝ} (hτ:2 ≤ τ) : 100*tierTemplate.R ≤ tierGamma*τ^60 := by
  have hp:(2:ℝ)^60 ≤ τ^60:=pow_le_pow_left₀ (by norm_num) hτ _
  have hc:100*tierTemplate.R ≤ tierGamma*(2:ℝ)^60:=by norm_num [tierTemplate,tierGamma]
  exact hc.trans (mul_le_mul_of_nonneg_left hp (by norm_num [tierGamma]))

lemma heavy_shift {τ:ℝ} (hτ:2 ≤ τ) : (51200:ℝ) ≤ heavyGamma*τ^60 := by
  have hp:(2:ℝ)^60 ≤ τ^60:=pow_le_pow_left₀ (by norm_num) hτ _
  have hc:(51200:ℝ) ≤ heavyGamma*(2:ℝ)^60:=by norm_num [heavyGamma]
  exact hc.trans (mul_le_mul_of_nonneg_left hp (by norm_num [heavyGamma]))

variable {k H:ℕ} [NeZero k]

lemma actual_logratio_sum (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (σ:Fin H→Y) (hσ:0 < law.val σ) (t:Fin H) {r₀ τ:ℝ} (hr:0 ≤ r₀) (hτ:2 ≤ τ) (n:ℕ) :
    (∑ j∈range n, logratio s law σ t (radius r₀ τ j)) ≤ 60*Real.log k := by
  exact logratio_sum (mu s law (t.val+1) σ) (mu_nonneg s law (t.val+1) σ)
    (σ t) (mu_served s law t σ hσ) (mu_total s law (t.val+1) σ hσ) hr (by linarith)
    (by norm_num [tierGamma]) (by norm_num [tierGamma,tierTemplate]) 60 n (tier_shift hτ)

lemma actual_nonheavy_count (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (σ:Fin H→Y) (hσ:0 < law.val σ) (t:Fin H) {r₀ τ:ℝ} (hr:0 ≤ r₀) (hτ:2 ≤ τ) (n:ℕ) :
    (∑ j∈range n,if mass (mu s law (t.val+1) σ) (ball (σ t) (51200*radius r₀ τ j)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (ball (σ t) (heavyGamma*radius r₀ τ j)) then (0:ℝ) else 1)
      ≤ (60*Real.log k)/Real.log (1+heavyDelta) := by
  exact nonheavy_count (mu s law (t.val+1) σ) (mu_nonneg s law (t.val+1) σ)
    (σ t) (mu_served s law t σ hσ) (mu_total s law (t.val+1) σ hσ) hr (by linarith)
    (by norm_num [heavyGamma]) (by norm_num [heavyGamma]) (by norm_num [heavyDelta])
    60 n (heavy_shift hτ)
end KServer.LevelScale

end


/-! The complete-level first-covering probability bound, with its individual
local log ratio (not the largest tier times the number of scales). -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.LevelSpatial
open LevelKeys LevelCoverage LevelLaw FiniteExperiment TierProcess Pilot
attribute [local instance] Classical.propDecidable
attribute [local instance] Classical.decEq
local instance (priority := 2000) finDecEq (n:ℕ) : DecidableEq (Fin n) := Classical.decEq _

lemma fin_prefix_sum (f:ℕ→ℝ) {N n:ℕ} (hn:n < N) :
    (∑ i:Fin N,if i.val ≤ n then f i else 0)=∑ i∈range (n+1),f i := by
  have he:=Fin.sum_univ_eq_sum_range (fun m:ℕ=>if m ≤ n then f m else 0) N
  rw [he]
  calc (∑ i∈range N,if i ≤ n then f i else 0)=∑ i∈range (n+1),if i ≤ n then f i else 0 := by
        symm
        refine sum_subset (range_mono (by omega)) ?_
        intro i hi hni
        exact ite_eq_right (by simp only [mem_range] at hni; omega)
       _ = _ := by apply sum_congr rfl; intro i hi; exact ite_eq_left (by have := mem_range.mp hi; omega)

lemma structure_prefix_sum {k:ℕ} (p:Structure k→ℝ) (i:Tier k) :
    (∑ j∈univ.filter (fun j:Structure k=>j ≤ (i:Structure k)),p j)=
      p (⊥:Structure k)+∑ j:Tier k,if j ≤ i then p (j:Structure k) else 0 := by
  let f : Structure k → ℝ := fun j=>if j ≤ (i:Structure k) then p j else 0
  have hs : (∑ j∈univ.filter (fun j:Structure k=>j ≤ (i:Structure k)),p j)=∑ j:Structure k,f j := by
    rw [sum_filter]
  rw [hs]
  let e : Structure k ≃ Option (Tier k) := Equiv.refl _
  rw [Fintype.sum_equiv e f (fun j=>f (e.symm j)) (fun _=>rfl)]
  have he:=Fintype.sum_option (fun j:Option (Tier k)=>f (e.symm j))
  rw [he]
  have hb : f (e.symm none)=p (⊥:Structure k) := by
    change f (⊥:Structure k)=_
    simp only [f,bot_le,ite_true]
  rw [hb]
  congr 1
  apply sum_congr rfl
  intro j _
  change (if (j:Structure k) ≤ (i:Structure k) then p (j:Structure k) else 0)=_
  simp only [WithBot.coe_le_coe]

variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def separation (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 ≤ r) (σ:Fin H→Y) (t:ℕ) (x y:Y) : ℝ :=
  ∑ a:Tape Y k H r,if map s law hr σ a t x≠map s law hr σ a t y then weight r a else 0

lemma separation_nonneg (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (t:ℕ) (x y:Y) : 0 ≤ separation s law hr.le σ t x y :=
  sum_nonneg (fun a _=>by split_ifs <;> first | exact weight_nonneg hr a | exact le_rfl)

lemma separation_le_one (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (t:ℕ) (x y:Y) : separation s law hr.le σ t x y ≤ 1 := by
  calc _ ≤ ∑ a:Tape Y k H r,weight r a := by
        apply sum_le_sum; intro a _; split_ifs <;> first | exact le_rfl | exact weight_nonneg hr a
       _ = 1 := weight_sum hr

lemma separation_self (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 ≤ r) (σ:Fin H→Y) (t:ℕ) (x:Y) : separation s law hr σ t x x=0 := by
  simp [separation]

lemma prefix_bound (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (t:ℕ) (x y:Y) (hxy:4*dist x y < r)
    (i:Tier k) (hi:∀ a:Tape Y k H r,keys s law hr.le σ a t (some i) x≠none) :
    separation s law hr.le σ t x y ≤ dist x y/(4*r)+
      (262*dist x y/r)*(∑ j∈range (i.val+1),(2:ℝ)^j) := by
  have hp:=PriorityKeys.probability_prefix_bound (I:=Structure k) (weight r) (weight_nonneg hr)
    (fun a:Tape Y k H r=>keys s law hr.le σ a t) x y (i:Structure k) hi
  have he : separation s law hr.le σ t x y =
      ∑ a:Tape Y k H r,if PriorityKeys.key (I:=Structure k) (keys s law hr.le σ a t) x ≠
        PriorityKeys.key (I:=Structure k) (keys s law hr.le σ a t) y then weight r a else 0 := by
    apply sum_congr rfl
    intro a _
    unfold LevelKeys.map
    split_ifs <;> rfl
  have hp' : separation s law hr.le σ t x y ≤
      ∑ j∈univ.filter (fun j:Structure k=>j ≤ (i:Structure k)),
        ∑ a:Tape Y k H r,if keys s law hr.le σ a t j x≠keys s law hr.le σ a t j y then weight r a else 0 := by
    rw [he]
    convert hp using 1
    · apply sum_congr rfl
      intro a _
      split_ifs <;> rfl
    · simp only [sum_filter]
      apply sum_congr rfl
      intro j _
      split_ifs <;> rfl
  rw [structure_prefix_sum] at hp'
  refine hp'.trans ?_
  apply add_le_add (heavy_spatial s law hr σ t x y hxy)
  have hs:(∑ j:Tier k,if j ≤ i then height j else 0)=∑ j∈range (i.val+1),(2:ℝ)^j := by
    exact fin_prefix_sum (fun n=>(2:ℝ)^n) i.isLt
  rw [←hs,mul_sum]
  apply sum_le_sum
  intro j _
  by_cases hj:j ≤ i
  · simp only [hj,ite_true]
    have hd:dist x y ≤ r:=by linarith [dist_nonneg (x:=x) (y:=y)]
    have hb:=tier_spatial s law hr σ t j x y hd
    have hl:Real.log (1+(tierK (height j):ℝ)^2) ≤ 131*height j:=
      TierDyadic.radius_coefficient (height_ge j)
    apply hb.trans
    have hc:=mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hl (by norm_num : (0:ℝ) ≤ 2))
      (div_nonneg (dist_nonneg (x:=x) (y:=y)) hr.le)
    convert hc using 1 <;> ring
  · simp only [hj,ite_false,mul_zero,le_refl]

lemma request_bound (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (hσ:0 < law.val σ) (t:Fin H) (y:Y)
    (hxy:4*dist (σ t) y < r) :
    separation s law hr.le σ (t.val+1) (σ t) y ≤
      1050*(1+logratio s law σ t r)*dist (σ t) y/r := by
  let i:Tier k:=⟨firstTier s law σ t r,by have hh:=firstTier_le s law σ hσ t hr.le; omega⟩
  have hq:tierQualifies s law r σ i t:=firstTier_qualifies s law σ hσ t hr.le
  have hi (a:Tape Y k H r):keys s law hr.le σ a (t.val+1) (some i) (σ t)≠none:=by
    obtain ⟨b,hb⟩:=TierKeys.guaranteed_coverage (request s σ) hr
      (lt_of_lt_of_le (by omega : 0 < 2) (tierK_ge_two (height_ge i)))
      (tierQualifies s law r σ i) t t.isLt hq (a.2 i).1 (a.2 i).2
    change TierKeys.key (request s σ) hr.le (tierK (height i)) (tierQualifies s law r σ i)
      (a.2 i).1 (a.2 i).2 (t.val+1) (σ t)≠none
    rw [request_fin] at hb
    rw [hb]
    exact Option.some_ne_none _
  have hb:=prefix_bound s law hr σ (t.val+1) (σ t) y hxy i hi
  have hL:=logratio_bounds s law σ hσ t hr.le
  have hsum: (∑ j∈range (i.val+1),(2:ℝ)^j) ≤ 4*(1+logratio s law σ t r):=
    TierDyadic.qualified_sum hL.1
  have hmul:=mul_le_mul_of_nonneg_left hsum (by positivity : 0 ≤ 262*dist (σ t) y/r)
  have hc:dist (σ t) y/(4*r) ≤ 2*(1+logratio s law σ t r)*dist (σ t) y/r:=by
    apply (div_le_div_iff₀ (by positivity : 0 < 4*r) hr).mpr
    have hd:=mul_nonneg hL.1 (dist_nonneg (x:=σ t) (y:=y))
    have hdr:=mul_nonneg hd hr.le
    nlinarith [mul_nonneg (dist_nonneg (x:=σ t) (y:=y)) hr.le]
  calc _ ≤ dist (σ t) y/(4*r)+(262*dist (σ t) y/r)*(∑ j∈range (i.val+1),(2:ℝ)^j) := hb
       _ ≤ 2*(1+logratio s law σ t r)*dist (σ t) y/r+(262*dist (σ t) y/r)*(4*(1+logratio s law σ t r)) := add_le_add hc hmul
       _ = _ := by ring

lemma map_eq_of_heavy (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (t:Fin H) (y:Y) (hxy:4*dist (σ t) y < r)
    (hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r)))
    (a:Tape Y k H r) : map s law hr.le σ a (t.val+1) (σ t)=map s law hr.le σ a (t.val+1) y := by
  obtain ⟨b,hb,hby⟩:=heavy_agrees s law σ t hr hh a.1 y hxy
  by_contra hn
  obtain ⟨j,hj,hd⟩:=PriorityKeys.key_ne_prefix (keys s law hr.le σ a (t.val+1)) (σ t) y none
    (by change HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 (t.val+1) (σ t)≠none
        rw [hb]; exact Option.some_ne_none _) hn
  have he:j=none:=bot_unique hj
  subst j
  exact hd (hb.trans hby.symm)

lemma heavy_zero (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 < r) (σ:Fin H→Y) (t:Fin H) (y:Y) (hxy:4*dist (σ t) y < r)
    (hh:mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*r)) ≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*r))) :
    separation s law hr.le σ (t.val+1) (σ t) y=0 := by
  apply sum_eq_zero
  intro a _
  exact ite_eq_right (not_not.mpr (map_eq_of_heavy s law hr σ t y hxy hh a))

/-- The complete-level estimate (final-map-separation), with an explicit
absolute factor and no number-of-scales or largest-tier multiplier. -/
lemma spatial_sum (s:Configuration k Y) (law:RequestLaw Y H)
    (σ:Fin H→Y) (hσ:0 < law.val σ) (t:Fin H) (y:Y)
    {r₀ τ:ℝ} (hr:0 < r₀) (hτ:2 ≤ τ) (n:ℕ) :
    (∑ j∈range n, Pilot.radius r₀ τ j *
      separation s law (Pilot.radius_pos hr (by linarith) j).le σ (t.val+1) (σ t) y) ≤
      (8+1050*(60/Real.log (1+heavyDelta)+60)*Real.log k)*dist (σ t) y := by
  let R:=Pilot.radius r₀ τ
  let L (j:ℕ):=logratio s law σ t (R j)
  let N (j:ℕ):ℝ:=if Pilot.mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (51200*R j)) ≤
    (1+heavyDelta)*Pilot.mass (mu s law (t.val+1) σ) (Pilot.ball (σ t) (heavyGamma*R j)) then 0 else 1
  have hR (j:ℕ):0 < R j:=Pilot.radius_pos hr (by linarith) j
  have hL (j:ℕ):0 ≤ L j:=(logratio_bounds s law σ hσ t (hR j).le).1
  have hN (j:ℕ):0 ≤ N j:=by dsimp [N]; split_ifs <;> norm_num
  have hpoint (j:ℕ):R j*separation s law (hR j).le σ (t.val+1) (σ t) y ≤
      (if R j ≤ 4*dist (σ t) y then R j else 0)+1050*dist (σ t) y*(N j+L j):=by
    by_cases hsmall:R j ≤ 4*dist (σ t) y
    · rw [ite_eq_left hsmall]
      have hs:=mul_le_mul_of_nonneg_left (separation_le_one s law (hR j) σ (t.val+1) (σ t) y) (hR j).le
      have hmore:0 ≤ 1050*dist (σ t) y*(N j+L j):=mul_nonneg (by positivity) (add_nonneg (hN j) (hL j))
      linarith
    · rw [ite_eq_right hsmall]
      have hbig:4*dist (σ t) y < R j:=lt_of_not_ge hsmall
      dsimp only [N]
      split_ifs with hh
      · rw [heavy_zero s law (hR j) σ t y hbig hh,mul_zero,zero_add,zero_add]
        exact mul_nonneg (by positivity) (hL j)
      · have hs:=request_bound s law (hR j) σ hσ t y hbig
        have hm:=mul_le_mul_of_nonneg_left hs (hR j).le
        have he:R j*(1050*(1+L j)*dist (σ t) y/R j)=1050*dist (σ t) y*(1+L j):=by field_simp [(hR j).ne']
        change R j*separation s law (hR j).le σ (t.val+1) (σ t) y ≤ R j*(1050*(1+L j)*dist (σ t) y/R j) at hm
        simpa only [he,zero_add] using hm
  have hsum:=sum_le_sum (fun j (_:j∈range n)=>hpoint j)
  rw [sum_add_distrib,←mul_sum,sum_add_distrib] at hsum
  have hsmall:=Pilot.radius_truncated_sum hr.le hτ (by positivity : 0 ≤ 4*dist (σ t) y) n
  have hlogs:=LevelScale.actual_logratio_sum s law σ hσ t hr.le hτ n
  have hcount:=LevelScale.actual_nonheavy_count s law σ hσ t hr.le hτ n
  have hlarge:=mul_le_mul_of_nonneg_left (add_le_add hcount hlogs)
    (by positivity : 0 ≤ 1050*dist (σ t) y)
  have htotal:=hsum.trans (add_le_add hsmall hlarge)
  convert htotal using 1; first | rfl | ring
end KServer.LevelSpatial

end


/-! Physical movement of the tier noncoverage potential on steps without an
insertion.  Unqualified dyadic heights sum against the local log ratio. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.LevelNoInsert
open ActualRoster LevelKeys LevelCoverage LevelLaw LevelTierEdits LevelRetirement FiniteExperiment TierProcess Pilot
attribute [local instance] Classical.propDecidable Classical.decEq
local instance (priority := 2000) finDecEq (n:ℕ) : DecidableEq (Fin n) := Classical.decEq _

lemma filtered_powers {L:ℝ} (hL:0 ≤ L) (n:ℕ) :
    (∑ i∈range n,if (2:ℝ)^i<L then (2:ℝ)^i else 0) ≤ 2*L := by
  induction n with
  | zero => simp only [range_zero,sum_empty]; linarith
  | succ n ih =>
    by_cases hn:(2:ℝ)^n<L
    · have he : (∑ i∈range (n+1),if (2:ℝ)^i<L then (2:ℝ)^i else 0)=
          ∑ i∈range (n+1),(2:ℝ)^i := by
        apply sum_congr rfl
        intro i hi
        exact ite_eq_left ((pow_le_pow_right₀ (by norm_num : (1:ℝ) ≤ 2)
          (by have hh:=mem_range.mp hi; omega)).trans_lt hn)
      rw [he,TierDyadic.tier_sum]
      linarith
    · rw [sum_range_succ,ite_eq_right hn,add_zero]
      exact ih

lemma tier_count (k:ℕ) : (Fintype.card (Tier k):ℝ) ≤ 4*(1+Real.log k) := by
  by_cases hk:k=0
  · subst k
    norm_num [Tier,TierDyadic.index_zero (show (0:ℝ) ≤ 1 by norm_num)]
  have hl:0 ≤ Real.log k:=Real.log_nonneg (by exact_mod_cast Nat.one_le_iff_ne_zero.mpr hk)
  have hp:=TierDyadic.qualified_sum hl
  have hi : (Fintype.card (Tier k):ℝ) ≤ ∑ i∈range (TierDyadic.index (Real.log k)+1),(2:ℝ)^i := by
    calc _ = ∑ i∈range (TierDyadic.index (Real.log k)+1),(1:ℝ) := by simp [Tier]
         _ ≤ _ := sum_le_sum (fun i _=>one_le_pow₀ (by norm_num))
  exact hi.trans hp

variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

lemma unqualified_height_sum (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0 ≤ r) (σ:Fin H→Y) (hs:0 < law.val σ) (t:Fin H) :
    (∑ i:Tier k,if tierQualifies s law r σ i t then 0 else height i) ≤
      2*logratio s law σ t r := by
  trans ∑ i:Tier k,if height i<logratio s law σ t r then height i else 0
  · apply sum_le_sum
    intro i _
    by_cases hq:tierQualifies s law r σ i t
    · rw [ite_eq_left hq]; split_ifs
      · exact (show (0:ℝ) ≤ 1 by norm_num).trans (height_ge i)
      · rfl
    · have hi:height i<logratio s law σ t r:=lt_of_not_ge (fun hn=>hq (qualifies_of_log s law σ hs t hr hn))
      rw [ite_eq_right hq,ite_eq_left hi]
  · unfold height
    have he:=Fin.sum_univ_eq_sum_range (fun j:ℕ=>if (2:ℝ)^j<logratio s law σ t r then (2:ℝ)^j else 0) (TierDyadic.index (Real.log k)+1)
    rw [he]
    exact filtered_powers (logratio_bounds s law σ hs t hr).1 _

/-- Positive error is zero on insertion steps here; those steps are separately
charged to the actual retirement and pilot budgets. -/
def error (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 ≤ r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) : ℝ :=
  if inserted s law r σ t i then 0 else mean r (fun a=>
    LevelTierEdits.charge s law hr σ a t i p+uncovered s law hr σ a (t.val+1) i (σ t)-
      uncovered s law hr σ a t i p)

lemma error_le_one (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) : error s law hr.le σ t i p ≤ 1 := by
  unfold error
  split_ifs with hin
  · norm_num
  · have hb:=mean_mono hr (fun a=>no_insert_mover s law hr σ a t i p hin)
    refine hb.trans ((mean_mono hr (fun a=>?_)).trans_eq (mean_const hr 1))
    split_ifs
    · norm_num
    · unfold indicator; split_ifs <;> norm_num

lemma error_spatial (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) (hp:dist (σ t) p ≤ r) :
    error s law hr.le σ t i p ≤
      (262*dist (σ t) p/r)*(if tierQualifies s law r σ i t then 0 else height i) := by
  have hnon:0 ≤ 262*dist (σ t) p/r:=by positivity
  unfold error
  by_cases hin:inserted s law r σ t i
  · rw [ite_eq_left hin]
    exact mul_nonneg hnon (by split_ifs <;> first | rfl | exact (height_ge i).trans' (by norm_num))
  · rw [ite_eq_right hin]
    have hb:=mean_mono hr (fun a=>no_insert_mover s law hr σ a t i p hin)
    by_cases hq:tierQualifies s law r σ i t
    · simp only [ite_eq_left hq,mul_zero,mean_const hr] at hb ⊢
      exact hb
    · simp only [ite_eq_right hq] at hb ⊢
      rw [mean_indicator] at hb
      have hc:=LevelLaw.tier_spatial s law hr σ (t.val+1) i (σ t) p hp
      have hh:=mul_le_mul_of_nonneg_right (TierDyadic.radius_coefficient (height_ge i))
        (div_nonneg (dist_nonneg (x:=σ t) (y:=p)) hr.le)
      dsimp only [keys] at hb hc
      have hbound : (∑ a:Tape Y k H r,if TierKeys.key (request s σ) hr.le (tierK (height i))
          (tierQualifies s law r σ i) (a.2 i).1 (a.2 i).2 (t.val+1) (σ t) ≠
          TierKeys.key (request s σ) hr.le (tierK (height i)) (tierQualifies s law r σ i)
            (a.2 i).1 (a.2 i).2 (t.val+1) p then weight r a else 0) ≤
          (262*dist (σ t) p/r)*height i := by
        refine hc.trans ?_
        convert mul_le_mul_of_nonneg_left hh (by norm_num : (0:ℝ) ≤ 2) using 1 <;> ring
      apply hb.trans
      convert hbound using 1; first | rfl | (apply sum_congr rfl; intro a _; congr 1)

lemma level_error (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0 < r)
    (σ:Fin H→Y) (hs:0 < law.val σ) (t:Fin H) (p:Y) :
    r*(∑ i:Tier k,error s law hr.le σ t i p) ≤
      (if r ≤ 4*dist (σ t) p then (Fintype.card (Tier k):ℝ)*r else 0)+
        524*dist (σ t) p*logratio s law σ t r := by
  by_cases hp:r ≤ 4*dist (σ t) p
  · rw [ite_eq_left hp]
    have hb:=sum_le_sum (fun i (_:i∈univ)=>error_le_one s law hr σ t i p)
    simp only [sum_const,card_univ,nsmul_eq_mul,mul_one] at hb
    have hc:=mul_le_mul_of_nonneg_left hb hr.le
    have hn:=mul_nonneg (by positivity : 0 ≤ 524*dist (σ t) p) (logratio_bounds s law σ hs t hr.le).1
    nlinarith
  · rw [ite_eq_right hp,zero_add]
    have hdist:dist (σ t) p ≤ r:=by linarith [dist_nonneg (x:=σ t) (y:=p)]
    have hb:=sum_le_sum (fun i (_:i∈univ)=>error_spatial s law hr σ t i p hdist)
    rw [←mul_sum] at hb
    have hc:=hb.trans (mul_le_mul_of_nonneg_left (unqualified_height_sum s law hr.le σ hs t) (by positivity))
    have hd:=mul_le_mul_of_nonneg_left hc hr.le
    calc _ ≤ r*((262*dist (σ t) p/r)*(2*logratio s law σ t r)) := hd
         _ = _ := by field_simp [hr.ne']; ring

lemma scales_error (s:Configuration k Y) (law:RequestLaw Y H)
    (σ:Fin H→Y) (hs:0 < law.val σ) (t:Fin H) (p:Y)
    {r₀ τ:ℝ} (hr:0 < r₀) (hτ:2 ≤ τ) (n:ℕ) :
    (∑ j∈range n,Pilot.radius r₀ τ j *
      (∑ i:Tier k,error s law (Pilot.radius_pos hr (by linarith) j).le σ t i p)) ≤
      (32*(1+Real.log k)+31440*Real.log k)*dist (σ t) p := by
  have hb:=sum_le_sum (fun j (_:j∈range n)=>level_error s law (Pilot.radius_pos hr (by linarith) j) σ hs t p)
  rw [sum_add_distrib,←mul_sum] at hb
  have he:(∑ j∈range n,if Pilot.radius r₀ τ j ≤ 4*dist (σ t) p then
      (Fintype.card (Tier k):ℝ)*Pilot.radius r₀ τ j else 0)=
      (Fintype.card (Tier k):ℝ)*∑ j∈range n,if Pilot.radius r₀ τ j ≤ 4*dist (σ t) p then Pilot.radius r₀ τ j else 0 := by
    rw [mul_sum]
    apply sum_congr rfl
    intro j _
    split_ifs <;> ring
  rw [he] at hb
  have hsmall:=mul_le_mul_of_nonneg_left (Pilot.radius_truncated_sum hr.le hτ
    (by positivity : 0 ≤ 4*dist (σ t) p) n) (Nat.cast_nonneg (Fintype.card (Tier k)): (0:ℝ) ≤ _)
  have hlarge:=mul_le_mul_of_nonneg_left (LevelScale.actual_logratio_sum s law σ hs t hr.le hτ n)
    (by positivity : 0 ≤ 524*dist (σ t) p)
  have hcount:=mul_le_mul_of_nonneg_right (tier_count k) (by positivity : 0 ≤ 8*dist (σ t) p)
  have ht:=hb.trans (add_le_add hsmall hlarge)
  nlinarith
end KServer.LevelNoInsert

end

end OAI