lean/OAI/Combinatorics/KServer/AllocationBudget.lean

import Mathlib
import OAI.Combinatorics.KServer.ScheduleBudget

namespace OAI

/-! True-prefix filtering followed by paid literal profile edits.  In particular
no event chosen at the new history is allowed to select a filtering term. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ScheduledFiltering
attribute [local instance] Classical.propDecidable
open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule
open SimplexFamilies AdaptiveAllocation AdaptiveMinimization
variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R]
variable {w : Ω→ℝ}

lemma filtering_zero {δ:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (C ell ct:ℝ)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (H:ℕ→Ω→ℕ)
    (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z) (t:ℕ) :
    let d:=StarSimplex.input hδ hδu C ell ct P key
    let a:=StarSimplex.proportion hδ hδu C ell ct P key
    avg w (fun ω=>(family C ell).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)-
      (family C ell).value (d t ω).data (d t ω).ranks (a t ω))=0 := by
  intro d a
  simp_rw [(family C ell).input_difference]
  rw [avg_sum_any]
  apply sum_eq_zero
  intro ir _
  apply filtering_affine (P ir.1 ir.2)
  intro ω z he
  rw [hH,hH] at he
  have hd:=congrArg CausalSimplex.Input.data (StarSimplex.input_adapted hδ hδu C ell ct P key H hH hr hkey t ω z he)
  have ha:=StarSimplex.proportion_adapted hδ hδu C ell ct P key H hH hr hkey t ω z he
  change (family C ell).coefficient (d t ω).data (a t ω) ir=(family C ell).coefficient (d t z).data (a t z) ir
  change (d t ω).data=(d t z).data at hd
  change a t ω=a t z at ha
  rw [hd,ha]

lemma payment_step {δ C ct k:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (hC:0<C) (hct:0<ct) (hctu:ct*20002≤1) (hgap:700<C*ct) (hk:1≤k)
    (hw:∀ ω,0≤w ω) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (H:ℕ→Ω→ℕ)
    (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z) (t:ℕ) :
    let ell:=1+Real.log (k+1)
    let d:=StarSimplex.input hδ hδu C ell ct P key
    let a:=StarSimplex.proportion hδ hδu C ell ct P key
    avg w (fun ω=>CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω))≤
      avg w (fun ω=>(family C ell).value (d t ω).data (d t ω).ranks (a t ω))-
      avg w (fun ω=>(family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω))+
      13*C*ell*(∑ ir:J×R,avg w (fun ω=>|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))+
      avg w (ScheduledPayment.expense C ell δ P key t) := by
  intro ell d a
  have hpoint (ω:Ω) : CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤
      ((family C ell).value (d t ω).data (d t ω).ranks (a t ω)-
      (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω))+
      ((family C ell).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)-
      (family C ell).value (d t ω).data (d t ω).ranks (a t ω))+
      13*C*ell*(∑ ir:J×R,|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|)+
      ScheduledPayment.expense C ell δ P key t ω := by
    have hp:=ScheduledPayment.payment hδ hδu hC hct hctu hgap hk P key hs t ω
    have ha:=StarSimplex.proportion_mem hδ hδu C ell ct P key t ω
    have hl:=ScheduledSlope.actual_bound hδ hδu hC.le hct.le hctu hk P key hs t ω _ ha
    have hd: (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)-
        (family C ell).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)≤
        13*C*ell*(∑ ir:J×R,|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|) :=
      (le_abs_self _).trans ((family C ell).input_lipschitz (d t ω).data _ _ (a t ω) hl)
    change _≤(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)-
      (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_ at hp
    linarith
  have he:=avg_mono hw hpoint
  simp only [avg_add,avg_sub,avg_mul,avg_sum_any] at he
  have hf:=filtering_zero hδ hδu C ell ct P key H hH hr hkey t
  dsimp only at hf
  rw [avg_sub] at hf
  change avg w (fun ω=>(family C ell).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω))-
    avg w (fun ω=>(family C ell).value (d t ω).data (d t ω).ranks (a t ω))=0 at hf
  rw [hf,add_zero] at he
  exact he

lemma payment {δ C ct k:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (hC:0<C) (hct:0<ct) (hctu:ct*20002≤1) (hgap:700<C*ct) (hk:1≤k)
    (hw:∀ ω,0≤w ω) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (H:ℕ→Ω→ℕ)
    (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z) (n:ℕ) :
    let ell:=1+Real.log (k+1)
    let d:=StarSimplex.input hδ hδu C ell ct P key
    let a:=StarSimplex.proportion hδ hδu C ell ct P key
    (∑ t∈range n,avg w (fun ω=>CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)))≤
      avg w (fun ω=>(family C ell).value (d 0 ω).data (d 0 ω).ranks (a 0 ω))-
      avg w (fun ω=>(family C ell).value (d n ω).data (d n ω).ranks (a n ω))+
      13*C*ell*(∑ t∈range n,∑ ir:J×R,avg w (fun ω=>|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))+
      ∑ t∈range n,avg w (ScheduledPayment.expense C ell δ P key t) := by
  intro ell d a
  induction n with
  | zero=>simp
  | succ n ih=>
    simp only [sum_range_succ]
    have hp:=payment_step hδ hδu hC hct hctu hgap hk hw P key hs H hH hr hkey n
    change avg w (fun ω=>CausalSimplex.mass (d (n+1) ω)*ChangingDomains.variation (a (n+1) ω) (a n ω))≤
      avg w (fun ω=>(family C ell).value (d n ω).data (d n ω).ranks (a n ω))-
      avg w (fun ω=>(family C ell).value (d (n+1) ω).data (d (n+1) ω).ranks (a (n+1) ω))+_+_ at hp
    linarith

lemma bounded_endpoint {δ C ct k:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (hC:0≤C) (hct:0≤ct) (hctu:ct*20002≤1) (hk:1≤k)
    (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) :
    let ell:=1+Real.log (k+1)
    let d:=StarSimplex.input hδ hδu C ell ct P key
    let a:=StarSimplex.proportion hδ hδu C ell ct P key
    |avg w (fun ω=>(family C ell).value (d t ω).data (d t ω).ranks (a t ω))|≤572*C*ell*k := by
  intro ell d a
  have hel:0≤ell:=by dsimp [ell]; have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith
  calc _≤avg w (fun ω=>|(family C ell).value (d t ω).data (d t ω).ranks (a t ω)|) := by
        unfold avg
        exact (abs_sum_le_sum_abs _ _).trans_eq (by
          congr 1; funext ω; rw [abs_mul,abs_of_nonneg (hw ω)])
       _≤avg w (fun _=>572*C*ell*k) := by
        apply avg_mono hw
        intro ω
        have h:=ScheduledEndpoint.actual_bound hδ hδu hC hct hctu hk P key hs t ω
          (d t ω).ranks (fun ir=>(P ir.1 ir.2).range t ω) (a t ω)
          (StarSimplex.proportion_mem hδ hδu C ell ct P key t ω)
        have ht:=StarProfile.vector_total hδ hδu P t ω (hs t ω)
        have hm:=mul_le_mul_of_nonneg_left ht (show 0≤520*C*ell by positivity)
        change |(family C ell).value (d t ω).data (d t ω).ranks (a t ω)|≤520*C*ell*EpochSchedule.total (vector cutoff δ P ω t) at h
        change (∑ i,vector cutoff δ P ω t i)≤_ at ht
        unfold EpochSchedule.total at h hm
        nlinarith
       _= _ :=avg_const w hw1 _

end KServer.ScheduledFiltering

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.SideFiltering
attribute [local instance] Classical.propDecidable Classical.decEq
open AdaptiveMinimization RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule StarSide SideFamilies
variable {Ω J R K : Type} [Fintype Ω] [Fintype J]  [Fintype R]
variable {w:Ω→ℝ}

lemma filtering_zero {cw ell:ℝ} (hcw:0<cw) (hel:0<ell) (δ:ℝ)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) (H:ℕ→Ω→ℕ)
    (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z)
    (hb:∀ t ω z,H t ω=H t z→b t ω=b t z) (t:ℕ) :
    let d:=input hcw hel δ P key b
    let a:=proportion hcw hel δ P key b
    avg w (fun ω=>(family 40).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)-
      (family 40).value (d t ω).data (d t ω).ranks (a t ω))=0 := by
  intro d a
  simp_rw [(family 40).input_difference]
  rw [avg_sum_any]
  apply sum_eq_zero
  intro ir _
  apply filtering_affine (P ir.1 ir.2)
  intro ω z he
  rw [hH,hH] at he
  have hd:=congrArg CausalSide.Input.data (input_adapted hcw hel δ P key b H hH hr hkey hb t ω z he)
  have ha:=proportion_adapted hcw hel δ P key b H hH hr hkey hb t ω z he
  change (family 40).coefficient (d t ω).data (a t ω) ir=(family 40).coefficient (d t z).data (a t z) ir
  change (d t ω).data=(d t z).data at hd
  change a t ω=a t z at ha
  rw [hd,ha]

lemma slope {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k)
    (hcw:0<cw) (hcwu:cw*20002≤1) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) (hb:0≤b t ω) (hbu:b t ω≤4) :
    let ell:=1+Real.log (k+1)
    let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith
    let d:=input hcw hel δ P key b
    let a:=proportion hcw hel δ P key b
    ∀ ir,|(family 40).coefficient (d t ω).data (a t ω) ir|≤3600/cw*ell := by
  intro ell hel d a ir
  have hell:1≤ell:=by dsimp [ell]; linarith [Real.log_nonneg (show 1≤k+1 by linarith)]
  have hM (i:J):b t ω+cw*logs δ P key t ω i/ell≤5:=by
    have h:=SideActualEdits.theta_bound hδ hδu hk hcw hcwu P key hs t ω i
    change cw*logs δ P key t ω i/ell≤1 at h
    linarith
  exact SideProfile.coefficient_bound hcw hell (sides δ P key t ω) (sideFlags δ P key t ω)
    (logs δ P key t ω) (fun i=>le_max_left _ _) hb hM (a t ω) (proportion_mem hcw hel δ P key b t ω) ir

lemma payment_step {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k)
    (hcw:0<cw) (hcwu:cw*20002≤1) (hw:∀ ω,0≤w ω)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k)
    (hb:∀ t ω,1≤b t ω) (hbu:∀ t ω,b t ω≤4)
    (hbe:∀ t ω,key t ω=key (t+1) ω→b t ω=b (t+1) ω)
    (H:ℕ→Ω→ℕ) (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z)
    (hbad:∀ t ω z,H t ω=H t z→b t ω=b t z) (t:ℕ) :
    let ell:=1+Real.log (k+1)
    let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith
    let d:=input hcw hel δ P key b
    let a:=proportion hcw hel δ P key b
    avg w (fun ω=>scale δ P key (t+1) ω*ChangingDomains.variation (a (t+1) ω) (a t ω))≤
      avg w (fun ω=>(family 40).value (d t ω).data (d t ω).ranks (a t ω))-
      avg w (fun ω=>(family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω))+
      3600/cw*ell*(∑ ir:J×R,avg w (fun ω=>|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))+
      avg w (SidePayment.expense cw ell δ P key t) := by
  intro ell hel d a
  have hpoint (ω:Ω) : scale δ P key (t+1) ω*ChangingDomains.variation (a (t+1) ω) (a t ω)≤
      ((family 40).value (d t ω).data (d t ω).ranks (a t ω)-
      (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω))+
      ((family 40).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)-
      (family 40).value (d t ω).data (d t ω).ranks (a t ω))+
      3600/cw*ell*(∑ ir:J×R,|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|)+
      SidePayment.expense cw ell δ P key t ω := by
    have hp:=SidePayment.payment hδ hδu hk hcw hcwu P key b hs t ω (fun s=>hb s ω) (fun s=>hbu s ω) (hbe t ω)
    have hl:=slope hδ hδu hk hcw hcwu P key b hs t ω (by linarith [hb t ω]) (hbu t ω)
    have hd: (family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)-
        (family 40).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω)≤
        3600/cw*ell*(∑ ir:J×R,|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|) :=
      (le_abs_self _).trans ((family 40).input_lipschitz (d t ω).data _ _ (a t ω) hl)
    change _≤(family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)-
      (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_ at hp
    linarith
  have he:=avg_mono hw hpoint
  simp only [avg_add,avg_sub,avg_mul,avg_sum_any] at he
  have hf:=filtering_zero hcw hel δ P key b H hH hr hkey hbad t
  dsimp only at hf
  rw [avg_sub] at hf
  change avg w (fun ω=>(family 40).value (d t ω).data (fun ir=>(P ir.1 ir.2).before (t+1) ω) (a t ω))-
    avg w (fun ω=>(family 40).value (d t ω).data (d t ω).ranks (a t ω))=0 at hf
  rw [hf,add_zero] at he
  exact he

lemma payment {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k)
    (hcw:0<cw) (hcwu:cw*20002≤1) (hw:∀ ω,0≤w ω)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k)
    (hb:∀ t ω,1≤b t ω) (hbu:∀ t ω,b t ω≤4)
    (hbe:∀ t ω,key t ω=key (t+1) ω→b t ω=b (t+1) ω)
    (H:ℕ→Ω→ℕ) (hH:∀ i r t ω,(P i r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hkey:∀ t ω z,H t ω=H t z→key t ω=key t z)
    (hbad:∀ t ω z,H t ω=H t z→b t ω=b t z) (n:ℕ) :
    let ell:=1+Real.log (k+1)
    let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith
    let d:=input hcw hel δ P key b
    let a:=proportion hcw hel δ P key b
    (∑ t∈range n,avg w (fun ω=>scale δ P key (t+1) ω*ChangingDomains.variation (a (t+1) ω) (a t ω)))≤
      avg w (fun ω=>(family 40).value (d 0 ω).data (d 0 ω).ranks (a 0 ω))-
      avg w (fun ω=>(family 40).value (d n ω).data (d n ω).ranks (a n ω))+
      3600/cw*ell*(∑ t∈range n,∑ ir:J×R,avg w (fun ω=>|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))+
      ∑ t∈range n,avg w (SidePayment.expense cw ell δ P key t) := by
  intro ell hel d a
  induction n with
  | zero=>simp
  | succ n ih=>
    simp only [sum_range_succ]
    have hp:=payment_step hδ hδu hk hcw hcwu hw P key b hs hb hbu hbe H hH hr hkey hbad n
    change avg w (fun ω=>scale δ P key (n+1) ω*ChangingDomains.variation (a (n+1) ω) (a n ω))≤
      avg w (fun ω=>(family 40).value (d n ω).data (d n ω).ranks (a n ω))-
      avg w (fun ω=>(family 40).value (d (n+1) ω).data (d (n+1) ω).ranks (a (n+1) ω))+_+_ at hp
    linarith

end KServer.SideFiltering

end


/-! Expected movement of the literal minimizers, with uniform endpoint bills. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualCharges
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar ActualOutput
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}

lemma drift_le_stock (hw:∀ ω,0≤w ω) (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (N:ℕ):
    drift (flat P) N≤ stock P Q N:=
  (le_add_of_nonneg_right (Nat.cast_nonneg (Fintype.card (J×R)))).trans (inventory_child_le hw P Q N)
lemma raw_drift_eq (P:J→R→FilteredRanks w) (N:ℕ):
    (∑ t∈range N,∑ ir:J×R,avg w (fun ω=>|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))=
      drift (flat P) N:=by simp only [drift,flat,avg_sum]

lemma simplex_mass (k:ℝ) (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (t:ℕ) (ω:Ω):
    CausalSimplex.mass (StarSimplex.input (δ:=ds) (by norm_num [ds]) (by norm_num [ds])
      C (ActualCaps.ell k) ct P (key Q) t ω)=S P t ω:=by
  simp only [CausalSimplex.mass,StarSimplex.input_core]
  rfl

lemma simplex_movement {k:ℝ} (hk:1≤k) (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤k)
    (H:ℕ→Ω→ℕ) (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z) (N:ℕ):
    total w N (fun t ω=>S P (t+1) ω*ChangingDomains.variation (α k P Q (t+1) ω) (α k P Q t ω))≤
      1144*C*ActualCaps.ell k*k+(13*C+simplexConstant)*ActualCaps.ell k*stock P Q N:=by
  have hs' t ω: (∑ i,size (P i) t ω)≤k:=(hs t ω).trans (hq t ω)
  have hp:=ScheduledFiltering.payment (δ:=ds) (by norm_num [ds]) (by norm_num [ds])
    positive.2.2.2.2.1 positive.2.2.1 small.1 small.2.2.1 hk hw P (key Q) hs' H hP hr
    (key_adapted Q H hQ hr) N
  have he t:=ScheduledFiltering.bounded_endpoint (δ:=ds) (by norm_num [ds]) (by norm_num [ds])
    positive.2.2.2.2.1.le positive.2.2.1.le small.1 hk hw hw1 P (key Q) hs' t
  dsimp only at hp he
  have hl:(1+Real.log (k+1))=ActualCaps.ell k:=rfl
  simp only [hl,simplex_mass,raw_drift_eq] at hp he
  change total w N (fun t ω=>S P (t+1) ω*ChangingDomains.variation (α k P Q (t+1) ω) (α k P Q t ω))≤_ at hp
  have he0:=(abs_le.mp (he 0)).2
  have heN:=(abs_le.mp (he N)).1
  have hx:=simplex_expense hw hw1 (ActualCaps.ell_ge_one hk) P Q hs N
  have hd:=mul_le_mul_of_nonneg_left (drift_le_stock hw P Q N)
    (show 0≤13*C*ActualCaps.ell k by have hc:=positive.2.2.2.2.1; have he:=ActualCaps.ell_pos hk; positivity)
  dsimp only [total] at hx
  linarith only [hp,he0,heN,hx,hd]

lemma side_endpoint {k:ℝ} (hk:1≤k) (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤k) (t:ℕ):
    |avg w (fun ω=>(SideFamilies.family 40).value (sideData hk P Q t ω).data
      (sideData hk P Q t ω).ranks (side hk P Q t ω))|≤220000*(1/cw+1)*ActualCaps.ell k*k:=by
  have hc:0<cw:=positive.2.2.2.1
  have hel:0<ActualCaps.ell k:=ActualCaps.ell_pos hk
  calc _≤avg w (fun ω=>|(SideFamilies.family 40).value (sideData hk P Q t ω).data
        (sideData hk P Q t ω).ranks (side hk P Q t ω)|):=by
          unfold avg
          exact (abs_sum_le_sum_abs _ _).trans_eq (by
            congr 1; funext ω; rw [abs_mul,abs_of_nonneg (hw ω)])
       _≤avg w (fun _=>220000*(1/cw+1)*ActualCaps.ell k*k):=by
          apply avg_mono hw
          intro ω
          have hp:=SideActualBounds.endpoint (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) hk hc small.2.1
            P (key Q) (b k Q) (fun s z=>(hs s z).trans (hq s z)) t ω
            (by linarith [(b_range hk Q t ω (hq t ω)).1]) (b_range hk Q t ω (hq t ω)).2
            (sideData hk P Q t ω).ranks (fun ir=>(P ir.1 ir.2).range t ω)
          change |(SideFamilies.family 40).value (sideData hk P Q t ω).data
            (sideData hk P Q t ω).ranks (side hk P Q t ω)|≤_ at hp
          have ht:=StarProfile.vector_total (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) P t ω ((hs t ω).trans (hq t ω))
          have hm:=mul_le_mul_of_nonneg_left ht (show 0≤200000*(1/cw+1)*ActualCaps.ell k by positivity)
          dsimp only [EpochSchedule.total,ActualCaps.ell] at hp hm ⊢
          nlinarith only [hp,hm]
       _= _:=avg_const w hw1 _

lemma side_movement {k:ℝ} (hk:1≤k) (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤k)
    (H:ℕ→Ω→ℕ) (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z) (N:ℕ):
    total w N (fun t ω=>D P Q (t+1) ω*ChangingDomains.variation (side hk P Q (t+1) ω) (side hk P Q t ω))≤
      440000*(1/cw+1)*ActualCaps.ell k*k+(3600/cw+sideConstant)*ActualCaps.ell k*stock P Q N:=by
  have hc:0<cw:=positive.2.2.2.1
  have hel:0<ActualCaps.ell k:=ActualCaps.ell_pos hk
  have hp:=SideFiltering.payment (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) hk hc small.2.1 hw
    P (key Q) (b k Q) (fun s z=>(hs s z).trans (hq s z))
    (fun t ω=>by linarith [(b_range hk Q t ω (hq t ω)).1])
    (fun t ω=>(b_range hk Q t ω (hq t ω)).2)
    (fun t ω he=>by unfold b; rw [he]) H hP hr
    (key_adapted Q H hQ hr) (b_adapted k Q H hQ hr) N
  dsimp only at hp
  have hl:(1+Real.log (k+1))=ActualCaps.ell k:=rfl
  simp only [hl,raw_drift_eq] at hp
  change total w N (fun t ω=>D P Q (t+1) ω*ChangingDomains.variation (side hk P Q (t+1) ω) (side hk P Q t ω))≤
    avg w (fun ω=>(SideFamilies.family 40).value (sideData hk P Q 0 ω).data (sideData hk P Q 0 ω).ranks (side hk P Q 0 ω))-
    avg w (fun ω=>(SideFamilies.family 40).value (sideData hk P Q N ω).data (sideData hk P Q N ω).ranks (side hk P Q N ω))+
    3600/cw*ActualCaps.ell k*drift (flat P) N+total w N (SidePayment.expense cw (ActualCaps.ell k) ds P (key Q)) at hp
  have he0:=(abs_le.mp (side_endpoint hk hw hw1 P Q hs hq 0)).2
  have heN:=(abs_le.mp (side_endpoint hk hw hw1 P Q hs hq N)).1
  have hx:=side_expense hw hw1 hel.le P Q hs N
  have hd:=mul_le_mul_of_nonneg_left (drift_le_stock hw P Q N) (show 0≤3600/cw*ActualCaps.ell k by positivity)
  linarith
end KServer.ActualCharges

end


/-! Switch charges from the actual regime recursion, including uniform
initialization and literal wholesale bills. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualCharges
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar ActualOutput
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}

def ruleConstant:ℝ:=flagConstant+scaleConstant+81*wholesaleConstant
lemma ruleConstant_nonneg:0≤ ruleConstant:=by
  have hf:=constants_nonneg.2.2
  have hh:=more_constants_nonneg.1
  have hs:=more_constants_nonneg.2.1
  dsimp [ruleConstant]; positivity

lemma core_coarse (P:J→R→FilteredRanks w) (t:ℕ) (ω:Ω):
    S P t ω≤40*EpochSchedule.total (vector cutoff ds P ω t):=by
  unfold S EpochSchedule.total
  rw [mul_sum]
  exact sum_le_sum fun i _=>ScheduleEdits.raw_core_bound (δ:=ds) (by norm_num [ds])
    (by norm_num [ds]) (P i) t ω (fun r=>(P i r).p t ω) (fun r=>(P i r).range t ω)
lemma joint_coarse (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (t:ℕ) (ω:Ω):
    S P t ω+D P Q t ω≤81*EpochSchedule.total (vector cutoff ds P ω t):=by
  have h:=SideActualBounds.scale_bound (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) P (key Q) t ω
  change D P Q t ω≤_ at h
  linarith [core_coarse P t ω]
lemma ruleS_eq (P:J→R→FilteredRanks w):RuleSchedule.S (flat P) (ruleFlags P)=S P:=by
  funext t ω; exact rule_S P t ω
lemma ruleJ_eq (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w):
    RuleSchedule.J (flat P) (ruleFlags P) (marked P Q) (reset P Q) (D P Q)=switchCharge P Q:=by
  funext t ω
  simp only [RuleSchedule.J,ruleS_eq,switchCharge,rule]
lemma rule_expense_step (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (t:ℕ) (ω:Ω):
    RuleSchedule.expense (flat P) (ruleFlags P) (reset P Q) (D P Q) t ω≤
      flags P t ω+|D P Q (t+1) ω-D P Q t ω|+81*wholesale P Q t ω:=by
  have hf:(∑ ir:J×R,if ruleFlags P t ω ir=ruleFlags P (t+1) ω ir then (0:ℝ) else 1)=flags P t ω:=by
    rw [flags_eq]
    apply sum_congr rfl
    intro ir _
    unfold ruleFlags CoreFlags.change
    by_cases h : CoreFlags.flag (P ir.1 ir.2) t ω=CoreFlags.flag (P ir.1 ir.2) (t+1) ω
    · simp only [ite_eq_left h,ite_eq_left h.symm]
    · simp only [ite_eq_right h,ite_eq_right (Ne.symm h)]
  simp only [RuleSchedule.expense,ruleS_eq,hf]
  apply add_le_add le_rfl
  cases he:reset P Q (t+1) ω with
  | false=>simp only [Bool.false_eq_true,ite_false]; exact mul_nonneg (by norm_num) (wholesale_nonneg P Q t ω)
  | true=>
    simp only [ite_true]
    have hr:EpochSchedule.reset (vector cutoff ds P ω t) (vector cutoff ds P ω (t+1))
      (key Q t ω) (key Q (t+1) ω) (EpochSchedule.run (vector cutoff ds P ω) (fun s=>key Q s ω) t):=by
        simpa only [reset,Nat.add_sub_cancel,decide_eq_true_eq] using he
    rw [wholesale,EpochSchedule.wholesale,ite_eq_left hr]
    have h:=joint_coarse P Q (t+1) ω
    linarith [EpochSchedule.total_nonneg (vector_nonneg cutoff ds P ω t)]
lemma rule_expense (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ):
    total w N (RuleSchedule.expense (flat P) (ruleFlags P) (reset P Q) (D P Q))≤ ruleConstant*stock P Q N:=by
  have h:=total_mono hw (N:=N) (rule_expense_step P Q)
  rw [total_add,total_add,total_mul] at h
  have hf:=flags_bound hw hw1 P Q N
  have hd:=scale_bound hw hw1 P Q hs N
  have hh:=wholesale_bound hw hw1 P Q hs N
  dsimp only [ruleConstant]
  linarith
lemma rule_initial {k:ℝ} (hk:1≤k) (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤k):
    avg w (RuleSchedule.potential (flat P) (ruleFlags P) (marked P Q) (reset P Q) (D P Q) 0)≤90*k:=by
  calc _≤avg w (fun _=>90*k):=by
        apply avg_mono hw
        intro ω
        have hv:=RuleSchedule.value_upper (S_nonneg P 0 ω) (D_nonneg P Q 0 ω) (marked P Q 0 ω) (rule P Q 0 ω)
        have hj:=joint_coarse P Q 0 ω
        have ht:=StarProfile.vector_total (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) P 0 ω ((hs 0 ω).trans (hq 0 ω))
        simp only [RuleSchedule.potential,ruleS_eq]
        change RuleSchedule.value (marked P Q 0 ω) (rule P Q 0 ω) (S P 0 ω) (D P Q 0 ω)≤_
        unfold EpochSchedule.total at hj ht
        linarith
       _= _:=avg_const w hw1 _
lemma switch_movement {k:ℝ} (hk:1≤k) (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤k)
    (H:ℕ→Ω→ℕ) (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z) (N:ℕ):
    total w N (switchCharge P Q)≤180*k+2*(1+ruleConstant)*stock P Q N:=by
  have hp:=RuleSchedule.payment (flat P) (ruleFlags P) (marked P Q) (reset P Q) (D P Q) H hw
    (D_nonneg P Q) (fun t ω he=>congrArg Option.isSome (ordinary_mark P Q t ω he))
    (fun ir=> hP ir.1 ir.2) hr (flags_adapted P H hP) (marked_adapted P Q H hP hQ hr)
    (reset_adapted P Q H hP hQ hr) (D_adapted P Q H hP hQ hr) N
  simp only [ruleJ_eq,flat,raw_drift_eq] at hp
  have hi:=rule_initial hk hw hw1 P Q hs hq
  have he:=rule_expense hw hw1 P Q hs N
  have hd:=drift_le_stock hw P Q N
  change total w N (switchCharge P Q)≤2*(_+drift (flat P) N+_) at hp
  dsimp only [total] at he
  linarith only [hp,hi,he,hd]

end KServer.ActualCharges
end


/-! All-step output charging, including wholesale jumps without a charge per
child or per epoch. The parent variation retains coefficient exactly one. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualOutput
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar OutputDynamics
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}

lemma coarse_output {k:ℝ} (hk:1≤ k) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤ k)
    (t:ℕ) (ω:Ω) (q:ℝ)
    (hp:(∑ i,(n P t ω i-β k Q t ω*B P t ω i+f k P Q t ω i))≤ q) (i:J):
    out hk P Q t ω q i≤80*vector cutoff ds P ω t i:=by
  have hd:=output_domination hk P Q hs hq t ω q hp i
  by_cases hi:i∈ActualStar.active P t ω
  · have hl:0<(CoarseProcess.active cutoff ds (P i) ω t).value:=by
      exact (AllocationSchedule.mem_activeSet (vector cutoff ds P ω t) i).mp hi
    have ha:=(active_accuracy (by norm_num [cutoff]:0<cutoff) (by norm_num [ds]:0<ds)
      (by norm_num [ds]:ds≤1/1000) (P i) ω t).1
      ((live_iff (by norm_num [ds]) (by norm_num [ds]) (P i) t ω).mp hl)
    change _≤80*(CoarseProcess.active cutoff ds (P i) ω t).value
    linarith [ha.1]
  · have hf:=(out_feasible hk P Q hs hq t ω q hp).1 i
    rw [inactive_d hk P Q t ω (hq t ω) hi] at hf
    exact hf.2.trans (mul_nonneg (by norm_num) (vector_nonneg cutoff ds P ω t i))

lemma wholesale_output {k:ℝ} (hk:1≤ k) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤ k)
    (t:ℕ) (ω:Ω) (q q':ℝ)
    (hp:(∑ i,(n P t ω i-β k Q t ω*B P t ω i+f k P Q t ω i))≤ q)
    (hp':(∑ i,(n P (t+1) ω i-β k Q (t+1) ω*B P (t+1) ω i+f k P Q (t+1) ω i))≤ q')
    (he:reset P Q (t+1) ω=true):
    variation (out hk P Q (t+1) ω q') (out hk P Q t ω q)≤80*ActualCharges.wholesale P Q t ω:=by
  have hr:EpochSchedule.reset (vector cutoff ds P ω t) (vector cutoff ds P ω (t+1))
      (key Q t ω) (key Q (t+1) ω) (EpochSchedule.run (vector cutoff ds P ω) (fun s=>key Q s ω) t):=by
    simpa only [reset,Nat.add_sub_cancel,decide_eq_true_eq] using he
  rw [ActualCharges.wholesale,EpochSchedule.wholesale,ite_eq_left hr]
  calc _≤∑ i,(out hk P Q (t+1) ω q' i+out hk P Q t ω q i):=by
        apply sum_le_sum
        intro i _
        exact (abs_sub _ _).trans_eq (by rw [abs_of_nonneg (output_domination hk P Q hs hq (t+1) ω q' hp' i).1,          abs_of_nonneg (output_domination hk P Q hs hq t ω q hp i).1])
       _≤∑ i,(80*vector cutoff ds P ω (t+1) i+80*vector cutoff ds P ω t i):=
        sum_le_sum fun i _=>add_le_add (coarse_output hk P Q hs hq (t+1) ω q' hp' i)
          (coarse_output hk P Q hs hq t ω q hp i)
       _= _:=by simp only [sum_add_distrib,←mul_sum,EpochSchedule.total]; ring

lemma all_movement {k:ℝ} (hk:1≤ k) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤ k)
    (t:ℕ) (ω:Ω) (q q':ℝ)
    (hp:(∑ i,(n P t ω i-β k Q t ω*B P t ω i+f k P Q t ω i))≤ q)
    (hp':(∑ i,(n P (t+1) ω i-β k Q (t+1) ω*B P (t+1) ω i+f k P Q (t+1) ω i))≤ q'):
    variation (out hk P Q (t+1) ω q') (out hk P Q t ω q)≤
      |q'-q|+2*(if reset P Q (t+1) ω then 0 else variation (d k P Q (t+1) ω) (d k P Q t ω))+
      40*(S P (t+1) ω*variation (α k P Q (t+1) ω) (α k P Q t ω)+
        D P Q (t+1) ω*variation (side hk P Q (t+1) ω) (side hk P Q t ω)+
        |D P Q (t+1) ω-D P Q t ω|+switchCharge P Q t ω)+80*ActualCharges.wholesale P Q t ω:=by
  cases he:reset P Q (t+1) ω with
  | false=>
    simp only [Bool.false_eq_true,ite_false]
    exact (ordinary_movement hk P Q hs t ω (hq (t+1) ω) q q' hp' he).trans
      (le_add_of_nonneg_right (mul_nonneg (by norm_num) (ActualCharges.wholesale_nonneg P Q t ω)))
  | true=>
    have hh:=wholesale_output hk P Q hs hq t ω q q' hp hp' he
    simp only [ite_true,mul_zero,add_zero]
    have hS:=mul_nonneg (S_nonneg P (t+1) ω) (variation_nonneg (α k P Q (t+1) ω) (α k P Q t ω))
    have hD:=mul_nonneg (D_nonneg P Q (t+1) ω) (variation_nonneg (side hk P Q (t+1) ω) (side hk P Q t ω))
    linarith [abs_nonneg (q'-q),abs_nonneg (D P Q (t+1) ω-D P Q t ω),switchCharge_nonneg P Q t ω]
end KServer.ActualOutput

end


/-! The unconditional local allocation movement theorem for the
literal output already constructed. Its parent coefficient is exactly one;
all other costs are true drift and a fixed, law/horizon-independent inventory. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualCharges
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar ActualOutput
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}

def fineConstant:ℝ:=2*(160/rho+flagConstant)
def movementConstant:ℝ:=2*fineConstant+40*(13*C+simplexConstant+3600/cw+sideConstant+
  scaleConstant+2*(1+ruleConstant))+80*wholesaleConstant
def endpointConstant:ℝ:=40*(1144*C+440000*(1/cw+1)+180)
def localConstant:ℝ:=movementConstant+endpointConstant+1
lemma output_constants_nonneg:0≤ fineConstant ∧ 0≤ movementConstant ∧ 0≤ endpointConstant ∧ 0<localConstant:=by
  have hc:=positive.2.2.2.2.1
  have hw:=positive.2.2.2.1
  have hr:=positive.2.2.2.2.2.2.2.1
  have hf:=constants_nonneg.2.2
  have hh:=more_constants_nonneg.1
  have hs:=more_constants_nonneg.2.1
  have he:=edit_constants_nonneg.1
  have he2:=edit_constants_nonneg.2
  have hb:=ruleConstant_nonneg
  have hfi:0≤ fineConstant:=by dsimp [fineConstant]; positivity
  have hm:0≤ movementConstant:=by dsimp only [movementConstant]; positivity
  have hep:0≤ endpointConstant:=by dsimp only [endpointConstant]; positivity
  refine ⟨hfi,hm,hep,?_⟩
  dsimp only [localConstant]; linarith

lemma fine_movement {k:ℝ} (hk:1≤ k) (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (hq:∀ t ω,size Q t ω≤ k) (N:ℕ):
    total w N (fun t ω=>if reset P Q (t+1) ω then 0 else
      ChangingDomains.variation (d k P Q (t+1) ω) (d k P Q t ω))≤ fineConstant*ActualCaps.ell k*stock P Q N:=by
  have hp:=fine_budget hk hw hw1 P Q hq N
  change total w N (fun t ω=>if reset P Q (t+1) ω then 0 else
    ChangingDomains.variation (d k P Q (t+1) ω) (d k P Q t ω))≤
      2*(160/(rho/ActualCaps.ell k)+flagConstant)*inventory (flat P) N at hp
  have hc:0≤ 2*(160/(rho/ActualCaps.ell k)+flagConstant):=by
    have hr:=positive.2.2.2.2.2.2.2.1; have he:=ActualCaps.ell_pos hk; have hf:=constants_nonneg.2.2
    positivity
  have hu:=mul_le_mul_of_nonneg_left (inventory_child_le hw P Q N) hc
  have hell:=ActualCaps.ell_ge_one hk
  have hf:=mul_nonneg constants_nonneg.2.2 (stock_nonneg hw P Q N)
  have herr:=mul_nonneg (sub_nonneg.mpr hell) hf
  rw [div_div_eq_mul_div] at hp hu
  simp only [fineConstant,div_eq_mul_inv] at hp hu ⊢
  nlinarith only [hp,hu,herr]

lemma output_movement {k:ℝ} (hk:1≤ k) (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤ k)
    (H:ℕ→Ω→ℕ) (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (q:ℕ→Ω→ℝ)
    (hp:∀ t ω,(∑ i,(n P t ω i-β k Q t ω*B P t ω i+f k P Q t ω i))≤ q t ω) (N:ℕ):
    total w N (fun t ω=>ChangingDomains.variation (out hk P Q (t+1) ω (q (t+1) ω)) (out hk P Q t ω (q t ω)))≤
      total w N (fun t ω=>|q (t+1) ω-q t ω|)+
        movementConstant*ActualCaps.ell k*stock P Q N+endpointConstant*ActualCaps.ell k*k:=by
  have h:=total_mono hw (N:=N) (fun t ω=>all_movement hk P Q hs hq t ω (q t ω) (q (t+1) ω) (hp t ω) (hp (t+1) ω))
  simp only [total_add,total_mul] at h
  simp only [OutputDynamics.variation,ChangingDomains.variation] at h ⊢
  have hf:=fine_movement hk hw hw1 P Q hq N
  have ha:=simplex_movement hk hw hw1 P Q hs hq H hP hQ hr N
  have hb:=side_movement hk hw hw1 P Q hs hq H hP hQ hr N
  have hd:=scale_bound hw hw1 P Q hs N
  have hc:=switch_movement hk hw hw1 P Q hs hq H hP hQ hr N
  have hh:=wholesale_bound hw hw1 P Q hs N
  simp only [ChangingDomains.variation] at hf ha hb
  have hel:=ActualCaps.ell_ge_one hk
  have hst:=stock_nonneg hw P Q N
  have h1:=mul_nonneg (sub_nonneg.mpr hel) (mul_nonneg more_constants_nonneg.2.1 hst)
  have h2:=mul_nonneg (sub_nonneg.mpr hel) (mul_nonneg more_constants_nonneg.1 hst)
  have h3:=mul_nonneg (sub_nonneg.mpr hel) (mul_nonneg (add_nonneg zero_le_one ruleConstant_nonneg) hst)
  have h4:=mul_nonneg (sub_nonneg.mpr hel) (show 0≤ k by linarith)
  dsimp only [movementConstant,endpointConstant]
  nlinarith only [h,hf,ha,hb,hd,hc,hh,h1,h2,h3,h4]

lemma local_movement {k:ℝ} (hk:1≤ k) (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1)
    (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (hq:∀ t ω,size Q t ω≤ k)
    (H:ℕ→Ω→ℕ) (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (q:ℕ→Ω→ℝ)
    (hp:∀ t ω,(∑ i,(n P t ω i-β k Q t ω*B P t ω i+f k P Q t ω i))≤ q t ω) (N:ℕ):
    total w N (fun t ω=>ChangingDomains.variation (out hk P Q (t+1) ω (q (t+1) ω)) (out hk P Q t ω (q t ω)))≤
      total w N (fun t ω=>|q (t+1) ω-q t ω|)+
        localConstant*ActualCaps.ell k*(drift (flat P) N+drift Q N+(Fintype.card (J×R):ℝ)+Fintype.card R+k):=by
  have h:=output_movement hk hw hw1 P Q hs hq H hP hQ hr q hp N
  have hs0:=stock_nonneg hw P Q N
  have hek:=mul_nonneg (ActualCaps.ell_pos hk).le (show 0≤ k by linarith)
  have hes:=mul_nonneg (ActualCaps.ell_pos hk).le hs0
  have hm:=output_constants_nonneg.2.1
  have he:=output_constants_nonneg.2.2.1
  have hstock : drift (flat P) N+drift Q N+(Fintype.card (J×R):ℝ)+Fintype.card R+k=stock P Q N+k:=by
    dsimp only [stock,inventory]; ring
  rw [hstock]
  dsimp only [localConstant]
  nlinarith only [h,hes,hek,mul_nonneg hm hek,mul_nonneg he hes]
end KServer.ActualCharges

end


/-! The actual top-down allocation, summed over the fixed complete-prefix
hierarchy. All initialization costs depend only on the fixed label inventory. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HierarchicalQuota
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking ActualCharges
variable {Ω A Y:Type} [Fintype Ω] [Fintype A] {k:ℕ} {w:Ω→ℝ}

lemma sum_snoc {d:ℕ} (f:(Fin (d+1)→A)→ℝ):
    (∑ word,f word)=∑ word:Fin d→A,∑ a:A,f (Fin.snoc word a):=by
  calc _ = ∑ p:A×(Fin d→A),f (Fin.snoc p.2 p.1):=
          (Fintype.sum_equiv (Fin.snocEquiv (fun _ : Fin (d+1)=>A)) _ _ (fun _=>rfl)).symm
       _ = _:=by rw [Fintype.sum_prod_type,sum_comm]

lemma total_sum {I:Type} [Fintype I] (w:Ω→ℝ) (N:ℕ) (f:I→ℕ→Ω→ℝ):
    total w N (fun t ω=>∑ i,f i t ω)=∑ i,total w N (f i):=by
  unfold total
  simp_rw [avg_sum]
  exact sum_comm

lemma drift_flat {R:Type} [Fintype R] (P:A→R→FilteredRanks w) (N:ℕ):
    drift (flat P) N=∑ a,drift (P a) N:=by
  unfold drift flat
  simp_rw [Fintype.sum_prod_type,avg_sum]
  rw [sum_comm]

variable (hw:∀ ω,0 ≤ w ω) (H:ℕ→Ω→ℕ)
variable (hr:∀ t ω ρ,H (t+1) ω=H (t+1) ρ→H t ω=H t ρ)
variable (maps:ℕ→Ω→ℕ→Y→A) (q:ℕ→Ω→Fin k→Y)

def nodeMove (hk:1 ≤ (k:ℝ)) {d:ℕ} (word:Fin d→A) (N:ℕ):ℝ:=
  total w N (fun t ω=>|quota hw H hr maps q hk d word (t+1) ω-quota hw H hr maps q hk d word t ω|)
def levelMove (hk:1 ≤ (k:ℝ)) (d N:ℕ):ℝ:=∑ word:Fin d→A,nodeMove hw H hr maps q hk word N
def levelDrift (d N:ℕ):ℝ:=∑ word:Fin d→A,drift (parent hw H hr maps q word) N

def levelInventory (A:Type) [Fintype A] (k d:ℕ):ℝ:=
  Fintype.card (Fin d→A)*((Fintype.card (A×Fin k):ℝ)+Fintype.card (Fin k)+(k:ℝ))

lemma levelMove_nonneg (hk:1 ≤ (k:ℝ)) (d N:ℕ):0 ≤ levelMove hw H hr maps q hk d N:=by
  unfold levelMove nodeMove total
  exact sum_nonneg fun _ _=>sum_nonneg fun _ _=>sum_nonneg fun ω _=>mul_nonneg (hw ω) (abs_nonneg _)
lemma levelDrift_nonneg (d N:ℕ):0 ≤ levelDrift hw H hr maps q d N:=by
  unfold levelDrift drift
  exact sum_nonneg fun _ _=>sum_nonneg fun _ _=>sum_nonneg fun ω _=>mul_nonneg (hw ω) (sum_nonneg fun _ _=>abs_nonneg _)
lemma levelMove_zero (hk:1 ≤ (k:ℝ)) (N:ℕ):levelMove hw H hr maps q hk 0 N=0:=by
  simp [levelMove,nodeMove,quota,total,avg]
lemma levelDrift_zero (N:ℕ):levelDrift hw H hr maps q 0 N=0:=by
  unfold levelDrift drift
  apply sum_eq_zero
  intro word _
  apply sum_eq_zero
  intro t _
  unfold avg
  apply sum_eq_zero
  intro ω _
  have he:∀ a:Fin k,(parent hw H hr maps q word a).p (t+1) ω=0:=fun a=>
    HierarchicalRanks.family_root hw H hr maps q word a (t+1) ω
  have hb:∀ a:Fin k,(parent hw H hr maps q word a).before (t+1) ω=0:=by
    intro a
    change PosteriorRanks.posterior w (H (t+1)) (PosteriorRanks.rank
      (fun ρ=>HierarchyCounts.count (maps t ρ) word (q t ρ)) a.val) ω=0
    have hz:PosteriorRanks.rank (fun ρ=>HierarchyCounts.count (maps t ρ) word (q t ρ)) a.val=fun _=>0:=by
      funext ρ
      simp only [PosteriorRanks.rank,HierarchyCounts.count_zero]
      exact ite_eq_right (by omega)
    rw [hz]
    simp [PosteriorRanks.posterior,PosteriorRanks.numerator]
  simp only [he,hb,sub_self,abs_zero,sum_const_zero,mul_zero]

lemma level_movement (hk:1 ≤ (k:ℝ)) (hw1:∑ ω,w ω=1) (hwpos:∀ ω,0<w ω) (d N:ℕ):
    levelMove hw H hr maps q hk (d+1) N ≤ levelMove hw H hr maps q hk d N+
      localConstant*ActualCaps.ell k*(levelDrift hw H hr maps q d N+
        levelDrift hw H hr maps q (d+1) N+levelInventory A k d):=by
  have h word:=local_movement hk hw hw1 (children hw H hr maps q word) (parent hw H hr maps q word)
    (sizes hw H hr maps q word hwpos) (size_bound hw H hr maps q word) H
    (fun _ _ _ _=>rfl) (fun _ _ _=>rfl) hr (quota hw H hr maps q hk d word)
    (fun t ω=>parent_budget hw H hr maps q hk word hwpos t ω _
      (quota_bounds hw H hr maps q hk hwpos d word t ω).1) N
  have hs:=sum_le_sum (s:=univ) (fun word _=>h word)
  simp only [ChangingDomains.variation,total_sum,←quota_snoc,drift_flat] at hs
  change (∑ word:Fin d→A,∑ a:A,nodeMove hw H hr maps q hk (Fin.snoc word a) N) ≤ _ at hs
  rw [←sum_snoc (fun word=>nodeMove hw H hr maps q hk word N)] at hs
  simp only [sum_add_distrib,←mul_sum] at hs
  change levelMove hw H hr maps q hk (d+1) N ≤ levelMove hw H hr maps q hk d N+_ at hs
  have he:(∑ word:Fin d→A,∑ a:A,drift (children hw H hr maps q word a) N)=levelDrift hw H hr maps q (d+1) N:=by
    rw [levelDrift,sum_snoc (fun word=>drift (parent hw H hr maps q word) N)]
    rfl
  rw [he] at hs
  simp only [sum_const,nsmul_eq_mul,card_univ] at hs
  convert hs using 1; simp only [levelDrift,levelInventory]; ring
end KServer.HierarchicalQuota

end


/-! Geometric absorption with the literal parent coefficient one. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HierarchicalQuota

lemma weighted_shift (r m:ℕ→ℝ) (hr:∀ d,0 ≤ r d) (hm:∀ d,0 ≤ m d)
    (hroot:m 0=0) (hhalf:∀ d,r (d+1) ≤ r d/2) (L:ℕ):
    (∑ d∈range L,r d*m d) ≤ (1/2:ℝ)*∑ d∈range L,r d*m (d+1):=by
  cases L with
  | zero=>simp
  | succ L=>
    rw [sum_range_succ',hroot,mul_zero,add_zero]
    calc _ ≤ ∑ d∈range L,(1/2:ℝ)*(r d*m (d+1)):=by
            apply sum_le_sum
            intro d _
            have h:=mul_le_mul_of_nonneg_right (hhalf d) (hm (d+1))
            linarith
         _ = (1/2:ℝ)*∑ d∈range L,r d*m (d+1):=by rw [mul_sum]
         _ ≤ (1/2:ℝ)*∑ d∈range (L+1),r d*m (d+1):=by
            apply mul_le_mul_of_nonneg_left _ (by norm_num)
            rw [sum_range_succ]
            exact le_add_of_nonneg_right (mul_nonneg (hr L) (hm (L+1)))

variable {Ω A Y:Type} [Fintype Ω] [Fintype A] {k:ℕ} {w:Ω→ℝ}
variable (hw:∀ ω,0 ≤ w ω) (H:ℕ→Ω→ℕ)
variable (hr:∀ t ω ρ,H (t+1) ω=H (t+1) ρ→H t ω=H t ρ)
variable (maps:ℕ→Ω→ℕ→Y→A) (q:ℕ→Ω→Fin k→Y)

open ActualCharges

def treeMove (hk:1 ≤ (k:ℝ)) (r:ℕ→ℝ) (L N:ℕ):ℝ:=
  ∑ d∈range L,r d*levelMove hw H hr maps q hk (d+1) N
def treeDrift (r:ℕ→ℝ) (L N:ℕ):ℝ:=
  ∑ d∈range L,r d*(levelDrift hw H hr maps q d N+levelDrift hw H hr maps q (d+1) N)
def treeInventory (A:Type) [Fintype A] (k:ℕ) (r:ℕ→ℝ) (L:ℕ):ℝ:=
  ∑ d∈range L,r d*levelInventory A k d
lemma treeInventory_nonneg (A:Type) [Fintype A] (k:ℕ) (r:ℕ→ℝ) (hr:∀ d,0 ≤ r d) (L:ℕ):
    0 ≤ treeInventory A k r L:=by
  unfold treeInventory levelInventory
  exact sum_nonneg fun d _=>mul_nonneg (hr d) (by positivity)

theorem allocation_absorption (hk:1 ≤ (k:ℝ)) (hw1:∑ ω,w ω=1) (hwpos:∀ ω,0<w ω)
    (r:ℕ→ℝ) (hrad:∀ d,0 ≤ r d) (hhalf:∀ d,r (d+1) ≤ r d/2) (L N:ℕ):
    treeMove hw H hr maps q hk r L N ≤
      2*localConstant*ActualCaps.ell k*(treeDrift hw H hr maps q r L N+treeInventory A k r L):=by
  have hp:=weighted_shift r (fun d=>levelMove hw H hr maps q hk d N) hrad
    (fun d=>levelMove_nonneg hw H hr maps q hk d N) (levelMove_zero hw H hr maps q hk N) hhalf L
  have he:(∑ d∈range L,r d*(localConstant*ActualCaps.ell k*
      (levelDrift hw H hr maps q d N+levelDrift hw H hr maps q (d+1) N+levelInventory A k d)))=
      localConstant*ActualCaps.ell k*(treeDrift hw H hr maps q r L N+treeInventory A k r L):=by
    unfold treeDrift treeInventory
    rw [←sum_add_distrib,mul_sum]
    apply sum_congr rfl
    intro d _
    ring
  have hs':treeMove hw H hr maps q hk r L N ≤      (∑ d∈range L,r d*levelMove hw H hr maps q hk d N)+      localConstant*ActualCaps.ell k*(treeDrift hw H hr maps q r L N+treeInventory A k r L):=by    have hh:=sum_le_sum (s:=range L) (fun d _=>      mul_le_mul_of_nonneg_left (level_movement hw H hr maps q hk hw1 hwpos d N) (hrad d))    simp only [mul_add,sum_add_distrib] at hh
    rw [←he]
    simpa only [mul_add,sum_add_distrib,treeMove] using hh
  change _ ≤ (1/2:ℝ)*treeMove hw H hr maps q hk r L N at hp
  linarith
end KServer.HierarchicalQuota

end


/-! Conditional-drift coupling for literal fixed-prefix occupancies. The
right side is movement of the hidden labeled configurations, not observation
noise or a hypothesized allocation cost. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HierarchicalQuota
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking ActualCharges HierarchyCounts

lemma histogram_distance {I B:Type} [Fintype I] [Fintype B] [DecidableEq B] (f g:I→B):
    (∑ b:B,|(∑ i:I,if f i=b then (1:ℝ) else 0)-(∑ i:I,if g i=b then (1:ℝ) else 0)|) ≤
      2*∑ i:I,if f i=g i then (0:ℝ) else 1:=by
  calc _ ≤ ∑ b:B,∑ i:I,|((if f i=b then (1:ℝ) else 0)-(if g i=b then (1:ℝ) else 0))|:=by
            apply sum_le_sum
            intro b _
            rw [←sum_sub_distrib]
            exact abs_sum_le_sum_abs _ _
       _ = ∑ i:I,∑ b:B,|((if f i=b then (1:ℝ) else 0)-(if g i=b then (1:ℝ) else 0))|:=sum_comm
       _ = _:=by
            rw [mul_sum]
            apply sum_congr rfl
            intro i _
            by_cases h:f i=g i
            · simp [h]
            · have hp:∀ b:B,|((if f i=b then (1:ℝ) else 0)-(if g i=b then (1:ℝ) else 0))|=
                (if b=f i then 1 else 0)+(if b=g i then 1 else 0):=by
                intro b
                by_cases hf:b=f i <;> by_cases hg:b=g i
                · exact False.elim (h (hf.symm.trans hg))
                · simp [hf,Ne.symm h,h]
                · simp [hg,Ne.symm h,h]
                · simp [Ne.symm hf,Ne.symm hg,hf,hg]
              simp only [hp,sum_add_distrib]
              norm_num [h]

variable {Ω A Y:Type} [Fintype Ω] [Fintype A] {k:ℕ} {w:Ω→ℝ}
variable (hw:∀ ω,0 ≤ w ω) (H:ℕ→Ω→ℕ)
variable (hr:∀ t ω ρ,H (t+1) ω=H (t+1) ρ→H t ω=H t ρ)
variable (maps:ℕ→Ω→ℕ→Y→A) (q:ℕ→Ω→Fin k→Y)

def address (d:ℕ) (t:ℕ) (ω:Ω) (l:Fin k):Fin d→A:=fun i=>maps t ω i.val (q t ω l)
def prefixCross (d:ℕ) (t:ℕ) (ω:Ω):ℝ:=
  ∑ l:Fin k,if address maps q d (t+1) ω l=address maps q d t ω l then 0 else 1

def levelHidden (d N:ℕ):ℝ:=total w N (fun t ω=>∑ word:Fin d→A,
  |(count (maps (t+1) ω) word (q (t+1) ω):ℝ)-count (maps t ω) word (q t ω)|)

omit [Fintype Ω] [Fintype A] in
lemma count_histogram {d:ℕ} (word:Fin d→A) (t:ℕ) (ω:Ω):
    (count (maps t ω) word (q t ω):ℝ)=∑ l:Fin k,if address maps q d t ω l=word then (1:ℝ) else 0:=by
  simp only [count,card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero]
  apply sum_congr rfl
  intro l _
  have he:hit (maps t ω) word (q t ω l)↔address maps q d t ω l=word:=by
    exact ⟨fun h=>funext h,fun h i=>congrFun h i⟩
  simp only [he]

lemma level_drift_count (d N:ℕ):levelDrift hw H hr maps q d N ≤ levelHidden (w:=w) maps q d N:=by
  unfold levelDrift drift levelHidden total
  rw [sum_comm]
  apply sum_le_sum
  intro t _
  rw [avg_sum]
  apply sum_le_sum
  intro word _
  rw [avg_sum]
  exact PosteriorRanks.rankProcess_drift hw H hr
    (fun t ω=>count (maps t ω) word (q t ω)) (fun t ω=>count_le _ _ _) t

include hw in
lemma level_count_cross (d N:ℕ):levelHidden (w:=w) maps q d N ≤ 2*total w N (prefixCross maps q d):=by
  unfold levelHidden
  rw [←total_mul]
  apply total_mono hw
  intro t ω
  simp only [count_histogram maps q]
  unfold prefixCross
  exact (histogram_distance (I:=Fin k) (B:=Fin d→A) (address maps q d (t+1) ω) (address maps q d t ω))

omit [Fintype Ω] [Fintype A] in
lemma prefixCross_nonneg (d t:ℕ) (ω:Ω):0 ≤ prefixCross maps q d t ω:=by
  unfold prefixCross
  exact sum_nonneg fun _ _=>by split_ifs <;> norm_num

end KServer.HierarchicalQuota

end

end OAI