| import Mathlib |
| import OAI.Combinatorics.KServer.AllocationMovement |
| import OAI.Combinatorics.KServer.Hierarchy |
| import OAI.Combinatorics.KServer.PartitionBudget |
|
|
| namespace OAI |
|
|
| /-! The posterior counting measure is built from labeled hidden positions. |
| Integrating adapted metric tests is exactly conditional expectation, and |
| prefix quota domination is relative to this measure, not an extra premise. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.PosteriorCounting |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking PosteriorRanks HierarchyCounts |
| variable {Ω Y A:Type} [Fintype Ω] [Fintype Y] [Fintype A] |
| variable {w:Ω→ℝ} (hw:∀ ω,0≤w ω) {k:ℕ} |
|
|
| def atoms (q:Fin k→Y) (y:Y):ℝ:=∑ l:Fin k,if q l=y then 1 else 0 |
|
|
| def measure (H:Ω→ℕ) (q:Ω→Fin k→Y) (ω:Ω) (y:Y):ℝ:= |
| posterior w H (fun ρ=>atoms (q ρ) y) ω |
|
|
| omit [Fintype Y] in |
| lemma atoms_nonneg (q:Fin k→Y) (y:Y):0≤atoms q y:=by |
| exact sum_nonneg fun _ _=>by split_ifs <;> norm_num |
|
|
| lemma atoms_total (q:Fin k→Y):(∑ y,atoms q y)=(k:ℝ):=by |
| unfold atoms |
| rw [sum_comm] |
| simp |
|
|
| include hw in |
| omit [Fintype Y] in |
| lemma measure_nonneg (H:Ω→ℕ) (q:Ω→Fin k→Y) (ω:Ω) (y:Y): |
| 0 ≤ measure (w:=w) H q ω y:=posterior_nonneg hw H (fun _=>atoms_nonneg _ _) ω |
|
|
| omit [Fintype Y] in |
| lemma measure_adapted (H:Ω→ℕ) (q:Ω→Fin k→Y) (y:Y): |
| Adapted H (fun ω=>measure (w:=w) H q ω y):=posterior_adapted w H _ |
|
|
| include hw in |
| lemma measure_total (H:Ω→ℕ) (q:Ω→Fin k→Y) (ω:Ω) (hω:0<w ω): |
| (∑ y,measure (w:=w) H q ω y)=(k:ℝ):=by |
| unfold measure |
| rw [←posterior_sum] |
| exact posterior_fiber_const ω (fun _ _=>atoms_total _) (positive_mass hw H ω hω).ne' |
|
|
| lemma atoms_integral (q:Fin k→Y) (f:Y→ℝ): |
| (∑ y,atoms q y*f y)=∑ l:Fin k,f (q l):=by |
| unfold atoms |
| simp only [sum_mul,ite_mul,one_mul,zero_mul] |
| rw [sum_comm] |
| simp |
|
|
| lemma conditional_integral (H:Ω→ℕ) (q:Ω→Fin k→Y) (ω:Ω) |
| (F:Ω→Y→ℝ) (hF:∀ ρ,H ρ=H ω→F ρ=F ω): |
| (∑ y,measure (w:=w) H q ω y*F ω y)= |
| posterior w H (fun ρ=>∑ l:Fin k,F ρ (q ρ l)) ω:=by |
| unfold measure |
| simp_rw [←posterior_mul] |
| rw [←posterior_sum] |
| unfold posterior numerator |
| congr 1 |
| apply sum_congr rfl |
| intro ρ hρ |
| dsimp only |
| rw [atoms_integral,hF ρ (mem_filter.mp hρ).2] |
|
|
| lemma conditional_mean (H:Ω→ℕ) (f:Ω→ℝ) (ω:Ω): |
| (∑ ρ,conditional w H ω ρ*f ρ)=posterior w H f ω:=by |
| unfold conditional posterior numerator |
| simp only [ite_mul,zero_mul,div_mul_eq_mul_div] |
| rw [←sum_filter,←sum_div] |
| rfl |
|
|
| omit [Fintype A] in |
| lemma prefix_mass (H:Ω→ℕ) (maps:Ω→ℕ→Y→A) (q:Ω→Fin k→Y) |
| {d:ℕ} (word:Fin d→A) (ω:Ω) (hm:∀ ρ,H ρ=H ω→maps ρ=maps ω): |
| (∑ y∈univ.filter (hit (maps ω) word),measure (w:=w) H q ω y)= |
| posterior w H (fun ρ=>(count (maps ρ) word (q ρ):ℝ)) ω:=by |
| unfold measure posterior numerator |
| rw [←sum_div] |
| congr 1 |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro ρ hρ |
| rw [←mul_sum] |
| congr 1 |
| have he:=hm ρ (mem_filter.mp hρ).2 |
| dsimp only |
| rw [he] |
| unfold atoms count |
| rw [sum_comm] |
| simp only [card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero] |
| apply sum_congr rfl |
| intro l _ |
| simp [eq_comm] |
|
|
| lemma size_prefix_bound (H:ℕ→Ω→ℕ) |
| (hr:∀ t ω ρ,H (t+1) ω=H (t+1) ρ→H t ω=H t ρ) |
| (maps:ℕ→Ω→ℕ→Y→A) (q:ℕ→Ω→Fin k→Y) |
| {d:ℕ} (word:Fin d→A) (t:ℕ) (ω:Ω) (hω:0<w ω) |
| (hm:∀ ρ,H t ρ=H t ω→maps t ρ=maps t ω): |
| HierarchicalRanks.size hw H hr maps q word t ω≤ |
| ∑ y∈univ.filter (hit (maps t ω) word),measure (w:=w) (H t) (q t) ω y:=by |
| rw [prefix_mass (H t) (maps t) (q t) word ω hm,HierarchicalRanks.size_eq] |
| rw [←conditional_mean] |
| exact (HierarchyCounts.compatible w hw (H t) ω hω (maps t) word (q t) |
| (z:=0) (by norm_num)).2.2 |
|
|
| end KServer.PosteriorCounting |
|
|
| end |
|
|
|
|
| /-! Removing null atoms preserves the literal conditional experiment. This |
| allows quota feasibility to be used only on positive posterior fibers. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.PositiveExperiment |
| open RankTracking PosteriorRanks |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| variable {Ω:Type} [Fintype Ω] |
|
|
| abbrev Support (w:Ω→ℝ):= {ω:Ω // 0<w ω} |
|
|
| def weight (w:Ω→ℝ):Support w→ℝ:=fun ω=>w ω.val |
|
|
| omit [Fintype Ω] in |
| lemma weight_pos (w:Ω→ℝ) (ω:Support w):0<weight w ω:=ω.property |
|
|
| lemma sum_support {w:Ω→ℝ} (hw:∀ ω,0≤w ω) (f:Ω→ℝ): |
| (∑ ω:Support w,weight w ω*f ω.val)=∑ ω,w ω*f ω:=by |
| have hh:=Fintype.sum_subtype_add_sum_subtype (fun ω=>0<w ω) (fun ω=>w ω*f ω) |
| have hz:(∑ ω:{ω:Ω // ¬0<w ω},w ω.val*f ω.val)=0:=by |
| apply sum_eq_zero |
| intro ω _ |
| have he:w ω.val=0:=le_antisymm (le_of_not_gt ω.property) (hw ω.val) |
| rw [he,zero_mul] |
| simpa only [hz,add_zero,weight] using hh |
|
|
| lemma weight_sum {w:Ω→ℝ} (hw:∀ ω,0≤w ω) (hw1:∑ ω,w ω=1): |
| (∑ ω:Support w,weight w ω)=1:=by |
| simpa only [mul_one] using (sum_support hw (fun _=>1)).trans (by simpa only [mul_one] using hw1) |
|
|
| lemma mass_support {w:Ω→ℝ} (hw:∀ ω,0≤w ω) (H:Ω→ℕ) (h:ℕ): |
| PosteriorRanks.mass (weight w) (fun ω=>H ω.val) h=PosteriorRanks.mass w H h:=by |
| simpa only [PosteriorRanks.mass,PosteriorRanks.fiber,sum_filter,mul_ite,mul_one,mul_zero] |
| using sum_support hw (fun ω=>if H ω=h then 1 else 0) |
|
|
| lemma numerator_support {w:Ω→ℝ} (hw:∀ ω,0≤w ω) (H:Ω→ℕ) (f:Ω→ℝ) (h:ℕ): |
| PosteriorRanks.numerator (weight w) (fun ω=>H ω.val) (fun ω=>f ω.val) h= |
| PosteriorRanks.numerator w H f h:=by |
| simpa only [PosteriorRanks.numerator,PosteriorRanks.fiber,sum_filter,mul_ite,mul_zero] |
| using sum_support hw (fun ω=>if H ω=h then f ω else 0) |
|
|
| lemma posterior_support {w:Ω→ℝ} (hw:∀ ω,0≤w ω) (H:Ω→ℕ) (f:Ω→ℝ) (ω:Support w): |
| posterior (weight w) (fun ρ=>H ρ.val) (fun ρ=>f ρ.val) ω=posterior w H f ω.val:=by |
| simp only [posterior,mass_support hw,numerator_support hw] |
|
|
| lemma measure_support {Y:Type} [Fintype Y] {k:ℕ} {w:Ω→ℝ} (hw:∀ ω,0≤w ω) |
| (H:Ω→ℕ) (q:Ω→Fin k→Y) (ω:Support w) (y:Y): |
| PosteriorCounting.measure (w:=weight w) (fun ρ=>H ρ.val) (fun ρ=>q ρ.val) ω y= |
| PosteriorCounting.measure (w:=w) H q ω.val y:= |
| posterior_support hw H (fun ρ=>PosteriorCounting.atoms (q ρ) y) ω |
|
|
| end KServer.PositiveExperiment |
|
|
| end |
|
|
|
|
| /-! The single positive finite joint request/tape experiment for every scale. |
| All maps use precisely the request history and the independent finite tapes. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.JointExperiment |
| open FiniteExperiment PartitionProbabilities RankTracking PosteriorRanks |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| variable {Y:Type} [MetricSpace Y] [Fintype Y] {k H L:ℕ} |
|
|
| instance (priority := 2000) levelTapeFintype (r:ℝ):Fintype (LevelKeys.Tape Y k H r):=by |
| letI (n:ℕ):DecidableEq (Fin n):=Classical.decEq _ |
| infer_instance |
|
|
| abbrev Tape (Y:Type) [MetricSpace Y] [Fintype Y] (k H L:ℕ) (r:Fin L→ℝ):= |
| (d:Fin L)→LevelKeys.Tape Y k H (r d) |
|
|
| def tapeWeight (r:Fin L→ℝ):Tape Y k H L r→ℝ:= |
| productWeight (fun d=>LevelLaw.weight (Y:=Y) (k:=k) (H:=H) (r d)) |
|
|
| lemma tapeWeight_sum {r:Fin L→ℝ} (hr:∀ d,0<r d): |
| (∑ a:Tape Y k H L r,tapeWeight r a)=1:=by |
| unfold tapeWeight |
| convert productWeight_sum (fun d=>LevelLaw.weight (Y:=Y) (k:=k) (H:=H) (r d)) |
| (fun d=>LevelLaw.weight_sum (Y:=Y) (k:=k) (H:=H) (hr d)) using 1 |
| congr 1 |
| ext x |
| simp only [mem_univ] |
|
|
| lemma tapeWeight_nonneg {r:Fin L→ℝ} (hr:∀ d,0<r d) (a:Tape Y k H L r): |
| 0≤tapeWeight r a:= |
| productWeight_nonneg (fun d b=>LevelLaw.weight_nonneg (Y:=Y) (k:=k) (H:=H) (hr d) b) a |
|
|
| def tapeLaw {r:Fin L→ℝ} (hr:∀ d,0<r d):FiniteDistribution (Tape Y k H L r):= |
| ⟨tapeWeight r,tapeWeight_nonneg hr,tapeWeight_sum hr⟩ |
|
|
| abbrev Raw (Y:Type) [MetricSpace Y] [Fintype Y] (k H L:ℕ) (r:Fin L→ℝ):= |
| (Fin H→Y)×Tape Y k H L r |
|
|
| variable (law:FiniteDistribution (Fin H→Y)) {r:Fin L→ℝ} (hr:∀ d,0<r d) |
|
|
| def rawWeight:Raw Y k H L r→ℝ:=FiniteExperiment.weight law (tapeLaw (Y:=Y) (k:=k) (H:=H) hr) |
| abbrev Atom:=PositiveExperiment.Support (rawWeight (k:=k) law hr) |
| def weight:Atom (k:=k) law hr→ℝ:=PositiveExperiment.weight (rawWeight law hr) |
|
|
| lemma raw_nonneg (ω:Raw Y k H L r):0≤rawWeight law hr ω:= |
| FiniteExperiment.weight_nonneg law (tapeLaw (Y:=Y) (k:=k) (H:=H) hr) ω |
| lemma weight_pos (ω:Atom (k:=k) law hr):0<weight law hr ω:=ω.property |
| lemma weight_nonneg (ω:Atom (k:=k) law hr):0≤weight law hr ω:=(weight_pos law hr ω).le |
| lemma weight_sum:(∑ ω:Atom (k:=k) law hr,weight law hr ω)=1:= |
| PositiveExperiment.weight_sum (raw_nonneg law hr) (FiniteExperiment.weight_sum law (tapeLaw (Y:=Y) (k:=k) (H:=H) hr)) |
|
|
| lemma avg_raw (f:Raw Y k H L r→ℝ): |
| avg (weight (k:=k) law hr) (fun ω=>f ω.val)=avg (rawWeight law hr) f:= |
| PositiveExperiment.sum_support (raw_nonneg law hr) f |
|
|
| lemma request_pos (ω:Atom (k:=k) law hr):0<law.val ω.val.1:=by |
| have hp:=weight_pos law hr ω |
| change 0<law.val ω.val.1*(tapeLaw (Y:=Y) (k:=k) (H:=H) hr).val ω.val.2 at hp |
| exact pos_of_mul_pos_left hp ((tapeLaw (Y:=Y) (k:=k) (H:=H) hr).property.1 ω.val.2) |
|
|
| lemma tape_pos (ω:Atom (k:=k) law hr):0<(tapeLaw (Y:=Y) (k:=k) (H:=H) hr).val ω.val.2:=by |
| have hp:=weight_pos law hr ω |
| change 0<law.val ω.val.1*(tapeLaw (Y:=Y) (k:=k) (H:=H) hr).val ω.val.2 at hp |
| exact pos_of_mul_pos_right hp (law.property.1 _) |
|
|
| def history (t:ℕ) (ω:Atom (k:=k) law hr):ℕ:=FiniteExperiment.history t ω.val |
|
|
| lemma history_refines (t:ℕ) (ω ρ:Atom (k:=k) law hr) |
| (h:history law hr (t+1) ω=history law hr (t+1) ρ): |
| history law hr t ω=history law hr t ρ:=FiniteExperiment.history_refines t ω.val ρ.val h |
|
|
| lemma history_eq (t:ℕ) (ω ρ:Atom (k:=k) law hr) |
| (h:history law hr t ω=history law hr t ρ): |
| ω.val.2=ρ.val.2 ∧ requestPrefix ω.val.1 t=requestPrefix ρ.val.1 t:= |
| (FiniteExperiment.history_eq_iff t ω.val ρ.val).mp h |
|
|
| variable [NeZero k] (s:Configuration k Y) |
|
|
| def hidden (t:ℕ) (ω:Atom (k:=k) law hr):Fin k→Y:=FiniteExperiment.hidden s ω.val.1 t |
|
|
| def maps (t:ℕ) (ω:Atom (k:=k) law hr) (d:ℕ) (y:Y):LevelKeys.Key Y k:= |
| if hd:d<L then LevelKeys.map s law (hr ⟨d,hd⟩).le ω.val.1 (ω.val.2 ⟨d,hd⟩) t y |
| else Sum.inr y |
|
|
| lemma maps_adapted (t:ℕ) (ω ρ:Atom (k:=k) law hr) |
| (h:history law hr t ω=history law hr t ρ):maps law hr s t ω=maps law hr s t ρ:=by |
| obtain ⟨ht,hp⟩:=history_eq law hr t ω ρ h |
| have hh:requestHistory t ω.val.1=requestHistory t ρ.val.1:= |
| (requestHistory_eq_iff _ _ _).mpr hp |
| funext d y |
| unfold maps |
| split_ifs with hd |
| · rw [ht] |
| exact KeysAdapted.map_adapted s law (hr ⟨d,hd⟩).le (ρ.val.2 ⟨d,hd⟩) t y _ _ hh |
| · rfl |
|
|
| lemma measure_eq (t:ℕ) (ω:Atom (k:=k) law hr) (y:Y): |
| PosteriorCounting.measure (w:=weight law hr) (history law hr t) (hidden law hr s t) ω y= |
| mu s law t ω.val.1 y:=by |
| change posterior (PositiveExperiment.weight (rawWeight law hr)) |
| (fun z=>FiniteExperiment.history t z.val) |
| (fun z=>PosteriorCounting.atoms (FiniteExperiment.hidden s z.val.1 t) y) ω=_ |
| rw [PositiveExperiment.posterior_support (raw_nonneg law hr) (FiniteExperiment.history t) |
| (fun z:Raw Y k H L r=>PosteriorCounting.atoms (FiniteExperiment.hidden s z.1 t) y) ω] |
| unfold rawWeight FiniteExperiment.mu |
| convert posterior_tape_irrelevant law (tapeLaw (Y:=Y) (k:=k) (H:=H) hr) t ω.val (tape_pos law hr ω).ne' (fun σ=>PosteriorCounting.atoms (FiniteExperiment.hidden s σ t) y) using 1 |
| simp only [FiniteExperiment.metricCount,PosteriorCounting.atoms] |
|
|
| omit [NeZero k] in |
| lemma request_history (t:Fin H) (ω ρ:Atom (k:=k) law hr) |
| (h:history law hr (t.val+1) ω=history law hr (t.val+1) ρ):ω.val.1 t=ρ.val.1 t:= |
| prefix_request t (history_eq law hr _ ω ρ h).2 |
|
|
| lemma hidden_covers (t:Fin H) (ω:Atom (k:=k) law hr): |
| ∃ i,hidden law hr s (t.val+1) ω i=ω.val.1 t:= |
| ⟨mover s ω.val.1 t,FiniteExperiment.hidden_covers s ω.val.1 t⟩ |
|
|
| omit [NeZero k] in |
| lemma scale_mean (d:Fin L) (f:(Fin H→Y)→LevelKeys.Tape Y k H (r d)→ℝ): |
| avg (weight (k:=k) law hr) (fun ω=>f ω.val.1 (ω.val.2 d))= |
| avg law.val (fun σ=>LevelRetirement.mean (r d) (f σ)):=by |
| rw [avg_raw law hr (fun ω:Raw Y k H L r=>f ω.1 (ω.2 d))] |
| unfold RankTracking.avg rawWeight FiniteExperiment.weight |
| rw [Fintype.sum_prod_type] |
| apply sum_congr rfl |
| intro σ _ |
| simp only [mul_assoc,←mul_sum] |
| congr 1 |
| unfold tapeLaw tapeWeight LevelRetirement.mean |
| convert FiniteTape.marginal (fun j=>LevelLaw.weight (r j)) |
| (fun j=>LevelLaw.weight_sum (hr j)) d (f σ) using 1 |
| congr 1 |
| ext x |
| simp only [mem_univ] |
|
|
| end KServer.JointExperiment |
|
|
| end |
|
|
|
|
| /-! The dependent permanent key alphabet is genuinely finite. -/ |
| noncomputable section |
| namespace KServer.LevelKeys |
| instance alphabetFintype {Y:Type*} [Fintype Y] (k:ℕ) (i:Structure k):Fintype (Alphabet Y k i):=by |
| cases i <;> dsimp only [Alphabet] <;> infer_instance |
| end KServer.LevelKeys |
|
|
| end |
|
|
|
|
| /-! Endpoint costs on the actual schedule are charged to active size, rather |
| than to all inactive fixed labels. This is needed for wholesale edits. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ScheduledEndpoint |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule |
| open SimplexFamilies |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w : Ω → ℝ} |
|
|
| lemma masked_value_bound (C ell : ℝ) (d : Data J R) (p : J×R→ℝ) (a : J→ℝ) {L:ℝ} |
| (hc : ∀ ir,|coefficient C ell d a ir|≤L) |
| (hp : ∀ ir,p ir∈Set.Icc 0 1) : |
| |(family C ell).value d p a|≤L*(∑ i,∑ r,if d.flags i r then (1:ℝ) else 0) := by |
| change |0+∑ ir,coefficient C ell d a ir*p ir|≤_ |
| rw [zero_add] |
| calc _≤∑ ir,|coefficient C ell d a ir*p ir|:= abs_sum_le_sum_abs _ _ |
| _≤∑ ir:J×R,L*(if d.flags ir.1 ir.2 then (1:ℝ) else 0) := by |
| apply sum_le_sum |
| intro ir _ |
| by_cases hf:d.flags ir.1 ir.2=true |
| · simp only [hf,ite_true,mul_one,abs_mul,abs_of_nonneg (hp ir).1] |
| exact (mul_le_mul_of_nonneg_left (hp ir).2 (abs_nonneg _)).trans (by simpa using hc ir) |
| · have hz:coefficient C ell d a ir=0 := by simp [coefficient,hf] |
| simp [hz,hf] |
| _= _ := by rw [←mul_sum,Fintype.sum_prod_type] |
|
|
| lemma actual_bound {δ C ct k : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) |
| (hC : 0≤C) (hct : 0≤ct) (hctu : ct*20002≤1) (hk : 1≤k) |
| (P : J→R→FilteredRanks w) (key : ℕ→Ω→K) |
| (hs : ∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) |
| (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) |
| (a:J→ℝ) (ha:a∈ChangingDomains.simplex (activeSet (vector cutoff δ P ω t))) : |
| |(family C (1+Real.log (k+1))).value |
| (StarSimplex.input hδ hδu C (1+Real.log (k+1)) ct P key t ω).data p a|≤ |
| 520*C*(1+Real.log (k+1))*EpochSchedule.total (vector cutoff δ P ω t) := by |
| have hel : 0≤1+Real.log (k+1) := by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith |
| have hL : 0≤13*C*(1+Real.log (k+1)) := by positivity |
| have hh:=masked_value_bound C (1+Real.log (k+1)) |
| (StarSimplex.input hδ hδu C (1+Real.log (k+1)) ct P key t ω).data p a |
| (ScheduledSlope.actual_bound hδ hδu hC hct hctu hk P key hs t ω a ha) hp |
| have hn:(∑ i,∑ r,if (StarSimplex.input hδ hδu C (1+Real.log (k+1)) ct P key t ω).data.flags i r |
| then (1:ℝ) else 0)≤40*EpochSchedule.total (vector cutoff δ P ω t) := by |
| simp only [StarSimplex.input,data_flags,StarSimplex.flags] |
| change (∑ i,TrackedCaps.count (P i) t ω)≤40*(∑ i,vector cutoff δ P ω t i) |
| rw [mul_sum] |
| exact sum_le_sum fun i _=>ScheduleEdits.count_bound hδ hδu (P i) t ω |
| calc _≤13*C*(1+Real.log (k+1))*(40*EpochSchedule.total (vector cutoff δ P ω t)) := |
| hh.trans (mul_le_mul_of_nonneg_left hn hL) |
| _= _ := by ring |
|
|
| end KServer.ScheduledEndpoint |
|
|
| end |
|
|
| end OAI |
|
|
