import Mathlib
import OAI.Combinatorics.KServer.RankProportions

namespace OAI

noncomputable section
open scoped BigOperators
open Finset

namespace KServer.CoarseSchedule
open Finset

structure State where
  active : Bool
  value : ℝ

def Valid (s : State) : Prop := 0 ≤ s.value ∧ (s.active = false → s.value = 0)

noncomputable def update (c δ x : ℝ) (s : State) : State :=
  if s.active then
    if x ≤ 2*c then ⟨false,0⟩
    else if (1+δ)*s.value < x ∨ (1+δ)*x < s.value then ⟨true,x⟩ else s
  else if 5*c ≤ x then ⟨true,x⟩ else s

noncomputable def charge (s t : State) : ℝ := if s.value = t.value then 0 else s.value+t.value
noncomputable def factor (δ : ℝ) : ℝ := 1+2/δ
noncomputable def potential (c δ x : ℝ) (s : State) : ℝ :=
  factor δ * |x-s.value| + (if s.active then 2*(factor δ+1)*c else 0)

lemma factor_ge_seven (δ : ℝ) (hδ : 0 < δ) (hδu : δ ≤ 1/3) : 7 ≤ factor δ := by
  have hh : 6 ≤ 2/δ := (le_div_iff₀ hδ).mpr (by linarith)
  exact by dsimp [factor]; linarith

lemma update_valid {s : State} (hs : Valid s) {c δ x : ℝ} (hx : 0 ≤ x) :
    Valid (update c δ x s) := by
  unfold update
  split_ifs <;> simp_all [Valid]

lemma charge_self (s : State) : charge s s = 0 := by simp [charge]
lemma charge_le {s t : State} (hs : 0 ≤ s.value) (ht : 0 ≤ t.value) :
    charge s t ≤ s.value+t.value := by
  unfold charge
  split_ifs <;> linarith

lemma update_credit {c δ x : ℝ} {s : State} (hc : 0 ≤ c)
    (hδ : 0 < δ) (hδu : δ ≤ 1/3) (hx : 0 ≤ x) (hs : Valid s) :
    charge s (update c δ x s) + potential c δ x (update c δ x s) ≤ potential c δ x s := by
  have hC := factor_ge_seven δ hδ hδu
  have hC0 : 0 ≤ factor δ := by linarith
  have hC1 : 1 ≤ factor δ := by linarith
  have hCs : |x-s.value| ≤ factor δ*|x-s.value| := by nlinarith [abs_nonneg (x-s.value)]
  unfold update
  split_ifs with hon hoff href hon'
  · have hsx : s.value ≤ |x-s.value|+x := by
      have hh := le_abs_self (s.value-x)
      rw [abs_sub_comm s.value x] at hh
      linarith
    have hch := charge_le (s := s) (t := ⟨false,0⟩) hs.1 (by norm_num)
    simp only [potential, Bool.false_eq_true, ite_false, sub_zero, abs_of_nonneg hx]
    simp only [hon, ite_true]
    have hbound : (factor δ+1)*x ≤ 2*(factor δ+1)*c := by
      nlinarith [mul_le_mul_of_nonneg_left hoff (show 0 ≤ factor δ+1 by linarith)]
    linarith
  · have hch := charge_le (s := s) (t := ⟨true,x⟩) hs.1 hx
    have hfac := RankTracking.factor_change_charge hs.1 hx hδ href
    rw [abs_sub_comm] at hfac
    change s.value+x ≤ factor δ*|x-s.value| at hfac
    simp only [potential, sub_self, abs_zero, mul_zero, zero_add, hon, ite_true]
    linarith
  · simp [charge_self]
  · have hfalse : s.active = false := by simpa using hon
    have hz := hs.2 hfalse
    have hch := charge_le (s := s) (t := ⟨true,x⟩) hs.1 hx
    simp only [potential, sub_self, abs_zero, mul_zero, zero_add, hfalse, Bool.false_eq_true, ite_false, ite_true,
      hz, sub_zero, abs_of_nonneg hx]
    have hc1 : 2*(factor δ+1)*c ≤ (factor δ-1)*(5*c) := by nlinarith
    have hc2 : (factor δ-1)*(5*c) ≤ (factor δ-1)*x :=
      mul_le_mul_of_nonneg_left hon' (by linarith)
    simp only [hz] at hch
    linarith
  · simp [charge_self]

lemma potential_nonneg {c δ x : ℝ} {s : State} (hc : 0 ≤ c) (hδ : 0 < δ) :
    0 ≤ potential c δ x s := by
  unfold potential factor
  split_ifs <;> positivity

lemma potential_input {c δ x y : ℝ} (s : State) (hδ : 0 < δ) :
    potential c δ y s ≤ potential c δ x s + factor δ*|y-x| := by
  have h0 : 0 ≤ factor δ := by unfold factor; positivity
  have hh := mul_le_mul_of_nonneg_left (abs_sub_le y x s.value) h0
  simpa only [potential, mul_add] using (show
    factor δ*|y-s.value|+(if s.active then 2*(factor δ+1)*c else 0) ≤
    factor δ*|x-s.value|+(if s.active then 2*(factor δ+1)*c else 0)+factor δ*|y-x| by
      linarith)

noncomputable def run (c δ : ℝ) (x : ℕ → ℝ) (initial : State) : ℕ → State
  | 0 => initial
  | t+1 => update c δ (x (t+1)) (run c δ x initial t)

lemma run_valid {c δ : ℝ} {x : ℕ → ℝ} {initial : State}
    (hx : ∀ t, 0 ≤ x t) (hi : Valid initial) : ∀ t, Valid (run c δ x initial t)
  | 0 => hi
  | t+1 => update_valid (run_valid hx hi t) (hx (t+1))

/-- Uniform-in-horizon amortization of the literal §03 active-size schedule.
This pays genuine old-plus-new charges, not merely total variation. -/
theorem active_size_budget {c δ : ℝ} {x : ℕ → ℝ} {initial : State}
    (hc : 0 ≤ c) (hδ : 0 < δ) (hδu : δ ≤ 1/3)
    (hx : ∀ t, 0 ≤ x t) (hi : Valid initial) (N : ℕ) :
    (∑ t ∈ range N, charge (run c δ x initial t) (run c δ x initial (t+1))) ≤
      factor δ*(∑ t ∈ range N, |x (t+1)-x t|) + potential c δ (x 0) initial := by
  have hstrong : (∑ t ∈ range N, charge (run c δ x initial t) (run c δ x initial (t+1))) +
      potential c δ (x N) (run c δ x initial N) ≤
      factor δ*(∑ t ∈ range N, |x (t+1)-x t|) + potential c δ (x 0) initial := by
    induction N with
    | zero => simp [run]
    | succ N ih =>
      have hcredit := update_credit hc hδ hδu (hx (N+1)) (run_valid (c := c) (δ := δ) hx hi N)
      have hinput := potential_input (c := c) (δ := δ) (x := x N) (y := x (N+1))
        (run c δ x initial N) hδ
      simp only [sum_range_succ, mul_add, run] at *
      linarith
  linarith [potential_nonneg (x := x N) (s := run c δ x initial N) hc hδ]

end KServer.CoarseSchedule


/-! The actual epoch/wholesale recurrence of §03. The old credit is discarded
on a parent refresh, never spent twice. Empty transitions are forced by the
same variation test. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.EpochSchedule
variable {J K : Type*} [Fintype J]

def total (x : J → ℝ) : ℝ := ∑ i, x i
def variation (x y : J → ℝ) : ℝ := ∑ i, |x i-y i|
lemma variation_nonneg (x y : J → ℝ) : 0 ≤ variation x y := sum_nonneg fun _ _ => abs_nonneg _
lemma total_nonneg {x : J → ℝ} (hx : ∀ i, 0 ≤ x i) : 0 ≤ total x := sum_nonneg fun _ _ => hx _
lemma total_change (x y : J → ℝ) : |total x-total y| ≤ variation x y := by
  rw [total,total,←sum_sub_distrib]
  exact abs_sum_le_sum_abs _ _
lemma coordinate_change (x y : J → ℝ) (i : J) : |x i-y i| ≤ variation x y :=
  single_le_sum (fun j _ => abs_nonneg (x j-y j)) (mem_univ i)
lemma variation_triangle (x y z : J → ℝ) : variation x z ≤ variation x y+variation y z := by
  rw [variation,variation,variation,←sum_add_distrib]
  exact sum_le_sum fun i _ => abs_sub_le _ _ _

structure State (J : Type*) where
  reference : J → ℝ
  credit : ℝ

def Valid (x : J → ℝ) (s : State J) : Prop :=
  (∀ i, 0 ≤ s.reference i) ∧ 0 ≤ s.credit ∧ s.credit ≤ total s.reference/100 ∧
    variation x s.reference ≤ s.credit

def reset (x y : J → ℝ) (a b : K) (s : State J) : Prop :=
  a≠b ∨ total s.reference/100 < s.credit+variation y x

instance (x y : J → ℝ) (a b : K) (s : State J) : Decidable (reset x y a b s) := Classical.propDecidable _

def update (x y : J → ℝ) (a b : K) (s : State J) : State J :=
  if reset x y a b s then ⟨y,0⟩ else ⟨s.reference,s.credit+variation y x⟩

lemma update_valid {x y : J → ℝ} {a b : K} {s : State J}
    (hy : ∀ i, 0 ≤ y i) (hs : Valid x s) : Valid y (update x y a b s) := by
  unfold update
  split_ifs with hr
  · refine ⟨hy,le_rfl,div_nonneg (total_nonneg hy) (by norm_num),?_⟩
    simp [variation]
  · have hh := not_or.mp hr
    refine ⟨hs.1,add_nonneg hs.2.1 (variation_nonneg _ _),le_of_not_gt hh.2,?_⟩
    exact (variation_triangle y x s.reference).trans (by linarith [hs.2.2.2])

lemma valid_total {x : J → ℝ} {s : State J} (hs : Valid x s) :
    (99/100:ℝ)*total s.reference ≤ total x ∧ total x ≤ (101/100:ℝ)*total s.reference := by
  have hd := (abs_le.mp ((total_change x s.reference).trans hs.2.2.2))
  constructor <;> linarith [hs.2.2.1]

lemma valid_coordinate {x : J → ℝ} {s : State J} (hs : Valid x s) (i : J) :
    s.reference i-total s.reference/100 ≤ x i ∧ x i ≤ s.reference i+total s.reference/100 := by
  have hd := abs_le.mp ((coordinate_change x s.reference i).trans hs.2.2.2)
  constructor <;> linarith [hs.2.2.1]

lemma empty_transition {x y : J → ℝ} {a b : K} {s : State J}
    (hs : Valid x s)
    (he : (total x=0 ∧ 0 < total y) ∨ (0 < total x ∧ total y=0)) : reset x y a b s := by
  apply Or.inr
  have ha := total_nonneg hs.1
  have ht := valid_total hs
  have hd := abs_le.mp (total_change y x)
  rcases he with he | he
  · have hz : total s.reference=0 := by linarith
    rw [hz]
    linarith [hs.2.1]
  · have hi := hs.2.2.1
    have hn := variation_nonneg y x
    have hp : 0 < total s.reference := by linarith
    linarith [hs.2.1]

def wholesale (x y : J → ℝ) (a b : K) (s : State J) : ℝ :=
  if reset x y a b s then total x+total y else 0

def parentCharge (x y : J → ℝ) (a b : K) : ℝ := by
  classical
  exact if a≠b then total x+total y else 0

/-- Each volume-triggered wholesale consumes only its epoch's accumulated
variation. The constant 203 is the literal bound used in the source. -/
lemma update_budget {x y : J → ℝ} {a b : K} {s : State J}
    (hs : Valid x s) :
    wholesale x y a b s+203*(update x y a b s).credit ≤
      203*s.credit+203*variation y x+parentCharge x y a b := by
  classical
  by_cases hk : a≠b
  · have hr : reset x y a b s := Or.inl hk
    simp only [wholesale,update,ite_eq_left hr,parentCharge,ite_eq_left hk]
    linarith [hs.2.1,variation_nonneg y x]
  · by_cases hv : total s.reference/100 < s.credit+variation y x
    · have hr : reset x y a b s := Or.inr hv
      simp only [wholesale,update,ite_eq_left hr,parentCharge,ite_eq_right hk]
      have ht := (valid_total hs).2
      have hd := (abs_le.mp (total_change y x)).2
      have hd' := variation_nonneg y x
      linarith [hs.2.1]
    · have hr : ¬reset x y a b s := not_or.mpr ⟨hk,hv⟩
      simp only [wholesale,update,ite_eq_right hr,parentCharge,ite_eq_right hk]
      ring_nf
      exact le_rfl

def run (x : ℕ → J → ℝ) (key : ℕ → K) : ℕ → State J
  | 0 => ⟨x 0,0⟩
  | t+1 => update (x t) (x (t+1)) (key t) (key (t+1)) (run x key t)

lemma run_valid (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) :
    ∀ t, Valid (x t) (run x key t) := by
  intro t
  induction t with
  | zero => refine ⟨hx 0,le_rfl,by exact div_nonneg (total_nonneg (hx 0)) (by norm_num),?_⟩; simp [run,variation]
  | succ t ih => exact update_valid (hx (t+1)) ih

/-- Deterministic finite-horizon wholesale budget, with no terminal charge and
no dependence on the horizon in its constants. -/
theorem wholesale_budget (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (n : ℕ) :
    (∑ t ∈ range n, wholesale (x t) (x (t+1)) (key t) (key (t+1)) (run x key t)) ≤
      203*(∑ t ∈ range n, variation (x (t+1)) (x t))+
      ∑ t ∈ range n, parentCharge (x t) (x (t+1)) (key t) (key (t+1)) := by
  have hh : ∀ m, (∑ t ∈ range m, wholesale (x t) (x (t+1)) (key t) (key (t+1)) (run x key t))+
      203*(run x key m).credit ≤
      203*(∑ t ∈ range m, variation (x (t+1)) (x t))+
      ∑ t ∈ range m, parentCharge (x t) (x (t+1)) (key t) (key (t+1)) := by
    intro m
    induction m with
    | zero => simp [run]
    | succ m ih =>
      have hs := update_budget (a := key m) (b := key (m+1)) (y := x (m+1)) (run_valid x key hx m)
      change wholesale _ _ _ _ _+203*(run x key (m+1)).credit ≤ _ at hs
      simp only [sum_range_succ]
      linarith
  have hn := (run_valid x key hx n).2.1
  linarith [hh n]

/-- Exact dominant selection; the same reference, hence the same mark, is
held until a wholesale event. -/
def dominant (s : State J) : Option J :=
  if h : ∃ i, 0 < total s.reference ∧ (85/100:ℝ)*total s.reference ≤ s.reference i
  then some h.choose else none

lemma dominant_large {x : J → ℝ} {s : State J} {o : J} (hs : Valid x s)
    (ho : dominant s=some o) : (84/100:ℝ)*total s.reference ≤ x o := by
  unfold dominant at ho
  split_ifs at ho with h
  · have he : h.choose=o := Option.some.inj ho
    have hh := h.choose_spec
    rw [he] at hh
    linarith [(valid_coordinate hs o).1]

lemma regular_small {x : J → ℝ} {s : State J} {i : J} (hs : Valid x s)
    (hi : dominant s≠some i) : x i ≤ (86/100:ℝ)*total s.reference := by
  classical
  have ha := total_nonneg hs.1
  have hh : s.reference i ≤ (85/100:ℝ)*total s.reference := by
    by_cases hp : 0 < total s.reference
    · by_contra hle
      have hbig : (85/100:ℝ)*total s.reference ≤ s.reference i := le_of_lt (lt_of_not_ge hle)
      have hex : ∃ j, 0 < total s.reference ∧ (85/100:ℝ)*total s.reference ≤ s.reference j := ⟨i,hp,hbig⟩
      have heq : hex.choose=i := by
        by_contra hn
        have hsum := sum_le_sum_of_subset_of_nonneg (show ({hex.choose,i} : Finset J) ⊆ univ by simp)
          (fun j _ _ => hs.1 j)
        simp only [sum_pair hn] at hsum
        change s.reference hex.choose+s.reference i ≤ total s.reference at hsum
        linarith [hex.choose_spec.2]
      exact hi (by simp [dominant,hex,heq])
    · have hz : total s.reference=0 := le_antisymm (le_of_not_gt hp) ha
      have hb := single_le_sum (fun j _ => hs.1 j) (mem_univ i)
      change s.reference i ≤ total s.reference at hb
      rw [hz] at hb ⊢
      simpa using hb
  linarith [(valid_coordinate hs i).2]

lemma side_total [DecidableEq J] {x : J → ℝ} {s : State J} {o : J} (hs : Valid x s)
    (ho : dominant s=some o) : (∑ i ∈ univ.erase o, x i) ≤ (16/100:ℝ)*total s.reference := by
  classical
  have hr : (85/100:ℝ)*total s.reference ≤ s.reference o := by
    unfold dominant at ho
    split_ifs at ho with h
    · have he : h.choose=o := Option.some.inj ho
      simpa only [he] using h.choose_spec.2
  have hd : (∑ i ∈ univ.erase o, x i) ≤ (∑ i ∈ univ.erase o, s.reference i)+variation x s.reference := by
    calc _ ≤ (∑ i ∈ univ.erase o, s.reference i)+(∑ i ∈ univ.erase o, |x i-s.reference i|) := by
          rw [←sum_add_distrib]
          exact sum_le_sum fun i _ => by linarith [le_abs_self (x i-s.reference i)]
         _ ≤ _ := by
          have hn : (∑ i ∈ univ.erase o, |x i-s.reference i|) ≤ variation x s.reference :=
            sum_le_sum_of_subset_of_nonneg (erase_subset _ _) (fun i _ _ => abs_nonneg _)
          exact add_le_add le_rfl hn
  have he := sum_erase_add univ s.reference (mem_univ o)
  change (∑ i ∈ univ.erase o, s.reference i)+s.reference o=total s.reference at he
  linarith [hs.2.2.1,hs.2.2.2]

end KServer.EpochSchedule

namespace KServer.CoarseProcess
open RankTracking RankFunctions CoarseSchedule
variable {Ω J R : Type} [Fintype Ω] [Fintype J] [Fintype R] {w : Ω → ℝ}
attribute [local instance] Classical.propDecidable Classical.decEq

/-- Literal sum of the independently maintained size-rank references. -/
def estimate (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) : ℝ :=
  ∑ a, sizeRank (held (factorTest sizeRank δ) (P a).p t ω)
def size (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) : ℝ :=
  ∑ a, sizeRank ((P a).p t ω)

lemma estimate_nonneg (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    0 ≤ estimate δ P t ω := sum_nonneg fun _ _ => sizeRank_nonneg _
lemma size_nonneg (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    0 ≤ size P t ω := sum_nonneg fun _ _ => sizeRank_nonneg _

lemma estimate_accuracy {δ : ℝ} (hδ : 0 < δ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    size P t ω ≤ (1+δ)*estimate δ P t ω ∧
      estimate δ P t ω ≤ (1+δ)*size P t ω := by
  constructor
  · rw [estimate,mul_sum]
    apply sum_le_sum
    intro a _
    have hh := (factor_held_accurate sizeRank hδ (fun _ _ => sizeRank_nonneg _) (P a).range t ω).1
    exact (inv_mul_le_iff₀ (by linarith : 0 < 1+δ)).mp hh
  · rw [size,mul_sum]
    exact sum_le_sum fun a _ =>
      (factor_held_accurate sizeRank hδ (fun _ _ => sizeRank_nonneg _) (P a).range t ω).2

lemma estimate_bound (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    estimate δ P t ω ≤ Fintype.card R := by
  calc _ ≤ ∑ _ : R, (1:ℝ) := by
        apply sum_le_sum
        intro a _
        have hr := held_range (factorTest sizeRank δ) (P a).range t ω
        exact (sizeRank_le_complement hr).trans (by linarith [hr.1])
       _ = _ := by simp

lemma term_variation {δ : ℝ} (hδ : 0 < δ) (hδu : δ < 1/2)
    (hw : ∀ ω, 0 ≤ w ω) (hw1 : ∑ ω, w ω=1) (P : FilteredRanks w) (N : ℕ) :
    (∑ t ∈ range N, avg w (fun ω =>
        |sizeRank (held (factorTest sizeRank δ) P.p (t+1) ω)-
          sizeRank (held (factorTest sizeRank δ) P.p t ω)|)) ≤
      (5*(4/3:ℝ)^2/δ)*((∑ t ∈ range N, avg w (fun ω => |P.p (t+1) ω-P.before (t+1) ω|))+1) := by
  have hlip (p q : ℝ) : |Real.sqrt (sizeRank p)-Real.sqrt (sizeRank q)| ≤ (4/3:ℝ)*|p-q| := by
    simpa only [Real.dist_eq,NNReal.coe_div,NNReal.coe_ofNat] using
      sqrt_sizeRank_lipschitz.dist_le_mul p q
  calc _ ≤ ∑ t ∈ range N, avg w (fun ω => (5*(4/3:ℝ)^2/δ)*credit (factorTest sizeRank δ) P.p t ω) :=
        sum_le_sum fun t _ => avg_mono hw (factor_movement_credit sizeRank hδ hδu (by norm_num)
          (fun _ _ => sizeRank_nonneg _) (fun p _ q _ => hlip p q) P.range t)
       _ = (5*(4/3:ℝ)^2/δ)*(∑ t ∈ range N, avg w (credit (factorTest sizeRank δ) P.p t)) := by
        simp_rw [avg_mul]; rw [mul_sum]
       _ ≤ _ := mul_le_mul_of_nonneg_left (reset_credit_bound (factorTest sizeRank δ) hw hw1 P N)
        (by positivity)

lemma estimate_variation {δ : ℝ} (hδ : 0 < δ) (hδu : δ < 1/2)
    (hw : ∀ ω, 0 ≤ w ω) (hw1 : ∑ ω, w ω=1) (P : R → FilteredRanks w) (N : ℕ) :
    (∑ t ∈ range N, avg w (fun ω => |estimate δ P (t+1) ω-estimate δ P t ω|)) ≤
      (5*(4/3:ℝ)^2/δ)*
        ((∑ a, ∑ t ∈ range N, avg w (fun ω => |(P a).p (t+1) ω-(P a).before (t+1) ω|))+
          Fintype.card R) := by
  calc _ ≤ ∑ t ∈ range N, ∑ a, avg w (fun ω =>
        |sizeRank (held (factorTest sizeRank δ) (P a).p (t+1) ω)-
          sizeRank (held (factorTest sizeRank δ) (P a).p t ω)|) := by
        apply sum_le_sum
        intro t _
        rw [←avg_sum]
        apply avg_mono hw
        intro ω
        simp only [estimate,←sum_sub_distrib]
        exact Finset.abs_sum_le_sum_abs _ _
       _ = ∑ a, ∑ t ∈ range N, avg w (fun ω =>
        |sizeRank (held (factorTest sizeRank δ) (P a).p (t+1) ω)-
          sizeRank (held (factorTest sizeRank δ) (P a).p t ω)|) := by rw [sum_comm]
       _ ≤ ∑ a, (5*(4/3:ℝ)^2/δ)*
          ((∑ t ∈ range N, avg w (fun ω => |(P a).p (t+1) ω-(P a).before (t+1) ω|))+1) := by
        apply sum_le_sum
        intro a _
        exact term_variation hδ hδu hw hw1 (P a) N
       _ = _ := by simp only [mul_add,sum_add_distrib,←mul_sum,sum_const,card_univ,nsmul_eq_mul]; ring

/-- All invariants are established after actually executing the hysteretic rule. -/
lemma update_accuracy {c δ x : ℝ} {s : CoarseSchedule.State}
    (hc : 0 < c) (hδ : 0 < δ) (hx : 0 ≤ x) (hs : CoarseSchedule.Valid s) :
    let a := CoarseSchedule.update c δ x s
    (a.active=true → 2*c < x ∧ x ≤ (1+δ)*a.value ∧ a.value ≤ (1+δ)*x) ∧
    (a.active=false → x < 5*c ∧ a.value=0) := by
  have he : x ≤ (1+δ)*x := by nlinarith [mul_nonneg hδ.le hx]
  cases ha : s.active with
  | false =>
    by_cases ht : 5*c ≤ x
    · simp only [CoarseSchedule.update,ha,Bool.false_eq_true,ite_false,ite_eq_left ht]
      simp only [Bool.true_eq_false, false_implies, and_true, true_implies]
      exact ⟨by linarith,he,he⟩
    · simp [CoarseSchedule.update,ha,ht,hs.2 ha,lt_of_not_ge ht]
  | true =>
    by_cases ht : x ≤ 2*c
    · simp [CoarseSchedule.update,ha,ht,show x < 5*c by linarith]
    · by_cases hf : (1+δ)*s.value < x ∨ (1+δ)*x < s.value
      · simp only [CoarseSchedule.update,ha,ite_true,ite_eq_right ht,ite_eq_left hf]
        simp only [Bool.true_eq_false,false_implies,and_true,true_implies]
        exact ⟨lt_of_not_ge ht,he,he⟩
      · simp only [CoarseSchedule.update,ha,ite_true,ite_eq_right ht,ite_eq_right hf]
        simp only [Bool.true_eq_false,false_implies,and_true,true_implies]
        have hh := not_or.mp hf
        exact ⟨lt_of_not_ge ht,le_of_not_gt hh.1,le_of_not_gt hh.2⟩

/-- Trackers are not reinitialized; the active state alone is updated. -/
def active (c δ : ℝ) (P : R → FilteredRanks w) (ω : Ω) : ℕ → CoarseSchedule.State :=
  CoarseSchedule.run c δ (fun t => estimate δ P t ω)
    (CoarseSchedule.update c δ (estimate δ P 0 ω) ⟨false,0⟩)

lemma active_valid (c δ : ℝ) (P : R → FilteredRanks w) (ω : Ω) (t : ℕ) :
    CoarseSchedule.Valid (active c δ P ω t) :=
  run_valid (fun t => estimate_nonneg δ P t ω)
    (update_valid (by simp [CoarseSchedule.Valid]) (estimate_nonneg δ P 0 ω)) t

lemma active_accuracy {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (P : R → FilteredRanks w) (ω : Ω) (t : ℕ) :
    let a := active c δ P ω t
    (a.active=true → (9/10)*size P t ω ≤ a.value ∧ a.value ≤ (11/10)*size P t ω ∧ c ≤ size P t ω) ∧
    (10*c ≤ size P t ω → a.active=true) := by
  have hx := estimate_nonneg δ P t ω
  have hm := size_nonneg P t ω
  have hh : let a := active c δ P ω t
      (a.active=true → 2*c < estimate δ P t ω ∧ estimate δ P t ω ≤ (1+δ)*a.value ∧
        a.value ≤ (1+δ)*estimate δ P t ω) ∧
      (a.active=false → estimate δ P t ω < 5*c ∧ a.value=0) := by
    cases t with
    | zero => exact update_accuracy hc hδ hx (by simp [CoarseSchedule.Valid])
    | succ t => exact update_accuracy hc hδ hx (active_valid c δ P ω t)
  have hrough : (1+δ)^2 ≤ 11/10 := by nlinarith [sq_nonneg (δ-1/1000)]
  have hs := estimate_accuracy hδ P t ω
  have hav : 0 ≤ (active c δ P ω t).value := (active_valid c δ P ω t).1
  constructor
  · intro ha
    have h := hh.1 ha
    have hmul₁ := mul_le_mul_of_nonneg_left h.2.1 (by linarith : 0 ≤ 1+δ)
    have hmul₂ := mul_le_mul_of_nonneg_left hs.2 (by linarith : 0 ≤ 1+δ)
    have hbound := mul_le_mul_of_nonneg_right hrough hav
    have hbound₂ := mul_le_mul_of_nonneg_right hrough hm
    constructor
    · nlinarith
    constructor
    · nlinarith
    · nlinarith [mul_nonneg (by linarith : 0 ≤ 1-δ) hm]
  · intro hM
    by_contra hn
    have hf : (active c δ P ω t).active=false := Bool.eq_false_of_not_eq_true hn
    have hhf := hh.2 hf
    have hmul := mul_le_mul_of_nonneg_right (show 1+δ ≤ 2 by linarith) hx
    nlinarith


lemma charge_nonneg {s t : CoarseSchedule.State} (hs : CoarseSchedule.Valid s)
    (ht : CoarseSchedule.Valid t) : 0 ≤ CoarseSchedule.charge s t := by
  unfold CoarseSchedule.charge
  split_ifs
  · rfl
  · exact add_nonneg hs.1 ht.1

lemma initial_potential {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/3)
    (P : R → FilteredRanks w) (ω : Ω) :
    potential c δ (estimate δ P 0 ω) (active c δ P ω 0) ≤ factor δ*Fintype.card R := by
  have hi : CoarseSchedule.Valid ⟨false,0⟩ := by simp [CoarseSchedule.Valid]
  have hx := estimate_nonneg δ P 0 ω
  have hh := update_credit hc.le hδ hδu hx hi
  have hn := charge_nonneg hi (update_valid hi hx (c:=c) (δ:=δ))
  have hb := mul_le_mul_of_nonneg_left (estimate_bound δ P 0 ω)
    (show 0 ≤ factor δ by unfold factor; positivity)
  have hp0 : CoarseSchedule.potential c δ (estimate δ P 0 ω) ⟨false,0⟩ = factor δ*estimate δ P 0 ω := by
    simp [CoarseSchedule.potential,abs_of_nonneg hx]
  change 0 ≤ charge ⟨false,0⟩ (active c δ P ω 0) at hn
  rw [hp0] at hh
  change CoarseSchedule.charge ⟨false,0⟩ (active c δ P ω 0)+
    potential c δ (estimate δ P 0 ω) (active c δ P ω 0) ≤ factor δ*estimate δ P 0 ω at hh
  linarith

lemma avg_range (w : Ω → ℝ) (f : ℕ → Ω → ℝ) (N : ℕ) :
    (∑ t ∈ range N, avg w (f t))=avg w (fun ω => ∑ t ∈ range N,f t ω) := by
  simp only [avg,mul_sum]
  exact sum_comm

/-- Actual old-plus-new active refresh budget, with a fixed-star endpoint. -/
theorem active_budget {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (hw : ∀ ω, 0 ≤ w ω) (hw1 : ∑ ω, w ω=1) (P : R → FilteredRanks w) (N : ℕ) :
    (∑ t ∈ range N, avg w (fun ω =>
        charge (active c δ P ω t) (active c δ P ω (t+1)))) ≤
      (factor δ*(5*(4/3:ℝ)^2/δ)) *
        (∑ a, ∑ t ∈ range N, avg w (fun ω => |(P a).p (t+1) ω-(P a).before (t+1) ω|))+
      (factor δ*(5*(4/3:ℝ)^2/δ+1))*Fintype.card R := by
  have hf : 0 ≤ factor δ := by unfold factor; positivity
  have hs (ω : Ω) := active_size_budget hc.le hδ (show δ ≤ 1/3 by linarith)
    (fun t => estimate_nonneg δ P t ω)
    (update_valid (show CoarseSchedule.Valid ⟨false,0⟩ by simp [CoarseSchedule.Valid])
      (estimate_nonneg δ P 0 ω) (c:=c) (δ:=δ)) N
  have hb (ω : Ω) := initial_potential hc hδ (show δ ≤ 1/3 by linarith) P ω
  have hs' (ω : Ω) : (∑ t ∈ range N, charge (active c δ P ω t) (active c δ P ω (t+1))) ≤
      factor δ*(∑ t ∈ range N, |estimate δ P (t+1) ω-estimate δ P t ω|)+
      potential c δ (estimate δ P 0 ω) (active c δ P ω 0) := hs ω
  have hh := avg_mono hw (fun ω => hs' ω |>.trans (add_le_add_right (hb ω) _))
  change avg w (fun ω => ∑ t ∈ range N, charge (active c δ P ω t) (active c δ P ω (t+1))) ≤
    avg w (fun ω => factor δ * (∑ t ∈ range N, |estimate δ P (t+1) ω-estimate δ P t ω|)+
      factor δ*Fintype.card R) at hh
  rw [avg_add,avg_mul,avg_const w hw1,←avg_range,←avg_range] at hh
  have hv := mul_le_mul_of_nonneg_left (estimate_variation hδ (by linarith) hw hw1 P N) hf
  exact hh.trans (by nlinarith)

lemma estimate_adapted (δ : ℝ) (P : R → FilteredRanks w) (H : ℕ → Ω → ℕ)
    (hH : ∀ a t ω, (P a).history t ω=H t ω) (t : ℕ) :
    Adapted (H t) (estimate δ P t) := by
  intro ω z he
  unfold estimate
  apply sum_congr rfl
  intro a _
  rw [held_adapted (factorTest sizeRank δ) (P a) t ω z (by simpa only [hH] using he)]

lemma active_adapted (c δ : ℝ) (P : R → FilteredRanks w) (H : ℕ → Ω → ℕ)
    (hH : ∀ a t ω, (P a).history t ω=H t ω)
    (href : ∀ t ω z, H (t+1) ω=H (t+1) z → H t ω=H t z) (t : ℕ) :
    ∀ ω z, H t ω=H t z → active c δ P ω t=active c δ P z t := by
  induction t with
  | zero =>
    intro ω z he
    simp only [active,run]
    rw [estimate_adapted δ P H hH 0 ω z he]
  | succ t ih =>
    intro ω z he
    change update c δ (estimate δ P (t+1) ω) (active c δ P ω t)=
      update c δ (estimate δ P (t+1) z) (active c δ P z t)
    rw [estimate_adapted δ P H hH (t+1) ω z he,ih ω z (href t ω z he)]

/-- The parent's scalar relative reference, and later the side-total reference,
use exactly the manuscript's two-sided factor test, including zero crossings. -/
def relative (δ : ℝ) (x : ℕ → Ω → ℝ) : ℕ → Ω → ℝ := held (factorTest id δ) x

omit [Fintype Ω] in
lemma relative_nonneg {δ : ℝ} (x : ℕ → Ω → ℝ) (hx : ∀ t ω, 0 ≤ x t ω) (t : ℕ) (ω : Ω) :
    0 ≤ relative δ x t ω := by
  induction t with
  | zero => exact hx 0 ω
  | succ t ih =>
    simp only [relative,held]
    split_ifs
    · exact hx (t+1) ω
    · exact ih

omit [Fintype Ω] in
lemma relative_accuracy {δ : ℝ} (hδ : 0 < δ) (x : ℕ → Ω → ℝ)
    (hx : ∀ t ω, 0 ≤ x t ω) (t : ℕ) (ω : Ω) :
    x t ω ≤ (1+δ)*relative δ x t ω ∧ relative δ x t ω ≤ (1+δ)*x t ω := by
  have he (y : ℝ) (hy : 0 ≤ y) : y ≤ (1+δ)*y := by nlinarith [mul_nonneg hδ.le hy]
  cases t with
  | zero => exact ⟨he _ (hx _ _),he _ (hx _ _)⟩
  | succ t =>
    simp only [relative,held]
    split_ifs with ht
    · exact ⟨he _ (hx _ _),he _ (hx _ _)⟩
    · simp only [factorTest,id_eq,not_or,not_lt] at ht
      exact ⟨ht.2,ht.1⟩

def relativeCharge (δ : ℝ) (x : ℕ → Ω → ℝ) (t : ℕ) (ω : Ω) : ℝ :=
  if relative δ x t ω=relative δ x (t+1) ω then 0 else
    relative δ x t ω+relative δ x (t+1) ω

omit [Fintype Ω] in
lemma relative_charge_bound {δ : ℝ} (hδ : 0 < δ) (x : ℕ → Ω → ℝ)
    (hx : ∀ t ω, 0 ≤ x t ω) (t : ℕ) (ω : Ω) :
    relativeCharge δ x t ω ≤ factor δ*|relative δ x (t+1) ω-relative δ x t ω| := by
  by_cases ht : factorTest id δ (x (t+1) ω) (relative δ x t ω)
  · have he : relative δ x (t+1) ω=x (t+1) ω := by
      change (if factorTest id δ (x (t+1) ω) (relative δ x t ω) then x (t+1) ω else relative δ x t ω)=_
      exact ite_eq_left ht
    have hh := factor_change_charge (hx (t+1) ω) (relative_nonneg x hx t ω) hδ ht
    rw [relativeCharge,he]
    split_ifs
    · exact mul_nonneg (by unfold factor; positivity) (abs_nonneg _)
    · unfold factor; linarith
  · have he : relative δ x (t+1) ω=relative δ x t ω := by
      change (if factorTest id δ (x (t+1) ω) (relative δ x t ω) then x (t+1) ω else relative δ x t ω)=_
      exact ite_eq_right ht
    simp [relativeCharge,he]

omit [Fintype Ω] in
lemma relative_budget {δ : ℝ} (hδ : 0 < δ) (x : ℕ → Ω → ℝ)
    (hx : ∀ t ω, 0 ≤ x t ω) (N : ℕ) (ω : Ω) :
    (∑ t ∈ range N, relativeCharge δ x t ω) ≤
      factor δ*(∑ t ∈ range N, |x (t+1) ω-x t ω|) := by
  calc _ ≤ ∑ t ∈ range N, factor δ*|relative δ x (t+1) ω-relative δ x t ω| :=
        sum_le_sum fun t _ => relative_charge_bound hδ x hx t ω
       _ = factor δ*(∑ t ∈ range N, |relative δ x (t+1) ω-relative δ x t ω|) := (mul_sum _ _ _).symm
       _ ≤ _ := mul_le_mul_of_nonneg_left (held_variation (factorTest id δ) x N ω)
        (by unfold factor; positivity)

end KServer.CoarseProcess

end
end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CoarseEpoch
open RankTracking CoarseSchedule CoarseProcess
variable {Ω R J : Type} [Fintype Ω] [Fintype R] [Fintype J]
variable {w : Ω → ℝ}

def clipped (c δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) : ℝ :=
  max c (estimate δ P t ω)

def parent (c δ : ℝ) (P : R → FilteredRanks w) : ℕ → Ω → ℝ :=
  relative δ (clipped c δ P)

lemma clipped_nonneg {c : ℝ} (hc : 0 ≤ c) (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    0 ≤ clipped c δ P t ω := hc.trans (le_max_left _ _)

lemma clipped_variation (c δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    |clipped c δ P (t+1) ω-clipped c δ P t ω| ≤ |estimate δ P (t+1) ω-estimate δ P t ω| := by
  unfold clipped
  simpa only [max_comm c] using abs_max_sub_max_le_abs (estimate δ P (t+1) ω) (estimate δ P t ω) c

lemma clipped_accuracy {c δ : ℝ} (hc : 0 ≤ c) (hδ : 0 < δ)
    (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    max c (size P t ω) ≤ (1+δ)*clipped c δ P t ω ∧
      clipped c δ P t ω ≤ (1+δ)*max c (size P t ω) := by
  have h := estimate_accuracy hδ P t ω
  have he : 0 ≤ 1+δ := by linarith
  have hcc : c ≤ (1+δ)*c := by nlinarith [mul_nonneg hδ.le hc]
  constructor
  · apply max_le
    · exact hcc.trans (mul_le_mul_of_nonneg_left (le_max_left _ _) he)
    · exact h.1.trans (mul_le_mul_of_nonneg_left (le_max_right _ _) he)
  · apply max_le
    · exact (le_max_left _ _).trans (by nlinarith [mul_nonneg hδ.le (hc.trans (le_max_left c (size P t ω)))])
    · exact h.2.trans (mul_le_mul_of_nonneg_left (le_max_right _ _) he)

lemma parent_accuracy {c δ : ℝ} (hc : 0 ≤ c) (hδ : 0 < δ)
    (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    max c (size P t ω) ≤ (1+δ)^2*parent c δ P t ω ∧
      parent c δ P t ω ≤ (1+δ)^2*max c (size P t ω) := by
  have ha := clipped_accuracy hc hδ P t ω
  have hb := relative_accuracy hδ (clipped c δ P) (clipped_nonneg hc δ P) t ω
  change clipped c δ P t ω ≤ (1+δ)*parent c δ P t ω ∧ parent c δ P t ω ≤ (1+δ)*clipped c δ P t ω at hb
  have he : 0 ≤ 1+δ := by linarith
  constructor
  · exact ha.1.trans (by nlinarith [mul_le_mul_of_nonneg_left hb.1 he])
  · exact hb.2.trans (by nlinarith [mul_le_mul_of_nonneg_left ha.2 he])

lemma parent_nonneg {c : ℝ} (hc : 0 ≤ c) (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    0 ≤ parent c δ P t ω := relative_nonneg _ (clipped_nonneg hc δ P) t ω

lemma parent_budget {c δ : ℝ} (hc : 0 ≤ c) (hδ : 0 < δ) (hδu : δ ≤ 1/3)
    (hw : ∀ ω, 0 ≤ w ω) (hw1 : ∑ ω,w ω=1) (P : R → FilteredRanks w) (N : ℕ) :
    (∑ t ∈ range N, avg w (relativeCharge δ (clipped c δ P) t)) ≤
      (factor δ*(5*(4/3:ℝ)^2/δ))*
        ((∑ a, ∑ t ∈ range N, avg w (fun ω => |(P a).p (t+1) ω-(P a).before (t+1) ω|))+Fintype.card R) := by
  have hf : 0 ≤ factor δ := by unfold factor; positivity
  rw [avg_range]
  calc _ ≤ avg w (fun ω => factor δ*(∑ t ∈ range N, |estimate δ P (t+1) ω-estimate δ P t ω|)) := by
        apply avg_mono hw
        intro ω
        exact (relative_budget hδ _ (clipped_nonneg hc δ P) N ω).trans
          (mul_le_mul_of_nonneg_left (sum_le_sum fun t _ => clipped_variation c δ P t ω) hf)
       _ = factor δ*(∑ t ∈ range N, avg w (fun ω => |estimate δ P (t+1) ω-estimate δ P t ω|)) := by
        rw [avg_mul,←avg_range]
       _ ≤ _ := by
        calc _ ≤ factor δ*((5*(4/3:ℝ)^2/δ)*
            ((∑ a, ∑ t ∈ range N, avg w (fun ω => |(P a).p (t+1) ω-(P a).before (t+1) ω|))+Fintype.card R)) :=
            mul_le_mul_of_nonneg_left (CoarseProcess.estimate_variation hδ (by linarith) hw hw1 P N) hf
             _ = _ := by ring

def vector (c δ : ℝ) (P : J → R → FilteredRanks w) (ω : Ω) (t : ℕ) : J → ℝ :=
  fun i => (active c δ (P i) ω t).value

omit [Fintype J] in
lemma vector_nonneg (c δ : ℝ) (P : J → R → FilteredRanks w) (ω : Ω) (t : ℕ) (i : J) :
    0 ≤ vector c δ P ω t i := (active_valid c δ (P i) ω t).1

lemma value_bound {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (P : R → FilteredRanks w) (ω : Ω) (t : ℕ) :
    (active c δ P ω t).value ≤ (11/10)*size P t ω := by
  cases ha : (active c δ P ω t).active with
  | true => exact ((active_accuracy hc hδ hδu P ω t).1 ha).2.1
  | false => rw [(active_valid c δ P ω t).2 ha]; exact mul_nonneg (by norm_num) (size_nonneg P t ω)

lemma total_parent {c δ ε : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (hε : 0 < ε) (hεu : ε ≤ 1/1000) (P : J → R → FilteredRanks w) (V : R → FilteredRanks w)
    (htree : ∀ t ω, (∑ i,size (P i) t ω) ≤ size V t ω) (ω : Ω) (t : ℕ) :
    EpochSchedule.total (vector c δ P ω t) ≤ 2*parent c ε V t ω := by
  have h := parent_accuracy hc.le hε V t ω
  have hp := parent_nonneg hc.le ε V t ω
  have hsq : (11/10:ℝ)*(1+ε)^2 ≤ 2 := by nlinarith [sq_nonneg (ε-1/1000)]
  calc _ ≤ ∑ i, (11/10:ℝ)*size (P i) t ω := sum_le_sum fun i _ => value_bound hc hδ hδu (P i) ω t
       _ = (11/10:ℝ)*(∑ i,size (P i) t ω) := (mul_sum _ _ _).symm
       _ ≤ (11/10:ℝ)*size V t ω := mul_le_mul_of_nonneg_left (htree t ω) (by norm_num)
       _ ≤ (11/10:ℝ)*((1+ε)^2*parent c ε V t ω) :=
          mul_le_mul_of_nonneg_left ((le_max_right _ _).trans h.1) (by norm_num)
       _ ≤ _ := by nlinarith [mul_le_mul_of_nonneg_right hsq hp]

lemma value_variation {s t : CoarseSchedule.State} (hs : CoarseSchedule.Valid s) (ht : CoarseSchedule.Valid t) :
    |s.value-t.value| ≤ charge s t := by
  unfold charge
  split_ifs with he
  · simp [he]
  · exact abs_sub_le_iff.mpr ⟨by linarith [ht.1],by linarith [hs.1]⟩

lemma vector_variation (c δ : ℝ) (P : J → R → FilteredRanks w) (ω : Ω) (t : ℕ) :
    EpochSchedule.variation (vector c δ P ω (t+1)) (vector c δ P ω t) ≤
      ∑ i, charge (active c δ (P i) ω t) (active c δ (P i) ω (t+1)) := by
  apply sum_le_sum
  intro i _
  rw [abs_sub_comm]
  exact value_variation (active_valid c δ (P i) ω t) (active_valid c δ (P i) ω (t+1))

lemma wholesale_parent {c δ ε : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (hε : 0 < ε) (hεu : ε ≤ 1/1000) (P : J → R → FilteredRanks w) (V : R → FilteredRanks w)
    (htree : ∀ t ω, (∑ i,size (P i) t ω) ≤ size V t ω) (β : ℝ → ℝ) (ω : Ω) (t : ℕ) :
    EpochSchedule.parentCharge (vector c δ P ω t) (vector c δ P ω (t+1))
        (β (parent c ε V t ω)) (β (parent c ε V (t+1) ω)) ≤
      2*relativeCharge ε (clipped c ε V) t ω := by
  classical
  unfold EpochSchedule.parentCharge
  split_ifs with he
  · have hn : parent c ε V t ω≠parent c ε V (t+1) ω := fun hh => he (congrArg β hh)
    change _ ≤ 2*(if parent c ε V t ω=parent c ε V (t+1) ω then 0 else parent c ε V t ω+parent c ε V (t+1) ω)
    rw [ite_eq_right hn]
    linarith [total_parent hc hδ hδu hε hεu P V htree ω t,
      total_parent hc hδ hδu hε hεu P V htree ω (t+1)]
  · unfold relativeCharge
    split_ifs
    · norm_num
    · exact mul_nonneg (by norm_num) (add_nonneg (parent_nonneg hc.le ε V t ω) (parent_nonneg hc.le ε V (t+1) ω))

/-- The literal epoch recurrence is paid by actual active-size and parent
reference changes; the test does not assume its own amortized conclusion. -/
lemma wholesale_budget {c δ ε : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (hε : 0 < ε) (hεu : ε ≤ 1/1000) (P : J → R → FilteredRanks w) (V : R → FilteredRanks w)
    (htree : ∀ t ω, (∑ i,size (P i) t ω) ≤ size V t ω) (β : ℝ → ℝ) (ω : Ω) (N : ℕ) :
    (∑ t ∈ range N, EpochSchedule.wholesale (vector c δ P ω t) (vector c δ P ω (t+1))
        (β (parent c ε V t ω)) (β (parent c ε V (t+1) ω))
        (EpochSchedule.run (vector c δ P ω) (fun t => β (parent c ε V t ω)) t)) ≤
      203*(∑ t ∈ range N, ∑ i,charge (active c δ (P i) ω t) (active c δ (P i) ω (t+1)))+
      2*(∑ t ∈ range N, relativeCharge ε (clipped c ε V) t ω) := by
  have hb := EpochSchedule.wholesale_budget (vector c δ P ω) (fun t => β (parent c ε V t ω))
    (vector_nonneg c δ P ω) N
  exact hb.trans (add_le_add
    (mul_le_mul_of_nonneg_left (sum_le_sum fun t _ => vector_variation c δ P ω t) (by norm_num))
    (by rw [mul_sum]; exact sum_le_sum fun t _ => wholesale_parent hc hδ hδu hε hεu P V htree β ω t))

end KServer.CoarseEpoch

end


noncomputable section
open scoped BigOperators
open Finset
local instance (p : Prop) : Decidable p := Classical.propDecidable p
namespace KServer.CoarseSide
open RankTracking CoarseSchedule EpochSchedule

/-- Relative reference with genuine wholesale resets. Resetting discards,
rather than spends, the unused scalar variation credit. -/
def held (δ : ℝ) (x : ℕ → ℝ) (reset : ℕ → Prop) : ℕ → ℝ
  | 0 => x 0
  | t+1 => if reset t ∨ factorTest id δ (x (t+1)) (held δ x reset t)
      then x (t+1) else held δ x reset t

lemma held_nonneg (δ : ℝ) (x : ℕ → ℝ) (reset : ℕ → Prop) (hx : ∀ t, 0 ≤ x t) (t : ℕ) :
    0 ≤ held δ x reset t := by
  induction t with
  | zero => exact hx 0
  | succ t ih => simp only [held]; split_ifs; exact hx (t+1); exact ih

lemma held_accuracy {δ : ℝ} (hδ : 0 < δ) (x : ℕ → ℝ) (reset : ℕ → Prop)
    (hx : ∀ t, 0 ≤ x t) (t : ℕ) :
    x t ≤ (1+δ)*held δ x reset t ∧ held δ x reset t ≤ (1+δ)*x t := by
  have he (t : ℕ) : x t ≤ (1+δ)*x t := by nlinarith [mul_nonneg hδ.le (hx t)]
  cases t with
  | zero => exact ⟨he 0,he 0⟩
  | succ t =>
    simp only [held]
    split_ifs with hr
    · exact ⟨he (t+1),he (t+1)⟩
    · have hf := (not_or.mp hr).2
      simp only [factorTest,id_eq,not_or,not_lt] at hf
      exact ⟨hf.2,hf.1⟩

def charge (δ : ℝ) (x : ℕ → ℝ) (reset : ℕ → Prop) (t : ℕ) : ℝ :=
  if ¬reset t ∧ factorTest id δ (x (t+1)) (held δ x reset t) then x t+x (t+1) else 0

def stepVariation (x : ℕ → ℝ) (reset : ℕ → Prop) (t : ℕ) : ℝ :=
  if reset t then 0 else |x (t+1)-x t|

def C (δ : ℝ) : ℝ := (1+δ)*factor δ

lemma C_nonneg {δ : ℝ} (hδ : 0 < δ) : 0 ≤ C δ := by unfold C factor; positivity

lemma update_budget {δ : ℝ} (hδ : 0 < δ) (x : ℕ → ℝ) (reset : ℕ → Prop)
    (hx : ∀ t, 0 ≤ x t) (t : ℕ) :
    charge δ x reset t+C δ*|x (t+1)-held δ x reset (t+1)| ≤
      C δ*|x t-held δ x reset t|+C δ*stepVariation x reset t := by
  have hC := C_nonneg hδ
  have hU := held_nonneg δ x reset hx t
  have ha := held_accuracy hδ x reset hx t
  by_cases hr : reset t
  · simp only [held,charge,not_true_eq_false,hr,false_and,true_or,ite_false,sub_self,abs_zero,mul_zero,add_zero,stepVariation,ite_true]
    exact mul_nonneg hC (abs_nonneg _)
  · by_cases hf : factorTest id δ (x (t+1)) (held δ x reset t)
    · have hp := factor_change_charge (hx (t+1)) hU hδ hf
      have hp' : x t+x (t+1) ≤ C δ*|x (t+1)-held δ x reset t| := by
        have he := mul_le_mul_of_nonneg_left hp (show 0 ≤ 1+δ by linarith)
        have hh : x (t+1) ≤ (1+δ)*x (t+1) := by nlinarith [mul_nonneg hδ.le (hx (t+1))]
        unfold C factor
        change x (t+1)+held δ x reset t ≤ (1+2/δ)*|x (t+1)-held δ x reset t| at hp
        nlinarith
      simp only [held,charge,hr,not_false_eq_true,hf,and_self,or_true,ite_true,
        sub_self,abs_zero,mul_zero,add_zero,stepVariation,ite_false]
      exact hp'.trans (by nlinarith [mul_le_mul_of_nonneg_left (abs_sub_le (x (t+1)) (x t) (held δ x reset t)) hC])
    · simp only [held,charge,hr,not_false_eq_true,hf,and_false,false_or,ite_false,zero_add,stepVariation]
      nlinarith [mul_le_mul_of_nonneg_left (abs_sub_le (x (t+1)) (x t) (held δ x reset t)) hC]

lemma budget {δ : ℝ} (hδ : 0 < δ) (x : ℕ → ℝ) (reset : ℕ → Prop)
    (hx : ∀ t, 0 ≤ x t) (N : ℕ) :
    (∑ t ∈ range N, charge δ x reset t) ≤ C δ*(∑ t ∈ range N, stepVariation x reset t) := by
  have hh : (∑ t ∈ range N, charge δ x reset t)+C δ*|x N-held δ x reset N| ≤
      C δ*(∑ t ∈ range N, stepVariation x reset t) := by
    induction N with
    | zero => simp [held]
    | succ N ih =>
      have h := update_budget hδ x reset hx N
      rw [sum_range_succ,sum_range_succ,mul_add]
      linarith
  linarith [mul_nonneg (C_nonneg hδ) (abs_nonneg (x N-held δ x reset N))]

variable {J K : Type} [Fintype J]

def side (x : J → ℝ) (s : EpochSchedule.State J) : ℝ :=
  ∑ i, if dominant s=some i then 0 else if (dominant s).isSome then x i else 0

lemma side_nonneg {x : J → ℝ} (hx : ∀ i, 0 ≤ x i) (s : EpochSchedule.State J) :
    0 ≤ side x s := by
  apply sum_nonneg; intro i _; split_ifs; rfl; exact hx i; rfl

lemma side_le_total {x : J → ℝ} (hx : ∀ i, 0 ≤ x i) (s : EpochSchedule.State J) :
    side x s ≤ total x := by
  apply sum_le_sum; intro i _; split_ifs; exact hx i; rfl; exact hx i

lemma mark_unchanged {x y : J → ℝ} {a b : K} {s : EpochSchedule.State J}
    (hr : ¬EpochSchedule.reset x y a b s) :
    dominant (EpochSchedule.update x y a b s)=dominant s := by
  simp only [EpochSchedule.update,ite_eq_right hr,dominant]

lemma side_variation {x y : J → ℝ} {s t : EpochSchedule.State J}
    (he : dominant s=dominant t) : |side x s-side y t| ≤ variation x y := by
  unfold side
  rw [←sum_sub_distrib]
  calc _ ≤ ∑ i, |(if dominant s=some i then 0 else if (dominant s).isSome then x i else 0)-
        (if dominant t=some i then 0 else if (dominant t).isSome then y i else 0)| := abs_sum_le_sum_abs _ _
       _ ≤ _ := by
        apply sum_le_sum
        intro i _
        rw [he]
        split_ifs <;> simp [abs_nonneg]

/-- Actual side totals and reset times are derived from the epoch recurrence. -/
def sideInput (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : ℝ := side (x t) (run x key t)
def epochReset (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : Prop :=
  EpochSchedule.reset (x t) (x (t+1)) (key t) (key (t+1)) (run x key t)

lemma side_stepVariation (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) :
    stepVariation (sideInput x key) (epochReset x key) t ≤ variation (x (t+1)) (x t) := by
  unfold stepVariation
  split_ifs with hr
  · exact variation_nonneg _ _
  · apply side_variation
    exact mark_unchanged hr

/-- Side-reference refreshes are paid independently of the number of epochs. -/
lemma side_budget {δ : ℝ} (hδ : 0 < δ) (x : ℕ → J → ℝ)
    (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (N : ℕ) :
    (∑ t ∈ range N, charge δ (sideInput x key) (epochReset x key) t) ≤
      C δ*(∑ t ∈ range N, variation (x (t+1)) (x t)) := by
  exact (budget hδ _ _ (fun t => side_nonneg (hx t) _) N).trans
    (mul_le_mul_of_nonneg_left (sum_le_sum fun t _ => side_stepVariation x key t) (C_nonneg hδ))

end KServer.CoarseSide

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CoarseParameters

lemma regular_log_comparison {x : ℝ} (hx : (50/43:ℝ) ≤ x) :
    (1/20:ℝ)*(1+Real.log x) ≤ Real.log ((81/100:ℝ)*x+2/11) := by
  have hx0 : 0 < x := by linarith
  have ha : 0 < (81/100:ℝ)*x+2/11 := by positivity
  have hs : x ≤ ((81/100:ℝ)*x+2/11)^2 := by nlinarith [sq_nonneg (x-50/43)]
  have hl := Real.log_le_log hx0 hs
  rw [Real.log_pow] at hl
  have hl₀ : (7/50:ℝ) ≤ Real.log x := by
    have h := Real.one_sub_inv_le_log_of_pos (show 0 < (50/43:ℝ) by norm_num)
    norm_num at h
    exact h.trans (Real.log_le_log (by norm_num) hx)
  nlinarith

lemma dominant_log_comparison {u m : ℝ} (hu : 0 ≤ u) (huu : u ≤ 1/4)
    (hm : 1+u/2 ≤ m) : u/3 ≤ Real.log m := by
  have hpos : 0 < 1+u/2 := by linarith
  have h := Real.one_sub_inv_le_log_of_pos hpos
  have hi : (1+u/2)⁻¹ ≤ 1-u/3 := by
    rw [inv_eq_one_div]
    apply (div_le_iff₀ hpos).mpr
    nlinarith
  have hl := Real.log_le_log hpos hm
  linarith

variable {J : Type} [Fintype J]

/-- Quantitative size-ratio estimate from the genuine superadditive parent
size, without discarding the child's own true size. -/
lemma size_ratio {M a : J → ℝ} {V : ℝ} (hM : ∀ i, 0 ≤ M i)
    (_ : ∀ i, 0 ≤ a i) (hupper : ∀ i, a i ≤ (11/10)*M i)
    (hV : (∑ i,M i) ≤ V) (i : J) (hMi : 0 < M i) (hai : 0 < a i)
    (hlower : (9/10)*M i ≤ a i) :
    1+(9/11)*((∑ j,a j)/a i-1) ≤ V/M i := by
  classical
  have hs : (∑ j,a j)-a i ≤ (11/10)*(V-M i) := by
    have h := sum_le_sum (s:=univ.erase i) (f:=a) (g:=fun j => (11/10:ℝ)*M j) (fun j _ => hupper j)
    rw [←mul_sum,sum_erase_eq_sub (mem_univ i),sum_erase_eq_sub (mem_univ i)] at h
    nlinarith
  have hVm : M i ≤ V := (single_le_sum (fun j _ => hM j) (mem_univ i)).trans hV
  have hx := mul_le_mul_of_nonneg_right hlower (sub_nonneg.mpr hVm)
  apply (le_div_iff₀ hMi).mpr
  apply (mul_le_mul_iff_left₀ hai).mp
  field_simp
  nlinarith [mul_le_mul_of_nonneg_right hs hMi.le]

lemma regular_gap {M a : J → ℝ} {V A : ℝ} (hM : ∀ i, 0 ≤ M i)
    (ha : ∀ i, 0 ≤ a i) (hupper : ∀ i, a i ≤ (11/10)*M i)
    (hV : (∑ i,M i) ≤ V) (i : J) (hMi : 0 < M i) (hai : 0 < a i)
    (hlower : (9/10)*M i ≤ a i) (hA : (99/100)*A ≤ ∑ j,a j)
    (hreg : a i ≤ (86/100)*A) :
    (1/20:ℝ)*(1+Real.log (A/a i)) ≤ Real.log (V/M i) := by
  have hx : (50/43:ℝ) ≤ A/a i := (le_div_iff₀ hai).mpr (by linarith)
  have hr := size_ratio hM ha hupper hV i hMi hai hlower
  have hm : (81/100:ℝ)*(A/a i)+2/11 ≤ V/M i := by
    have h := div_le_div_of_nonneg_right hA hai.le
    rw [mul_div_assoc] at h
    nlinarith
  exact (regular_log_comparison hx).trans (Real.log_le_log (by positivity) hm)

lemma dominant_gap {M a : J → ℝ} {V A U : ℝ} (hM : ∀ i, 0 ≤ M i)
    (ha : ∀ i, 0 ≤ a i) (hupper : ∀ i, a i ≤ (11/10)*M i)
    (hV : (∑ i,M i) ≤ V) (i : J) (hMi : 0 < M i) (hai : 0 < a i)
    (hlower : (9/10)*M i ≤ a i) (hA : 0 < A) (haA : a i ≤ (101/100)*A)
    (hU : 0 ≤ U) (hUs : U ≤ (1001/1000)*((∑ j,a j)-a i))
    (hUu : U/A ≤ 1/4) :
    (1/20:ℝ)*(U/A) ≤ Real.log (V/M i) := by
  have hu : 0 ≤ U/A := div_nonneg hU hA.le
  have hr := size_ratio hM ha hupper hV i hMi hai hlower
  have hs : 0 ≤ (∑ j,a j)-a i := sub_nonneg.mpr (single_le_sum (fun j _ => ha j) (mem_univ i))
  have hb : U*a i ≤ (18/11)*A*((∑ j,a j)-a i) := by
    have h₁ := mul_le_mul_of_nonneg_right hUs hai.le
    have h₂ := mul_le_mul_of_nonneg_left haA hs
    nlinarith
  have hratio : U/A/2 ≤ (9/11)*((∑ j,a j)/a i-1) := by
    apply (mul_le_mul_iff_right₀ hA).mp
    apply (mul_le_mul_iff_right₀ hai).mp
    field_simp
    nlinarith
  have hl := dominant_log_comparison hu hUu (by linarith : 1+(U/A)/2 ≤ V/M i)
  linarith

/-- Literal true and held beta parameters. Their coefficient is chosen only
once; these functions do not depend on the horizon or posterior law. -/
def beta (k c cb ell M : ℝ) : ℝ := 3+cb/ell*Real.log (k/max M c)
def lowerSize (c δ H : ℝ) : ℝ := max c (H/(1+δ)^2)
def upperBeta (k c cb ell δ H : ℝ) : ℝ := 3+cb/ell*Real.log (k/lowerSize c δ H)

lemma beta_difference {k c cb ell M V : ℝ} (hk : 0 < k) (hc : 0 < c) (hM : c ≤ M) (hMV : M ≤ V) :
    beta k c cb ell M-beta k c cb ell V=cb/ell*Real.log (V/M) := by
  have hM0 : 0 < M := hc.trans_le hM
  have hV0 : 0 < V := hM0.trans_le hMV
  simp only [beta,max_eq_left hM,max_eq_left (hM.trans hMV)]
  rw [Real.log_div hk.ne' hM0.ne',Real.log_div hk.ne' hV0.ne',Real.log_div hV0.ne' hM0.ne']
  ring

lemma lowerSize_accuracy {c δ X H : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hX : c ≤ X)
    (_ : 0 ≤ H) (hlo : X ≤ (1+δ)^2*H) (hhi : H ≤ (1+δ)^2*X) :
    0 < lowerSize c δ H ∧ lowerSize c δ H ≤ X ∧ X ≤ (1+δ)^4*lowerSize c δ H := by
  have he : 0 < 1+δ := by linarith
  have he2 : 0 < (1+δ)^2 := sq_pos_of_pos he
  have hlow : H/(1+δ)^2 ≤ X := (div_le_iff₀ he2).mpr (by nlinarith)
  have hmax : H/(1+δ)^2 ≤ lowerSize c δ H := le_max_right _ _
  have hm : H ≤ (1+δ)^2*lowerSize c δ H := by
    have h := (div_le_iff₀ he2).mp hmax
    nlinarith
  refine ⟨hc.trans_le (le_max_left _ _),max_le hX hlow,?_⟩
  nlinarith [mul_le_mul_of_nonneg_left hm he2.le]

lemma beta_upper_error {k c cb ell δ X H : ℝ} (hk : 0 < k) (hc : 0 < c)
    (hcb : 0 ≤ cb) (hell : 0 < ell) (hδ : 0 < δ) (hX : c ≤ X)
    (hH : 0 ≤ H) (hlo : X ≤ (1+δ)^2*H) (hhi : H ≤ (1+δ)^2*X) :
    beta k c cb ell X ≤ upperBeta k c cb ell δ H ∧
      upperBeta k c cb ell δ H ≤ beta k c cb ell X+4*cb*δ/ell := by
  have h := lowerSize_accuracy hc hδ hX hH hlo hhi
  have hX0 : 0 < X := hc.trans_le hX
  have hfac : 0 ≤ cb/ell := div_nonneg hcb hell.le
  have he : 0 < 1+δ := by linarith
  have hlog : 0 ≤ Real.log (X/lowerSize c δ H) ∧ Real.log (X/lowerSize c δ H) ≤ 4*δ := by
    constructor
    · apply Real.log_nonneg
      exact (one_le_div h.1).mpr h.2.1
    · have hb : X/lowerSize c δ H ≤ (1+δ)^4 := (div_le_iff₀ h.1).mpr (by nlinarith [h.2.2])
      have hl := Real.log_le_log (div_pos hX0 h.1) hb
      rw [Real.log_pow] at hl
      have hh := Real.log_le_sub_one_of_pos he
      nlinarith
  have hd : upperBeta k c cb ell δ H-beta k c cb ell X=cb/ell*Real.log (X/lowerSize c δ H) := by
    simp only [beta,upperBeta,max_eq_left hX]
    rw [Real.log_div hk.ne' h.1.ne',Real.log_div hk.ne' hX0.ne',Real.log_div hX0.ne' h.1.ne']
    ring
  constructor
  · nlinarith [mul_nonneg hfac hlog.1]
  · have hh := mul_le_mul_of_nonneg_left hlog.2 hfac
    have heq : cb/ell*(4*δ)=4*cb*δ/ell := by ring
    rw [heq] at hh
    linarith

end KServer.CoarseParameters

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CoarseScale
open RankTracking RankFunctions CoreFlags
variable {Ω J R : Type} [Fintype Ω] [Fintype J] [Fintype R] {w : Ω → ℝ}

lemma size_antitone : Antitone sizeRank := by
  apply antitone_of_hasDerivAt_nonpos sizeRank_derivative
  intro p
  exact mul_nonpos_of_nonpos_of_nonneg (by norm_num) (le_max_right _ _)

lemma rank_size {z p : ℝ} (hz : z ∈ Set.Icc 0 (1/100:ℝ)) (hp : 0 ≤ p) :
    rank z p ≤ 36*sizeRank p := by
  by_cases hs : p ≤ sstar
  · have h := size_antitone hs
    have he : sizeRank sstar=1/36 := by norm_num [sizeRank,sstar]
    rw [he] at h
    linarith [(rank_range hz hp).2]
  · rw [rank_cutoff z (le_of_not_ge hs)]
    exact mul_nonneg (by norm_num) (sizeRank_nonneg p)

def noncore (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) : ℝ :=
  ∑ a, if flag (P a) t ω then 0 else FineCaps.estimate δ 0 (P a) t ω

lemma noncore_nonneg (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    0 ≤ noncore δ P t ω := by
  apply sum_nonneg
  intro a _
  split_ifs
  · rfl
  · exact (FineCaps.estimate_range (by norm_num) (P a) t ω).1

lemma noncore_bound {δ : ℝ} (hδ : 0 < δ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    noncore δ P t ω ≤ 36*(1+δ)*CoarseProcess.size P t ω := by
  calc _ ≤ ∑ a, FineCaps.estimate δ 0 (P a) t ω := by
        apply sum_le_sum
        intro a _
        split_ifs
        · exact (FineCaps.estimate_range (by norm_num) (P a) t ω).1
        · rfl
       _ ≤ ∑ a, (1+δ)*(36*sizeRank ((P a).p t ω)) := by
        apply sum_le_sum
        intro a _
        exact (FineCaps.estimate_accuracy hδ (by norm_num) (P a) t ω).2.trans
          (mul_le_mul_of_nonneg_left (rank_size (by norm_num) ((P a).range t ω).1) (by linarith))
       _ = _ := by unfold CoarseProcess.size; rw [←mul_sum,←mul_sum]; ring

lemma term_variation {e e' : ℝ} (he : e ∈ Set.Icc 0 1) (he' : e' ∈ Set.Icc 0 1)
    (b b' : Bool) :
    |(if b' then 0 else e')-(if b then 0 else e)| ≤ |e'-e|+(if b'=b then (0:ℝ) else 1) := by
  cases b <;> cases b' <;> simp [abs_of_nonneg he.1,abs_of_nonneg he'.1] <;>
    linarith [he.2,he'.2,abs_nonneg (e'-e)]

lemma noncore_variation (δ : ℝ) (P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
    |noncore δ P (t+1) ω-noncore δ P t ω| ≤
      (∑ a, |FineCaps.estimate δ 0 (P a) (t+1) ω-FineCaps.estimate δ 0 (P a) t ω|)+
      ∑ a,change (P a) t ω := by
  unfold noncore
  rw [←sum_sub_distrib,←sum_add_distrib]
  exact (abs_sum_le_sum_abs _ _).trans (sum_le_sum fun a _ =>
    term_variation (FineCaps.estimate_range (by norm_num) (P a) t ω)
      (FineCaps.estimate_range (by norm_num) (P a) (t+1) ω) _ _)

lemma mark_positive {x : J → ℝ} {s : EpochSchedule.State J} {o : J}
    (hs : EpochSchedule.Valid x s) (ho : EpochSchedule.dominant s=some o) : 0 < x o := by
  have hp : 0 < EpochSchedule.total s.reference := by
    unfold EpochSchedule.dominant at ho
    split_ifs at ho with h
    exact h.choose_spec.1
  have := EpochSchedule.dominant_large hs ho
  linarith

def scale (δ : ℝ) (P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω)
    (s : EpochSchedule.State J) : ℝ :=
  (EpochSchedule.dominant s).elim 0 (fun i => noncore δ (P i) t ω)

lemma scale_nonneg (δ : ℝ) (P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω)
    (s : EpochSchedule.State J) : 0 ≤ scale δ P t ω s := by
  unfold scale
  cases EpochSchedule.dominant s with
  | none => rfl
  | some i => exact noncore_nonneg δ (P i) t ω

lemma scale_bound {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω) (s : EpochSchedule.State J)
    (hs : EpochSchedule.Valid (CoarseEpoch.vector c δ P ω t) s) :
    scale δ P t ω s ≤ 41*EpochSchedule.total (CoarseEpoch.vector c δ P ω t) := by
  classical
  unfold scale
  cases ho : EpochSchedule.dominant s with
  | none => exact mul_nonneg (by norm_num) (EpochSchedule.total_nonneg (CoarseEpoch.vector_nonneg c δ P ω t))
  | some i =>
    have hp := mark_positive hs ho
    have ha : (CoarseProcess.active c δ (P i) ω t).active=true := by
      cases he : (CoarseProcess.active c δ (P i) ω t).active with
      | true => rfl
      | false =>
        have hz := (CoarseProcess.active_valid c δ (P i) ω t).2 he
        change 0 < (CoarseProcess.active c δ (P i) ω t).value at hp
        linarith
    have hlo := ((CoarseProcess.active_accuracy hc hδ hδu (P i) ω t).1 ha).1
    have hv := single_le_sum (fun j _ => CoarseEpoch.vector_nonneg c δ P ω t j) (mem_univ i)
    change (CoarseProcess.active c δ (P i) ω t).value ≤ EpochSchedule.total (CoarseEpoch.vector c δ P ω t) at hv
    have hb := noncore_bound hδ (P i) t ω
    have hm := CoarseProcess.size_nonneg (P i) t ω
    have hd := mul_le_mul_of_nonneg_right hδu hm
    change noncore δ (P i) t ω ≤ _
    nlinarith

lemma scale_unchanged_variation (δ : ℝ) (P : J → R → FilteredRanks w)
    (t : ℕ) (ω : Ω) (s s' : EpochSchedule.State J)
    (he : EpochSchedule.dominant s'=EpochSchedule.dominant s) :
    |scale δ P (t+1) ω s'-scale δ P t ω s| ≤
      ∑ i, ((∑ a, |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)+
        ∑ a,change (P i a) t ω) := by
  have hnonneg i : 0 ≤ (∑ a, |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)+
      ∑ a,change (P i a) t ω := by
    apply add_nonneg (sum_nonneg fun _ _ => abs_nonneg _)
    apply sum_nonneg; intro a _; unfold change; split_ifs <;> norm_num
  unfold scale
  rw [he]
  cases ho : EpochSchedule.dominant s with
  | none => simpa using sum_nonneg (fun i _ => hnonneg i)
  | some i => exact (noncore_variation δ (P i) t ω).trans (single_le_sum (fun i _ => hnonneg i) (mem_univ i))

end KServer.CoarseScale

namespace KServer.CoarseScale
open RankTracking RankFunctions CoreFlags
variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [Fintype R] {w : Ω → ℝ}

lemma scale_step {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (P : J → R → FilteredRanks w) (ω : Ω) (key : ℕ → K) (t : ℕ) :
    let x := CoarseEpoch.vector c δ P ω
    let s := EpochSchedule.run x key
    |scale δ P (t+1) ω (s (t+1))-scale δ P t ω (s t)| ≤
      (∑ i, ((∑ a, |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)+
        ∑ a,change (P i a) t ω))+
      41*EpochSchedule.wholesale (x t) (x (t+1)) (key t) (key (t+1)) (s t) := by
  intro x s
  have hv n := EpochSchedule.run_valid x key (CoarseEpoch.vector_nonneg c δ P ω) n
  by_cases hr : EpochSchedule.reset (x t) (x (t+1)) (key t) (key (t+1)) (s t)
  · have hb₀ := scale_bound hc hδ hδu P t ω (s t) (hv t)
    have hb₁ := scale_bound hc hδ hδu P (t+1) ω (s (t+1)) (hv (t+1))
    have hn₀ := scale_nonneg δ P t ω (s t)
    have hn₁ := scale_nonneg δ P (t+1) ω (s (t+1))
    have hj : 0 ≤ ∑ i, ((∑ a, |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)+
        ∑ a,change (P i a) t ω) := by
      apply sum_nonneg
      intro i _
      apply add_nonneg (sum_nonneg fun _ _ => abs_nonneg _)
      apply sum_nonneg; intro a _; unfold change; split_ifs <;> norm_num
    rw [EpochSchedule.wholesale,ite_eq_left hr]
    apply abs_le.mpr
    constructor <;> linarith
  · rw [EpochSchedule.wholesale,ite_eq_right hr,mul_zero,add_zero]
    apply scale_unchanged_variation
    exact CoarseSide.mark_unchanged hr

/-- The change of dominant flex scale is paid by actual elementary trackers,
core flips, and wholesale totals. This includes changes of dominant identity. -/
lemma scale_budget {c δ : ℝ} (hc : 0 < c) (hδ : 0 < δ) (hδu : δ ≤ 1/1000)
    (hw : ∀ ω, 0 ≤ w ω) (hw1 : ∑ ω,w ω=1)
    (P : J → R → FilteredRanks w) (key : Ω → ℕ → K) (N : ℕ) :
    (∑ t ∈ range N, avg w (fun ω =>
      |scale δ P (t+1) ω (EpochSchedule.run (CoarseEpoch.vector c δ P ω) (key ω) (t+1))-
       scale δ P t ω (EpochSchedule.run (CoarseEpoch.vector c δ P ω) (key ω) t)|)) ≤
      (80/δ+(CoreFlags.tolerance^2)⁻¹)*
        ((∑ i, ∑ a, ∑ t ∈ range N, avg w (fun ω => |(P i a).p (t+1) ω-(P i a).before (t+1) ω|))+
          Fintype.card J*Fintype.card R)+
      41*(∑ t ∈ range N, avg w (fun ω => EpochSchedule.wholesale
        (CoarseEpoch.vector c δ P ω t) (CoarseEpoch.vector c δ P ω (t+1))
        (key ω t) (key ω (t+1)) (EpochSchedule.run (CoarseEpoch.vector c δ P ω) (key ω) t))) := by
  let drift i a := ∑ t ∈ range N, avg w (fun ω => |(P i a).p (t+1) ω-(P i a).before (t+1) ω|)
  have he i a := FineCaps.estimate_variation_budget hw hw1 hδ (by linarith) (by norm_num : (0:ℝ) ∈ Set.Icc 0 (1/100)) (P i a) N
  have hf := CoreFlags.core_change_budget hw hw1 (fun ia : J × R => P ia.1 ia.2) N
  have hest : (∑ t ∈ range N, avg w (fun ω => ∑ i,∑ a,
      |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)) ≤
      (80/δ)*((∑ i,∑ a,drift i a)+Fintype.card J*Fintype.card R) := by
    simp_rw [avg_sum]
    rw [sum_comm]
    calc _ = ∑ i, ∑ a, ∑ t ∈ range N, avg w (fun ω =>
        |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|) := by
          apply sum_congr rfl; intro i _; exact sum_comm
         _ ≤ ∑ i,∑ a,(80/δ)*(drift i a+1) := sum_le_sum fun i _ => sum_le_sum fun a _ => he i a
         _ = _ := by simp_rw [←mul_sum,sum_add_distrib,sum_const,nsmul_eq_mul,mul_one,card_univ]
  have hflags : (∑ t ∈ range N, avg w (fun ω => ∑ i,∑ a,change (P i a) t ω)) ≤
      (CoreFlags.tolerance^2)⁻¹*((∑ i,∑ a,drift i a)+Fintype.card J*Fintype.card R) := by
    have hd : (∑ t ∈ range N, avg w (fun ω => ∑ i,∑ a,
        |(P i a).p (t+1) ω-(P i a).before (t+1) ω|)) = ∑ i,∑ a,drift i a := by
      simp_rw [avg_sum]
      rw [sum_comm]
      apply sum_congr rfl
      intro i _
      exact sum_comm
    simpa only [Fintype.sum_prod_type,Fintype.card_prod,Nat.cast_mul,hd] using hf
  calc _ ≤ ∑ t ∈ range N, avg w (fun ω =>
        (∑ i, ((∑ a, |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|)+
        ∑ a,change (P i a) t ω))+
        41*EpochSchedule.wholesale (CoarseEpoch.vector c δ P ω t) (CoarseEpoch.vector c δ P ω (t+1))
          (key ω t) (key ω (t+1)) (EpochSchedule.run (CoarseEpoch.vector c δ P ω) (key ω) t)) := by
        exact sum_le_sum fun t _ => avg_mono hw (fun ω => scale_step hc hδ hδu P ω (key ω) t)
       _ = (∑ t ∈ range N, avg w (fun ω => ∑ i,∑ a,
          |FineCaps.estimate δ 0 (P i a) (t+1) ω-FineCaps.estimate δ 0 (P i a) t ω|))+
         (∑ t ∈ range N, avg w (fun ω => ∑ i,∑ a,change (P i a) t ω))+
         41*(∑ t ∈ range N, avg w (fun ω => EpochSchedule.wholesale
           (CoarseEpoch.vector c δ P ω t) (CoarseEpoch.vector c δ P ω (t+1))
           (key ω t) (key ω (t+1)) (EpochSchedule.run (CoarseEpoch.vector c δ P ω) (key ω) t))) := by
          simp_rw [sum_add_distrib,avg_add,avg_mul,sum_add_distrib,←mul_sum]
       _ ≤ _ := by dsimp only [drift] at hest hflags; nlinarith

end KServer.CoarseScale

end

end OAI