Download data/lean/OAI/Combinatorics/KServer/Coarse.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 63.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/Coarse.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/KServer/Coarse.lean
-
curl -L -o Coarse.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/Coarse.lean
63.2 kB
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
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)