import Mathlib
import OAI.Combinatorics.KServer.RosterEdits

namespace OAI

/-! Literal conditional averaging for the hidden optimum's stationary members.
Only conditioning on the true request prefix is used; tape averages may be
performed first without conditioning on a surviving random roster. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HiddenAverages
open FiniteExperiment PosteriorRanks RankTracking
attribute [local instance] Classical.propDecidable
variable {Y : Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

omit [MetricSpace Y] [NeZero k] in
lemma counting_integral (c:Configuration k Y) (f:Y→ℝ) :
    (∑ y,metricCount c y*f y)=∑ i,f (c i) := by
  classical
  simp only [metricCount,sum_mul]
  rw [sum_comm]
  apply sum_congr rfl
  intro i _
  simp

lemma expected_counting_test (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:ℕ) (f:(Fin H→Y)→Y→ℝ)
    (hf:∀ y,Adapted (requestHistory t) (fun σ=>f σ y)) :
    avg law.val (fun σ=>∑ y,mu s law t σ y*f σ y)=
      avg law.val (fun σ=>∑ i,f σ (hidden s σ t i)) := by
  rw [avg_sum]
  have he y : avg law.val (fun σ=>mu s law t σ y*f σ y)=
      avg law.val (fun σ=>metricCount (hidden s σ t) y*f σ y) := by
    simpa only [mu,mul_comm] using weighted_posterior law.property.1 (requestHistory t)
      (fun σ=>metricCount (hidden s σ t) y) (fun σ=>f σ y) (hf y)
  simp_rw [he]
  rw [←avg_sum]
  congr 1
  funext σ
  exact counting_integral _ _

lemma expected_before_test (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (f:(Fin H→Y)→Y→ℝ)
    (hf:∀ y,Adapted (requestHistory (t.val+1)) (fun σ=>f σ y)) :
    avg law.val (fun σ=>∑ y,muBefore s law t σ y*f σ y)=
      avg law.val (fun σ=>∑ i,f σ (hidden s σ t i)) := by
  rw [avg_sum]
  have he y : avg law.val (fun σ=>muBefore s law t σ y*f σ y)=
      avg law.val (fun σ=>metricCount (hidden s σ t) y*f σ y) := by
    simpa only [muBefore,mul_comm] using weighted_posterior law.property.1 (requestHistory (t.val+1))
      (fun σ=>metricCount (hidden s σ t) y) (fun σ=>f σ y) (hf y)
  simp_rw [he]
  rw [←avg_sum]
  congr 1
  funext σ
  exact counting_integral _ _

lemma expected_mover_test (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (f:(Fin H→Y)→Y→ℝ)
    (hf:∀ y,Adapted (requestHistory (t.val+1)) (fun σ=>f σ y)) :
    avg law.val (fun σ=>∑ y,nu s law t σ y*f σ y)=
      avg law.val (fun σ=>f σ (hidden s σ t (mover s σ t))) := by
  classical
  rw [avg_sum]
  have he y : avg law.val (fun σ=>nu s law t σ y*f σ y)=
      avg law.val (fun σ=>(if hidden s σ t (mover s σ t)=y then 1 else 0)*f σ y) := by
    simpa only [nu,mul_comm] using weighted_posterior law.property.1 (requestHistory (t.val+1))
      (fun σ=>if hidden s σ t (mover s σ t)=y then (1:ℝ) else 0) (fun σ=>f σ y) (hf y)
  simp_rw [he]
  rw [←avg_sum]
  congr 1
  funext σ
  simp

def stationary (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (σ:Fin H→Y) (y:Y) : ℝ := muBefore s law t σ y-nu s law t σ y

lemma stationary_nonneg (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (σ:Fin H→Y) (y:Y) : 0 ≤ stationary s law t σ y :=
  sub_nonneg.mpr (nu_le_muBefore s law t σ y)

lemma stationary_le (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (σ:Fin H→Y) (hs:0<law.val σ) (y:Y) : stationary s law t σ y ≤ mu s law (t.val+1) σ y := by
  rw [mu_move s law t σ hs y]
  dsimp only [stationary]
  split_ifs <;> linarith

lemma stationary_identity (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (σ:Fin H→Y) (hs:0<law.val σ) (y:Y) :
    stationary s law t σ y=mu s law (t.val+1) σ y-(if σ t=y then 1 else 0) := by
  classical
  rw [mu_move s law t σ hs y]
  dsimp only [stationary]
  ring

lemma expected_stationary_test (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
    (t:Fin H) (f:(Fin H→Y)→Y→ℝ)
    (hf:∀ y,Adapted (requestHistory (t.val+1)) (fun σ=>f σ y)) :
    avg law.val (fun σ=>∑ y,stationary s law t σ y*f σ y)=
      avg law.val (fun σ=>∑ i∈univ.erase (mover s σ t),f σ (hidden s σ t i)) := by
  classical
  simp only [stationary,sub_mul,sum_sub_distrib,avg_sub]
  rw [expected_before_test s law t f hf,expected_mover_test s law t f hf,←avg_sub]
  congr 1
  funext σ
  exact (sum_erase_eq_sub (mem_univ (mover s σ t))).symm

end KServer.HiddenAverages

end


/-! Literal tier edit potentials along the selected hidden optimum.
Retirement averages are over the complete independent tape, before request
prefix conditioning.  All quantities below refer to constructed keys. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierTemporal
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw LevelTierEdits
open LevelRetirement HiddenAverages RankTracking PosteriorRanks
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]

omit [NeZero k] in
lemma mean_add (r:ℝ) (f g:Tape Y k H r→ℝ) :
    mean r (fun a=>f a+g a)=mean r f+mean r g := by simp [mean,mul_add,sum_add_distrib]
omit [NeZero k] in
lemma mean_sub (r:ℝ) (f g:Tape Y k H r→ℝ) :
    mean r (fun a=>f a-g a)=mean r f-mean r g := by simp [mean,mul_sub,sum_sub_distrib]
omit [NeZero k] in
lemma mean_sum (r:ℝ) {I:Type*} (S:Finset I) (f:I→Tape Y k H r→ℝ) :
    mean r (fun a=>∑ i∈S,f i a)=∑ i∈S,mean r (f i) := by
  simp only [mean,mul_sum]
  exact sum_comm

lemma mover_inner (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) :
    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 ≤ 0 := by
  rw [heavy_inner_charge s law hr σ a t i p hh hp,zero_add,
    covered_qualified s law hr σ a t i hin.1]
  exact sub_nonpos.mpr (ActualRoster.indicator_nonneg _)

lemma mover_mean_inner (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)
    (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))) :
    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) ≤
        if heavyGamma*r<dist (σ t) p then 49/(tierK (height i):ℝ) else 0 := by
  split_ifs with hp
  · exact mover_mean s law hr σ t i p hin
  · exact (mean_mono hr (fun a=>mover_inner s law hr σ a t i p hin hh (le_of_not_gt hp))).trans_eq (mean_const hr 0)

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma dyadic_exp_sum (k:ℕ) : (∑ i:Tier k,Real.exp (-height i))≤1 := by
  have hc (i:ℕ) : (i:ℝ)+1≤(2:ℝ)^i := by
    induction i with
    | zero => norm_num
    | succ i ih =>
      rw [pow_succ,Nat.cast_add,Nat.cast_one]
      have hi : (0:ℝ) ≤ (i:ℝ) := Nat.cast_nonneg i
      nlinarith
  calc _ ≤ ∑ i:Tier k,Real.exp (-(i.val+1:ℝ)) := by
         apply sum_le_sum
         intro i _
         exact Real.exp_le_exp.mpr (neg_le_neg (hc i.val))
       _ ≤ _ := by
         have he:=Fin.sum_univ_eq_sum_range (fun n:ℕ=>Real.exp (-(n+1:ℝ))) (TierDyadic.index (Real.log k)+1)
         rw [he]
         exact tier_weight_sum _

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma dyadic_reciprocal_sum (k:ℕ) : (∑ i:Tier k,1/(tierK (height i):ℝ))≤1 := by
  refine (sum_le_sum (fun i (_:i∈univ)=>?_)).trans (dyadic_exp_sum k)
  have hi:=height_ge i
  have hb:=tier_reciprocal_absorb hi
  have he:Real.exp (-2*height i)≤Real.exp (-height i):=Real.exp_le_exp.mpr (by linarith)
  have ht:64*heavyDelta≤1:=by norm_num [heavyDelta]
  exact hb.trans ((mul_le_mul_of_nonneg_left he (by norm_num [heavyDelta])).trans
    (mul_le_of_le_one_left (Real.exp_nonneg _) ht))

def potential (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) : ℝ :=
  ∑ l:Fin k,uncovered s law hr σ a t i (hidden s σ t l)

def editCost (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) : ℝ :=
  ∑ l:Fin k,LevelTierEdits.charge s law hr σ a t i (hidden s σ t l)

lemma potential_bounds (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) :
    potential s law hr σ a t i∈Set.Icc 0 (k:ℝ) := by
  constructor
  · exact sum_nonneg (fun l _=>ActualRoster.indicator_nonneg _)
  · unfold potential uncovered
    exact (sum_le_sum (fun l (_:l∈univ)=>ActualRoster.indicator_le_one _)).trans_eq (by simp)

lemma potential_step (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) :
    editCost s law hr σ a t i+potential s law hr σ a (t.val+1) i-potential s law hr σ a t i=
      (∑ l∈univ.erase (mover s σ t),(LevelTierEdits.charge s law hr σ a t i (hidden s σ t l)+
        uncovered s law hr σ a (t.val+1) i (hidden s σ t l)-uncovered s law hr σ a t i (hidden s σ t l)))+
      (LevelTierEdits.charge s law hr σ a t i (hidden s σ t (mover s σ t))+
        uncovered s law hr σ a (t.val+1) i (σ t)-uncovered s law hr σ a t i (hidden s σ t (mover s σ t))) := by
  have he:potential s law hr σ a (t.val+1) i=
    (∑ l∈univ.erase (mover s σ t),uncovered s law hr σ a (t.val+1) i (hidden s σ t l))+
      uncovered s law hr σ a (t.val+1) i (σ t) := by
    unfold potential
    rw [←sum_erase_add _ _ (mem_univ (mover s σ t)),hidden_covers]
    congr 1
    apply sum_congr rfl
    intro l hl
    congr 1
    have he:=congrFun (hidden_step s σ t) l
    simpa [serve,(mem_erase.mp hl).1] using he
  rw [he]
  unfold editCost potential
  have hC:=sum_erase_add univ (fun l:Fin k=>LevelTierEdits.charge s law hr σ a t i (hidden s σ t l)) (mem_univ (mover s σ t))
  have hU:=sum_erase_add univ (fun l:Fin k=>uncovered s law hr σ a t i (hidden s σ t l)) (mem_univ (mover s σ t))
  simp only [sum_sub_distrib,sum_add_distrib]
  linarith

end KServer.TierTemporal

end


/-! True-prefix payment of literal tier retirement errors by the posterior
insertion mass.  No conditioning on the realized random tape is used. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierAverages
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw LevelTierEdits
open LevelRetirement HiddenAverages RankTracking PosteriorRanks TierTemporal ActualRoster
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def region (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) : Finset Y :=
  tierRegion tierTemplate r heavyGamma heavyDelta (mu s law (t.val+1) σ) (σ t)

def test (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) : ℝ :=
  if inserted s law r σ t i then indicator (p∈region s law r σ t) else 0

lemma test_nonneg (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) :
    0≤test s law r σ t i p := by unfold test; split_ifs; exact indicator_nonneg _; rfl

lemma inserted_adapted (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:Fin H) (i:Tier k)
    (σ ρ:Fin H→Y) (hh:requestHistory (t.val+1) σ=requestHistory (t.val+1) ρ) :
    inserted s law r σ t i ↔ inserted s law r ρ t i := by
  have hm (ω:Fin H→Y) : inserted s law r ω t i ↔
    (t:ℕ)∈roster s law tierTemplate r tierGamma (height i) (tierK (height i)) ω (t.val+1) := by
    rw [roster,Chronological.schedule_mem]
    exact (and_iff_right (Nat.lt_succ_self t.val)).symm
  rw [hm,hm,roster_adapted s law tierTemplate r tierGamma (height i) (tierK (height i)) (t.val+1) σ ρ hh]

lemma test_adapted (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:Fin H) (i:Tier k) (p:Y) :
    Adapted (requestHistory (t.val+1)) (fun σ=>test s law r σ t i p) := by
  intro σ ρ hh
  have hm:mu s law (t.val+1) σ=mu s law (t.val+1) ρ:=funext (fun y=>mu_adapted s law (t.val+1) y σ ρ hh)
  simp only [test,region,inserted_adapted s law r t i σ ρ hh,hm,request_of_history t σ ρ hh]

lemma retirement_region (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (σ:Fin H→Y) (t:Fin H) (p:Y)
    (hp:dist (σ t) p≤22*r)
    (hh:¬(mass (mu s law (t.val+1) σ) (ball (σ t) (51200*r))≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (ball (σ t) (heavyGamma*r)) ∧ dist (σ t) p≤heavyGamma*r)) :
    p∈region s law r σ t := by
  unfold region tierRegion
  split_ifs with h
  · refine mem_sdiff.mpr ⟨mem_filter.mpr ⟨mem_univ _,by nlinarith⟩,?_⟩
    intro hm
    exact hh ⟨h,(mem_filter.mp hm).2⟩
  · apply mem_filter.mpr ⟨mem_univ _,?_⟩
    norm_num [tierTemplate]
    nlinarith

lemma stationary_test_bound (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (σ:Fin H→Y) (t:Fin H) (i:Tier k) (p:Y) :
    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) ≤
      (98/(tierK (height i):ℝ))*test s law r σ t i p := by
  by_cases hin:inserted s law r σ t i
  · have hb:=stationary_mean s law hr σ t i p hin
    refine hb.trans ?_
    rw [test,ite_eq_left hin]
    split_ifs with he
    · rw [indicator,ite_eq_left (retirement_region s law hr σ t p he.1 he.2),mul_one]
    · exact mul_nonneg (by positivity) (indicator_nonneg _)
  · rw [test,ite_eq_right hin,mul_zero]
    have he (a:Tape Y k H r):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=0:=
        no_insert_stationary s law hr.le σ a t i p hin
    simp only [he,mean_const hr,le_refl]

lemma test_mass (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) :
    (∑ y,mu s law (t.val+1) σ y*test s law r σ t i y)=
      if inserted s law r σ t i then mass (mu s law (t.val+1) σ) (region s law r σ t) else 0 := by
  unfold test
  split_ifs with h
  · simp only [indicator,mul_ite,mul_one,mul_zero]
    rw [←sum_filter]
    congr 1
    ext y
    simp
  · simp

lemma expected_stationary_bound (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:Fin H) (i:Tier k) :
    avg law.val (fun σ=>∑ l∈univ.erase (mover s σ t),test s law r σ t i (hidden s σ t l)) ≤
      avg law.val (fun σ=>if inserted s law r σ t i then mass (mu s law (t.val+1) σ) (region s law r σ t) else 0) := by
  rw [←expected_stationary_test s law t (fun σ p=>test s law r σ t i p) (test_adapted s law r t i)]
  trans avg law.val (fun σ=>∑ y,mu s law (t.val+1) σ y*test s law r σ t i y)
  · apply sum_le_sum
    intro σ _
    by_cases hs:0<law.val σ
    · apply mul_le_mul_of_nonneg_left _ hs.le
      apply sum_le_sum
      intro y _
      exact mul_le_mul_of_nonneg_right (stationary_le s law t σ hs y) (test_nonneg s law r σ t i y)
    · have hz:law.val σ=0:=le_antisymm (le_of_not_gt hs) (law.property.1 σ)
      simp only [hz,zero_mul,le_refl]
  · apply le_of_eq
    congr 1
    funext σ
    exact test_mass s law r σ t i

lemma nonheavy_mass (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (σ:Fin H→Y) (hs:0<law.val σ) (t:Fin H)
    (hh:¬ mass (mu s law (t.val+1) σ) (ball (σ t) (51200*r))≤
      (1+heavyDelta)*mass (mu s law (t.val+1) σ) (ball (σ t) (heavyGamma*r))) :
      1 ≤ mass (mu s law (t.val+1) σ) (region s law r σ t) := by
  unfold region tierRegion
  rw [ite_eq_right hh]
  have hm:σ t∈ball (σ t) (100*tierTemplate.R*r):=by
    simp only [ball,mem_filter,mem_univ,true_and,dist_self]
    norm_num [tierTemplate]
    positivity
  exact (mu_served s law t σ hs).trans (single_le_sum (fun y _=>mu_nonneg s law (t.val+1) σ y) hm)

end KServer.TierAverages

end


/-! Literal one-step tier cost + potential accounting at the true observation
filtration. The insertion term is the existing geometric pilot charge. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierBudget
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw LevelTierEdits
open LevelRetirement HiddenAverages RankTracking PosteriorRanks TierTemporal TierAverages ActualRoster
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def paidMass (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) : ℝ :=
  if inserted s law r σ t i then mass (mu s law (t.val+1) σ) (region s law r σ t) else 0

lemma paidMass_nonneg (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) :
    0≤paidMass s law r σ t i := by
  unfold paidMass
  split_ifs
  · exact mass_nonneg (mu_nonneg s law (t.val+1) σ) _
  · rfl

lemma paidMass_charge (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (i:Tier k) :
    r*paidMass s law r σ t i=TierProcess.charge s law tierTemplate r heavyGamma tierGamma heavyDelta
      (height i) (tierK (height i)) t σ := by
  unfold paidMass TierProcess.charge
  change r*(if inserted s law r σ t i then _ else 0)=(if inserted s law r σ t i then _ else 0)
  split_ifs <;> first | rfl | simp

lemma mover_bound (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) (p:Y) :
    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):ℝ))*paidMass s law r σ t i+
      (49/(tierK (height i):ℝ))*indicator (heavyGamma*r<dist (σ t) p)+
      LevelNoInsert.error s law hr.le σ t i p := by
  have hC:(0:ℝ)≤49/(tierK (height i):ℝ):=by positivity
  have hP:=mul_nonneg hC (paidMass_nonneg s law r σ t i)
  have hD:=mul_nonneg hC (indicator_nonneg (heavyGamma*r<dist (σ t) p))
  by_cases hin:inserted s law r σ t i
  · rw [LevelNoInsert.error,ite_eq_left hin,add_zero]
    by_cases hh:mass (mu s law (t.val+1) σ) (ball (σ t) (51200*r))≤
        (1+heavyDelta)*mass (mu s law (t.val+1) σ) (ball (σ t) (heavyGamma*r))
    · have hb:=mover_mean_inner s law hr σ t i p hin hh
      have he:(if heavyGamma*r<dist (σ t) p then 49/(tierK (height i):ℝ) else 0)=
          (49/(tierK (height i):ℝ))*indicator (heavyGamma*r<dist (σ t) p):=by
        unfold indicator
        split_ifs <;> ring
      rw [he] at hb
      linarith
    · have hm:=nonheavy_mass s law hr σ hs t hh
      have hp:1≤paidMass s law r σ t i:=by rw [paidMass,ite_eq_left hin]; exact hm
      have hb:=mover_mean s law hr σ t i p hin
      have hm:=mul_le_mul_of_nonneg_left hp hC
      linarith
  · rw [LevelNoInsert.error,ite_eq_right hin]
    linarith

lemma average_step (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (t:Fin H) (i:Tier k) :
    avg law.val (fun σ=>mean r (fun a=>editCost s law hr.le σ a t i+
      TierTemporal.potential s law hr.le σ a (t.val+1) i-TierTemporal.potential s law hr.le σ a t i)) ≤
      (147/(tierK (height i):ℝ))*avg law.val (fun σ=>paidMass s law r σ t i)+
      (49/(tierK (height i):ℝ))*avg law.val (fun σ=>indicator (heavyGamma*r<dist (σ t) (hidden s σ t (mover s σ t))))+
      avg law.val (fun σ=>LevelNoInsert.error s law hr.le σ t i (hidden s σ t (mover s σ t))) := by
  let stationaryTerm:=fun σ=>∑ l∈univ.erase (mover s σ t),test s law r σ t i (hidden s σ t l)
  have hpoint (σ:Fin H→Y) (hs:0<law.val σ):
      mean r (fun a=>editCost s law hr.le σ a t i+TierTemporal.potential s law hr.le σ a (t.val+1) i-
        TierTemporal.potential s law hr.le σ a t i) ≤
      (98/(tierK (height i):ℝ))*stationaryTerm σ+
        ((49/(tierK (height i):ℝ))*paidMass s law r σ t i+
        (49/(tierK (height i):ℝ))*indicator (heavyGamma*r<dist (σ t) (hidden s σ t (mover s σ t)))+
        LevelNoInsert.error s law hr.le σ t i (hidden s σ t (mover s σ t))) := by
    simp_rw [potential_step,mean_add,mean_sum]
    apply add_le_add _ (mover_bound s law hr σ hs t i _)
    have hd:TierTemporal.finDecEq k=instDecidableEqFin k:=Subsingleton.elim _ _
    rw [hd]
    exact (sum_le_sum (fun l (_:l∈univ.erase (mover s σ t))=>
      stationary_test_bound s law hr σ t i (hidden s σ t l))).trans_eq (mul_sum _ _ _).symm
  have hb:avg law.val (fun σ=>mean r (fun a=>editCost s law hr.le σ a t i+
      TierTemporal.potential s law hr.le σ a (t.val+1) i-TierTemporal.potential s law hr.le σ a t i)) ≤
        avg law.val (fun σ=>(98/(tierK (height i):ℝ))*stationaryTerm σ+
        ((49/(tierK (height i):ℝ))*paidMass s law r σ t i+
        (49/(tierK (height i):ℝ))*indicator (heavyGamma*r<dist (σ t) (hidden s σ t (mover s σ t)))+
        LevelNoInsert.error s law hr.le σ t i (hidden s σ t (mover s σ t)))) := by
    apply sum_le_sum
    intro σ _
    by_cases hs:0<law.val σ
    · exact mul_le_mul_of_nonneg_left (hpoint σ hs) hs.le
    · have hz:law.val σ=0:=le_antisymm (le_of_not_gt hs) (law.property.1 σ)
      simp only [hz,zero_mul,le_refl]
  simp only [avg_add,avg_mul] at hb
  have hs:=mul_le_mul_of_nonneg_left (expected_stationary_bound s law r t i)
    (show (0:ℝ)≤98/(tierK (height i):ℝ) by positivity)
  change (98/(tierK (height i):ℝ))*avg law.val stationaryTerm ≤
    (98/(tierK (height i):ℝ))*avg law.val (fun σ=>paidMass s law r σ t i) at hs
  have hc:(147/(tierK (height i):ℝ))=98/(tierK (height i):ℝ)+49/(tierK (height i):ℝ):=by ring
  rw [hc,add_mul]
  linarith only [hb,hs]

end KServer.TierBudget

end


/-! Horizon-independent endpoint bound for the actual dyadic-tier edits. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierGlobal
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw LevelTierEdits
open LevelRetirement HiddenAverages RankTracking PosteriorRanks TierTemporal TierAverages ActualRoster TierBudget
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma telescope_budget (p:ℕ→ℝ) (c b:Fin H→ℝ)
    (hs:∀ t,c t+p (t.val+1)-p t≤b t) (hF:0≤p H) :
    (∑ t,c t) ≤ ∑ t,b t+p 0 := by
  have hd:(∑ t:Fin H,(p (t.val+1)-p t))=p H-p 0 := by
    calc _ = ∑ t∈range H,(p (t+1)-p t) := Fin.sum_univ_eq_sum_range (fun t:ℕ=>p (t+1)-p t) H
         _ = _ := sum_range_sub p H
  have he:=sum_le_sum (fun t (_:t∈univ)=>hs t)
  have heq:(∑ t:Fin H,(c t+p (t.val+1)-p t))=(∑ t,c t)+(p H-p 0):=by
    simp_rw [show ∀ t:Fin H,c t+p (t.val+1)-p t=c t+(p (t.val+1)-p t) by intro t; ring]
    rw [sum_add_distrib,hd]
  rw [heq] at he
  linarith

lemma potential_mean_bounds (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (t:ℕ) (i:Tier k) :
    avg law.val (fun σ=>mean r (fun a=>TierTemporal.potential s law hr.le σ a t i))∈Set.Icc 0 (k:ℝ) := by
  constructor
  · calc 0 = avg law.val (fun _=>mean (Y:=Y) (k:=k) (H:=H) r (fun _=>0)) := by
           rw [mean_const hr,avg_const _ law.property.2]
         _ ≤ _ := avg_mono law.property.1 (fun σ=>mean_mono hr
           (fun a=>(potential_bounds s law hr.le σ a t i).1))
  · calc _ ≤ avg law.val (fun _=>mean (Y:=Y) (k:=k) (H:=H) r (fun _=>(k:ℝ))) :=
           avg_mono law.property.1 (fun σ=>mean_mono hr
             (fun a=>(potential_bounds s law hr.le σ a t i).2))
         _ = _ := by rw [mean_const hr,avg_const _ law.property.2]

lemma tier_budget (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r) (i:Tier k) :
    (∑ t:Fin H,avg law.val (fun σ=>mean r (fun a=>editCost s law hr.le σ a t i))) ≤
      (147/(tierK (height i):ℝ))*(∑ t:Fin H,avg law.val (fun σ=>paidMass s law r σ t i))+
      (49/(tierK (height i):ℝ))*(∑ t:Fin H,avg law.val (fun σ=>indicator
        (heavyGamma*r<dist (σ t) (hidden s σ t (mover s σ t)))))+
      (∑ t:Fin H,avg law.val (fun σ=>LevelNoInsert.error s law hr.le σ t i (hidden s σ t (mover s σ t))))+k := by
  have hs:=fun t:Fin H=>average_step s law hr t i
  simp only [mean_sub,mean_add,avg_sub,avg_add] at hs
  have hb:=telescope_budget (fun t=>avg law.val (fun σ=>mean r
    (fun a=>TierTemporal.potential s law hr.le σ a t i))) _ _ hs
    (potential_mean_bounds s law hr H i).1
  simp only [sum_add_distrib,←mul_sum] at hb
  exact hb.trans (add_le_add le_rfl (potential_mean_bounds s law hr 0 i).2)

omit [Fintype Y] in
lemma actual_move_cost (s:Configuration k Y) (σ:Fin H→Y) :
    (∑ t:Fin H,dist (σ t) (hidden s σ t (mover s σ t)))=optimalCost s (List.ofFn σ) := by
  simp_rw [dist_comm (σ _),←hidden_movement]
  exact hidden_total_cost s σ

lemma far_scales {r₀ τ d:ℝ} (hr:0<r₀) (hτ:2≤τ) (hd:0≤d) (n:ℕ) :
    (∑ j∈range n,radius r₀ τ j*indicator (heavyGamma*radius r₀ τ j<d)) ≤ 2*d/heavyGamma := by
  have hg:(0:ℝ)<heavyGamma:=by norm_num [heavyGamma]
  have hb:=radius_truncated_sum hr.le hτ (div_nonneg hd hg.le) n
  have he:2*(d/heavyGamma)=2*d/heavyGamma:=by ring
  refine (sum_le_sum (fun j (_:j∈range n)=>?_)).trans (hb.trans_eq he)
  by_cases hj:heavyGamma*radius r₀ τ j<d
  · have hle:radius r₀ τ j≤d/heavyGamma:=(le_div_iff₀ hg).mpr (by linarith)
    simp only [indicator,ite_eq_left hj,mul_one,ite_eq_left hle,le_refl]
  · simp only [indicator,ite_eq_right hj,mul_zero]
    split_ifs
    · exact (radius_pos hr (by linarith) j).le
    · rfl

end KServer.TierGlobal

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TierScaleBudget
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw LevelTierEdits
open LevelRetirement HiddenAverages RankTracking PosteriorRanks TierTemporal TierAverages ActualRoster TierBudget TierGlobal
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma avg_finset_sum {Ω I:Type*} [Fintype Ω] (w:Ω→ℝ) (S:Finset I) (f:I→Ω→ℝ) :
    avg w (fun ω=>∑ i∈S,f i ω)=∑ i∈S,avg w (f i) := by
  simp only [avg,mul_sum]
  exact sum_comm

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma factor_sum {I:Type*} [Fintype I] (f:I→ℝ) (c M:ℝ) :
    c*(∑ i,f i)*M=∑ i,c*f i*M := by rw [mul_sum,sum_mul]

lemma insertion_budget (s:Configuration k Y) (law:RequestLaw Y H)
    {r₀ τ:ℝ} (hr:0<r₀) (hτ:2≤τ) (n:ℕ) (i:Tier k) :
    (∑ j∈range n,radius r₀ τ j*((147/(tierK (height i):ℝ))*
      (∑ t:Fin H,avg law.val (fun σ=>paidMass s law (radius r₀ τ j) σ t i)))) ≤
      147*Real.exp (-height i)*(tierDrift*(1+Real.log ((k:ℝ)+1))*
        ∑ σ,law.val σ*optimalCost s (List.ofFn σ))+
      147*Real.exp (-height i)*(∑ j∈range n,2*radius r₀ τ j*(k:ℝ)) := by
  have hb:=weighted_insertion_budget s law n hr hτ (height_ge i)
  have he:(∑ j∈range n,radius r₀ τ j*((147/(tierK (height i):ℝ))*
      (∑ t:Fin H,avg law.val (fun σ=>paidMass s law (radius r₀ τ j) σ t i))))=
      147*(∑ t:Fin H,avg law.val (fun σ=>∑ j∈range n,
        TierProcess.charge s law tierTemplate (radius r₀ τ j) heavyGamma tierGamma heavyDelta
          (height i) (tierK (height i)) t σ/(tierK (height i):ℝ))) := by
    simp_rw [←paidMass_charge,div_eq_mul_inv,avg_finset_sum]
    rw [sum_comm]
    simp only [mul_sum,avg]
    apply sum_congr rfl
    intro j _
    apply sum_congr rfl
    intro t _
    apply sum_congr rfl
    intro σ _
    ring
  rw [he]
  exact (mul_le_mul_of_nonneg_left hb (by norm_num : (0:ℝ)≤147)).trans_eq (by ring)

lemma insertion_all (s:Configuration k Y) (law:RequestLaw Y H)
    {r₀ τ:ℝ} (hr:0<r₀) (hτ:2≤τ) (n:ℕ) :
    (∑ i:Tier k,∑ j∈range n,radius r₀ τ j*((147/(tierK (height i):ℝ))*
      (∑ t:Fin H,avg law.val (fun σ=>paidMass s law (radius r₀ τ j) σ t i)))) ≤
      147*(tierDrift*(1+Real.log ((k:ℝ)+1))*
        ∑ σ,law.val σ*optimalCost s (List.ofFn σ))+
      147*(∑ j∈range n,2*radius r₀ τ j*(k:ℝ)) := by
  let A:=tierDrift*(1+Real.log ((k:ℝ)+1))*(∑ σ,law.val σ*optimalCost s (List.ofFn σ))
  let B:=∑ j∈range n,2*radius r₀ τ j*(k:ℝ)
  have hn:0≤A:=by
    apply mul_nonneg
    · apply mul_nonneg
      · exact driftConstant_nonneg tierTemplate 60 (by norm_num [tierGamma]) (by norm_num [tierDelta])
      · have hl:0≤Real.log ((k:ℝ)+1):= Real.log_nonneg (by have hk:=Nat.cast_nonneg (α:=ℝ) k; linarith)
        linarith
    · exact sum_nonneg (fun σ _=>mul_nonneg (law.property.1 σ) (optimalCost_nonneg s (List.ofFn σ)))
  have he:0≤B:=sum_nonneg (fun j _=>by
    have hj:=(radius_pos (τ:=τ) hr (by linarith) j).le
    exact mul_nonneg (mul_nonneg (by norm_num) hj) (Nat.cast_nonneg k))
  calc _ ≤ ∑ i:Tier k,(147*Real.exp (-height i)*A+147*Real.exp (-height i)*B) :=
           sum_le_sum (fun i (_:i∈univ)=>insertion_budget s law hr hτ n i)
       _ = 147*(∑ i:Tier k,Real.exp (-height i))*(A+B) := by
           simp only [mul_add,mul_sum,sum_mul,sum_add_distrib]
       _ ≤ 147*1*(A+B) := mul_le_mul_of_nonneg_right
           (mul_le_mul_of_nonneg_left (dyadic_exp_sum k) (by norm_num)) (add_nonneg hn he)
       _ = _ := by ring

lemma far_all (s:Configuration k Y) (law:RequestLaw Y H)
    {r₀ τ:ℝ} (hr:0<r₀) (hτ:2≤τ) (n:ℕ) :
    (∑ i:Tier k,∑ j∈range n,radius r₀ τ j*((49/(tierK (height i):ℝ))*
      (∑ t:Fin H,avg law.val (fun σ=>indicator (heavyGamma*radius r₀ τ j<dist (σ t) (hidden s σ t (mover s σ t))))))) ≤
      (98/heavyGamma)*(∑ σ,law.val σ*optimalCost s (List.ofFn σ)) := by
  let M:ℝ:=∑ t:Fin H,avg law.val (fun σ=>∑ j∈range n,radius r₀ τ j*
    indicator (heavyGamma*radius r₀ τ j<dist (σ t) (hidden s σ t (mover s σ t))))
  have hM: M≤(2/heavyGamma)*(∑ σ,law.val σ*optimalCost s (List.ofFn σ)):=by
    have hb:=sum_le_sum (fun t (_:t∈univ)=>avg_mono law.property.1 (fun σ=>
      far_scales hr hτ (dist_nonneg (x:=σ t) (y:=hidden s σ t (mover s σ t))) n))
    have he:(∑ t:Fin H,avg law.val (fun σ=>2*dist (σ t) (hidden s σ t (mover s σ t))/heavyGamma))=
        (2/heavyGamma)*(∑ σ,law.val σ*optimalCost s (List.ofFn σ)):=by
      simp only [avg]
      rw [sum_comm,mul_sum]
      apply sum_congr rfl
      intro σ _
      rw [←actual_move_cost s σ]
      simp only [mul_sum]
      apply sum_congr rfl
      intro t _
      ring
    exact hb.trans_eq he
  have hn:0≤M:=by
    exact sum_nonneg (fun t _=>sum_nonneg (fun σ _=>mul_nonneg (law.property.1 σ)
      (sum_nonneg (fun j _=>mul_nonneg (radius_pos (τ:=τ) hr (by linarith) j).le (indicator_nonneg _)))))
  have he:(∑ i:Tier k,∑ j∈range n,radius r₀ τ j*((49/(tierK (height i):ℝ))*
      (∑ t:Fin H,avg law.val (fun σ=>indicator (heavyGamma*radius r₀ τ j<dist (σ t) (hidden s σ t (mover s σ t)))))))=
      49*(∑ i:Tier k,1/(tierK (height i):ℝ))*M := by
    rw [factor_sum]
    apply sum_congr rfl
    intro i _
    unfold M
    simp_rw [avg_finset_sum,avg_mul]
    rw [sum_comm]
    simp only [mul_sum]
    apply sum_congr rfl
    intro j _
    apply sum_congr rfl
    intro t _
    ring
  rw [he]
  have hsum:=mul_le_mul_of_nonneg_left (dyadic_reciprocal_sum k) (by positivity : (0:ℝ)≤49*M)
  have hbound:=mul_le_mul_of_nonneg_left hM (by norm_num : (0:ℝ)≤49)
  calc _ ≤ 49*M := by nlinarith only [hsum]
       _ ≤ _ := hbound.trans_eq (by ring)

lemma noinsert_all (s:Configuration k Y) (law:RequestLaw Y H)
    {r₀ τ:ℝ} (hr:0<r₀) (hτ:2≤τ) (n:ℕ) :
    (∑ i:Tier k,∑ j∈range n,radius r₀ τ j*(∑ t:Fin H,avg law.val (fun σ=>
      LevelNoInsert.error s law (radius_pos (τ:=τ) hr (by linarith) j).le σ t i
        (hidden s σ t (mover s σ t))))) ≤
      (32*(1+Real.log k)+31440*Real.log k)*(∑ σ,law.val σ*optimalCost s (List.ofFn σ)) := by
  have hb:=sum_le_sum (fun t (_:t∈univ)=>sum_le_sum (fun σ (_:σ∈univ)=>show
    law.val σ*(∑ j∈range n,radius r₀ τ j*(∑ i:Tier k,
      LevelNoInsert.error s law (radius_pos (τ:=τ) hr (by linarith) j).le σ t i
        (hidden s σ t (mover s σ t)))) ≤
    law.val σ*((32*(1+Real.log k)+31440*Real.log k)*
      dist (σ t) (hidden s σ t (mover s σ t))) from by
        by_cases hs:law.val σ=0
        · simp only [hs,zero_mul,le_refl]
        · exact mul_le_mul_of_nonneg_left (LevelNoInsert.scales_error s law σ
            (lt_of_le_of_ne (law.property.1 σ) (Ne.symm hs)) t _ hr hτ n) (law.property.1 σ)))
  have he:(∑ i:Tier k,∑ j∈range n,radius r₀ τ j*(∑ t:Fin H,avg law.val (fun σ=>
      LevelNoInsert.error s law (radius_pos (τ:=τ) hr (by linarith) j).le σ t i
        (hidden s σ t (mover s σ t)))))=
      ∑ t:Fin H,∑ σ,law.val σ*(∑ j∈range n,radius r₀ τ j*(∑ i:Tier k,
      LevelNoInsert.error s law (radius_pos (τ:=τ) hr (by linarith) j).le σ t i
        (hidden s σ t (mover s σ t)))) := by
    simp only [avg,mul_sum]
    calc _ = ∑ j∈range n,∑ t:Fin H,∑ σ,∑ i:Tier k,
        radius r₀ τ j*(law.val σ*LevelNoInsert.error s law
          (radius_pos (τ:=τ) hr (by linarith) j).le σ t i
          (hidden s σ t (mover s σ t))) := by
            rw [sum_comm]
            apply sum_congr rfl
            intro j _
            rw [sum_comm]
            apply sum_congr rfl
            intro t _
            rw [sum_comm]
         _ = _ := by
            rw [sum_comm]
            apply sum_congr rfl
            intro t _
            rw [sum_comm]
            apply sum_congr rfl
            intro σ _
            apply sum_congr rfl
            intro j _
            exact sum_congr rfl (fun i _=>by ring)
  rw [he]
  refine hb.trans_eq ?_
  rw [sum_comm,mul_sum]
  apply sum_congr rfl
  intro σ _
  rw [←actual_move_cost s σ]
  simp only [mul_sum]
  exact sum_congr rfl (fun t _=>by ring)

end KServer.TierScaleBudget

end


/-! Literal deterministic heavy-center schedule and its clipped distance profile,
§07 of the current manuscript. Random heavy radii do not affect this schedule. -/
noncomputable section
open scoped BigOperators
open Finset Set
namespace KServer.HeavyEdit

/-- The heavy profile is zero up to radius 9 and one from radius 10. -/
def ramp (u : ℝ) : ℝ := min 1 (max 0 (u-9))
lemma ramp_bounds (u : ℝ) : ramp u ∈ Set.Icc 0 1 :=
  ⟨le_min (by norm_num) (le_max_left _ _),min_le_left _ _⟩
lemma ramp_zero {u : ℝ} (hu : u ≤ 9) : ramp u=0 := by
  simp [ramp,max_eq_left (by linarith : u-9 ≤ 0)]
lemma ramp_one {u : ℝ} (hu : 10 ≤ u) : ramp u=1 := by
  exact min_eq_left ((by linarith : 1 ≤ u-9).trans (le_max_right _ _))
lemma ramp_lipschitz (u v : ℝ) : |ramp u-ramp v| ≤ |u-v| := by
  rw [abs_le]
  constructor <;> unfold ramp <;>
    simp only [min_def,max_def] <;> split_ifs <;>
    have h1 := le_abs_self (u-v) <;> have h2 := neg_le_abs (u-v) <;> linarith

attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y : Type*} [MetricSpace Y]

/-- Finite minimum with a default value 1, also for the empty center set. -/
def profile (r : ℝ) (C : Finset Y) (y : Y) : ℝ :=
  (insert 1 (C.image (fun a => ramp (dist a y/r)))).min' ⟨1,mem_insert_self _ _⟩

lemma profile_nonneg (r : ℝ) (C : Finset Y) (y : Y) : 0 ≤ profile r C y := by
  apply le_min'
  intro z hz
  rcases mem_insert.mp hz with rfl | hz
  · norm_num
  · obtain ⟨a,_,rfl⟩ := mem_image.mp hz
    exact (ramp_bounds _).1

lemma profile_le_one (r : ℝ) (C : Finset Y) (y : Y) : profile r C y ≤ 1 :=
  min'_le _ _ (mem_insert_self _ _)
lemma profile_bounds (r : ℝ) (C : Finset Y) (y : Y) : profile r C y ∈ Set.Icc 0 1 :=
  ⟨profile_nonneg _ _ _,profile_le_one _ _ _⟩
lemma profile_le (r : ℝ) {C : Finset Y} {a : Y} (ha : a∈C) (y : Y) :
    profile r C y ≤ ramp (dist a y/r) :=
  min'_le _ _ (mem_insert_of_mem (mem_image.mpr ⟨a,ha,rfl⟩))
lemma le_profile (r : ℝ) (C : Finset Y) (y : Y) {u : ℝ} (hu : u ≤ 1)
    (h : ∀ a∈C,u ≤ ramp (dist a y/r)) : u ≤ profile r C y := by
  apply le_min'
  intro z hz
  rcases mem_insert.mp hz with rfl | hz
  · exact hu
  · obtain ⟨a,ha,rfl⟩ := mem_image.mp hz
    exact h a ha
lemma profile_empty (r : ℝ) (y : Y) : profile r ∅ y=1 := by
  simp [profile]
lemma profile_eq_one {r : ℝ} (hr : 0<r) {C : Finset Y} {y : Y}
    (h : ∀ a∈C,10*r ≤ dist a y) : profile r C y=1 := by
  apply le_antisymm (profile_le_one _ _ _)
  apply le_profile _ _ _ le_rfl
  intro a ha
  rw [ramp_one ((le_div_iff₀ hr).mpr (h a ha))]
lemma profile_eq_zero {r : ℝ} (hr : 0<r) {C : Finset Y} {a y : Y}
    (ha : a∈C) (hay : dist a y ≤ 9*r) : profile r C y=0 := by
  apply le_antisymm _ (profile_nonneg _ _ _)
  exact (profile_le r ha y).trans_eq (ramp_zero ((div_le_iff₀ hr).mpr hay))

lemma profile_gt_witness {r : ℝ} {C : Finset Y} {y : Y} {u : ℝ}
    (hu : u ≤ 1) (h : profile r C y<u) :
    ∃ a∈C,ramp (dist a y/r)<u := by
  by_contra hn
  push Not at hn
  exact (not_lt_of_ge (le_profile r C y hu hn)) h

lemma profile_lipschitz {r : ℝ} (hr : 0<r) (C : Finset Y) (y z : Y) :
    |profile r C y-profile r C z| ≤ dist y z/r := by
  have hdir (y z : Y) : profile r C y-profile r C z ≤ dist y z/r := by
    suffices profile r C y-dist y z/r ≤ profile r C z by linarith
    apply le_profile r C z
    · linarith [profile_le_one r C y,div_nonneg (dist_nonneg (x := y) (y := z)) hr.le]
    · intro a ha
      have hl := ramp_lipschitz (dist a y/r) (dist a z/r)
      have hm : |dist a y-dist a z| ≤ dist y z := by
        simpa only [dist_comm a] using abs_dist_sub_le y z a
      rw [←sub_div,abs_div,abs_of_pos hr] at hl
      have hb := hl.trans (div_le_div_of_nonneg_right hm hr.le)
      have hc := (le_abs_self (ramp (dist a y/r)-ramp (dist a z/r))).trans hb
      linarith [profile_le r ha y]
  rw [abs_sub_le_iff]
  exact ⟨hdir y z,by simpa only [dist_comm z y] using hdir z y⟩


open HeavyCenters HeavyLabels HeavyKeys

lemma profile_far {r:ℝ} (hr:0<r) (C:Finset Y) {x p:Y}
    (hp:120*r<dist x p) : profile r (replace r C x) p=profile r C p := by
  apply le_antisymm
  · apply le_profile _ _ _ (profile_le_one _ _ _)
    intro a ha
    by_cases hax:100*r<dist a x
    · exact profile_le r (mem_insert_of_mem (mem_filter.mpr ⟨ha,hax⟩)) p
    · have ht:=dist_triangle x a p
      rw [dist_comm x a] at ht
      have hap:10*r≤dist a p:=by linarith
      rw [ramp_one ((le_div_iff₀ hr).mpr hap)]
      exact profile_le_one _ _ _
  · apply le_profile _ _ _ (profile_le_one _ _ _)
    intro a ha
    rcases mem_insert.mp ha with hax|ha
    · subst a
      rw [ramp_one ((le_div_iff₀ hr).mpr (by linarith))]
      exact profile_le_one _ _ _
    · exact profile_le r (mem_filter.mp ha).1 p

variable [Fintype Y]

def oldKey (C:Finset Y) (rad:Y→ℝ) (lab:Y→Pool Y) (p:Y) : Option (Pool Y) :=
  (centerKey C rad p).map lab

def newKey (C D:Finset Y) (rad:Y→ℝ) (lab prev:Y→Pool Y) (r:ℝ) (x:Y) (R:ℝ)
    (p:Y) : Option (Pool Y) :=
  (centerKey (replace r C x) (Function.update rad x R) p).map
    (updatedLabel C D rad lab prev x R)

omit [Fintype Y] in
lemma replace_separated {r:ℝ} {C:Finset Y} {x:Y}
    (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b)) :
    (replace r C x:Set Y).Pairwise (fun a b=>100*r<dist a b) := by
  intro a ha b hb hn
  rcases mem_insert.mp ha with hax|ha
  · subst a
    have hb':=(mem_insert.mp hb).resolve_left (Ne.symm hn)
    simpa only [dist_comm] using (mem_filter.mp hb').2
  · rcases mem_insert.mp hb with hbx|hb
    · subst b; exact (mem_filter.mp ha).2
    · exact hC (mem_filter.mp ha).1 (mem_filter.mp hb).1 hn

omit [Fintype Y] in
lemma new_radius {r R:ℝ} (hr:0<r) {C:Finset Y} {x:Y} {rad:Y→ℝ}
    (hrad:∀ a∈C,rad a≤20*r) (hR:R≤20*r) :
    ∀ a∈replace r C x,Function.update rad x R a≤20*r := by
  intro a ha
  rcases mem_insert.mp ha with hax|ha
  · subst a; simpa only [Function.update_self] using hR
  · have hn:a≠x:=by intro he; have h:=(mem_filter.mp ha).2; rw [he,dist_self] at h; linarith
    simpa only [Function.update_of_ne hn] using hrad a (mem_filter.mp ha).1

lemma inner_reuses {r R:ℝ} (hr:0<r) {C D:Finset Y} {x p a:Y} {rad:Y→ℝ}
    {lab prev:Y→Pool Y} (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b))
    (hrad:∀ a∈C,rad a∈Set.Icc (16*r) (20*r)) (hR:R∈Set.Icc (16*r) (20*r))
    (ha:a∈C) (hap:dist a p≤10*r) (hxp:dist x p≤3*r) :
    oldKey C rad lab p=newKey C D rad lab prev r x R p := by
  have haP:dist a p≤rad a:=by linarith [(hrad a ha).1]
  have hxP:dist x p≤R:=by linarith [hR.1]
  have ho:centerKey C rad p=some a:=
    (centerKey_some hr hC (fun a ha=>(hrad a ha).2)).mpr ⟨ha,haP⟩
  have hn:centerKey (replace r C x) (Function.update rad x R) p=some x:=
    (centerKey_some hr (replace_separated hC) (new_radius hr (fun a ha=>(hrad a ha).2) hR.2)).mpr
      ⟨mem_insert_self _ _,by simpa only [Function.update_self] using hxP⟩
  have hl:=inserted_reuses (D:=D) (label:=lab) (prev:=prev) hr hC
    (fun a ha=>(hrad a ha).2) hR.2 (mem_filter.mpr ⟨ha,⟨p,haP,hxP⟩⟩)
  simp only [oldKey,newKey,ho,hn,Option.map_some,updatedLabel,Function.update_self,hl]

lemma keys_far {r R:ℝ} (hr:0<r) {C D:Finset Y} {x p:Y} {rad:Y→ℝ}
    {lab prev:Y→Pool Y} (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b))
    (hrad:∀ a∈C,rad a≤20*r) (hR:R≤20*r) (hp:120*r<dist x p) :
    oldKey C rad lab p=newKey C D rad lab prev r x R p := by
  have hnc:¬dist x p≤R:=by linarith
  cases he:centerKey C rad p with
  | none =>
    have hn:centerKey (replace r C x) (Function.update rad x R) p=none:=by
      apply (centerKey_none _ _ _).mpr
      intro a ha
      rcases mem_insert.mp ha with hax|ha
      · subst a; simpa only [Function.update_self] using lt_of_not_ge hnc
      · have hax:a≠x:=by intro hh; have h:=(mem_filter.mp ha).2; rw [hh,dist_self] at h; linarith
        rw [Function.update_of_ne hax]
        exact (centerKey_none C rad p).mp he a (mem_filter.mp ha).1
    simp only [oldKey,newKey,he,hn,Option.map_none]
  | some a =>
    obtain ⟨ha,hap⟩:=(centerKey_some hr hC hrad).mp he
    have ht:=dist_triangle x a p
    rw [dist_comm x a] at ht
    have hax:100*r<dist a x:=by linarith [hrad a ha]
    have han:a≠x:=by intro hh; rw [hh,dist_self] at hax; linarith
    have hn:centerKey (replace r C x) (Function.update rad x R) p=some a:=by
      apply (centerKey_some hr (replace_separated hC) (new_radius hr hrad hR)).mpr
      exact ⟨mem_insert_of_mem (mem_filter.mpr ⟨ha,hax⟩),by simpa only [Function.update_of_ne han] using hap⟩
    simp only [oldKey,newKey,he,hn,Option.map_some,updatedLabel,Function.update_of_ne han]

lemma inner_paid {r R:ℝ} (hr:0<r) {C D:Finset Y} {x p:Y} {rad:Y→ℝ}
    {lab prev:Y→Pool Y} (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b))
    (hrad:∀ a∈C,rad a∈Set.Icc (16*r) (20*r)) (hR:R∈Set.Icc (16*r) (20*r))
    (hxp:dist x p≤3*r) :
    (if oldKey C rad lab p≠newKey C D rad lab prev r x R p then (1:ℝ) else 0) +
      profile r (replace r C x) p-profile r C p≤0 := by
  have hn:profile r (replace r C x) p=0:=profile_eq_zero hr (mem_insert_self _ _) (by linarith)
  rw [hn]
  by_cases he:∃ a∈C,dist a p≤10*r
  · obtain ⟨a,ha,hap⟩:=he
    rw [ite_eq_right (not_not.mpr (inner_reuses hr hC hrad hR ha hap hxp))]
    linarith [profile_nonneg r C p]
  · have hp:profile r C p=1:=by
      apply profile_eq_one hr
      intro a ha
      exact le_of_lt (lt_of_not_ge (fun hh=>he ⟨a,ha,hh⟩))
    rw [hp]
    split_ifs <;> norm_num

/-- Source heavy edit charge table for a stationary member. -/
theorem stationary {r R:ℝ} (hr:0<r) {C D:Finset Y} {x p:Y} {rad:Y→ℝ}
    {lab prev:Y→Pool Y} (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b))
    (hrad:∀ a∈C,rad a∈Set.Icc (16*r) (20*r)) (hR:R∈Set.Icc (16*r) (20*r)) :
    (if oldKey C rad lab p≠newKey C D rad lab prev r x R p then (1:ℝ) else 0) +
      profile r (replace r C x) p-profile r C p≤
        if 3*r<dist x p ∧ dist x p≤120*r then 2 else 0 := by
  by_cases hnear:dist x p≤3*r
  · rw [ite_eq_right (show ¬(3*r<dist x p ∧ dist x p≤120*r) from fun h=>not_lt_of_ge hnear h.1)]
    exact inner_paid hr hC hrad hR hnear
  · by_cases hfar:120*r<dist x p
    · rw [profile_far hr C hfar,ite_eq_right (show ¬(3*r<dist x p ∧ dist x p≤120*r) from fun h=>not_le_of_gt hfar h.2),
        ite_eq_right (not_not.mpr (keys_far (D:=D) (lab:=lab) (prev:=prev) hr hC (fun a ha=>(hrad a ha).2) hR.2 hfar))]
      ring_nf
      exact le_rfl
    · rw [ite_eq_left (show 3*r<dist x p ∧ dist x p≤120*r from ⟨lt_of_not_ge hnear,le_of_not_gt hfar⟩)]
      have ho:=profile_nonneg r C p
      have hn:=profile_le_one r (replace r C x) p
      split_ifs <;> linarith

/-- Source heavy edit charge table for the designated mover. -/
theorem mover {r R:ℝ} (hr:0<r) {C D:Finset Y} {x p:Y} {rad:Y→ℝ}
    {lab prev:Y→Pool Y} (hC:(C:Set Y).Pairwise (fun a b=>100*r<dist a b))
    (hrad:∀ a∈C,rad a∈Set.Icc (16*r) (20*r)) (hR:R∈Set.Icc (16*r) (20*r)) :
    (if oldKey C rad lab p≠newKey C D rad lab prev r x R p then (1:ℝ) else 0) +
      profile r (replace r C x) x-profile r C p≤ if 3*r<dist x p then 1 else 0 := by
  by_cases hnear:dist x p≤3*r
  · have hh:=inner_paid (D:=D) (lab:=lab) (prev:=prev) hr hC hrad hR hnear
    have hp:profile r (replace r C x) p=0:=profile_eq_zero hr (mem_insert_self _ _) (by linarith)
    have hx:profile r (replace r C x) x=0:=profile_eq_zero hr (mem_insert_self _ _) (by simpa only [dist_self] using (mul_nonneg (by norm_num : (0:ℝ)≤9) hr.le))
    rw [ite_eq_right (not_lt_of_ge hnear),hx]
    simpa only [hp] using hh
  · rw [ite_eq_left (lt_of_not_ge hnear)]
    have hx:profile r (replace r C x) x=0:=profile_eq_zero hr (mem_insert_self _ _) (by simpa only [dist_self] using (mul_nonneg (by norm_num : (0:ℝ)≤9) hr.le))
    rw [hx]
    have ho:=profile_nonneg r C p
    split_ifs <;> linarith
end KServer.HeavyEdit

end


/-! The actual heavy-priority stage, including its deterministic clipped-ramp
potential and the true hidden trajectory. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HeavyTemporal
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw PriorityKeys ActualRoster
open HeavyCenters HeavySchedule HeavyLabels LevelRetirement RankTracking PosteriorRanks
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def active (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) : Prop :=
  Active r heavyGamma heavyDelta (centers s law r heavyGamma heavyDelta σ t)
    (mu s law (t.val+1) σ) (σ t)

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

def profile (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:ℕ) (p:Y) : ℝ :=
  HeavyEdit.profile r (centers s law r heavyGamma heavyDelta σ t) p

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma ite_indicator (P:Prop) (d:Decidable P) : @ite ℝ P d 1 0=indicator P := by
  by_cases h:P <;> simp [indicator,h]

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:ℕ) (p:Y) :
    charge s law hr σ a t p ≤ indicator
      (HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 t p≠
        HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 (t+1) p) :=
  stage_charge _ _ _ _

lemma active_keys (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (ha:active s law r σ t) (p:Y) :
    HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 (t.val+1) p=
      HeavyEdit.newKey (centers s law r heavyGamma heavyDelta σ t)
      (centers s law r heavyGamma heavyDelta σ (t.val-1))
      (run s law r heavyGamma heavyDelta σ a.1 t).rad
      (run s law r heavyGamma heavyDelta σ a.1 t).label
      (run s law r heavyGamma heavyDelta σ a.1 t).previous r (σ t)
      (FiniteUniform.radius r (a.1 t)) p := by
  simp only [HeavyKeys.key,centers_succ,HeavyCenters.step,run,t.isLt,dite_eq_left,active] at ha ⊢
  simp only [ite_eq_left ha]
  rfl

lemma inactive_keys (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) (ha:¬active s law r σ t) (p:Y) :
    HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 (t.val+1) p=
      HeavyKeys.key s law r heavyGamma heavyDelta σ a.1 t p := by
  simp only [HeavyKeys.key,centers_succ,HeavyCenters.step,run,t.isLt,dite_eq_left,active] at ha ⊢
  simp only [ite_eq_right ha]

lemma inactive_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) (ha:¬active s law r σ t) (p:Y) :
    charge s law hr σ a t p=0 := by
  have hb:=charge_le s law hr σ a t p
  rw [inactive_keys s law r σ a t ha p] at hb
  simp only [ne_self_iff_false,indicator,ite_false] at hb
  exact le_antisymm hb (indicator_nonneg _)

lemma active_profile (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (t:Fin H) (ha:active s law r σ t) (p:Y) :
    profile s law r σ (t.val+1) p=HeavyEdit.profile r
      (replace r (centers s law r heavyGamma heavyDelta σ t) (σ t)) p := by
  dsimp only [active] at ha
  simp only [profile,centers_succ,HeavyCenters.step,ite_eq_left ha]

lemma inactive_profile (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ)
    (σ:Fin H→Y) (t:Fin H) (ha:¬active s law r σ t) (p:Y) :
    profile s law r σ (t.val+1) p=profile s law r σ t p := by
  dsimp only [active] at ha
  simp only [profile,centers_succ,HeavyCenters.step,ite_eq_right ha]

lemma 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) (p:Y) :
    charge s law hr.le σ a t p+profile s law r σ (t.val+1) p-profile s law r σ t p ≤
      if active s law r σ t then 2*indicator (3*r<dist (σ t) p ∧ dist (σ t) p≤120*r) else 0 := by
  by_cases ha:active s law r σ t
  · rw [ite_eq_left ha,active_profile s law r σ t ha p]
    have hc:=charge_le s law hr.le σ a t p
    rw [active_keys s law r σ a t ha p] at hc
    have hb:=HeavyEdit.stationary (x:=σ t) (D:=centers s law r heavyGamma heavyDelta σ (t.val-1))
      (lab:=(run s law r heavyGamma heavyDelta σ a.1 t).label)
      (prev:=(run s law r heavyGamma heavyDelta σ a.1 t).previous) hr
      (centers_separated s law r heavyGamma heavyDelta σ t)
      (run_valid s law hr heavyGamma heavyDelta σ a.1 t).1 (FiniteUniform.radius_range hr (a.1 t))
      (p:=p)
    simp only [HeavyKeys.key] at hc
    have he:(if 3*r<dist (σ t) p ∧ dist (σ t) p≤120*r then (2:ℝ) else 0)=
        2*indicator (3*r<dist (σ t) p ∧ dist (σ t) p≤120*r):=by
      unfold indicator
      split_ifs <;> norm_num
    rw [he] at hb
    dsimp only [profile]
    simp only [HeavyEdit.oldKey] at hb
    apply (sub_le_sub (add_le_add hc (le_refl _)) (le_refl _)).trans
    convert hb using 1; first | rfl | (simp only [indicator]; congr 4)
  · rw [ite_eq_right ha,inactive_charge s law hr.le σ a t ha p,inactive_profile s law r σ t ha p]
    ring_nf
    exact le_rfl


def heavy (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) : Prop :=
  mass (mu s law (t.val+1) σ) (ball (σ t) (51200*r))≤
    (1+heavyDelta)*mass (mu s law (t.val+1) σ) (ball (σ t) (heavyGamma*r))

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) (p:Y) :
    charge s law hr.le σ a t p+profile s law r σ (t.val+1) (σ t)-profile s law r σ t p ≤
      indicator (3*r<dist (σ t) p)+(if heavy s law r σ t then 0 else dist (σ t) p/r) := by
  by_cases ha:active s law r σ t
  · have hh:heavy s law r σ t:=ha.1
    rw [active_profile s law r σ t ha (σ t),ite_eq_left hh]
    have hc:=charge_le s law hr.le σ a t p
    rw [active_keys s law r σ a t ha p] at hc
    have hb:=HeavyEdit.mover (x:=σ t) (D:=centers s law r heavyGamma heavyDelta σ (t.val-1))
      (lab:=(run s law r heavyGamma heavyDelta σ a.1 t).label)
      (prev:=(run s law r heavyGamma heavyDelta σ a.1 t).previous) hr
      (centers_separated s law r heavyGamma heavyDelta σ t)
      (run_valid s law hr heavyGamma heavyDelta σ a.1 t).1 (FiniteUniform.radius_range hr (a.1 t))
      (p:=p)
    simp only [HeavyKeys.key] at hc
    simp only [HeavyEdit.oldKey] at hb
    dsimp only [profile]
    simp only [add_zero]
    apply (sub_le_sub (add_le_add hc (le_refl _)) (le_refl _)).trans
    convert hb using 1 <;> first | rfl | (simp only [indicator]; congr 4)
  · rw [inactive_charge s law hr.le σ a t ha p,inactive_profile s law r σ t ha (σ t)]
    by_cases hh:heavy s law r σ t
    · rw [ite_eq_left hh]
      have he:∃ a∈centers s law r heavyGamma heavyDelta σ t,dist a (σ t)≤8*r:=by
        by_contra hn
        push Not at hn
        exact ha ⟨hh,hn⟩
      obtain ⟨b,hb,hbd⟩:=he
      have hz:profile s law r σ t (σ t)=0:=HeavyEdit.profile_eq_zero hr hb (by linarith)
      rw [hz]
      have hp:=HeavyEdit.profile_nonneg r (centers s law r heavyGamma heavyDelta σ t) p
      have hi:=indicator_nonneg (3*r<dist (σ t) p)
      dsimp only [profile]
      linarith
    · rw [ite_eq_right hh]
      have hb:=(le_abs_self _).trans (HeavyEdit.profile_lipschitz hr
        (centers s law r heavyGamma heavyDelta σ t) (σ t) p)
      have hi:=indicator_nonneg (3*r<dist (σ t) p)
      dsimp only [profile]
      linarith

end KServer.HeavyTemporal

end


/-! True-prefix causality of the literal fixed-label complete level map.
The finite permanent colors and cooldown reservations do not read the future. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.KeysAdapted
open FiniteExperiment TierProcess Chronological ActualRoster LevelKeys LevelLaw
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

omit [MetricSpace Y] [NeZero k] in
lemma history_mono {t T:ℕ} (ht:t≤T) (σ ρ:Fin H→Y)
    (hh:requestHistory T σ=requestHistory T ρ) : requestHistory t σ=requestHistory t ρ := by
  rw [requestHistory_eq_iff] at hh ⊢
  funext i
  by_cases hi:i.val<t
  · have hiT:i.val<T:=lt_of_lt_of_le hi ht
    have he:=congrFun hh i
    simpa only [requestPrefix,ite_eq_left hi,ite_eq_left hiT] using he
  · simp only [requestPrefix,ite_eq_right hi]

lemma run_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (r γ δ:ℝ) (tape:Fin H→FiniteUniform.Outcome Y r) (t:ℕ)
    (σ ρ:Fin H→Y) (hh:requestHistory t σ=requestHistory t ρ) :
    HeavySchedule.run s law r γ δ σ tape t=HeavySchedule.run s law r γ δ ρ tape t := by
  induction t with
  | zero => rfl
  | succ t ih =>
    have h0:requestHistory t σ=requestHistory t ρ:=requestHistory_refines t σ ρ hh
    have hd:=ih h0
    have hc:=HeavyCenters.centers_adapted s law r γ δ t σ ρ h0
    have hp:=HeavyCenters.centers_adapted s law r γ δ (t-1) σ ρ (history_mono (Nat.sub_le _ _) σ ρ h0)
    have hm:mu s law (t+1) σ=mu s law (t+1) ρ:=funext (fun p=>mu_adapted s law (t+1) p σ ρ hh)
    simp only [HeavySchedule.run,hd,hc,hp,hm]
    by_cases ht:t<H
    · simp only [dite_eq_left ht]
      rw [request_of_history ⟨t,ht⟩ σ ρ hh]
    · simp only [dite_eq_right ht]

lemma heavy_key_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (r γ δ:ℝ) (tape:Fin H→FiniteUniform.Outcome Y r) (t:ℕ) (p:Y)
    (σ ρ:Fin H→Y) (hh:requestHistory t σ=requestHistory t ρ) :
    HeavyKeys.key s law r γ δ σ tape t p=HeavyKeys.key s law r γ δ ρ tape t p := by
  unfold HeavyKeys.key
  rw [run_adapted s law r γ δ tape t σ ρ hh,HeavyCenters.centers_adapted s law r γ δ t σ ρ hh]

lemma reserved_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (T:Pilot.Template) (r γ h:ℝ) (K t:ℕ) (σ ρ:Fin H→Y)
    (hh:requestHistory t σ=requestHistory t ρ) :
    reserved (request s σ) r K (qualifies s law T r γ h σ) t=
      reserved (request s ρ) r K (qualifies s law T r γ h ρ) t := by
  change young (request s σ) (roster s law T r γ h K σ t) (20*r) (K^2)=_
  have he:=roster_adapted s law T r γ h K t σ ρ hh
  change _=young (request s ρ) (roster s law T r γ h K ρ t) (20*r) (K^2)
  rw [←he]
  unfold young
  apply filter_congr
  intro i hi
  rw [ShortRoster.age_congr (request_adapted s (roster_before s law T r γ h K σ t i hi) σ ρ hh)
    (fun j hj=>request_adapted s (roster_before s law T r γ h K σ t j hj) σ ρ hh)]

lemma conflicts_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (T:Pilot.Template) (r γ h:ℝ) (K t:ℕ) (σ ρ:Fin H→Y)
    (hh:requestHistory t σ=requestHistory t ρ) :
    conflicts (request s σ) r K (qualifies s law T r γ h σ) t=
      conflicts (request s ρ) r K (qualifies s law T r γ h ρ) t := by
  unfold conflicts
  rw [reserved_adapted s law T r γ h K t σ ρ hh,
    reserved_adapted s law T r γ h K (t-1) σ ρ (history_mono (Nat.sub_le _ _) σ ρ hh)]

omit [MetricSpace Y] [Fintype Y] [NeZero k] in
lemma stage_congr {M t:ℕ} (hM:0<M) {c d:ℕ→Finset ℕ}
    (hc:∀ j,(c j).card<M) (hd:∀ j,(d j).card<M) (he:∀ j,j<t→c j=d j) :
    OnlineLabels.stage hM c hc t=OnlineLabels.stage hM d hd t := by
  induction t with
  | zero => rfl
  | succ t ih =>
    have hp:=ih (fun j hj=>he j (by omega))
    simp only [OnlineLabels.stage,hp,he t (by omega)]

lemma label_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (T:Pilot.Template) {r:ℝ} (hr:0≤r) (γ h:ℝ) (K t i:ℕ) (hi:i<t)
    (σ ρ:Fin H→Y) (hh:requestHistory t σ=requestHistory t ρ) :
    Chronological.label (request s σ) hr K (qualifies s law T r γ h σ) i=
      Chronological.label (request s ρ) hr K (qualifies s law T r γ h ρ) i := by
  unfold Chronological.label OnlineLabels.color
  have he:=stage_congr (t:=i+1) (pool_pos (Y:=Y) K)
    (conflicts_card (request s σ) hr K (qualifies s law T r γ h σ))
    (conflicts_card (request s ρ) hr K (qualifies s law T r γ h ρ))
    (fun j hj=>conflicts_adapted s law T r γ h K j σ ρ (history_mono (by omega) σ ρ hh))
  exact congrFun he i

lemma first_congr {c d:ℕ→Y} {I:Finset ℕ} {r:ℝ} {K:ℕ}
    (hc:∀ j∈I,c j=d j) (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (p:Y) :
    first c I r life rad p=first d I r life rad p := by
  have he:covered c I r life rad p=covered d I r life rad p:=by
    funext i
    apply propext
    unfold covered present
    by_cases hi:(i:ℕ)∈I
    · rw [ShortRoster.age_congr (hc i hi) hc,hc i hi]
    · simp only [hi,false_and]
  unfold first
  rw [he]

lemma tier_key_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    (T:Pilot.Template) {r:ℝ} (hr:0≤r) (γ h:ℝ) (K:ℕ)
    (life:Fin H→Lifetime K) (rad:Fin H→FiniteBallLaw.Outcome Y r) (t:ℕ) (p:Y)
    (σ ρ:Fin H→Y) (hh:requestHistory t σ=requestHistory t ρ) :
    TierKeys.key (request s σ) hr K (qualifies s law T r γ h σ) life rad t p=
      TierKeys.key (request s ρ) hr K (qualifies s law T r γ h ρ) life rad t p := by
  have hR:=roster_adapted s law T r γ h K t σ ρ hh
  have hf:first (request s σ) (roster s law T r γ h K σ t) r life rad p=
      first (request s ρ) (roster s law T r γ h K ρ t) r life rad p:=by
    exact (first_congr (fun j hj=>request_adapted s (roster_before s law T r γ h K σ t j hj) σ ρ hh) life rad p).trans
      (congrArg (fun I=>first (request s ρ) I r life rad p) hR)
  change (first (request s σ) (roster s law T r γ h K σ t) r life rad p).map
    (fun j:Fin H=>Chronological.label (request s σ) hr K (qualifies s law T r γ h σ) j)=
    (first (request s ρ) (roster s law T r γ h K ρ t) r life rad p).map
    (fun j:Fin H=>Chronological.label (request s ρ) hr K (qualifies s law T r γ h ρ) j)
  refine (Option.map_congr ?_).trans (congrArg (fun z=>z.map
    (fun j:Fin H=>Chronological.label (request s ρ) hr K (qualifies s law T r γ h ρ) j)) hf)
  intro i he
  have hi:=(first_some_iff (request s σ) (roster s law T r γ h K σ t) r life rad p i).mp he
  exact label_adapted s law T hr γ h K t i
    (roster_before s law T r γ h K σ t i hi.1.1.1) σ ρ hh

lemma keys_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0≤r) (a:Tape Y k H r) (t:ℕ) (σ ρ:Fin H→Y)
    (hh:requestHistory t σ=requestHistory t ρ) :
    keys s law hr σ a t=keys s law hr ρ a t := by
  funext i p
  cases i with
  | none => exact heavy_key_adapted s law _ _ _ a.1 t p σ ρ hh
  | some i =>
    exact tier_key_adapted s law tierTemplate hr tierGamma (height i) (tierK (height i))
      (a.2 i).1 (a.2 i).2 t p σ ρ hh

lemma map_adapted (s:Configuration k Y) (law:RequestLaw Y H)
    {r:ℝ} (hr:0≤r) (a:Tape Y k H r) (t:ℕ) (p:Y) (σ ρ:Fin H→Y)
    (hh:requestHistory t σ=requestHistory t ρ) :
    LevelKeys.map s law hr σ a t p=LevelKeys.map s law hr ρ a t p := by
  unfold LevelKeys.map
  rw [keys_adapted s law hr a t σ ρ hh]

end KServer.KeysAdapted

end


/-! True-prefix heavy edit accounting. The deterministic profile is telescoped
on the hidden labeled optimum; no surviving-radius conditioning is used. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HeavyBudget
open FiniteExperiment TierProcess Pilot LevelKeys LevelLaw PriorityKeys ActualRoster
open HeavyCenters HeavySchedule HeavyLabels LevelRetirement RankTracking PosteriorRanks
open HiddenAverages HeavyTemporal TierGlobal
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type*} [MetricSpace Y] [Fintype Y] {k H:ℕ} [NeZero k]

def test (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (p:Y) : ℝ :=
  if active s law r σ t then indicator (3*r<dist (σ t) p ∧ dist (σ t) p≤120*r) else 0

lemma test_nonneg (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) (p:Y) :
    0≤test s law r σ t p := by unfold test; split_ifs; exact indicator_nonneg _; rfl

lemma test_adapted (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:Fin H) (p:Y) :
    Adapted (requestHistory (t.val+1)) (fun σ=>test s law r σ t p) := by
  intro σ ρ hh
  have hm:mu s law (t.val+1) σ=mu s law (t.val+1) ρ:=funext (fun y=>mu_adapted s law (t.val+1) y σ ρ hh)
  have hp:requestHistory t.val σ=requestHistory t.val ρ:=by
    exact KeysAdapted.history_mono (Nat.le_succ _) σ ρ hh
  have hc:=centers_adapted s law r heavyGamma heavyDelta t.val σ ρ hp
  simp only [test,active,hm,hc,request_of_history t σ ρ hh]
  congr 4

lemma test_mass (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:Fin H) :
    (∑ y,mu s law (t.val+1) σ y*test s law r σ t y)=
      if active s law r σ t then mass (mu s law (t.val+1) σ) (HeavyCenters.annulus (σ t) r) else 0 := by
  unfold test
  split_ifs
  · simp only [indicator,mul_ite,mul_one,mul_zero]
    rw [←sum_filter]
    congr 1
  · simp

lemma stationary_bound (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:Fin H) :
    avg law.val (fun σ=>∑ l∈univ.erase (FiniteExperiment.mover s σ t),test s law r σ t (hidden s σ t l)) ≤
      avg law.val (fun σ=>if active s law r σ t then mass (mu s law (t.val+1) σ) (HeavyCenters.annulus (σ t) r) else 0) := by
  rw [←expected_stationary_test s law t (fun σ p=>test s law r σ t p) (test_adapted s law r t)]
  trans avg law.val (fun σ=>∑ y,mu s law (t.val+1) σ y*test s law r σ t y)
  · apply sum_le_sum
    intro σ _
    by_cases hs:0<law.val σ
    · apply mul_le_mul_of_nonneg_left _ hs.le
      apply sum_le_sum
      intro y _
      exact mul_le_mul_of_nonneg_right (stationary_le s law t σ hs y) (test_nonneg s law r σ t y)
    · have hz:law.val σ=0:=le_antisymm (le_of_not_gt hs) (law.property.1 σ)
      simp only [hz,zero_mul,le_refl]
  · apply le_of_eq
    congr 1
    funext σ
    exact test_mass s law r σ t

def potential (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:ℕ) : ℝ :=
  ∑ l,HeavyTemporal.profile s law r σ t (hidden s σ t l)

def editCost (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0≤r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) : ℝ :=
  ∑ l,HeavyTemporal.charge s law hr σ a t (hidden s σ t l)

lemma potential_bounds (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (σ:Fin H→Y) (t:ℕ) :
    potential s law r σ t∈Set.Icc 0 (k:ℝ) := by
  constructor
  · exact sum_nonneg (fun l _=>HeavyEdit.profile_nonneg _ _ _)
  · exact (sum_le_sum (fun l (_:l∈univ)=>HeavyEdit.profile_le_one _ _ _)).trans_eq (by simp)

lemma potential_step (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0≤r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) :
    editCost s law hr σ a t+potential s law r σ (t.val+1)-potential s law r σ t=
      (∑ l∈univ.erase (FiniteExperiment.mover s σ t),(HeavyTemporal.charge s law hr σ a t (hidden s σ t l)+
        HeavyTemporal.profile s law r σ (t.val+1) (hidden s σ t l)-HeavyTemporal.profile s law r σ t (hidden s σ t l)))+
      (HeavyTemporal.charge s law hr σ a t (hidden s σ t (FiniteExperiment.mover s σ t))+
        HeavyTemporal.profile s law r σ (t.val+1) (σ t)-HeavyTemporal.profile s law r σ t (hidden s σ t (FiniteExperiment.mover s σ t))) := by
  have he:potential s law r σ (t.val+1)=
    (∑ l∈univ.erase (FiniteExperiment.mover s σ t),HeavyTemporal.profile s law r σ (t.val+1) (hidden s σ t l))+
      HeavyTemporal.profile s law r σ (t.val+1) (σ t) := by
    unfold potential
    rw [←sum_erase_add _ _ (mem_univ (FiniteExperiment.mover s σ t)),hidden_covers]
    congr 1
    apply sum_congr rfl
    intro l hl
    congr 1
    have he:=congrFun (hidden_step s σ t) l
    simpa [serve,(mem_erase.mp hl).1] using he
  rw [he]
  unfold editCost potential
  have hC:=sum_erase_add univ (fun l:Fin k=>HeavyTemporal.charge s law hr σ a t (hidden s σ t l)) (mem_univ (FiniteExperiment.mover s σ t))
  have hU:=sum_erase_add univ (fun l:Fin k=>HeavyTemporal.profile s law r σ t (hidden s σ t l)) (mem_univ (FiniteExperiment.mover s σ t))
  simp only [sum_sub_distrib,sum_add_distrib]
  linarith

lemma step_bound (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (σ:Fin H→Y) (a:Tape Y k H r) (t:Fin H) :
    editCost s law hr.le σ a t+potential s law r σ (t.val+1)-potential s law r σ t≤
      2*(∑ l∈univ.erase (FiniteExperiment.mover s σ t),test s law r σ t (hidden s σ t l))+
      indicator (3*r<dist (σ t) (hidden s σ t (FiniteExperiment.mover s σ t)))+
      (if heavy s law r σ t then 0 else dist (σ t) (hidden s σ t (FiniteExperiment.mover s σ t))/r) := by
  rw [potential_step]
  have hs:=sum_le_sum (fun l (_:l∈univ.erase (FiniteExperiment.mover s σ t))=>HeavyTemporal.stationary s law hr σ a t (hidden s σ t l))
  have he: (∑ l∈univ.erase (FiniteExperiment.mover s σ t),(if active s law r σ t then
      2*indicator (3*r<dist (σ t) (hidden s σ t l) ∧ dist (σ t) (hidden s σ t l)≤120*r) else 0))=
      2*(∑ l∈univ.erase (FiniteExperiment.mover s σ t),test s law r σ t (hidden s σ t l)) := by
    unfold test
    split_ifs
    · rw [mul_sum]
    · simp
  rw [he] at hs
  have hm:=HeavyTemporal.mover s law hr σ a t (hidden s σ t (FiniteExperiment.mover s σ t))
  linarith

lemma average_step (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r)
    (t:Fin H) :
    avg law.val (fun σ=>mean r (fun a=>editCost s law hr.le σ a t))+
      avg law.val (fun σ=>potential s law r σ (t.val+1))-
      avg law.val (fun σ=>potential s law r σ t) ≤
    2*avg law.val (fun σ=>if active s law r σ t then mass (mu s law (t.val+1) σ) (HeavyCenters.annulus (σ t) r) else 0)+
      avg law.val (fun σ=>indicator (3*r<dist (σ t) (hidden s σ t (mover s σ t))))+
      avg law.val (fun σ=>if heavy s law r σ t then 0 else dist (σ t) (hidden s σ t (mover s σ t))/r) := by
  have hb:=avg_mono law.property.1 (fun σ=>(mean_mono hr (fun a=>step_bound s law hr σ a t)))
  simp only [TierTemporal.mean_sub,TierTemporal.mean_add,mean_const hr,avg_add,avg_sub,avg_mul] at hb
  have hs:=stationary_bound s law r t
  linarith

lemma mean_bounds (s:Configuration k Y) (law:RequestLaw Y H) (r:ℝ) (t:ℕ) :
    avg law.val (fun σ=>potential s law r σ t)∈Set.Icc 0 (k:ℝ) := by
  constructor
  · exact (show 0=avg law.val (fun _=>0) by rw [avg_const _ law.property.2]).le.trans
      (avg_mono law.property.1 (fun σ=>(potential_bounds s law r σ t).1))
  · calc _ ≤ avg law.val (fun _=>(k:ℝ)) := avg_mono law.property.1 (fun σ=>(potential_bounds s law r σ t).2)
         _ = _ := avg_const _ law.property.2 _

lemma heavy_budget (s:Configuration k Y) (law:RequestLaw Y H) {r:ℝ} (hr:0<r) :
    (∑ t:Fin H,avg law.val (fun σ=>mean r (fun a=>editCost s law hr.le σ a t))) ≤
    2*(∑ t:Fin H,avg law.val (fun σ=>if active s law r σ t then mass (mu s law (t.val+1) σ) (HeavyCenters.annulus (σ t) r) else 0))+
      (∑ t:Fin H,avg law.val (fun σ=>indicator (3*r<dist (σ t) (hidden s σ t (mover s σ t)))))+
      (∑ t:Fin H,avg law.val (fun σ=>if heavy s law r σ t then 0 else dist (σ t) (hidden s σ t (mover s σ t))/r))+k := by
  have hb:=telescope_budget (fun t=>avg law.val (fun σ=>potential s law r σ t)) _ _
    (average_step s law hr) (mean_bounds s law r H).1
  simp only [sum_add_distrib,←mul_sum] at hb
  exact hb.trans (add_le_add le_rfl (mean_bounds s law r 0).2)

end KServer.HeavyBudget

end

end OAI