Download data/lean/OAI/Combinatorics/KServer/AllocationSchedule.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 49.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/AllocationSchedule.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/KServer/AllocationSchedule.lean
-
curl -L -o AllocationSchedule.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/AllocationSchedule.lean
49.6 kB
import Mathlib
import OAI.Combinatorics.KServer.Coarse
import OAI.Combinatorics.KServer.OutputDynamics
namespace OAI
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.AllocationSchedule
local instance (p : Prop) : Decidable p := Classical.propDecidable p
open EpochSchedule
variable {J K : Type} [Fintype J] [DecidableEq J]
/-- Active domain and literal held epoch mass, rather than a bound supplied to
an allocation interface. -/
def activeSet (x : J → ℝ) : Finset J := univ.filter fun i => 0<x i
def mass (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : ℝ := total (run x key t).reference
def sideHeld (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) : ℕ → ℝ :=
CoarseSide.held δ (CoarseSide.sideInput x key) (CoarseSide.epochReset x key)
def sideRatio (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : ℝ :=
sideHeld δ x key t/mass x key t
def weight (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) (i : J) : ℝ :=
if dominant (run x key t)=some i then sideRatio δ x key t
else HeldWeights.regular (mass x key t) (x t i)
omit [DecidableEq J] in
lemma mem_activeSet (x : J → ℝ) (i : J) : i∈activeSet x ↔ 0<x i := by simp [activeSet]
omit [DecidableEq J] in
lemma sum_activeSet {x : J → ℝ} (hx : ∀ i, 0 ≤ x i) : (∑ i∈activeSet x,x i)=total x := by
apply sum_subset (by simp [activeSet])
intro i _ hi
have hh : ¬0<x i := by simpa [activeSet] using hi
exact le_antisymm (le_of_not_gt hh) (hx i)
omit [DecidableEq J] in
lemma mass_nonneg (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
0 ≤ mass x key t := total_nonneg (run_valid x key hx t).1
omit [DecidableEq J] in
lemma mass_accuracy (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
(99/100:ℝ)*mass x key t ≤ total (x t) ∧ total (x t) ≤ (101/100:ℝ)*mass x key t :=
valid_total (run_valid x key hx t)
omit [DecidableEq J] in
lemma dominant_mass_pos {s : State J} {o : J} (ho : dominant s=some o) :
0<total s.reference := by
unfold dominant at ho
split_ifs at ho with h
exact h.choose_spec.1
omit [DecidableEq J] in
lemma marked_active (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o : J} (ho : dominant (run x key t)=some o) : o∈activeSet (x t) := by
rw [mem_activeSet]
have hA := dominant_mass_pos ho
have hm := dominant_large (run_valid x key hx t) ho
linarith
lemma side_eq_erase (x : J → ℝ) (s : State J) {o : J} (ho : dominant s=some o) :
CoarseSide.side x s=∑ i∈univ.erase o,x i := by
unfold CoarseSide.side
simp only [ho,Option.isSome_some,ite_true,Option.some.injEq]
rw [sum_ite]
simp only [sum_const_zero,zero_add]
congr 1
ext i
simp [eq_comm]
omit [DecidableEq J] in
lemma side_held_nonneg (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) : 0 ≤ sideHeld δ x key t :=
CoarseSide.held_nonneg δ _ _ (fun t => CoarseSide.side_nonneg (hx t) _) t
omit [DecidableEq J] in
lemma side_held_accuracy {δ : ℝ} (hδ : 0<δ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
CoarseSide.sideInput x key t ≤ (1+δ)*sideHeld δ x key t ∧
sideHeld δ x key t ≤ (1+δ)*CoarseSide.sideInput x key t :=
CoarseSide.held_accuracy hδ _ _ (fun t => CoarseSide.side_nonneg (hx t) _) t
omit [DecidableEq J] in
lemma side_ratio_nonneg (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) : 0 ≤ sideRatio δ x key t :=
div_nonneg (side_held_nonneg δ x key hx t) (mass_nonneg x key hx t)
lemma side_ratio_upper {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o : J} (ho : dominant (run x key t)=some o) : sideRatio δ x key t ≤ 1/4 := by
have hA := dominant_mass_pos ho
have hs := side_total (run_valid x key hx t) ho
have hU := (side_held_accuracy hδ x key hx t).2
change sideHeld δ x key t ≤ (1+δ)*CoarseSide.side (x t) (run x key t) at hU
rw [side_eq_erase _ _ ho] at hU
have he : (1+δ)*((16/100:ℝ)*mass x key t) ≤ mass x key t/4 := by
dsimp [mass]
nlinarith [mul_nonneg hA.le (show 0 ≤ 1/1000-δ by linarith)]
apply (div_le_iff₀ hA).mpr
exact (hU.trans (mul_le_mul_of_nonneg_left hs (by linarith))).trans (by simpa [mass,div_eq_mul_inv,mul_comm] using he)
omit [DecidableEq J] in
lemma side_zero_iff {δ : ℝ} (hδ : 0<δ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) {o : J} (ho : dominant (run x key t)=some o) :
sideRatio δ x key t=0 ↔ CoarseSide.sideInput x key t=0 := by
have hA := dominant_mass_pos ho
have hU := side_held_accuracy hδ x key hx t
have hN := side_held_nonneg δ x key hx t
have hT := CoarseSide.side_nonneg (hx t) (run x key t)
change 0 ≤ CoarseSide.sideInput x key t at hT
rw [sideRatio,div_eq_zero_iff]
have hm : mass x key t≠0 := ne_of_gt hA
simp only [hm,or_false]
constructor <;> intro hz
· rw [hz,mul_zero] at hU
exact le_antisymm hU.1 hT
· rw [hz,mul_zero] at hU
exact le_antisymm hU.2 hN
lemma marked_zero_singleton {δ : ℝ} (hδ : 0<δ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) {o : J} (ho : dominant (run x key t)=some o)
(hu : sideRatio δ x key t=0) : activeSet (x t)={o} := by
have hz := (side_zero_iff hδ x key hx t ho).mp hu
change CoarseSide.side (x t) (run x key t)=0 at hz
rw [side_eq_erase _ _ ho] at hz
ext i
simp only [mem_singleton]
constructor
· intro hi
by_contra hn
have hb := single_le_sum (fun j _ => hx t j) (show i∈univ.erase o by simp [hn])
rw [hz] at hb
exact (not_lt_of_ge hb) ((mem_activeSet _ _).mp hi)
· intro hi
subst i
exact marked_active x key hx t ho
/-- On the true active sides, held logarithmic weights satisfy the special
marked profile condition used in the decrement-gap argument. -/
lemma weight_side_lower {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o i : J} (ho : dominant (run x key t)=some o)
(hi : i∈activeSet (x t)) (hio : i≠o) (hu : 0<sideRatio δ x key t) :
(1/2:ℝ)*(1+Real.log (1/sideRatio δ x key t)) ≤ weight δ x key t i := by
have hA := dominant_mass_pos ho
have hf : dominant (run x key t)≠some i := by rw [ho]; simpa [eq_comm] using hio
rw [weight,ite_eq_right hf]
apply HeldWeights.side_lower hA ((mem_activeSet _ _).mp hi) hu (side_ratio_upper hδ hδu x key hx t ho)
have hb := single_le_sum (fun j _ => hx t j) (show i∈univ.erase o by simp [hio])
have hU := (side_held_accuracy hδ x key hx t).1
change CoarseSide.side (x t) (run x key t) ≤ (1+δ)*sideHeld δ x key t at hU
rw [side_eq_erase _ _ ho] at hU
have hN := side_held_nonneg δ x key hx t
have he : 2*sideRatio δ x key t*mass x key t=2*sideHeld δ x key t := by
unfold sideRatio
have hm : mass x key t≠0 := ne_of_gt hA
field_simp [hm]
change x t i ≤ 2*sideRatio δ x key t*mass x key t
rw [he]
nlinarith [mul_nonneg hN (show 0 ≤ 1-δ by linarith)]
end KServer.AllocationSchedule
namespace KServer.AllocationSchedule
local instance (p : Prop) : Decidable p := Classical.propDecidable p
open EpochSchedule
variable {J K : Type} [Fintype J] [DecidableEq J]
omit [DecidableEq J] in
lemma mass_upper (x : ℕ → J → ℝ) (key : ℕ → K) {b : ℝ}
(hb : ∀ t, total (x t) ≤ b) (t : ℕ) : mass x key t ≤ b := by
induction t with
| zero => exact hb 0
| succ t ih =>
change total (update _ _ _ _ _).reference ≤ b
unfold update
split_ifs
· exact hb (t+1)
· exact ih
lemma regular_weight (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) (i : J)
(hi : dominant (run x key t)≠some i) :
weight δ x key t i=HeldWeights.regular (mass x key t) (x t i) := ite_eq_right hi
lemma marked_weight (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) (i : J)
(hi : dominant (run x key t)=some i) :
weight δ x key t i=sideRatio δ x key t := ite_eq_left hi
lemma weight_regular_one (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) (i : J)
(hi : dominant (run x key t)≠some i) : 1 ≤ weight δ x key t i := by
rw [regular_weight δ x key t i hi]
exact HeldWeights.regular_one _ _
lemma weight_nonneg (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) (i : J) : 0 ≤ weight δ x key t i := by
unfold weight
split_ifs
· exact side_ratio_nonneg δ x key hx t
· exact (by norm_num : (0:ℝ) ≤ 1).trans (HeldWeights.regular_one _ _)
lemma weight_upper {δ k : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000) (hk : 1 ≤ k)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(hxk : ∀ t, total (x t) ≤ (11/10)*k)
(hfloor : ∀ t i, 0<x t i → (9/100000:ℝ) ≤ x t i) (t : ℕ) (i : J) :
weight δ x key t i ≤ 20002*(1+Real.log (k+1)) := by
have hl : 0 ≤ Real.log (k+1) := Real.log_nonneg (by linarith)
by_cases ho : dominant (run x key t)=some i
· rw [marked_weight δ x key t i ho]
linarith [side_ratio_upper hδ hδu x key hx t ho]
· rw [regular_weight δ x key t i ho]
by_cases hi : 0<x t i
· exact HeldWeights.regular_upper hk (mass_nonneg x key hx t) (mass_upper x key hxk t) (hfloor t i hi)
· have hz : x t i=0 := le_antisymm (le_of_not_gt hi) (hx t i)
simp only [HeldWeights.regular,hz,div_zero,Real.log_zero,max_self]
linarith
lemma regular_exp_sum (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) (hA : 0 < mass x key t)
(ho : dominant (run x key t)=none) :
(∑ i∈activeSet (x t),Real.exp (-weight δ x key t i)) ≤ 2 := by
have hw (i : J) : weight δ x key t i=HeldWeights.regular (mass x key t) (x t i) :=
regular_weight δ x key t i (by simp [ho])
simp_rw [hw]
apply HeldWeights.exp_sum _ hA (fun i hi => (mem_activeSet _ _).mp hi)
rw [sum_activeSet (hx t)]
exact (mass_accuracy x key hx t).2
lemma side_exp_sum {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o : J} (ho : dominant (run x key t)=some o) :
(∑ i∈(activeSet (x t)).erase o, Real.exp (-weight δ x key t i)) ≤ 2*sideRatio δ x key t := by
have hA := dominant_mass_pos ho
have he : (∑ i∈(activeSet (x t)).erase o, Real.exp (-weight δ x key t i))=
∑ i∈(activeSet (x t)).erase o, Real.exp (-HeldWeights.regular (mass x key t) (x t i)) := by
apply sum_congr rfl
intro i hi
rw [regular_weight δ x key t i (by rw [ho]; simpa [eq_comm] using (mem_erase.mp hi).1)]
rw [he]
apply HeldWeights.side_exp_sum _ hA (fun i hi => (mem_activeSet _ _).mp (mem_erase.mp hi).2)
have hs : (∑ i∈(activeSet (x t)).erase o,x t i) ≤ ∑ i∈univ.erase o,x t i :=
sum_le_sum_of_subset_of_nonneg (erase_subset_erase o (subset_univ _)) (fun i _ _ => hx t i)
have hU := (side_held_accuracy hδ x key hx t).1
change CoarseSide.side (x t) (run x key t) ≤ (1+δ)*sideHeld δ x key t at hU
rw [side_eq_erase _ _ ho] at hU
have hN := side_held_nonneg δ x key hx t
nlinarith [mul_nonneg hN (show 0 ≤ 1-δ by linarith)]
/-- Epoch labels record the actual wholesale test. -/
def epoch (x : ℕ → J → ℝ) (key : ℕ → K) : ℕ → ℕ
| 0 => 0
| t+1 => if CoarseSide.epochReset x key t then epoch x key t+1 else epoch x key t
omit [DecidableEq J] in
lemma epoch_same_iff (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) :
epoch x key t=epoch x key (t+1) ↔ ¬CoarseSide.epochReset x key t := by
classical
rw [epoch]
split_ifs <;> simp_all
variable {R : Type} [Fintype R]
/-- Empty and genuinely side-free marked domains have the source's zero
potential. The dummy regular kernel is never evaluated by that potential. -/
def zeroData (A : Finset J) (flags : J → R → Bool) : SimplexFamilies.Data J R :=
{ SimplexFamilies.regular A flags (fun _ => 1) (fun _ => 0) (fun _ => le_rfl) with zeroPotential := true }
def data {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000) (_C ell ct : ℝ)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(flags : ℕ → J → R → Bool) (t : ℕ) : SimplexFamilies.Data J R := by
classical
let A := activeSet (x t)
let h := weight δ x key t
exact if A.Nonempty then
match ho : dominant (run x key t) with
| none => SimplexFamilies.regular A (flags t) h (fun i => ct*h i/ell)
(fun i => weight_regular_one δ x key t i (by simp [ho]))
| some o => if hu : 0<sideRatio δ x key t then
SimplexFamilies.marked A (flags t) o h (fun i => ct*h i/ell) (sideRatio δ x key t) hu
(by linarith [side_ratio_upper hδ hδu x key hx t ho])
(fun i hi => weight_regular_one δ x key t i (by rw [ho]; simpa [eq_comm] using hi))
else zeroData A (flags t)
else zeroData A (flags t)
omit [Fintype R] in
lemma data_active {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000) (C ell ct : ℝ)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(flags : ℕ → J → R → Bool) (t : ℕ) :
(data hδ hδu C ell ct x key hx flags t).active=activeSet (x t) := by
unfold data
dsimp only
split
· split
· rfl
· split <;> rfl
· rfl
omit [Fintype R] in
lemma data_flags {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000) (C ell ct : ℝ)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(flags : ℕ → J → R → Bool) (t : ℕ) :
(data hδ hδu C ell ct x key hx flags t).flags=flags t := by
unfold data
dsimp only
split
· split
· rfl
· split <;> rfl
· rfl
end KServer.AllocationSchedule
end
/-! Binding the literal filtered-rank size schedule to the live child domain.
In particular no core or positive lower-envelope rank is silently discarded
when the coarse active state turns off. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.StarProfile
attribute [local instance] Classical.propDecidable Classical.decEq
open RankTracking RankFunctions CoarseProcess CoarseEpoch AllocationSchedule
variable {Ω J R : Type} [Fintype Ω] [Fintype J] [Fintype R] {w : Ω → ℝ}
def cutoff : ℝ := 1/10000
lemma live_iff {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : R → FilteredRanks w) (t : ℕ) (ω : Ω) :
0<(active cutoff δ P ω t).value ↔ (active cutoff δ P ω t).active=true := by
have hv:=active_valid cutoff δ P ω t
have ha:=active_accuracy (by norm_num [cutoff] : 0<cutoff) hδ hδu P ω t
constructor
· intro h
cases hh : (active cutoff δ P ω t).active with
| false => have hz:=hv.2 hh; linarith
| true => rfl
· intro h
obtain ⟨hl,_,hf⟩:=ha.1 h
have hc : 0<cutoff := by norm_num [cutoff]
nlinarith
lemma too_small_inactive {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : R → FilteredRanks w) {t : ℕ} {ω : Ω}
(hn : ¬0<(active cutoff δ P ω t).value) : size P t ω<10*cutoff := by
by_contra! h
have ha:=(active_accuracy (by norm_num [cutoff] : 0<cutoff) hδ hδu P ω t).2 h
exact hn ((live_iff hδ hδu P t ω).mpr ha)
lemma inactive_rank_cutoff {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : R → FilteredRanks w) {t : ℕ} {ω : Ω}
(hn : ¬0<(active cutoff δ P ω t).value) (r : R) : sstar<(P r).p t ω := by
have hs:=too_small_inactive hδ hδu P hn
by_contra! h
have hr:=CompatibleBounds.sizeRank_below_cutoff h
have ht : sizeRank ((P r).p t ω)≤ size P t ω :=
single_le_sum (fun a _=>sizeRank_nonneg ((P a).p t ω)) (mem_univ r)
norm_num [cutoff] at hs
linarith
lemma inactive_lower_zero {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : R → FilteredRanks w) {t : ℕ} {ω : Ω}
(hn : ¬0<(active cutoff δ P ω t).value) (z : ℝ) :
(∑ r,rank z ((P r).p t ω))=0 := by
exact sum_eq_zero fun r _=>rank_cutoff z (inactive_rank_cutoff hδ hδu P hn r).le
lemma inactive_flag_false {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : R → FilteredRanks w) {t : ℕ} {ω : Ω}
(hn : ¬0<(active cutoff δ P ω t).value) (r : R) : CoreFlags.flag (P r) t ω=false := by
cases hf : CoreFlags.flag (P r) t ω with
| false => rfl
| true =>
have hl:=inactive_rank_cutoff hδ hδu P hn r
have hu:=CoreFlags.core_upper (P r) hf
norm_num [sstar] at hl
linarith
omit [Fintype J] in
lemma vector_floor {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω) (i : J)
(hi : 0<vector cutoff δ P ω t i) : (9/100000:ℝ)≤vector cutoff δ P ω t i := by
have hl:=(live_iff hδ hδu (P i) t ω).mp hi
obtain ⟨hb,_,hc⟩:=(active_accuracy (by norm_num [cutoff] : 0<cutoff) hδ hδu (P i) ω t).1 hl
change (9/100000:ℝ)≤(active cutoff δ (P i) ω t).value
norm_num [cutoff] at hc
linarith
lemma vector_total {δ k : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω)
(hk : (∑ i,size (P i) t ω)≤k) :
EpochSchedule.total (vector cutoff δ P ω t)≤(11/10)*k := by
calc _ ≤ ∑ i,(11/10:ℝ)*size (P i) t ω :=
sum_le_sum fun i _=>value_bound (by norm_num [cutoff]) hδ hδu (P i) ω t
_ = (11/10:ℝ)*(∑ i,size (P i) t ω) := (mul_sum _ _ _).symm
_ ≤ _ := mul_le_mul_of_nonneg_left hk (by norm_num)
lemma flags_supported {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(P : J → R → FilteredRanks w) (t : ℕ) (ω : Ω)
(i : J) (hi : i∉activeSet (vector cutoff δ P ω t)) (r : R) :
CoreFlags.flag (P i r) t ω=false :=
inactive_flag_false hδ hδu (P i) (fun h=>hi ((mem_activeSet _ _).mpr h)) r
omit [Fintype J] in
lemma vector_adapted (δ : ℝ) (P : J → R → FilteredRanks w) (H : ℕ → Ω → ℕ)
(hH : ∀ i r t ω,(P i r).history t ω=H t ω)
(hr : ∀ t ω z,H (t+1) ω=H (t+1) z → H t ω=H t z)
(t : ℕ) (ω z : Ω) (he : H t ω=H t z) :
vector cutoff δ P ω t=vector cutoff δ P z t := by
funext i
exact congrArg CoarseSchedule.State.value (active_adapted cutoff δ (P i) H (hH i) hr t ω z he)
lemma parent_adapted (c δ : ℝ) (P : R → FilteredRanks w) (H : ℕ → Ω → ℕ)
(hH : ∀ r t ω,(P 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) : parent c δ P t ω=parent c δ P t z := by
induction t with
| zero => exact congrArg (max c) (estimate_adapted δ P H hH 0 ω z he)
| succ t ih =>
have hh:=estimate_adapted δ P H hH (t+1) ω z he
have hp:=ih (hr t ω z he)
change (if factorTest id δ (clipped c δ P (t+1) ω) (parent c δ P t ω)
then clipped c δ P (t+1) ω else parent c δ P t ω)=_
simp only [clipped,hh,hp]
rfl
end KServer.StarProfile
end
/-! Feasibility of the literal held-size scheduler's minimizing simplex law,
including empty and side-free marked epochs. Constants are uniform in degree. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ScheduledSimplex
attribute [local instance] Classical.propDecidable
open AllocationSchedule EpochSchedule SimplexFamilies AdaptiveAllocation
variable {J R K : Type} [Fintype J] [DecidableEq J] [Fintype R]
lemma singleton_feasible {o : J} {B a : J → ℝ}
(hB : ∀ i,i≠o → B i=0) (ha : a∈ChangingDomains.simplex {o}) (i : J) :
(∑ j,B j)*a i=B i := by
classical
have hs : (∑ j,B j)=B o := by
apply sum_eq_single o
· intro j _ hj; exact hB j hj
· intro h; exact (h (mem_univ o)).elim
rw [hs]
by_cases hi : i=o
· subst i
have hsum : (∑ j,a j)=a o := by
apply sum_eq_single o
· intro j _ hj; exact ha.2.2 j (by simpa using hj)
· intro h; exact (h (mem_univ o)).elim
have hh : a o=1 := by simpa only [hsum,singleton_nonempty,ite_true] using ha.2.1
rw [hh,mul_one]
· rw [ha.2.2 i (by simpa [eq_comm] using hi),mul_zero,hB i hi]
omit [DecidableEq J] in
lemma nonempty_mass (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i,0≤x t i) (t : ℕ) (hn : (activeSet (x t)).Nonempty) :
0 < mass x key t := by
classical
obtain ⟨i,hi⟩:=hn
have hp: 0<x t i := (mem_activeSet _ _).mp hi
have hs : x t i≤total (x t) := single_le_sum (fun j _=>hx t j) (mem_univ i)
have hU: total (x t)≤(101/100:ℝ)*mass x key t := (mass_accuracy x key hx t).2
linarith
lemma update_feasible {δ C ell ct : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(hC : 0<C) (hel : 0<ell) (hct : 0<ct) (hgap : 700<C*ct)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i,0≤x t i)
(flags : ℕ → J → R → Bool) (t : ℕ)
(hmax : ∀ i∈activeSet (x t),ct*weight δ x key t i/ell≤1)
(p : J × R → ℝ) (hp : ∀ ir,0≤p ir)
(hf : ∀ i∉activeSet (x t),∀ r,flags t i r=false)
(a : J → ℝ) (ha : a∈ChangingDomains.simplex (activeSet (x t))) :
let d:=data hδ hδu C ell ct x key hx flags t
let B:=core d p
let a':=(family C ell).update d p (∑ i,B i) a
∀ i,(∑ j,B j)*a' i≤(1+ct*weight δ x key t i/ell)*B i := by
classical
intro d B a'
have hB : ∀ i,0≤B i := fun i=>ChangingDomains.core_nonneg (fun i r=>hp (i,r)) i
have hz : ∀ i∉activeSet (x t),B i=0 := by
intro i hi
simp only [B,core,d,data_flags,hf i hi,Bool.false_eq_true,ite_false,sum_const_zero]
have ha' : a'∈ChangingDomains.simplex (activeSet (x t)) := by
have h:=(family C ell).update_mem d p (∑ i,B i) a
change a'∈ChangingDomains.simplex d.active at h
simpa only [d,data_active] using h
by_cases hn : (activeSet (x t)).Nonempty
· cases ho : dominant (run x key t) with
| none =>
have hh : ∀ i,1≤weight δ x key t i := fun i=>
weight_regular_one δ x key t i (by simp [ho])
have hd : d=regular (activeSet (x t)) (flags t) (weight δ x key t)
(fun i=>ct*weight δ x key t i/ell) hh := by
unfold d data
dsimp only
rw [ite_eq_left hn]
split <;> simp_all
have ht:=regular_exp_sum δ x key hx t (nonempty_mass x key hx t hn) ho
have hg : 2*(25+32*(2:ℝ))*(1+1)<C*ct := by linarith
simpa only [a',B,hd] using regular_update_feasible hn (flags t) (weight δ x key t)
hh hC hel hct hmax (by norm_num : (0:ℝ)≤2) ht hg p hp hf a ha
| some o =>
by_cases hu : 0<sideRatio δ x key t
· have hh : ∀ i≠o,1≤weight δ x key t i := fun i hi=>
weight_regular_one δ x key t i (by rw [ho]; simpa [eq_comm] using hi)
have hum : sideRatio δ x key t≤1 := by linarith [side_ratio_upper hδ hδu x key hx t ho]
have hd : d=marked (activeSet (x t)) (flags t) o (weight δ x key t)
(fun i=>ct*weight δ x key t i/ell) (sideRatio δ x key t) hu hum hh := by
unfold d data
dsimp only
rw [ite_eq_left hn]
split <;> simp_all
have hg : 2*((25*(1/2:ℝ)+2+32*2)/(1/2))*(1+1)<C*ct := by linarith
simpa only [a',B,hd] using marked_update_feasible (marked_active x key hx t ho)
(flags t) (weight δ x key t) hu hum (marked_weight δ x key t o ho) hh
hC hel hct hmax (by norm_num : (0:ℝ)≤2) (by norm_num : (0:ℝ)<1/2)
(by norm_num : (1/2:ℝ)≤1)
(fun i hi hio=>weight_side_lower hδ hδu x key hx t ho hi hio hu)
(side_exp_sum hδ hδu x key hx t ho) hg p hp hf a ha
· have hu0 : sideRatio δ x key t=0 := le_antisymm (le_of_not_gt hu) (side_ratio_nonneg δ x key hx t)
have hA:=marked_zero_singleton hδ x key hx t ho hu0
intro i
have he:=singleton_feasible (fun j hj=>hz j (by simpa [hA] using hj)) (hA ▸ ha') i
rw [he]
have he0 : 0≤ct*weight δ x key t i/ell :=
div_nonneg (mul_nonneg hct.le (weight_nonneg δ x key hx t i)) hel.le
nlinarith [mul_nonneg he0 (hB i)]
· have he : activeSet (x t)=∅ := not_nonempty_iff_eq_empty.mp hn
have hzero : ∀ i,B i=0 := fun i=>hz i (by simp [he])
intro i
simp [hzero]
end KServer.ScheduledSimplex
end
/-! Actual true and held beta parameters. Their gaps follow from the true
parent/child size relation and the literal coarse epoch, not an output oracle. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ActualParameters
attribute [local instance] Classical.propDecidable
open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule
open CoarseParameters
variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R]
variable {w : Ω→ℝ}
omit [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] in
lemma log_bound {k M:ℝ} (hk:1≤k) (hM:M≤k) :
0≤Real.log (k/max M cutoff) ∧ Real.log (k/max M cutoff)≤10000*(1+Real.log (k+1)) := by
have hc:0<cutoff:=by norm_num [cutoff]
have hck:cutoff≤k:=by norm_num [cutoff]; linarith
have hm:0 < max M cutoff:=hc.trans_le (le_max_right _ _)
have hmk:max M cutoff≤k:=max_le hM hck
have hkn:0<k:=by linarith
have hl:0≤Real.log (k+1):=Real.log_nonneg (by linarith)
refine ⟨Real.log_nonneg ((one_le_div hm).mpr hmk),?_⟩
have hq:k/max M cutoff≤10000*(k+1) := by
apply (div_le_iff₀ hm).mpr
have h:=mul_le_mul_of_nonneg_left (le_max_right M cutoff) (show 0≤10000*(k+1) by positivity)
change 10000*(k+1)*(1/10000)≤10000*(k+1)*max M cutoff at h
linarith
have hs:=Real.log_le_log (div_pos hkn hm) hq
rw [Real.log_mul (by norm_num : (10000:ℝ)≠0) (by positivity : k+1≠0)] at hs
have hh:=Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<10000)
nlinarith
omit [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] in
lemma beta_bounds {k M cb:ℝ} (hk:1≤k) (hM:M≤k) (hcb:0≤cb) :
3≤beta k cutoff cb (1+Real.log (k+1)) M ∧
beta k cutoff cb (1+Real.log (k+1)) M≤3+10000*cb := by
have hel:0<1+Real.log (k+1):=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith
have h:=log_bound hk hM
have hfac:0≤cb/(1+Real.log (k+1)):=div_nonneg hcb hel.le
have hm:=mul_le_mul_of_nonneg_left h.2 hfac
have he:cb/(1+Real.log (k+1))*(10000*(1+Real.log (k+1)))=10000*cb:=by field_simp
rw [he] at hm
unfold beta
constructor
· linarith [mul_nonneg hfac h.1]
· linarith
lemma gap {δ k cb:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k) (hcb:0≤cb)
(P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (V:ℕ→Ω→ℝ)
(hV:∀ t ω,(∑ i,size (P i) t ω)≤V t ω) (t:ℕ) (ω:Ω) (i:J)
(hi:i∈activeSet (vector cutoff δ P ω t)) :
cb/20*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/(1+Real.log (k+1))≤
beta k cutoff cb (1+Real.log (k+1)) (size (P i) t ω)-
beta k cutoff cb (1+Real.log (k+1)) (V t ω) := by
let x:=vector cutoff δ P ω
let ky:=fun s=>key s ω
let M:=fun j=>size (P j) t ω
have hx:=vector_nonneg cutoff δ P ω
have hc:0<cutoff:=by norm_num [cutoff]
have hip:0<x t i:=(mem_activeSet _ _).mp hi
have ha:=(active_accuracy hc hδ hδu (P i) ω t).1 ((live_iff hδ hδu (P i) t ω).mp hip)
have hMi:0<M i:=hc.trans_le ha.2.2
have hMn:∀ j,0≤M j:=fun j=>size_nonneg (P j) t ω
have hMV:M i≤V t ω:=(single_le_sum (fun j _=>hMn j) (mem_univ i)).trans (hV t ω)
have hupper:∀ j,x t j≤(11/10)*M j:=fun j=>value_bound hc hδ hδu (P j) ω t
have hel:0<1+Real.log (k+1):=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith
rw [beta_difference (by linarith : 0<k) hc ha.2.2 hMV]
have hfac:0≤cb/(1+Real.log (k+1)):=div_nonneg hcb hel.le
have hg:(1/20:ℝ)*weight δ x ky t i≤Real.log (V t ω/M i) := by
by_cases ho:EpochSchedule.dominant (EpochSchedule.run x ky t)=some i
· rw [marked_weight δ x ky t i ho]
have hA:0 < mass x ky t:=ScheduledSimplex.nonempty_mass x ky hx t ⟨i,hi⟩
have hxi:x t i≤(101/100)*mass x ky t:=
(single_le_sum (fun j _=>hx t j) (mem_univ i)).trans (mass_accuracy x ky hx t).2
have hUn:0 ≤ sideHeld δ x ky t:=side_held_nonneg δ x ky hx t
have hUs:sideHeld δ x ky t≤(1001/1000)*((∑ j,x t j)-x t i) := by
have h:=(side_held_accuracy hδ x ky hx t).2
change sideHeld δ x ky t≤(1+δ)*CoarseSide.side (x t) (EpochSchedule.run x ky t) at h
rw [side_eq_erase _ _ ho,sum_erase_eq_sub (mem_univ i)] at h
have hn:0≤(∑ j,x t j)-x t i:=sub_nonneg.mpr (single_le_sum (fun j _=>hx t j) (mem_univ i))
nlinarith
exact dominant_gap hMn (hx t) hupper (hV t ω) i hMi hip ha.1 hA hxi hUn hUs
(side_ratio_upper hδ hδu x ky hx t ho)
· rw [regular_weight δ x ky t i ho]
have hs:=EpochSchedule.regular_small (EpochSchedule.run_valid x ky hx t) ho
change x t i≤(86/100:ℝ)*mass x ky t at hs
have hA:0 ≤ mass x ky t:=mass_nonneg x ky hx t
rw [HeldWeights.regular_eq hip (by linarith)]
exact regular_gap hMn (hx t) hupper (hV t ω) i hMi hip ha.1 (mass_accuracy x ky hx t).1 hs
have h:=mul_le_mul_of_nonneg_left hg hfac
calc _ = cb/(1+Real.log (k+1))*((1/20)*weight δ x ky t i) := by dsimp [x,ky]; ring
_ ≤ _ := h
omit [Fintype J] [DecidableEq J] in
lemma held_error {δ k cb:ℝ} (hδ:0<δ) (hk:1≤k) (hcb:0≤cb)
(Q:R→FilteredRanks w) (t:ℕ) (ω:Ω) :
beta k cutoff cb (1+Real.log (k+1)) (size Q t ω)≤
upperBeta k cutoff cb (1+Real.log (k+1)) δ (parent cutoff δ Q t ω) ∧
upperBeta k cutoff cb (1+Real.log (k+1)) δ (parent cutoff δ Q t ω)≤
beta k cutoff cb (1+Real.log (k+1)) (size Q t ω)+4*cb*δ/(1+Real.log (k+1)) := by
have hc:0<cutoff:=by norm_num [cutoff]
have hel:0<1+Real.log (k+1):=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith
have ha:=parent_accuracy hc.le hδ Q t ω
have h:=beta_upper_error (by linarith : 0<k) hc hcb hel hδ
(le_max_left cutoff (size Q t ω)) (parent_nonneg hc.le δ Q t ω) ha.1 ha.2
have he:max (max cutoff (size Q t ω)) cutoff=max cutoff (size Q t ω) := max_eq_left (le_max_left _ _)
simp only [beta] at h ⊢
rw [he] at h
simpa only [max_comm cutoff (size Q t ω)] using h
end KServer.ActualParameters
end
/-! Prefix causality of the literal epoch, mark, side-total, log-size and
simplex-data recurrences. These equalities use the real input prefix; there
is no reinitialization at a fictitious conditional prefix. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.ScheduleCausality
attribute [local instance] Classical.propDecidable
open AllocationSchedule EpochSchedule
variable {J K R : Type} [Fintype J] [DecidableEq J] [Fintype R]
def PrefixEq {A : Type*} (t : ℕ) (a b : ℕ → A) : Prop := ∀ s≤t,a s=b s
lemma PrefixEq.mono {A : Type*} {t s : ℕ} {a b : ℕ → A}
(h : PrefixEq t a b) (hs : s≤t) : PrefixEq s a b := fun j hj=>h j (hj.trans hs)
omit [DecidableEq J] in
lemma run_prefix (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : run x key t=run y key' t := by
induction t with
| zero => simp only [run,hx 0 le_rfl]
| succ t ih =>
have ht : t≤t+1 := Nat.le_succ t
simp only [run,hx t ht,hx (t+1) le_rfl,hk t ht,hk (t+1) le_rfl,
ih (hx.mono ht) (hk.mono ht)]
omit [DecidableEq J] in
lemma mass_prefix (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : mass x key t=mass y key' t :=
congrArg (fun s:State J=>total s.reference) (run_prefix x y key key' t hx hk)
omit [DecidableEq J] in
lemma side_prefix (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') :
CoarseSide.sideInput x key t=CoarseSide.sideInput y key' t := by
simp only [CoarseSide.sideInput,hx t le_rfl,run_prefix x y key key' t hx hk]
omit [DecidableEq J] in
lemma reset_prefix (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq (t+1) x y) (hk : PrefixEq (t+1) key key') :
CoarseSide.epochReset x key t=CoarseSide.epochReset y key' t := by
have ht : t≤t+1 := Nat.le_succ t
simp only [CoarseSide.epochReset,hx t ht,hx (t+1) le_rfl,hk t ht,hk (t+1) le_rfl,
run_prefix x y key key' t (hx.mono ht) (hk.mono ht)]
omit [DecidableEq J] in
lemma sideHeld_prefix (δ : ℝ) (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : sideHeld δ x key t=sideHeld δ y key' t := by
induction t with
| zero => exact side_prefix x y key key' 0 hx hk
| succ t ih =>
change (if CoarseSide.epochReset x key t ∨ RankTracking.factorTest id δ
(CoarseSide.sideInput x key (t+1)) (sideHeld δ x key t)
then CoarseSide.sideInput x key (t+1) else sideHeld δ x key t)=_
rw [reset_prefix x y key key' t hx hk,side_prefix x y key key' (t+1) hx hk,
ih (hx.mono (Nat.le_succ t)) (hk.mono (Nat.le_succ t))]
rfl
omit [DecidableEq J] in
lemma ratio_prefix (δ : ℝ) (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : sideRatio δ x key t=sideRatio δ y key' t := by
rw [sideRatio,sideRatio,sideHeld_prefix δ x y key key' t hx hk,mass_prefix x y key key' t hx hk]
lemma weight_prefix (δ : ℝ) (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : weight δ x key t=weight δ y key' t := by
funext i
simp only [weight,run_prefix x y key key' t hx hk,ratio_prefix δ x y key key' t hx hk,
hx t le_rfl,mass_prefix x y key key' t hx hk]
omit [DecidableEq J] in
lemma epoch_prefix (x y : ℕ → J → ℝ) (key key' : ℕ → K) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') : epoch x key t=epoch y key' t := by
induction t with
| zero => rfl
| succ t ih =>
simp only [epoch,reset_prefix x y key key' t hx hk,
ih (hx.mono (Nat.le_succ t)) (hk.mono (Nat.le_succ t))]
omit [Fintype R] in
lemma data_prefix {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(x y : ℕ → J → ℝ) (key key' : ℕ → K)
(hxn : ∀ t i,0≤x t i) (hyn : ∀ t i,0≤y t i)
(flags flags' : ℕ → J → R → Bool) (t : ℕ)
(hx : PrefixEq t x y) (hk : PrefixEq t key key') (hf : flags t=flags' t) :
data hδ hδu C ell ct x key hxn flags t=data hδ hδu C ell ct y key' hyn flags' t := by
have he:=run_prefix x y key key' t hx hk
have hw:=weight_prefix δ x y key key' t hx hk
have hu:=ratio_prefix δ x y key key' t hx hk
unfold data
dsimp only
congr 1
· exact congrArg (fun v=> (activeSet v).Nonempty) (hx t le_rfl)
· simp only [hx t le_rfl,hf,hw,hu]
have hd := congrArg dominant he
clear he
split
· rename_i hl
have hh : dominant (run y key' t)=none := hd.symm.trans hl
split
· rfl
· rename_i o hr
have hf := hh.symm.trans hr
cases hf
· rename_i o hl
have hh : dominant (run y key' t)=some o := hd.symm.trans hl
split
· rename_i hc
split
· rename_i hr
have hf := hh.symm.trans hr
cases hf
· rename_i j hr
have hj : o=j := Option.some.inj (hh.symm.trans hr)
subst j
rfl
· rename_i hc
split
· rename_i hr
have hf := hh.symm.trans hr
cases hf
· rfl
· simp only [hx t le_rfl,hf]
end KServer.ScheduleCausality
end
/-! The actual held-profile simplex proportion process, tied to the filtered
child ranks. Inactive coordinates are proved harmless, and feasibility holds
for its actual state at every time, including initialization and wholesale
restarts. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.StarSimplex
attribute [local instance] Classical.propDecidable
open RankTracking RankFunctions CoarseProcess CoarseEpoch
open AllocationSchedule StarProfile
variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R]
variable {w : Ω → ℝ}
def flags (P : J → R → FilteredRanks w) (ω : Ω) (t : ℕ) : J → R → Bool :=
fun i r=>CoreFlags.flag (P i r) t ω
def input {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) (t : ℕ) (ω : Ω) : CausalSimplex.Input J R :=
⟨data hδ hδu C ell ct (vector cutoff δ P ω) (fun s=>key s ω)
(vector_nonneg cutoff δ P ω) (flags P ω) t,
fun ir=>(P ir.1 ir.2).p t ω,
epoch (vector cutoff δ P ω) (fun s=>key s ω) t⟩
def proportion {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) : ℕ → Ω → J → ℝ :=
CausalSimplex.run C ell (input hδ hδu C ell ct P key)
lemma proportion_mem {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) (t : ℕ) (ω : Ω) :
proportion hδ hδu C ell ct P key t ω ∈ ChangingDomains.simplex (activeSet (vector cutoff δ P ω t)) := by
have h:=CausalSimplex.run_mem C ell (input hδ hδu C ell ct P key) t ω
simpa only [proportion,input,data_active] using h
lemma input_core {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) (t : ℕ) (ω : Ω) :
SimplexFamilies.core (input hδ hδu C ell ct P key t ω).data
(input hδ hδu C ell ct P key t ω).ranks =
fun i=>∑ r,if CoreFlags.flag (P i r) t ω then (P i r).p t ω else 0 := by
funext i
simp only [input,SimplexFamilies.core,data_flags,flags]
lemma feasible {δ C ct k : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000)
(hC : 0<C) (hct : 0<ct) (hctu : ct*20002≤1) (hgap : 700<C*ct) (hk : 1≤k)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K)
(hs : ∀ t ω,(∑ i,size (P i) t ω)≤k) (t : ℕ) (ω : Ω) :
let ell:=1+Real.log (k+1)
let B:=fun i=>∑ r,if CoreFlags.flag (P i r) t ω then (P i r).p t ω else 0
∀ i,(∑ j,B j)*proportion hδ hδu C ell ct P key t ω i ≤
(1+ct*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/ell)*B i := by
let ell:=1+Real.log (k+1)
let d:=input hδ hδu C ell ct P key
have hel : 0<ell := by
have h:=Real.log_nonneg (show 1≤k+1 by linarith)
dsimp [ell]; linarith
have hm (i:J) (_hi:i∈activeSet (vector cutoff δ P ω t)) :
ct*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/ell≤1 := by
apply (div_le_iff₀ hel).mpr
have h:=weight_upper hδ hδu hk (vector cutoff δ P ω) (fun s=>key s ω)
(vector_nonneg cutoff δ P ω) (fun s=>vector_total hδ hδu P s ω (hs s ω))
(fun s i hi=>vector_floor hδ hδu P s ω i hi) t i
have hmul:=mul_le_mul_of_nonneg_left h hct.le
have hmul2:=mul_le_mul_of_nonneg_right hctu hel.le
change _≤20002*ell at h
nlinarith
have hstep (a:J→ℝ) (ha:a∈ChangingDomains.simplex (activeSet (vector cutoff δ P ω t))) :=
ScheduledSimplex.update_feasible hδ hδu hC hel hct hgap
(vector cutoff δ P ω) (fun s=>key s ω) (vector_nonneg cutoff δ P ω)
(flags P ω) t hm (d t ω).ranks (fun ir=>(P ir.1 ir.2).range t ω|>.1)
(fun i hi r=>flags_supported hδ hδu P t ω i hi r) a ha
have hu (a:J→ℝ) (ha:a∈ChangingDomains.simplex (activeSet (vector cutoff δ P ω t))) :
∀ i,(∑ j,∑ r,if CoreFlags.flag (P j r) t ω then (P j r).p t ω else 0)*
(SimplexFamilies.family C ell).update (d t ω).data (d t ω).ranks
(CausalSimplex.mass (d t ω)) a i≤
(1+ct*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/ell)*
(∑ r,if CoreFlags.flag (P i r) t ω then (P i r).p t ω else 0) := by
simpa only [d,input,CausalSimplex.mass,SimplexFamilies.core,data_flags,flags] using hstep a ha
change ∀ i,(∑ j,∑ r,if CoreFlags.flag (P j r) t ω then (P j r).p t ω else 0)*
CausalSimplex.run C ell d t ω i≤
(1+ct*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/ell)*
(∑ r,if CoreFlags.flag (P i r) t ω then (P i r).p t ω else 0)
cases t with
| zero =>
rw [CausalSimplex.run_initial]
have hm : ChangingDomains.canonical (d 0 ω).data.active∈
ChangingDomains.simplex (activeSet (vector cutoff δ P ω 0)) := by
simpa only [d,input,data_active] using ChangingDomains.canonical_mem (d 0 ω).data.active
exact hu _ hm
| succ t =>
rw [CausalSimplex.run_successor]
have hm:=CausalSimplex.move_mem C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks
(CausalSimplex.run C ell d t ω)
have hm':CausalSimplex.move C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks
(CausalSimplex.run C ell d t ω)∈ChangingDomains.simplex (activeSet (vector cutoff δ P ω (t+1))) := by
simpa only [d,input,data_active] using hm
exact hu _ hm'
omit [Fintype Ω] in
lemma history_prefix (H : ℕ → Ω → ℕ)
(hr : ∀ t ω z,H (t+1) ω=H (t+1) z → H t ω=H t z)
{t s : ℕ} (hs : s≤t) {ω z : Ω} (he : H t ω=H t z) : H s ω=H s z := by
induction t with
| zero => exact (Nat.eq_zero_of_le_zero hs) ▸ he
| succ t ih =>
rcases Nat.eq_or_lt_of_le hs with h|h
· exact h ▸ he
· exact ih (Nat.le_of_lt_succ h) (hr t ω z he)
lemma input_adapted {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) (H:ℕ→Ω→ℕ)
(hH : ∀ i r t ω,(P i r).history t ω=H t ω)
(hr : ∀ t ω z,H (t+1) ω=H (t+1) z → H t ω=H t z)
(hkey:∀ t ω z,H t ω=H t z→key t ω=key t z) (t : ℕ) (ω z : Ω) (he:H t ω=H t z) :
input hδ hδu C ell ct P key t ω=input hδ hδu C ell ct P key t z := by
have hx:ScheduleCausality.PrefixEq t (vector cutoff δ P ω) (vector cutoff δ P z) :=
fun s hs=>vector_adapted δ P H hH hr s ω z (history_prefix H hr hs he)
have hk:ScheduleCausality.PrefixEq t (fun s=>key s ω) (fun s=>key s z) :=
fun s hs=>hkey s ω z (history_prefix H hr hs he)
have hh (i:J) (r:R):(P i r).history t ω=(P i r).history t z := by rw[hH,hH,he]
have hf:flags P ω t=flags P z t := by
funext i r
exact CoreFlags.flag_adapted (P i r) t (hh i r)
have hp:(fun ir:J×R=>(P ir.1 ir.2).p t ω)=(fun ir=>(P ir.1 ir.2).p t z) := by
funext ir
exact (P ir.1 ir.2).adapted t ω z (hh _ _)
unfold input
congr 1
· exact ScheduleCausality.data_prefix hδ hδu C ell ct _ _ _ _ _ _ _ _ t hx hk hf
· exact ScheduleCausality.epoch_prefix _ _ _ _ t hx hk
lemma proportion_adapted {δ : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) (C ell ct : ℝ)
(P : J → R → FilteredRanks w) (key : ℕ → Ω → K) (H:ℕ→Ω→ℕ)
(hH : ∀ i r t ω,(P i r).history t ω=H t ω)
(hr : ∀ t ω z,H (t+1) ω=H (t+1) z → H t ω=H t z)
(hkey:∀ t ω z,H t ω=H t z→key t ω=key t z) (t : ℕ) (ω z : Ω) (he:H t ω=H t z) :
proportion hδ hδu C ell ct P key t ω=proportion hδ hδu C ell ct P key t z :=
CausalSimplex.run_adapted C ell _ H hr (input_adapted hδ hδu C ell ct P key H hH hr hkey) t ω z he
end KServer.StarSimplex
end
/-! Literal causal side minimizers, including pre-minimization, zero deletion,
wholesale restart, and minimization on the new domain. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CausalSide
open AdaptiveMinimization SideFamilies
attribute [local instance] Classical.propDecidable Classical.decEq
variable {J R Ω : Type} [Fintype J] [Fintype R]
structure Input (J R : Type) where
data : SideFamilies.Data J R
ranks : J × R → ℝ
epoch : ℕ
def move (c : ℝ) (old new : Input J R) (p : J × R → ℝ) (a : J → ℝ) : J → ℝ :=
if old.epoch=new.epoch ∧ old.data.W=new.data.W then
SideFamilies.transport c old.data new.data p a else fun _=>0
omit [Fintype R] in
lemma zero_mem (d : SideFamilies.Data J R) :
(fun _=>0)∈ChangingDomains.sideDomain d.active d.W :=
⟨fun _=>le_rfl,by simpa using d.W_nonneg,fun _ _=>rfl⟩
lemma move_mem (c : ℝ) (old new : Input J R) (p : J × R → ℝ) (a : J → ℝ) :
move c old new p a∈ChangingDomains.sideDomain new.data.active new.data.W := by
unfold move
split_ifs with h
· exact SideFamilies.transport_mem c old.data new.data p a h.2
· exact zero_mem new.data
def model (c : ℝ) : Family (Input J R) (J × R) J where
domain d := ChangingDomains.sideDomain d.data.active d.data.W
compact _ := SideSupported.sideDomain_compact _ _
seed d := ⟨(SideFamilies.family c).update d.data d.ranks d.data.D (fun _=>0),
(SideFamilies.family c).update_mem _ _ _ _⟩
offset d := SideFamilies.offset c d.data
coefficient d := SideFamilies.coefficient c d.data
offset_continuous d := SideFamilies.offset_continuous c d.data
coefficient_continuous d := SideFamilies.coefficient_continuous c d.data
lemma model_value (c : ℝ) (d : Input J R) (p : J × R → ℝ) (a : J → ℝ) :
(model c).value d p a=(SideFamilies.family c).value d.data p a := rfl
lemma model_update (c : ℝ) (d : Input J R) (p : J × R → ℝ) (D : ℝ) (a : J → ℝ) :
(model c).update d p D a=(SideFamilies.family c).update d.data p D a := rfl
def transport (c : ℝ) : Transport (model (J:=J) (R:=R) c) where
map := move c
mem old new p a _ := move_mem c old new p a
def run (c : ℝ) (d : ℕ → Ω → Input J R) : ℕ → Ω → J → ℝ :=
state (model c) (transport c) d (fun t ω=>(d t ω).ranks) (fun t ω=>(d t ω).data.D)
lemma run_mem (c : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω) :
run c d t ω∈ChangingDomains.sideDomain (d t ω).data.active (d t ω).data.W :=
state_mem (model c) (transport c) d (fun t ω=>(d t ω).ranks)
(fun t ω=>(d t ω).data.D) t ω
lemma run_initial (c : ℝ) (d : ℕ → Ω → Input J R) (ω : Ω) :
run c d 0 ω=(SideFamilies.family c).update (d 0 ω).data (d 0 ω).ranks
(d 0 ω).data.D (fun _=>0) := rfl
lemma run_successor (c : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω) :
run c d (t+1) ω=(SideFamilies.family c).update (d (t+1) ω).data (d (t+1) ω).ranks
(d (t+1) ω).data.D (move c (d t ω) (d (t+1) ω) (d (t+1) ω).ranks (run c d t ω)) := rfl
lemma run_adapted (c : ℝ) (d : ℕ → Ω → Input J R) (H : ℕ → Ω → ℕ)
(href : ∀ t ω z,H (t+1) ω=H (t+1) z → H t ω=H t z)
(hd : ∀ t ω z,H t ω=H t z → d t ω=d t z) (t : ℕ) (ω z : Ω)
(he : H t ω=H t z) : run c d t ω=run c d t z :=
state_adapted _ _ _ _ _ H href hd
(fun t ω z h=>congrArg Input.ranks (hd t ω z h))
(fun t ω z h=>congrArg (fun d:Input J R=>d.data.D) (hd t ω z h)) t ω z he
lemma ordinary_successor (c : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω)
(he : (d t ω).epoch=(d (t+1) ω).epoch)
(hW : (d t ω).data.W=(d (t+1) ω).data.W) :
run c d (t+1) ω=SideFamilies.step c (d t ω).data (d (t+1) ω).data
(d (t+1) ω).ranks (run c d t ω) := by
rw [run_successor,move,ite_eq_left ⟨he,hW⟩]
rfl
lemma wholesale_successor (c : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω)
(he : (d t ω).epoch≠(d (t+1) ω).epoch) :
run c d (t+1) ω=(SideFamilies.family c).update (d (t+1) ω).data
(d (t+1) ω).ranks (d (t+1) ω).data.D (fun _=>0) := by
rw [run_successor,move,ite_eq_right (fun h=>he h.1)]
lemma run_feasible (d : ℕ → Ω → Input J R) {M : ℝ} (t : ℕ) (ω : Ω)
(hb : 1≤(d t ω).data.b) (hD : 0≤(d t ω).data.D)
(hM : ∀ i∈(d t ω).data.active,(d t ω).data.b+(d t ω).data.θ i≤M)
(hW : 2*M<(d t ω).data.W) (hp : ∀ ir,0≤(d t ω).ranks ir)
(hf : ∀ i∉(d t ω).data.active,∀ r,(d t ω).data.flags i r=false) :
(∀ i,(d t ω).data.D*run (8*M) d t ω i≤
((d t ω).data.b+(d t ω).data.θ i)*core (d t ω).data (d t ω).ranks i) ∧
((∑ i,core (d t ω).data (d t ω).ranks i)≤2*(d t ω).data.D → ∀ i,
(d t ω).data.b*core (d t ω).data (d t ω).ranks i-
(d t ω).data.θ i*(d t ω).data.z i*(d t ω).data.D≤(d t ω).data.D*run (8*M) d t ω i) := by
cases t with
| zero => exact update_feasible _ hb hD hM hW _ hp hf _ (zero_mem _)
| succ t => exact update_feasible _ hb hD hM hW _ hp hf _ (move_mem _ _ _ _ _)
lemma ordinary_payment (d : ℕ → Ω → Input J R) {M : ℝ} (t : ℕ) (ω : Ω)
(he : (d t ω).epoch=(d (t+1) ω).epoch)
(hWW : (d t ω).data.W=(d (t+1) ω).data.W)
(hb : 1≤(d t ω).data.b) (hD : 0≤(d (t+1) ω).data.D)
(hM : ∀ i∈(d t ω).data.active,(d t ω).data.b+(d t ω).data.θ i≤M)
(hW : 2*M<(d t ω).data.W) (hp : ∀ ir,0≤(d (t+1) ω).ranks ir) :
let old:=(d t ω).data
let new:=(d (t+1) ω).data
let p:=(d (t+1) ω).ranks
let a:=run (8*M) d t ω
new.D*ChangingDomains.variation (run (8*M) d (t+1) ω) a ≤
(SideFamilies.family (8*M)).value old p a-
(SideFamilies.family (8*M)).value new p (run (8*M) d (t+1) ω)+
|(SideFamilies.family (8*M)).value (prepareData old new) p a-
(SideFamilies.family (8*M)).value old p a|+
|(SideFamilies.family (8*M)).value new p (SideFamilies.transport (8*M) old new p a)-
(SideFamilies.family (8*M)).value (prepareData old new) p
(SideFamilies.transport (8*M) old new p a)| := by
dsimp only
rw [ordinary_successor _ _ _ _ he hWW]
exact step_payment _ _ hb hD hM hW _ hp _ (run_mem _ _ _ _) hWW
end KServer.CausalSide
end
end OAI
import Mathlib
import OAI.Combinatorics.KServer.Coarse
import OAI.Combinatorics.KServer.OutputDynamics
namespace OAI
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.AllocationSchedule
local instance (p : Prop) : Decidable p := Classical.propDecidable p
open EpochSchedule
variable {J K : Type} [Fintype J] [DecidableEq J]
/-- Active domain and literal held epoch mass, rather than a bound supplied to
an allocation interface. -/
def activeSet (x : J → ℝ) : Finset J := univ.filter fun i => 0<x i
def mass (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : ℝ := total (run x key t).reference
def sideHeld (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) : ℕ → ℝ :=
CoarseSide.held δ (CoarseSide.sideInput x key) (CoarseSide.epochReset x key)
def sideRatio (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) : ℝ :=
sideHeld δ x key t/mass x key t
def weight (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K) (t : ℕ) (i : J) : ℝ :=
if dominant (run x key t)=some i then sideRatio δ x key t
else HeldWeights.regular (mass x key t) (x t i)
omit [DecidableEq J] in
lemma mem_activeSet (x : J → ℝ) (i : J) : i∈activeSet x ↔ 0<x i := by simp [activeSet]
omit [DecidableEq J] in
lemma sum_activeSet {x : J → ℝ} (hx : ∀ i, 0 ≤ x i) : (∑ i∈activeSet x,x i)=total x := by
apply sum_subset (by simp [activeSet])
intro i _ hi
have hh : ¬0<x i := by simpa [activeSet] using hi
exact le_antisymm (le_of_not_gt hh) (hx i)
omit [DecidableEq J] in
lemma mass_nonneg (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
0 ≤ mass x key t := total_nonneg (run_valid x key hx t).1
omit [DecidableEq J] in
lemma mass_accuracy (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
(99/100:ℝ)*mass x key t ≤ total (x t) ∧ total (x t) ≤ (101/100:ℝ)*mass x key t :=
valid_total (run_valid x key hx t)
omit [DecidableEq J] in
lemma dominant_mass_pos {s : State J} {o : J} (ho : dominant s=some o) :
0<total s.reference := by
unfold dominant at ho
split_ifs at ho with h
exact h.choose_spec.1
omit [DecidableEq J] in
lemma marked_active (x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o : J} (ho : dominant (run x key t)=some o) : o∈activeSet (x t) := by
rw [mem_activeSet]
have hA := dominant_mass_pos ho
have hm := dominant_large (run_valid x key hx t) ho
linarith
lemma side_eq_erase (x : J → ℝ) (s : State J) {o : J} (ho : dominant s=some o) :
CoarseSide.side x s=∑ i∈univ.erase o,x i := by
unfold CoarseSide.side
simp only [ho,Option.isSome_some,ite_true,Option.some.injEq]
rw [sum_ite]
simp only [sum_const_zero,zero_add]
congr 1
ext i
simp [eq_comm]
omit [DecidableEq J] in
lemma side_held_nonneg (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) : 0 ≤ sideHeld δ x key t :=
CoarseSide.held_nonneg δ _ _ (fun t => CoarseSide.side_nonneg (hx t) _) t
omit [DecidableEq J] in
lemma side_held_accuracy {δ : ℝ} (hδ : 0<δ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) :
CoarseSide.sideInput x key t ≤ (1+δ)*sideHeld δ x key t ∧
sideHeld δ x key t ≤ (1+δ)*CoarseSide.sideInput x key t :=
CoarseSide.held_accuracy hδ _ _ (fun t => CoarseSide.side_nonneg (hx t) _) t
omit [DecidableEq J] in
lemma side_ratio_nonneg (δ : ℝ) (x : ℕ → J → ℝ) (key : ℕ → K)
(hx : ∀ t i, 0 ≤ x t i) (t : ℕ) : 0 ≤ sideRatio δ x key t :=
div_nonneg (side_held_nonneg δ x key hx t) (mass_nonneg x key hx t)
lemma side_ratio_upper {δ : ℝ} (hδ : 0<δ) (hδu : δ ≤ 1/1000)
(x : ℕ → J → ℝ) (key : ℕ → K) (hx : ∀ t i, 0 ≤ x t i)
(t : ℕ) {o : J} (ho : dominant (run x key t)=some o) : sideRatio δ x key t ≤ 1/4 := by
have hA := dominant_mass_pos ho
have hs := side_total (run_valid x key hx t) ho
have hU := (side_held_accuracy hδ x key hx t).2
change sideHeld δ x key t ≤ (1+δ)*CoarseSide.side (x t) (run x key t) at hU
rw [side_eq_erase _ _ ho] at hU
have he : (1+δ)*((16/100:ℝ)*mass x key t) ≤ mass x key t/4 := by