lean/OAI/Combinatorics/KServer/AllocationCausality.lean

import Mathlib
import OAI.Combinatorics.KServer.AllocationMovement
import OAI.Combinatorics.KServer.Hierarchy

namespace OAI

/-! Hysteresis switch budget with signed filtering before every reset test.
The only costs are actual rank drifts, actual flag changes, held-scale
variation, and the new potential at literal wholesale resets. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.RuleSchedule
attribute [local instance] Classical.propDecidable
open RankTracking
variable {Ω R : Type} [Fintype Ω] [Fintype R] {w : Ω→ℝ}

def S (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool) (t : ℕ) (ω : Ω) : ℝ :=
  core (flags t ω) (fun r=>(P r).p t ω)

def potential (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (t : ℕ) (ω : Ω) : ℝ :=
  value (marked t ω) (run marked reset (S P flags) D t ω) (S P flags t ω) (D t ω)

def J (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (t : ℕ) (ω : Ω) : ℝ :=
  charge (marked (t+1) ω) (reset (t+1) ω) (run marked reset (S P flags) D t ω)
    (S P flags (t+1) ω) (D (t+1) ω)

def expense (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (t : ℕ) (ω : Ω) : ℝ :=
  (∑ r,if flags t ω r=flags (t+1) ω r then (0:ℝ) else 1)+|D (t+1) ω-D t ω|+
    if reset (t+1) ω then S P flags (t+1) ω+D (t+1) ω else 0

lemma S_nonneg (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool) (t : ℕ) (ω : Ω) :
    0≤S P flags t ω :=core_nonneg _ (fun r=>((P r).range t ω).1)

lemma editing (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (hD : ∀ t ω,0≤D t ω)
    (hm : ∀ t ω,reset (t+1) ω=false→marked (t+1) ω=marked t ω) (t : ℕ) (ω : Ω) :
    J P flags marked reset D t ω/2+potential P flags marked reset D (t+1) ω≤
      value (marked t ω) (run marked reset (S P flags) D t ω)
        (core (flags t ω) (fun r=>(P r).p (t+1) ω)) (D t ω)+expense P flags reset D t ω := by
  let old:=run marked reset (S P flags) D t ω
  have hmid:=value_nonneg (core_nonneg (flags t ω) (fun r=>((P r).range (t+1) ω).1))
    (hD t ω) (marked t ω) old
  cases he:reset (t+1) ω with
  | true=>
    have hv:=value_upper (S_nonneg P flags (t+1) ω) (hD (t+1) ω) (marked (t+1) ω)
      (run marked reset (S P flags) D (t+1) ω)
    have hf:0≤∑ r,if flags t ω r=flags (t+1) ω r then (0:ℝ) else 1:=
      sum_nonneg fun _ _=>by positivity
    simp only [J,charge,he,ite_true,zero_div,zero_add,potential,expense] at ⊢
    dsimp only [old] at hmid
    linarith [abs_nonneg (D (t+1) ω-D t ω)]
  | false=>
    have hc:=ordinary_credit (S P flags (t+1) ω) (D (t+1) ω) (marked (t+1) ω) old
    have hd:=data_change (marked t ω) old (flags t ω) (flags (t+1) ω)
      (fun r=>(P r).p (t+1) ω) (D:=D t ω) (E:=D (t+1) ω) (fun r=>(P r).range (t+1) ω)
    rw [hm t ω he] at hc
    change value (marked t ω) old (S P flags (t+1) ω) (D (t+1) ω) -
      value (marked t ω) old (core (flags t ω) (fun r=>(P r).p (t+1) ω)) (D t ω)≤_ at hd
    simp only [J,potential,run,he,expense,Bool.false_eq_true,ite_false,add_zero,hm t ω he]
    change charge (marked t ω) false old _ _/2+value (marked t ω)
      (step (marked t ω) false _ _ old) _ _≤_
    linarith

lemma run_adapted (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (H : ℕ→Ω→ℕ)
    (hH : ∀ r t ω,(P r).history t ω=H t ω)
    (href : ∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hf : ∀ t ω z,H t ω=H t z→flags t ω=flags t z)
    (hm : ∀ t ω z,H t ω=H t z→marked t ω=marked t z)
    (hr : ∀ t ω z,H t ω=H t z→ reset t ω=reset t z)
    (hD : ∀ t ω z,H t ω=H t z→D t ω=D t z) (t : ℕ) (ω z : Ω) (he:H t ω=H t z) :
    run marked reset (S P flags) D t ω=run marked reset (S P flags) D t z := by
  have hh s (hs:s≤t):H s ω=H s z:=StarSimplex.history_prefix H href hs he
  apply run_congr marked reset (S P flags) D t ω z
  · exact fun s hs=>hm s ω z (hh s hs)
  · exact fun s hs=>hr s ω z (hh s hs)
  · intro s hs
    unfold S
    rw [hf s ω z (hh s hs)]
    congr 1
    funext r
    exact (P r).adapted s ω z (by simpa only [hH] using hh s hs)
  · exact fun s hs=>hD s ω z (hh s hs)

lemma filtering_zero (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (H : ℕ→Ω→ℕ)
    (hH : ∀ r t ω,(P r).history t ω=H t ω)
    (href : ∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hf : ∀ t ω z,H t ω=H t z→flags t ω=flags t z)
    (hm : ∀ t ω z,H t ω=H t z→marked t ω=marked t z)
    (hr : ∀ t ω z,H t ω=H t z→ reset t ω=reset t z)
    (hD : ∀ t ω z,H t ω=H t z→D t ω=D t z) (t : ℕ) :
    avg w (fun ω=>value (marked t ω) (run marked reset (S P flags) D t ω)
      (core (flags t ω) (fun r=>(P r).before (t+1) ω)) (D t ω)-
      potential P flags marked reset D t ω)=0 := by
  simp_rw [potential,S,input_difference,avg_sum]
  apply sum_eq_zero
  intro r _
  apply filtering_affine (P r) t
  intro ω z he
  have hh:H t ω=H t z:=by simpa only [hH] using he
  dsimp only
  rw [hm t ω z hh,run_adapted P flags marked reset D H hH href hf hm hr hD t ω z hh,hf t ω z hh]

lemma payment_step (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (H : ℕ→Ω→ℕ)
    (hw : ∀ ω,0≤w ω) (hDn : ∀ t ω,0≤D t ω)
    (hreset : ∀ t ω,reset (t+1) ω=false→marked (t+1) ω=marked t ω)
    (hH : ∀ r t ω,(P r).history t ω=H t ω)
    (href : ∀ t ω z,H (t+1) ω=H (t+1) z→H t ω=H t z)
    (hf : ∀ t ω z,H t ω=H t z→flags t ω=flags t z)
    (hm : ∀ t ω z,H t ω=H t z→marked t ω=marked t z)
    (hr : ∀ t ω z,H t ω=H t z→ reset t ω=reset t z)
    (hD : ∀ t ω z,H t ω=H t z→D t ω=D t z) (t : ℕ) :
    avg w (J P flags marked reset D t)/2+avg w (potential P flags marked reset D (t+1))≤
      avg w (potential P flags marked reset D t)+
      (∑ r,avg w (fun ω=>|(P r).p (t+1) ω-(P r).before (t+1) ω|))+
      avg w (expense P flags reset D t) := by
  have hp (ω:Ω):J P flags marked reset D t ω/2+potential P flags marked reset D (t+1) ω≤
      value (marked t ω) (run marked reset (S P flags) D t ω)
        (core (flags t ω) (fun r=>(P r).before (t+1) ω)) (D t ω)+
      (∑ r,|(P r).p (t+1) ω-(P r).before (t+1) ω|)+expense P flags reset D t ω := by
    have he:=editing P flags marked reset D hDn hreset t ω
    have hd:=(le_abs_self _).trans (input_lipschitz (marked t ω)
      (run marked reset (S P flags) D t ω) (flags t ω)
      (fun r=>(P r).p (t+1) ω) (fun r=>(P r).before (t+1) ω) (D t ω))
    linarith
  have ha:=avg_mono hw hp
  simp only [avg_add,avg_sum] at ha
  have hdiv:avg w (fun ω=>J P flags marked reset D t ω/2)=avg w (J P flags marked reset D t)/2:=by
    simp only [avg,←mul_div_assoc,sum_div]
  rw [hdiv] at ha
  have hzero:=filtering_zero P flags marked reset D H hH href hf hm hr hD t
  rw [avg_sub] at hzero
  linarith

lemma payment (P : R→FilteredRanks w) (flags : ℕ→Ω→R→Bool)
    (marked reset : ℕ→Ω→Bool) (D : ℕ→Ω→ℝ) (H : ℕ→Ω→ℕ)
    (hw : ∀ ω,0≤w ω) (hDn : ∀ t ω,0≤D t ω)
    (hreset : ∀ t ω,reset (t+1) ω=false→ marked (t+1) ω=marked t ω)
    (hH : ∀ r t ω,(P r).history t ω=H t ω)
    (href : ∀ t ω z,H (t+1) ω=H (t+1) z→ H t ω=H t z)
    (hf : ∀ t ω z,H t ω=H t z→ flags t ω=flags t z)
    (hm : ∀ t ω z,H t ω=H t z→ marked t ω=marked t z)
    (hr : ∀ t ω z,H t ω=H t z→ reset t ω=reset t z)
    (hD : ∀ t ω z,H t ω=H t z→ D t ω=D t z) (n : ℕ) :
    (∑ t∈range n,avg w (J P flags marked reset D t))≤
      2*(avg w (potential P flags marked reset D 0)+
        (∑ t∈range n,∑ r,avg w (fun ω=>|(P r).p (t+1) ω-(P r).before (t+1) ω|))+
        ∑ t∈range n,avg w (expense P flags reset D t)) := by
  have hh:(∑ t∈range n,avg w (J P flags marked reset D t))/2+
      avg w (potential P flags marked reset D n)≤
      avg w (potential P flags marked reset D 0)+
        (∑ t∈range n,∑ r,avg w (fun ω=>|(P r).p (t+1) ω-(P r).before (t+1) ω|))+
        ∑ t∈range n,avg w (expense P flags reset D t) := by
    induction n with
    | zero=>simp
    | succ n ih=>
      simp only [sum_range_succ]
      have hp:=payment_step P flags marked reset D H hw hDn hreset hH href hf hm hr hD n
      linarith
  have hn:0≤avg w (potential P flags marked reset D n):=
    sum_nonneg fun ω _=>mul_nonneg (hw ω)
      (value_nonneg (S_nonneg P flags n ω) (hDn n ω) _ _)
  linarith

end KServer.RuleSchedule

end


/-! Predictability of the *actual* star schedule and regime, for the common
observation history. In particular none of the filtering coefficients uses
the new reset event. -/
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
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}

lemma key_adapted (Q:R→ FilteredRanks w) (H:ℕ→Ω→ℕ)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→ H t ω=H t z)
    (t:ℕ) (ω z:Ω) (he:H t ω=H t z):key Q t ω=key Q t z:=
  parent_adapted cutoff dp Q H hQ hr t ω z he
lemma b_adapted (k:ℝ) (Q:R→ FilteredRanks w) (H:ℕ→Ω→ℕ)
    (hQ:∀ r t ω,(Q r).history t ω=H t ω)
    (hr:∀ t ω z,H (t+1) ω=H (t+1) z→ H t ω=H t z)
    (t:ℕ) (ω z:Ω) (he:H t ω=H t z):b k Q t ω=b k Q t z:=by
  unfold b
  rw [key_adapted Q H hQ hr t ω z he]

section
variable (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (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)
include hP hQ hr
omit [Fintype J] in
lemma schedule_prefix (t:ℕ) (ω z:Ω) (he:H t ω=H t z):
    ScheduleCausality.PrefixEq t (vector cutoff ds P ω) (vector cutoff ds P z) ∧
    ScheduleCausality.PrefixEq t (fun s=> key Q s ω) (fun s=> key Q s z):=by
  constructor
  · exact fun s hs=> vector_adapted ds P H hP hr s ω z (StarSimplex.history_prefix H hr hs he)
  · exact fun s hs=> key_adapted Q H hQ hr s ω z (StarSimplex.history_prefix H hr hs he)
lemma mark_adapted (t:ℕ) (ω z:Ω) (he:H t ω=H t z):mark P Q t ω=mark P Q t z:=by
  have hd:=schedule_prefix P Q H hP hQ hr t ω z he
  exact congrArg EpochSchedule.dominant (ScheduleCausality.run_prefix _ _ _ _ t hd.1 hd.2)
lemma marked_adapted (t:ℕ) (ω z:Ω) (he:H t ω=H t z):marked P Q t ω=marked P Q t z:=
  congrArg Option.isSome (mark_adapted P Q H hP hQ hr t ω z he)
lemma reset_adapted (t:ℕ) (ω z:Ω) (he:H t ω=H t z):reset P Q t ω=reset P Q t z:=by
  have hd:=schedule_prefix P Q H hP hQ hr t ω z he
  have ht:t-1≤ t:=Nat.sub_le _ _
  simp only [reset,hd.1 t le_rfl,hd.1 (t-1) ht,hd.2 t le_rfl,hd.2 (t-1) ht,
    ScheduleCausality.run_prefix _ _ _ _ (t-1) (hd.1.mono ht) (hd.2.mono ht)]
lemma D_adapted (t:ℕ) (ω z:Ω) (he:H t ω=H t z):D P Q t ω=D P Q t z:=by
  have hm:=mark_adapted P Q H hP hQ hr t ω z he
  change (match mark P Q t ω with | none=>0 | some o=> StarSide.coarseFlex ds (P o) t ω)=
    (match mark P Q t z with | none=>0 | some o=> StarSide.coarseFlex ds (P o) t z)
  rw [hm]
  cases mark P Q t z with
  | none=> rfl
  | some o=> exact StarSide.coarseFlex_adapted ds (P o) H (hP o) t ω z he
end

def ruleFlags (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω) (ir:J×R):Bool:=CoreFlags.flag (P ir.1 ir.2) t ω
lemma rule_S (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω):
    RuleSchedule.S (fun ir:J×R=> P ir.1 ir.2) (ruleFlags P) t ω=S P t ω:=by
  simp only [RuleSchedule.S,RuleSchedule.core,ruleFlags,S,B,TrackedCaps.core,Fintype.sum_prod_type]
  rfl
omit [Fintype J] [Fintype R] in
lemma flags_adapted (P:J→ R→ FilteredRanks w) (H:ℕ→Ω→ℕ)
    (hP:∀ i r t ω,(P i r).history t ω=H t ω)
    (t:ℕ) (ω z:Ω) (he:H t ω=H t z):ruleFlags P t ω=ruleFlags P t z:=by
  funext ir
  exact CoreFlags.flag_adapted (P ir.1 ir.2) t (by rw [hP,hP,he])
lemma rule_adapted (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (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)
    (t:ℕ) (ω z:Ω) (he:H t ω=H t z):rule P Q t ω=rule P Q t z:=by
  have hh:=RuleSchedule.run_adapted (fun ir:J×R=> P ir.1 ir.2) (ruleFlags P)
    (marked P Q) (reset P Q) (D P Q) H (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) t ω z he
  have hs : RuleSchedule.S (fun ir:J×R=> P ir.1 ir.2) (ruleFlags P)=S P:=by
    funext s u
    exact rule_S P s u
  simpa only [hs,rule] using hh
end KServer.ActualOutput

end


/-! Uniform affine slope and endpoint bounds for the literal marked-side
family; logarithmic cancellation removes dependence on the number of children. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.SideProfile
attribute [local instance] Classical.propDecidable
open SideTracker SideFamilies
variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R]

lemma B_bound {cw ell b h a:ℝ} (hcw:0<cw) (hel:1≤ell) (hh:1≤h)
    (hb:0≤b) (hM:b+cw*h/ell≤5) (ha:a∈Set.Icc 0 16) :
    Bcoef 40 b (cw*h/ell) (Real.exp (1-h)/h) a≤3600/cw*ell := by
  have hp:0<ell:=lt_of_lt_of_le zero_lt_one hel
  have hz:0<Real.exp (1-h)/h:=div_pos (Real.exp_pos _) (lt_of_lt_of_le zero_lt_one hh)
  have ht:0≤cw*h/ell:=by positivity
  have hl:=side_log_bound hh (by norm_num : (0:ℝ)≤16) ha
  have hlog:Real.log (1+(16:ℝ))+2≤18 := by
    have h:=Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<1+16)
    linarith
  have hm:=mul_le_mul_of_nonneg_right hlog (le_trans zero_le_one hh)
  have h:=Bcoef_bound (by norm_num : (0:ℝ)≤40) hb hz ha.1 hcw hp
    (lt_of_lt_of_le zero_lt_one hh) rfl (show b+(cw*h/ell)/2≤5 by linarith)
    (show Real.log (1+a/(Real.exp (1-h)/h))≤18*h from hl.trans hm)
  norm_num at h
  exact h

omit [DecidableEq J] in
lemma coefficient_bound {cw ell b D:ℝ} (hcw:0<cw) (hel:1≤ell)
    (A:Finset J) (f:J→R→Bool) (h:J→ℝ) (hh:∀ i,1≤h i)
    (hb:0≤b) (hM:∀ i,b+cw*h i/ell≤5) (a:J→ℝ)
    (ha:a∈ChangingDomains.sideDomain A 16) (ir:J×R) :
    let d:=fromLog A f 16 b D cw ell h (by norm_num) hcw
      (lt_of_lt_of_le zero_lt_one hel) hh
    |(family 40).coefficient d a ir|≤3600/cw*ell := by
  intro d
  have hw:a ir.1∈Set.Icc 0 16:=⟨ha.1 _,(single_le_sum (fun i _=>ha.1 i) (mem_univ _)).trans ha.2.1⟩
  have hbnd:=B_bound hcw hel (hh ir.1) hb (hM ir.1) hw
  have hn:0≤Bcoef 40 b (cw*h ir.1/ell) (Real.exp (1-h ir.1)/h ir.1) (a ir.1):=
    (coefficients_nonneg (by norm_num) hb
      (by have he:=lt_of_lt_of_le zero_lt_one hel; have hi:=lt_of_lt_of_le zero_lt_one (hh ir.1); positivity)
      (div_pos (Real.exp_pos _) (lt_of_lt_of_le zero_lt_one (hh ir.1))) hw.1).2
  change |if f ir.1 ir.2 then -Bcoef 40 b (cw*h ir.1/ell) (Real.exp (1-h ir.1)/h ir.1) (a ir.1) else 0|≤_
  split_ifs
  · simpa only [abs_neg,abs_of_nonneg hn] using hbnd
  · simp only [abs_zero]
    positivity

omit [DecidableEq J] in
lemma endpoint {cw ell b D:ℝ} (hcw:0<cw) (hel:1≤ell)
    (A:Finset J) (f:J→R→Bool) (h:J→ℝ) (hh:∀ i,1≤h i)
    (hb:0≤b) (hM:∀ i,b+cw*h i/ell≤5) (hD:0≤D)
    (p:J×R→ℝ) (hp:∀ ir,0≤p ir) (a:J→ℝ)
    (ha:a∈ChangingDomains.sideDomain A 16) :
    let d:=fromLog A f 16 b D cw ell h (by norm_num) hcw
      (lt_of_lt_of_le zero_lt_one hel) hh
    |(family 40).value d p a|≤640*(1/cw+1)*ell*D+
      (3600/cw*ell)*(∑ i,core d p i) := by
  intro d
  have hB (i:J):0≤core d p i:=sum_nonneg fun r _=>by split_ifs; exact hp _; rfl
  have he (i:J):|primitive 40 b (cw*h i/ell) (Real.exp (1-h i)/h i) (core d p i) D (a i)|≤
      40*(1/cw+1)*ell*(D*a i)+(3600/cw*ell)*core d p i := by
    have hw:a i∈Set.Icc 0 16:=⟨ha.1 _,(single_le_sum (fun i _=>ha.1 i) (mem_univ _)).trans ha.2.1⟩
    have hz:0<Real.exp (1-h i)/h i:=div_pos (Real.exp_pos _) (lt_of_lt_of_le zero_lt_one (hh i))
    have hn:=coefficients_nonneg (by norm_num : (0:ℝ)≤40) hb
      (show 0<cw*h i/ell by have he:=lt_of_lt_of_le zero_lt_one hel; have hi:=lt_of_lt_of_le zero_lt_one (hh i); positivity) hz hw.1
    rw [primitive_coefficients]
    calc _≤|Dcoef 40 (cw*h i/ell) (Real.exp (1-h i)/h i) (a i)*D|+
        |Bcoef 40 b (cw*h i/ell) (Real.exp (1-h i)/h i) (a i)*core d p i|:=abs_sub _ _
         _=Dcoef 40 (cw*h i/ell) (Real.exp (1-h i)/h i) (a i)*D+
          Bcoef 40 b (cw*h i/ell) (Real.exp (1-h i)/h i) (a i)*core d p i := by
            rw [abs_of_nonneg (mul_nonneg hn.1 hD),abs_of_nonneg (mul_nonneg hn.2 (hB i))]
         _≤(40*(1/cw+1)*ell*a i)*D+(3600/cw*ell)*core d p i:=
          add_le_add (mul_le_mul_of_nonneg_right (Dcoef_bound (by norm_num) hz hw.1 hcw hel (hh i) rfl) hD)
            (mul_le_mul_of_nonneg_right (B_bound hcw hel (hh i) hb (hM i) hw) (hB i))
         _= _:=by ring
  rw [value_eq]
  change |∑ i,primitive 40 b (cw*h i/ell) (Real.exp (1-h i)/h i) (core d p i) D (a i)|≤_
  calc _≤∑ i,|primitive 40 b (cw*h i/ell) (Real.exp (1-h i)/h i) (core d p i) D (a i)|:=abs_sum_le_sum_abs _ _
       _≤∑ i,(40*(1/cw+1)*ell*(D*a i)+(3600/cw*ell)*core d p i):=sum_le_sum fun i _=>he i
       _=40*(1/cw+1)*ell*D*(∑ i,a i)+(3600/cw*ell)*(∑ i,core d p i):=by
          simp only [sum_add_distrib,←mul_sum]; ring
       _≤640*(1/cw+1)*ell*D+(3600/cw*ell)*(∑ i,core d p i):=by
          have hc:0≤40*(1/cw+1)*ell*D:=by positivity
          have hm:=mul_le_mul_of_nonneg_left ha.2.1 hc
          nlinarith

end KServer.SideProfile

end


/-! Literal synthetic-flag preparation and selective held-log parameter edits
for the marked-side minimizers of the constructed star. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.SideEdits
attribute [local instance] Classical.propDecidable
open SideTracker SideFamilies
variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R]

def L (cw ell:ℝ):ℝ:=640*(1/cw+1)*ell
def Q (cw ell:ℝ):ℝ:=200*(Real.log 17+2)/cw*ell
def K (cw ell:ℝ):ℝ:=2*(200*(1/cw+1)+200*(Real.log 17+2)/cw)*ell

lemma Q_nonneg {cw ell:ℝ} (hcw:0<cw) (hel:0≤ell):0≤Q cw ell:=by
  have hl:=Real.log_nonneg (by norm_num : (1:ℝ)≤17)
  unfold Q; positivity

lemma pre_edit {cw ell b D E:ℝ} (hcw:0<cw) (hel:1≤ell)
    (A B:Finset J) (f g:J→R→Bool) (h h':J→ℝ) (hh:∀ i,1≤h i) (hh':∀ i,1≤h' i)
    (hb:0≤b) (hM:∀ i,b+cw*h i/ell≤5)
    (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1)
    (hf:∀ i∉A,∀ r,f i r=false) (hg:∀ i∉B,∀ r,g i r=false)
    (a:J→ℝ) (ha:a∈ChangingDomains.sideDomain A 16) :
    let old:=fromLog A f 16 b D cw ell h (by norm_num) hcw (lt_of_lt_of_le zero_lt_one hel) hh
    let new:=fromLog B g 16 b E cw ell h' (by norm_num) hcw (lt_of_lt_of_le zero_lt_one hel) hh'
    |(family 40).value (prepareData old new) p a-(family 40).value old p a|≤
      L cw ell*|E-D|+Q cw ell*ChangingDomains.changedFlags f g := by
  intro old new
  have hi:=fromLog_input_bound (R:=R) f h (by norm_num : (0:ℝ)≤16) hcw hel hh
    (by norm_num : (0:ℝ)≤40) hb hM (D:=E) (D':=D)
    (B:=core (prepareData old new) p) (B':=core old p) ha
  have hs:ChangingDomains.variation (core (prepareData old new) p) (core old p)≤
      ChangingDomains.changedFlags f g:=by
    have he:=(ChangingDomains.synthetic_errors (fun i r=>hp (i,r)) hf hg).1
    change ChangingDomains.variation (ChangingDomains.core (ChangingDomains.syntheticFlags A B g) (fun i r=>p (i,r)))
      (ChangingDomains.core f (fun i r=>p (i,r)))≤_
    simpa only [ChangingDomains.variation,abs_sub_comm] using he
  have hm:=mul_le_mul_of_nonneg_left hs (Q_nonneg hcw (le_trans zero_le_one hel))
  rw [value_eq,value_eq]
  change |potential 40 b (fun i=>cw*h i/ell) (fun i=>Real.exp (1-h i)/h i)
    (core (prepareData old new) p) E a-potential 40 b (fun i=>cw*h i/ell) (fun i=>Real.exp (1-h i)/h i)
    (core old p) D a|≤_
  calc _≤40*(1/cw+1)*ell*16*|E-D|+
      40*5*(Real.log (1+16)+2)/cw*ell*ChangingDomains.variation (core (prepareData old new) p) (core old p):=hi
       _≤L cw ell*|E-D|+Q cw ell*ChangingDomains.changedFlags f g:=by
        norm_num only at *
        unfold L Q at *
        linarith

lemma post_edit {cw ell b D E:ℝ} (hcw:0<cw) (hel:1≤ell)
    (A B:Finset J) (f g:J→R→Bool) (h h':J→ℝ) (hh:∀ i,1≤h i) (hh':∀ i,1≤h' i)
    (hb:1≤b) (hM:∀ i,b+cw*h i/ell≤5) (hM':∀ i,b+cw*h' i/ell≤5) (hE:0≤E)
    (p:J×R→ℝ) (hp:∀ ir,0≤p ir)
    (a:J→ℝ) (ha:a∈ChangingDomains.sideDomain A 16) :
    let old:=fromLog A f 16 b D cw ell h (by norm_num) hcw (lt_of_lt_of_le zero_lt_one hel) hh
    let new:=fromLog B g 16 b E cw ell h' (by norm_num) hcw (lt_of_lt_of_le zero_lt_one hel) hh'
    let z:=SideFamilies.transport 40 old new p a
    |(family 40).value new p z-(family 40).value (prepareData old new) p z|≤
      K cw ell*(∑ i,if h i=h' i then 0 else core (prepareData old new) p i) := by
  intro old new z
  have hz:z∈ChangingDomains.sideDomain B 16:=SideFamilies.transport_mem 40 old new p a rfl
  have hprep:=SideFamilies.update_feasible (prepareData old new) (M:=5) hb hE
    (fun i _=>hM i) (by norm_num : 2*(5:ℝ)<16) p hp
    (fun i hi r=>by
      change i∉A at hi
      change (if i∈A∩B then g i r else false)=false
      simp only [mem_inter,hi,false_and,ite_false]) a ha
  norm_num only at hprep
  have hcap:∀ i,E*z i≤5*core (prepareData old new) p i:=by
    intro i
    by_cases hi:i∈B
    · have hm:=mul_le_mul_of_nonneg_right (hM i)
        (show 0≤core (prepareData old new) p i from sum_nonneg fun r _=>by split_ifs; exact hp _; rfl)
      have ht:=hprep.1 i
      change E*SideFamilies.prepare 40 old new p a i≤(b+cw*h i/ell)*core (prepareData old new) p i at ht
      change E*ChangingDomains.transposeSide B (SideFamilies.prepare 40 old new p a) i≤_
      simp only [ChangingDomains.transposeSide,ite_eq_left hi]
      exact ht.trans hm
    · have he:z i=0:=hz.2.2 i hi
      rw [he,mul_zero]
      exact mul_nonneg (by norm_num) (sum_nonneg fun r _=>by split_ifs; exact hp _; rfl)
  have hew:potential 40 b (fun i=>cw*h' i/ell) (fun i=>Real.exp (1-h' i)/h' i) (core new p) E z=
      potential 40 b (fun i=>cw*h' i/ell) (fun i=>Real.exp (1-h' i)/h' i) (core (prepareData old new) p) E z:=by
    apply sum_congr rfl
    intro i _
    by_cases hi:i∈A∩B
    · have hc:core new p i=core (prepareData old new) p i:=by
        unfold core
        simp only [new,old,fromLog,prepareData,ChangingDomains.syntheticFlags,ite_eq_left hi]
      rw [hc]
    · have hz0:z i=0:=by
        by_cases hiB:i∈B
        · have hiA:i∉A:=fun h=>hi (mem_inter.mpr ⟨h,hiB⟩)
          have hp0:(SideFamilies.prepare 40 old new p a) i=0:=
            (SideFamilies.prepare_mem 40 old new p a).2.2 i hiA
          change ChangingDomains.transposeSide B (SideFamilies.prepare 40 old new p a) i=0
          simp only [ChangingDomains.transposeSide,ite_eq_left hiB,hp0]
        · exact hz.2.2 i hiB
      simp only [hz0,primitive,zero_div,add_zero,Real.log_one,mul_zero,sub_zero ]
  have he:=SideFamilies.parameter_jump (by norm_num : (0:ℝ)≤16) hcw hel hh hh'
    (by norm_num : (0:ℝ)≤40) (show 0≤b by linarith) hE
    (fun i=>show 0≤core (prepareData old new) p i from sum_nonneg fun r _=>by split_ifs; exact hp _; rfl)
    hM hM' ⟨hz.1,hz.2.1⟩ hcap
  rw [value_eq,value_eq]
  change |potential 40 b (fun i=>cw*h' i/ell) (fun i=>Real.exp (1-h' i)/h' i) (core new p) E z-
    potential 40 b (fun i=>cw*h i/ell) (fun i=>Real.exp (1-h i)/h i) (core (prepareData old new) p) E z|≤_
  rw [hew]
  norm_num only at he
  convert he using 1
  dsimp [K]
  ring

end KServer.SideEdits

end


/-! Every side edit is charged to the literal rank-flag and coarse-coordinate
schedule. No cardinality factor or charge to an unchanged dominant child. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.SideActualEdits
attribute [local instance] Classical.propDecidable
open RankTracking RankFunctions CoarseProcess CoarseEpoch AllocationSchedule StarProfile StarSide
variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R]
variable {w:Ω→ℝ}

omit [DecidableEq J] in
lemma ordinary_key (x:ℕ→J→ℝ) (key:ℕ→K) (t:ℕ)
    (he:epoch x key t=epoch x key (t+1)) : key t=key (t+1):=by
  have hn:=(epoch_same_iff x key t).mp he
  exact Classical.not_not.mp ((not_or.mp hn).1)

lemma flags_supported (δ:ℝ) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) :
    ∀ i∉sides δ P key t ω,∀ r,sideFlags δ P key t ω i r=false:=by
  intro i hi r
  simp only [sideFlags,ite_eq_right hi]

lemma flags_marked {δ:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) (o i:J) (r:R)
    (ho:mark δ P key t ω=some o) :
    sideFlags δ P key t ω i r=if i=o then false else CoreFlags.flag (P i r) t ω := by
  by_cases hi:i=o
  · subst i
    simp [sideFlags,sides,ho]
  · by_cases hA:i∈activeSet (vector cutoff δ P ω t)
    · simp [sideFlags,sides,ho,hi,hA]
    · have hf:=StarProfile.flags_supported hδ hδu P t ω i hA r
      change CoreFlags.flag (P i r) t ω=false at hf
      simp [sideFlags,sides,ho,hA,hi,hf]

lemma flags_change {δ:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω)
    (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t=
      epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) :
    ChangingDomains.changedFlags (sideFlags δ P key t ω) (sideFlags δ P key (t+1) ω)≤
      ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) := by
  have hm:mark δ P key (t+1) ω=mark δ P key t ω:=ScheduleEdits.ordinary_mark _ _ _ he
  cases ho:mark δ P key t ω with
  | none=>
    have hn:sideFlags δ P key t ω=fun _ _=>false:=by funext i r; simp [sideFlags,sides,ho]
    have hn':sideFlags δ P key (t+1) ω=fun _ _=>false:=by funext i r; simp [sideFlags,sides,hm,ho]
    rw [hn,hn']
    simp only [ChangingDomains.changedFlags,ite_true,sum_const_zero]
    exact sum_nonneg fun _ _=>sum_nonneg fun _ _=>by positivity
  | some o=>
    apply sum_le_sum
    intro i _
    apply sum_le_sum
    intro r _
    rw [flags_marked hδ hδu P key t ω o i r ho,
      flags_marked hδ hδu P key (t+1) ω o i r (hm.trans ho)]
    by_cases hi:i=o
    · simp only [ite_eq_left hi,ite_true]
      split_ifs <;> norm_num
    · simp only [ite_eq_right hi,StarSimplex.flags]
      exact le_rfl

lemma prepared_core_bound {δ cw ell:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (hcw:0<cw) (hel:0<ell) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ)
    (t:ℕ) (ω:Ω) (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) (i:J) :
    let d:=input hcw hel δ P key b
    SideFamilies.core (SideFamilies.prepareData (d t ω).data (d (t+1) ω).data) p i≤
      40*vector cutoff δ P ω (t+1) i := by
  intro d
  apply le_trans _ (ScheduleEdits.raw_core_bound hδ hδu (P i) (t+1) ω (fun r=>p (i,r)) (fun r=>hp (i,r)))
  apply sum_le_sum
  intro r _
  change (if ChangingDomains.syntheticFlags (sides δ P key t ω) (sides δ P key (t+1) ω)
      (sideFlags δ P key (t+1) ω) i r then p (i,r) else 0)≤
      (if CoreFlags.flag (P i r) (t+1) ω then p (i,r) else 0)
  by_cases hf:CoreFlags.flag (P i r) (t+1) ω=true
  · simp only [ChangingDomains.syntheticFlags,sideFlags,hf]
    split_ifs <;> first | exact (hp (i,r)).1 | exact le_rfl
  · simp [ChangingDomains.syntheticFlags,sideFlags,hf]

lemma logs_charge {δ cw ell:ℝ} (hδ:0<δ) (hδu:δ≤1/1000)
    (hcw:0<cw) (hel:0<ell) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ)
    (t:ℕ) (ω:Ω) (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1)
    (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t=
      epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) :
    let d:=input hcw hel δ P key b
    (∑ i,if logs δ P key t ω i=logs δ P key (t+1) ω i then 0 else
      SideFamilies.core (SideFamilies.prepareData (d t ω).data (d (t+1) ω).data) p i)≤
      40*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) := by
  intro d
  rw [mul_sum]
  apply sum_le_sum
  intro i _
  have hn:0≤CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)):=
    charge_nonneg (active_valid _ _ _ _ _) (active_valid _ _ _ _ _)
  split_ifs with hlog
  · linarith
  · by_cases hi:mark δ P key t ω=some i
    · have hc:SideFamilies.core (SideFamilies.prepareData (d t ω).data (d (t+1) ω).data) p i=0:=by
        apply SideFamilies.prepared_core_zero
        change i∉sides δ P key t ω∩sides δ P key (t+1) ω
        simp [sides,hi]
      rw [hc]
      linarith
    · have hx:(active cutoff δ (P i) ω t).value≠(active cutoff δ (P i) ω (t+1)).value:=by
        intro hv
        exact hlog (congrArg (max 1) (ScheduleEdits.ordinary_weight δ _ _ t he i hi hv))
      rw [CoarseSchedule.charge,ite_eq_right hx]
      have hbnd:=prepared_core_bound hδ hδu hcw hel P key b t ω p hp i
      change _≤40*(active cutoff δ (P i) ω (t+1)).value at hbnd
      linarith [(active_valid cutoff δ (P i) ω t).1]

lemma theta_bound {δ 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)
    (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) (i:J) :
    cw*logs δ P key t ω i/(1+Real.log (k+1))≤1 := by
  have hel:0<1+Real.log (k+1):=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith
  apply (div_le_iff₀ hel).mpr
  have hh:=mul_le_mul_of_nonneg_left (logs_upper hδ hδu hk P key hs t ω i) hcw.le
  have hg:=mul_le_mul_of_nonneg_right hcwu hel.le
  nlinarith

end KServer.SideActualEdits

end


/-! The non-wholesale cap variation of the literal output. All endpoint
trackers are charged over all times before selecting the ordinary steps. -/
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:Ω→ℝ}

def capScale (k:ℝ) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (t:ℕ) (ω:Ω) (i:J):ℝ:=if mark P Q t ω=some i then 1+lb/ActualCaps.ell k else 1-lb/ActualCaps.ell k

lemma capScale_range {k:ℝ} (hk:1≤ k) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (t:ℕ) (ω:Ω) (i:J):capScale k P Q t ω i∈Set.Icc 0 2:=by
  have h:=(ActualCaps.scalar_errors hk).2
  dsimp only [capScale]
  split_ifs <;> constructor <;> linarith [h.1,h.2.1]

lemma cap_sum (k:ℝ) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω) (i:J):
    d k P Q t ω i=∑ r,FineCaps.capTerm (rho/ActualCaps.ell k) (ActualCaps.a k Q t ω)
      (capScale k P Q t ω i) (P i r) t ω:=by
  rw [←TrackedCaps.cap,TrackedCaps.cap_eq]
  simp only [d,n,flexcap,ActualCaps.flexCap,decide_eq_true_eq,capScale]

lemma cap_parameters_held (k:ℝ) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w)
    (t:ℕ) (ω:Ω) (he:reset P Q (t+1) ω=false) (i:J):
    ActualCaps.a k Q (t+1) ω=ActualCaps.a k Q t ω ∧
      capScale k P Q (t+1) ω i=capScale k P Q t ω i:=by
  have hm:=ordinary_mark P Q t ω he
  have hkey:=SideActualEdits.ordinary_key (vector cutoff ds P ω) (fun s=> key Q s ω) t
    ((reset_iff P Q t ω).mp he)
  constructor
  · change 100*(CoarseParameters.upperBeta k cutoff cb (ActualCaps.ell k) dp (key Q (t+1) ω)-3)=_
    rw [←hkey]
    rfl
  · simp only [capScale,hm]

lemma fine_step (k:ℝ) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):
    (if reset P Q (t+1) ω then 0 else variation (d k P Q (t+1) ω) (d k P Q t ω))≤
      ∑ ir:J×R,FineCaps.fineVariation (rho/ActualCaps.ell k) (ActualCaps.a k Q)
        (fun s z=> capScale k P Q s z ir.1) (fun s z=> reset P Q (s+1) z) (P ir.1 ir.2) t ω:=by
  cases he:reset P Q (t+1) ω with
  | true=> simp only [he,ite_true,FineCaps.fineVariation,sum_const_zero,le_refl]
  | false=>
    simp only [he,Bool.false_eq_true,ite_false,FineCaps.fineVariation,Fintype.sum_prod_type]
    apply sum_le_sum
    intro i _
    change |d k P Q (t+1) ω i-d k P Q t ω i|≤_
    rw [cap_sum,cap_sum,←sum_sub_distrib]
    exact abs_sum_le_sum_abs _ _

lemma fine_budget {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:ℕ):
    (∑ t∈range N,avg w (fun ω=> if reset P Q (t+1) ω then 0 else
      variation (d k P Q (t+1) ω) (d k P Q t ω)))≤
      2*(160/(rho/ActualCaps.ell k)+(CoreFlags.tolerance^2)⁻¹)*
        ((∑ t∈range N,avg w (fun ω=>∑ ir:J×R,|(P ir.1 ir.2).p (t+1) ω-(P ir.1 ir.2).before (t+1) ω|))+
          Fintype.card (J×R)):=by
  have hξ:0< rho/ActualCaps.ell k:=(ActualCaps.scalar_errors hk).1
  have hξh:rho/ActualCaps.ell k<1/2:=by
    have h1:=ActualCaps.ell_ge_one hk
    have hr:rho<1/2:=by norm_num [rho,lb,cb]
    apply (div_lt_iff₀ (ActualCaps.ell_pos hk)).mpr
    linarith
  have hh:=FineCaps.fine_cap_budget (J:=J×R) hw hw1 hξ hξh
    (fun _=> ActualCaps.a k Q) (fun ir s z=> capScale k P Q s z ir.1)
    (fun _ s z=> reset P Q (s+1) z)
    (fun _ s z=>(ActualCaps.ranges hk Q s z (hq s z)).2.1)
    (fun ir s z=> capScale_range hk P Q s z ir.1)
    (fun ir s z he=> cap_parameters_held k P Q s z he ir.1)
    (fun ir=> P ir.1 ir.2) N
  exact (sum_le_sum fun t _=> avg_mono hw (fine_step k P Q t)).trans hh

end KServer.ActualOutput

end


/-! Every coordinate of the actual feasible star output depends only on
observed history and on the supplied parent quota. -/
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
variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ}
variable (P:J→R→FilteredRanks w) (Q:R→FilteredRanks w) (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)
include hP hQ hr
lemma d_adapted (k:ℝ) (t:ℕ) (ω z:Ω) (he:H t ω=H t z):d k P Q t ω=d k P Q t z:=by
  have hk:=key_adapted Q H hQ hr t ω z he
  have ha:ActualCaps.a k Q t ω=ActualCaps.a k Q t z:=by
    change 100*(CoarseParameters.upperBeta k cutoff cb (ActualCaps.ell k) dp (key Q t ω)-3)=_
    rw [hk]; rfl
  have hm:=mark_adapted P Q H hP hQ hr t ω z he
  have hs i:capScale k P Q t ω i=capScale k P Q t z i:=by unfold capScale; rw [hm]
  funext i
  rw [cap_sum,cap_sum,ha,hs]
  exact TrackedCaps.cap_adapted (P i) _ _ _ t (fun r=>by rw [hP,hP,he])
lemma α_adapted (k:ℝ) (t:ℕ) (ω z:Ω) (he:H t ω=H t z):α k P Q t ω=α k P Q t z:=
  StarSimplex.proportion_adapted (δ:=ds) (by norm_num [ds]) (by norm_num [ds]) C (ActualCaps.ell k) ct
    P (key Q) H hP hr (key_adapted Q H hQ hr) t ω z he
lemma side_adapted {k:ℝ} (hk:1≤k) (t:ℕ) (ω z:Ω) (he:H t ω=H t z):side hk P Q t ω=side hk P Q t z:=
  StarSide.proportion_adapted positive.2.2.2.1 (ActualCaps.ell_pos hk) ds P (key Q) (b k Q)
    H hP hr (key_adapted Q H hQ hr) (b_adapted k Q H hQ hr) t ω z he
lemma out_adapted {k:ℝ} (hk:1≤k) (t:ℕ) (ω z:Ω) (he:H t ω=H t z) (q:ℝ):
    out hk P Q t ω q=out hk P Q t z q:=by
  have hd:=d_adapted P Q H hP hQ hr k t ω z he
  have ha:=α_adapted P Q H hP hQ hr k t ω z he
  have hside:=side_adapted P Q H hP hQ hr hk t ω z he
  have hD:=D_adapted P Q H hP hQ hr t ω z he
  have hm:=mark_adapted P Q H hP hQ hr t ω z he
  have hreg:=rule_adapted P Q H hP hQ hr t ω z he
  simp only [out,hm,hreg]
  cases hmz:mark P Q t z with
  | none=>simp only [outI,hd,ha]
  | some o=>
    cases hrz:rule P Q t z with
    | false=>simp only [Bool.false_eq_true,ite_false,outI,hd,ha]
    | true=>
      simp only [ite_true]
      funext i
      simp only [outII,sideOut,hd,hside,hD]
end KServer.ActualOutput

end


/-! The literal recursive allocation is adapted to the request filtration.
No adaptedness of the hidden offline configurations is asserted or required. -/
noncomputable section
namespace KServer.HierarchicalQuota
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)
lemma quota_adapted (hk:1≤(k:ℝ)) (d:ℕ) (word:Fin d→A) (t:ℕ) (ω ρ:Ω)
    (he:H t ω=H t ρ):quota hw H hr maps q hk d word t ω=quota hw H hr maps q hk d word t ρ:=by
  induction d with
  | zero=>rfl
  | succ d ih=>
    simp only [quota,ih]
    exact congrFun (ActualOutput.out_adapted (children hw H hr maps q (Fin.init word))
      (parent hw H hr maps q (Fin.init word)) H (fun _ _ _ _=>rfl) (fun _ _ _=>rfl)
      hr hk t ω ρ he _) _
end KServer.HierarchicalQuota

end

end OAI