| import Mathlib |
| import OAI.Combinatorics.KServer.AllocationCausality |
| import OAI.Combinatorics.KServer.JointExperiment |
|
|
| namespace OAI |
|
|
| /-! Exact structural identifications of the scheduled integral family and |
| bounds on the actual slack coefficients. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ScheduleShape |
| 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 eta_bound {δ ct k : ℝ} (hδ : 0<δ) (hδu : δ≤1/1000) |
| (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:ℕ) (ω:Ω) (i:J) : |
| ct*weight δ (vector cutoff δ P ω) (fun s=>key s ω) t i/(1+Real.log (k+1))∈Set.Icc 0 1 := by |
| have hel : 0<1+Real.log (k+1) := by have h:=Real.log_nonneg (show 1≤k+1 by linarith); linarith |
| constructor |
| · exact div_nonneg (mul_nonneg hct (weight_nonneg δ _ _ (vector_nonneg cutoff δ P ω) t i)) hel.le |
| · 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 |
| have hmul2:=mul_le_mul_of_nonneg_right hctu hel.le |
| nlinarith |
|
|
| omit [Fintype R] in |
| lemma regular_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:ℕ) |
| (hA:(activeSet (x t)).Nonempty) |
| (hn:EpochSchedule.dominant (EpochSchedule.run x key t)=none) |
| (hh:∀ i,1≤weight δ x key t i) : |
| data hδ hδu C ell ct x key hx flags t= |
| regular (activeSet (x t)) (flags t) (weight δ x key t) (fun i=>ct*weight δ x key t i/ell) hh := by |
| unfold data |
| dsimp only |
| rw [ite_eq_left hA] |
| split <;> simp_all |
|
|
| omit [Fintype R] in |
| lemma marked_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:ℕ) (o:J) |
| (ho:EpochSchedule.dominant (EpochSchedule.run x key t)=some o) |
| (hu:0<sideRatio δ x key t) (hu1:sideRatio δ x key t≤1) |
| (hh:∀ i≠o,1≤weight δ x key t i) : |
| data hδ hδu C ell ct x key hx flags t= |
| 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 hu1 hh := by |
| have hA:(activeSet (x t)).Nonempty:=⟨o,marked_active x key hx t ho⟩ |
| unfold data |
| dsimp only |
| rw [ite_eq_left hA] |
| split <;> simp_all |
|
|
| end KServer.ScheduleShape |
|
|
| end |
|
|
|
|
| /- Deterministic scheduled-simplex payments use raw ranks before parameter edits. -/ |
|
|
|
|
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ScheduledPayment |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule |
| open SimplexFamilies AdaptiveAllocation ScheduleShape |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w : Ω → ℝ} |
|
|
| lemma ordinary_regular {δ 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:ℕ) (ω:Ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) |
| (hA:(activeSet (vector cutoff δ P ω t)).Nonempty) |
| (hB:(activeSet (vector cutoff δ P ω (t+1))).Nonempty) |
| (hn:EpochSchedule.dominant (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t)=none) : |
| let ell:=1+Real.log (k+1) |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+ |
| (6*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 320*C*ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) := by |
| intro ell d a |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| let h:=weight δ x ky t |
| let h':=weight δ x ky (t+1) |
| let f:=StarSimplex.flags P ω t |
| let g:=StarSimplex.flags P ω (t+1) |
| let A:=activeSet (x t) |
| let B:=activeSet (x (t+1)) |
| have hel:0<ell := by have hlog:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| change EpochSchedule.dominant (EpochSchedule.run x ky t)=none at hn |
| have hn':EpochSchedule.dominant (EpochSchedule.run x ky (t+1))=none := |
| (ScheduleEdits.ordinary_mark x ky t he).trans hn |
| have hh:∀ i,1≤h i := fun i=>weight_regular_one δ x ky t i (by simp [hn]) |
| have hh':∀ i,1≤h' i := fun i=>weight_regular_one δ x ky (t+1) i (by simp [hn']) |
| have heta:∀ i,ct*h i/ell∈Set.Icc 0 1 := eta_bound hδ hδu hct.le hctu hk P key hs t ω |
| have heta':∀ i,ct*h' i/ell∈Set.Icc 0 1 := eta_bound hδ hδu hct.le hctu hk P key hs (t+1) ω |
| have ht:=regular_exp_sum δ x ky (vector_nonneg cutoff δ P ω) t |
| (ScheduledSimplex.nonempty_mass x ky (vector_nonneg cutoff δ P ω) t hA) hn |
| have hgp:2*(25+32*(2:ℝ))*(1+1)<C*ct := by linarith |
| have hold:(d t ω).data=regular A f h (fun i=>ct*h i/ell) hh := |
| regular_data hδ hδu C ell ct x ky (vector_nonneg cutoff δ P ω) (StarSimplex.flags P ω) t hA hn hh |
| have hnew:(d (t+1) ω).data=regular B g h' (fun i=>ct*h' i/ell) hh' := |
| regular_data hδ hδu C ell ct x ky (vector_nonneg cutoff δ P ω) (StarSimplex.flags P ω) (t+1) hB hn' hh' |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1 := fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have hf:∀ i∉A,∀ r,f i r=false := fun i hi r=>flags_supported hδ hδu P t ω i hi r |
| have hg:∀ i∉B,∀ r,g i r=false := fun i hi r=>flags_supported hδ hδu P (t+1) ω i hi r |
| have ha:a t ω∈ChangingDomains.simplex A := StarSimplex.proportion_mem hδ hδu C ell ct P key t ω |
| have ha':a (t+1) ω∈ChangingDomains.simplex B := StarSimplex.proportion_mem hδ hδu C ell ct P key (t+1) ω |
| have hstep:a (t+1) ω=regularStep C ell ct A B g h h' hh hh' (d (t+1) ω).ranks (a t ω) := |
| CausalSimplex.regular_successor d t ω hA hB f g h h' hh hh' hC hel hct |
| (fun i _=>(heta i).2) (by norm_num : (0:ℝ)≤2) ht hgp (fun ir=>(hp ir).1) hold hnew he |
| have hpay:=regular_step_payment hA hB f g h h' hh hh' hC hel hct heta heta' |
| (fun i _=>(heta i).2) (by norm_num : (0:ℝ)≤2) ht hgp (d (t+1) ω).ranks hp hf hg (a t ω) ha |
| dsimp only at hpay |
| rw [←hstep] at hpay |
| have hv0: (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)= |
| potential C ell (regular A f h (fun i=>ct*h i/ell) hh) |
| (core (regular A f h (fun i=>ct*h i/ell) hh) (d (t+1) ω).ranks) (a t ω) := by |
| rw [hold] |
| exact value_eq C ell _ _ _ ha |
| have hv1: (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)= |
| potential C ell (regular B g h' (fun i=>ct*h' i/ell) hh') |
| (core (regular B g h' (fun i=>ct*h' i/ell) hh') (d (t+1) ω).ranks) (a (t+1) ω) := by |
| rw [hnew] |
| exact value_eq C ell _ _ _ ha' |
| have hc:=ScheduleEdits.regular_charge hδ hδu P key t ω he (d (t+1) ω).ranks hp univ |
| (fun i _=>by rw [hn]; simp) |
| change (∑ i,if h i=h' i then 0 else preparedInput A B g (d (t+1) ω).ranks i)≤ |
| 40*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) at hc |
| have hcn:0≤8*C*ell := by positivity |
| have hc':=mul_le_mul_of_nonneg_left hc hcn |
| rw [hv0,hv1] |
| change (∑ i,core (d (t+1) ω).data (d (t+1) ω).ranks i)*_≤_ |
| rw [hnew] |
| nlinarith |
| |
| |
| lemma ordinary_marked {δ 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:ℕ) (ω:Ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) (o:J) |
| (ho:EpochSchedule.dominant (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t)=some o) |
| (hu:0<sideRatio δ (vector cutoff δ P ω) (fun s=>key s ω) t) |
| (hu':0<sideRatio δ (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) : |
| let ell:=1+Real.log (k+1) |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+ |
| (26*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 320*C*ell*(∑ i∈univ.erase o,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))+ |
| 2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t := by |
| intro ell x ky d a |
| let h:=weight δ x ky t |
| let h':=weight δ x ky (t+1) |
| let u:=sideRatio δ x ky t |
| let u':=sideRatio δ x ky (t+1) |
| let f:=StarSimplex.flags P ω t |
| let g:=StarSimplex.flags P ω (t+1) |
| let A:=activeSet (x t) |
| let B:=activeSet (x (t+1)) |
| have hxn:=vector_nonneg cutoff δ P ω |
| have hel:0<ell := by have hlog:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| change EpochSchedule.dominant (EpochSchedule.run x ky t)=some o at ho |
| have ho':EpochSchedule.dominant (EpochSchedule.run x ky (t+1))=some o := |
| (ScheduleEdits.ordinary_mark x ky t he).trans ho |
| have hA:o∈A:=marked_active x ky hxn t ho |
| have hB:B.Nonempty:=⟨o,marked_active x ky hxn (t+1) ho'⟩ |
| have hh:∀ i≠o,1≤h i := fun i hi=>weight_regular_one δ x ky t i (by rw [ho]; simpa [eq_comm] using hi) |
| have hh':∀ i≠o,1≤h' i := fun i hi=>weight_regular_one δ x ky (t+1) i (by rw [ho']; simpa [eq_comm] using hi) |
| have heta:∀ i,ct*h i/ell∈Set.Icc 0 1 := eta_bound hδ hδu hct.le hctu hk P key hs t ω |
| have heta':∀ i,ct*h' i/ell∈Set.Icc 0 1 := eta_bound hδ hδu hct.le hctu hk P key hs (t+1) ω |
| have hu1:u≤1:= (side_ratio_upper hδ hδu x ky hxn t ho).trans (by norm_num) |
| have hu1':u'≤1:= (side_ratio_upper hδ hδu x ky hxn (t+1) ho').trans (by norm_num) |
| have how:h o=u:=marked_weight δ x ky t o ho |
| have how':h' o=u':=marked_weight δ x ky (t+1) o ho' |
| have hside:∀ i∈A,i≠o→(1/2:ℝ)*(1+Real.log (1/u))≤h i := |
| fun i hi hio=>weight_side_lower hδ hδu x ky hxn t ho hi hio hu |
| have ht:=side_exp_sum hδ hδu x ky hxn t ho |
| have hgp:2*((25*(1/2:ℝ)+2+32*2)/(1/2))*(1+1)<C*ct := by linarith |
| have hold:(d t ω).data=marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh := |
| marked_data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t o ho hu hu1 hh |
| have hnew:(d (t+1) ω).data=marked B g o h' (fun i=>ct*h' i/ell) u' hu' hu1' hh' := |
| marked_data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) o ho' hu' hu1' hh' |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1 := fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have hf:∀ i∉A,∀ r,f i r=false := fun i hi r=>flags_supported hδ hδu P t ω i hi r |
| have hg:∀ i∉B,∀ r,g i r=false := fun i hi r=>flags_supported hδ hδu P (t+1) ω i hi r |
| have ha:a t ω∈ChangingDomains.simplex A := StarSimplex.proportion_mem hδ hδu C ell ct P key t ω |
| have ha':a (t+1) ω∈ChangingDomains.simplex B := StarSimplex.proportion_mem hδ hδu C ell ct P key (t+1) ω |
| have hstep:a (t+1) ω=markedStep C ell ct A B g o h h' u u' hu hu1 hu' hu1' hh hh' (d (t+1) ω).ranks (a t ω) := |
| CausalSimplex.marked_successor d t ω hA hB f g h h' hu hu1 hu' hu1' how hh hh' hC hel hct |
| (fun i _=>(heta i).2) (by norm_num : (0:ℝ)≤2) (by norm_num : (0:ℝ)<1/2) |
| (by norm_num) hside ht hgp (fun ir=>(hp ir).1) hold hnew he |
| have hcte:ct≤ell:=by have hlog:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| have hote:ct*u/ell≤u:= (div_le_iff₀ hel).mpr (by nlinarith) |
| have hote':ct*u'/ell≤u':= (div_le_iff₀ hel).mpr (by nlinarith) |
| have hpay:=marked_step_payment hA hB f g h h' hu hu1 hu' hu1' how how' hh hh' hC hel hct heta heta' |
| hote hote' (fun i _=>(heta i).2) (by norm_num : (0:ℝ)≤2) (by norm_num : (0:ℝ)<1/2) |
| (by norm_num) hside ht hgp (d (t+1) ω).ranks hp hf hg (a t ω) ha |
| dsimp only at hpay |
| rw [←hstep] at hpay |
| have hv0: (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)= |
| potential C ell (marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh) |
| (core (marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh) (d (t+1) ω).ranks) (a t ω) := by |
| rw [hold] |
| exact value_eq C ell _ _ _ ha |
| have hv1: (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)= |
| potential C ell (marked B g o h' (fun i=>ct*h' i/ell) u' hu' hu1' hh') |
| (core (marked B g o h' (fun i=>ct*h' i/ell) u' hu' hu1' hh') (d (t+1) ω).ranks) (a (t+1) ω) := by |
| rw [hnew] |
| exact value_eq C ell _ _ _ ha' |
| have hc:=ScheduleEdits.regular_charge hδ hδu P key t ω he (d (t+1) ω).ranks hp (univ.erase o) |
| (fun i hi=>by rw [ho]; simpa [eq_comm] using (mem_erase.mp hi).1) |
| have huq:=ScheduleEdits.side_ratio_charge hδ hδu x ky hxn t he o ho |
| (preparedInput A B g (d (t+1) ω).ranks) |
| (ScheduleEdits.prepared_input_bound hδ hδu P A (t+1) ω (d (t+1) ω).ranks hp) |
| have hc':=mul_le_mul_of_nonneg_left hc (by positivity : 0≤8*C*ell) |
| have huq':=mul_le_mul_of_nonneg_left huq (by positivity : 0≤24*C*ell) |
| rw [hv0,hv1] |
| change (∑ i,core (d (t+1) ω).data (d (t+1) ω).ranks i)*_≤_ |
| rw [hnew] |
| nlinarith |
| |
| end KServer.ScheduledPayment |
| |
| end |
| |
| |
| /-! Actual singleton/side-free transitions: their cost is paid by changed |
| flags, not by a fresh charge to the persistent dominant mass. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SingletonPayment |
| attribute [local instance] Classical.propDecidable |
| open SimplexFamilies AdaptiveAllocation |
| variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R] |
| |
| def point (o:J) : J→ℝ := fun i=>if i=o then 1 else 0 |
| |
| lemma point_mem (o:J) {A:Finset J} (ho:o∈A) : point o∈ChangingDomains.simplex A := by |
| refine ⟨fun i=>by unfold point; split_ifs <;> norm_num,?_,?_⟩ |
| · simp [point,ite_eq_left (show A.Nonempty from ⟨o,ho⟩)] |
| · intro i hi |
| have hn:i≠o:=fun he=>hi (he ▸ ho) |
| simp [point,hn] |
| |
| lemma singleton_eq {o:J} {a:J→ℝ} (ha:a∈ChangingDomains.simplex {o}) : a=point o := by |
| have hz:∀ i,i≠o→a i=0:=fun i hi=>ha.2.2 i (by simpa using hi) |
| have hs:(∑ i,a i)=a o := sum_eq_single o (fun i _ hi=>hz i hi) (by simp) |
| have ho:a o=1:=by simpa only [hs,singleton_nonempty,ite_true] using ha.2.1 |
| funext i |
| by_cases hi:i=o |
| · subst i; simp [point,ho] |
| · simp [point,hi,hz i hi] |
| |
| lemma zero_value (C ell:ℝ) (d:Data J R) (p:J×R→ℝ) (a:J→ℝ) |
| (hz:d.zeroPotential=true) : (family C ell).value d p a=0 := by |
| simp [AdaptiveMinimization.Family.value,family,coefficient,hz] |
| |
| lemma base_value (C ell:ℝ) (d:Data J R) (p:J×R→ℝ) : |
| (family C ell).value d p d.base=0 := by |
| simp [AdaptiveMinimization.Family.value,family,coefficient,K,Z] |
| |
| lemma core_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,0≤p ir) : |
| |(family C ell).value d p a|≤L*(∑ i,core d p i) := 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 p ir else 0) := by |
| apply sum_le_sum |
| intro ir _ |
| by_cases hf:d.flags ir.1 ir.2=true |
| · simp only [hf,ite_true,abs_mul,abs_of_nonneg (hp ir)] |
| exact mul_le_mul_of_nonneg_right (hc ir) (hp 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]; rfl |
| |
| lemma candidate_singleton (C ell:ℝ) (old new:Data J R) (o:J) |
| (hA:old.active={o}) (p:J×R→ℝ) (a:J→ℝ) : |
| CausalSimplex.candidate C ell old new p a= |
| ChangingDomains.transposeSimplex new.active (∑ i,core (CausalSimplex.prepared old new) p i) (point o) := by |
| have hm := (family C ell).update_mem (CausalSimplex.prepared old new) p |
| (∑ i,core (CausalSimplex.prepared old new) p i) a |
| change CausalSimplex.prepare C ell old new p a∈ChangingDomains.simplex old.active at hm |
| rw [hA] at hm |
| exact congrArg (ChangingDomains.transposeSimplex new.active _) (singleton_eq hm) |
| |
| lemma old_singleton {C ell L:ℝ} (hL:0≤L) (old new:CausalSimplex.Input J R) |
| (o:J) (hA:old.data.active={o}) (ho:o∈new.data.active) |
| (he:old.epoch=new.epoch) (hz:old.data.zeroPotential=true) |
| (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) |
| (hf:∀ i∉old.data.active,∀ r,old.data.flags i r=false) |
| (hg:∀ i∉new.data.active,∀ r,new.data.flags i r=false) |
| (hbase:(family C ell).value new.data p (point o)=0) |
| (hcoeff:∀ a,a∈ChangingDomains.simplex new.data.active→∀ ir,|coefficient C ell new.data a ir|≤L) |
| (a:J→ℝ) (ha:a∈ChangingDomains.simplex old.data.active) : |
| let S:=∑ i,core new.data p i |
| let b:=CausalSimplex.move C ell old new p a |
| let c:=(family C ell).update new.data p S b |
| S*ChangingDomains.variation c a≤ |
| (family C ell).value old.data p a-(family C ell).value new.data p c+ |
| (L+2)*ChangingDomains.changedFlags old.data.flags new.data.flags := by |
| intro S b c |
| have hae:a=point o:=singleton_eq (hA ▸ ha) |
| have hB:new.data.active.Nonempty:=⟨o,ho⟩ |
| let T:=∑ i,core (CausalSimplex.prepared old.data new.data) p i |
| have hcand:=candidate_singleton C ell old.data new.data o hA p a |
| have hcm:CausalSimplex.candidate C ell old.data new.data p a∈ChangingDomains.simplex new.data.active := by |
| rw [hcand] |
| unfold ChangingDomains.transposeSimplex |
| split_ifs |
| · exact ChangingDomains.canonical_mem _ |
| · exact point_mem o ho |
| have hb:b=ChangingDomains.transposeSimplex new.data.active T (point o) := by |
| change CausalSimplex.move C ell old new p a=_ |
| rw [CausalSimplex.move,ite_eq_left he,ite_eq_left hcm,hcand] |
| have hbm:b∈ChangingDomains.simplex new.data.active:=CausalSimplex.move_mem C ell old new p a |
| have hSn:0≤S:=sum_nonneg fun i _=>ChangingDomains.core_nonneg (fun i r=>(hp (i,r)).1) i |
| have hpay: S*ChangingDomains.variation c b≤ |
| (family C ell).value new.data p b-(family C ell).value new.data p c := |
| (family C ell).update_payment new.data p S hbm |
| have hvold:=zero_value C ell old.data p a hz |
| rw [hvold] |
| by_cases ht:T=0 |
| · have herr:= (ChangingDomains.synthetic_errors (fun i r=>hp (i,r)) hf hg).2 |
| have hdiff:=le_of_abs_le ((total_variation_bound (core new.data p) |
| (core (CausalSimplex.prepared old.data new.data) p)).trans herr) |
| change S-T≤ChangingDomains.changedFlags old.data.flags new.data.flags at hdiff |
| rw [ht,sub_zero] at hdiff |
| have hv: (family C ell).value new.data p b≤L*S := |
| (le_abs_self _).trans (core_value_bound C ell new.data p b (hcoeff b hbm) (fun ir=>(hp ir).1)) |
| have htri:=mul_le_mul_of_nonneg_left (ChangingDomains.variation_triangle c b a) hSn |
| have hvar:=mul_le_mul_of_nonneg_left (ChangingDomains.simplex_variation hbm ha) hSn |
| have hmul:=mul_le_mul_of_nonneg_left hdiff (show 0≤L+2 by linarith) |
| nlinarith |
| · have hba:b=a:=by rw [hb,ChangingDomains.transposeSimplex,ite_eq_right ht,hae] |
| rw [hba] at hpay |
| rw [hae,hbase] at hpay |
| rw [hae] |
| have hfn:0≤ChangingDomains.changedFlags old.data.flags new.data.flags := by |
| apply sum_nonneg |
| intro i _ |
| apply sum_nonneg |
| intro r _ |
| split_ifs <;> norm_num |
| nlinarith [mul_nonneg (show 0≤L+2 by linarith) hfn] |
| |
| end KServer.SingletonPayment |
| |
| end |
| |
| |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SingletonPayment |
| attribute [local instance] Classical.propDecidable |
| open SimplexFamilies AdaptiveAllocation |
| variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R] |
| |
| omit [Fintype R] in |
| lemma marked_point_potential (A : Finset J) (f : J→R→Bool) (o:J) (h eta:J→ℝ) |
| {u:ℝ} (hu:0<u) (hu1:u≤1) (hh:∀ i≠o,1≤h i) (C ell:ℝ) (v:J→ℝ) : |
| potential C ell (marked A f o h eta u hu hu1 hh) v (point o)=0 := by |
| simp [potential,marked,SimplexAnalytic.primitive,point] |
| |
| lemma new_singleton {A:Finset J} {o:J} (hoA:o∈A) |
| (f g:J→R→Bool) (h:J→ℝ) {u:ℝ} (hu:0<u) (hu1:u≤1) |
| (ho:h o=u) (hh:∀ i≠o,1≤h i) |
| {C ell ct ηmax Cexp c:ℝ} (hC:0<C) (hl:0<ell) (hc:0<ct) |
| (he:∀ i,ct*h i/ell∈Set.Icc 0 1) |
| (hmax:∀ i∈A,ct*h i/ell≤ηmax) (hCexp:0≤Cexp) |
| (hsideC:0<c) (hsideC1:c≤1) |
| (hside:∀ i∈A,i≠o→c*(1+Real.log (1/u))≤h i) |
| (htail:∑ i∈A.erase o,Real.exp (-h i)≤Cexp*u) |
| (hgap:2*((25*c+2+32*Cexp)/c)*(1+ηmax)<C*ct) |
| (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) |
| (hf:∀ i∉A,∀ r,f i r=false) (hg:∀ i∉({o}:Finset J),∀ r,g i r=false) |
| (a:J→ℝ) (ha:a∈ChangingDomains.simplex A) : |
| let d0:=marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh |
| (∑ i,ChangingDomains.core g (fun i r=>p (i,r)) i)*ChangingDomains.variation (point o) a≤ |
| potential C ell d0 (core d0 p) a+(13*C*ell+4)*ChangingDomains.changedFlags f g := by |
| intro d0 |
| let B:=({o}:Finset J) |
| let v:=preparedInput A B g p |
| let d1:=marked A (preparedFlags A B g) o h (fun i=>ct*h i/ell) u hu hu1 hh |
| let a1:=markedPrepare C ell ct A B g o h u hu hu1 hh p a |
| let a2:=markedTransport C ell ct A B g o h u hu hu1 hh p a |
| let S:=∑ i,v i |
| let T:=∑ i,ChangingDomains.core g (fun i r=>p (i,r)) i |
| have hv:∀ i,0≤v i:=fun i=>ChangingDomains.core_nonneg (fun i r=>(hp (i,r)).1) i |
| have hSn:0≤S:=sum_nonneg fun i _=>hv i |
| have hB:B.Nonempty:=singleton_nonempty o |
| have ha1:a1∈ChangingDomains.simplex A := (family C ell).update_mem d1 p S a |
| have ha2:a2∈ChangingDomains.simplex B:=marked_transport_mem hoA hB g h hu hu1 ho hh |
| hC hl hc hmax hCexp hsideC hsideC1 hside htail hgap p (fun ir=>(hp ir).1) a ha |
| have hae:a2=point o:=singleton_eq ha2 |
| have ht:potential C ell d0 v a2=potential C ell d0 v a1 := |
| marked_transpose_value A B f o h (fun i=>ct*h i/ell) hu hu1 hh C ell v a1 hv |
| have hz:potential C ell d0 v a2=0 := by |
| rw [hae] |
| exact marked_point_potential A f o h (fun i=>ct*h i/ell) hu hu1 hh C ell v |
| have hpay:S*ChangingDomains.variation a1 a≤potential C ell d0 v a := by |
| have hp1:=literal_update_payment C ell d1 p S ha |
| change S*ChangingDomains.variation a1 a≤potential C ell d0 v a-potential C ell d0 v a1 at hp1 |
| rw [←ht,hz,sub_zero] at hp1 |
| exact hp1 |
| have herr:=ChangingDomains.synthetic_errors (fun i r=>hp (i,r)) hf hg |
| have hi:=marked_input_bound A ⟨o,hoA⟩ f o h (fun i=>ct*h i/ell) hu hu1 hh he hC.le hl.le |
| (B:=core d0 p) (B':=v) ha |
| have hdelta:=mul_le_mul_of_nonneg_left herr.1 (by positivity : 0≤13*C*ell) |
| have hzero:S*ChangingDomains.variation a2 a1=0:=ChangingDomains.transposeSimplex_payment B S a1 |
| have hST:S≤T:=sub_nonneg.mp (ChangingDomains.synthetic_total (A:=A) (B:=B) (g:=g) (fun i r=>(hp (i,r)).1)) |
| have hdiff:T-S≤ChangingDomains.changedFlags f g := |
| (le_abs_self _).trans ((total_variation_bound (ChangingDomains.core g (fun i r=>p (i,r))) v).trans herr.2) |
| have hm:=ChangingDomains.prepared_weight_comparison ha ha1 ha2 hSn hST hzero (a₃:=a2) |
| rw [ChangingDomains.variation_self,mul_zero,add_zero,hae] at hm |
| have hlow:=neg_le_of_abs_le hi |
| change -(13*C*ell*ChangingDomains.variation (core d0 p) v)≤ |
| potential C ell d0 (core d0 p) a-potential C ell d0 v a at hlow |
| change 13*C*ell*ChangingDomains.variation (core d0 p) v≤ |
| 13*C*ell*ChangingDomains.changedFlags f g at hdelta |
| change T*ChangingDomains.variation (point o) a≤_ |
| nlinarith |
|
|
| end KServer.SingletonPayment |
|
|
| end |
|
|
|
|
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ScheduledPayment |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule |
| open SimplexFamilies AdaptiveAllocation ScheduleShape SingletonPayment |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w : Ω→ℝ} |
|
|
| omit [Fintype Ω] [Fintype R] in |
| lemma marked_zero_flag {δ:ℝ} (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:ℕ) (o:J) (ho:EpochSchedule.dominant (EpochSchedule.run x key t)=some o) |
| (hu:sideRatio δ x key t=0) : |
| (data hδ hδu C ell ct x key hx flags t).zeroPotential=true := by |
| have hA:(activeSet (x t)).Nonempty:=⟨o,marked_active x key hx t ho⟩ |
| unfold data |
| dsimp only |
| rw [ite_eq_left hA] |
| split <;> simp_all [zeroData] |
|
|
| omit [Fintype Ω] in |
| lemma marked_point_value {δ:ℝ} (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:ℕ) (o:J) (ho:EpochSchedule.dominant (EpochSchedule.run x key t)=some o) |
| (p:J×R→ℝ) : |
| (family C ell).value (data hδ hδu C ell ct x key hx flags t) p (point o)=0 := by |
| by_cases hu:0<sideRatio δ x key t |
| · have hu1:sideRatio δ x key t≤1:=(side_ratio_upper hδ hδu x key hx t ho).trans (by norm_num) |
| 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) |
| rw [marked_data hδ hδu C ell ct x key hx flags t o ho hu hu1 hh] |
| exact base_value C ell _ p |
| · have hz:sideRatio δ x key t=0:=le_antisymm (le_of_not_gt hu) (side_ratio_nonneg δ x key hx t) |
| exact zero_value C ell _ p _ (marked_zero_flag hδ hδu C ell ct x key hx flags t o ho hz) |
|
|
| lemma ordinary_old_zero {δ 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:ℕ) (ω:Ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) (o:J) |
| (ho:EpochSchedule.dominant (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t)=some o) |
| (hu:sideRatio δ (vector cutoff δ P ω) (fun s=>key s ω) t=0) : |
| let ell:=1+Real.log (k+1) |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+ |
| (13*C*ell+2)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) := by |
| intro ell d a |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| have hxn:=vector_nonneg cutoff δ P ω |
| have hel:0≤ell:=by have hlog:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| have ho':EpochSchedule.dominant (EpochSchedule.run x ky (t+1))=some o:= |
| (ScheduleEdits.ordinary_mark x ky t he).trans ho |
| have hA:(d t ω).data.active={o}:=(data_active hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t).trans |
| (marked_zero_singleton hδ x ky hxn t ho hu) |
| have hoB:o∈(d (t+1) ω).data.active:=by |
| change o∈(data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1)).active |
| rw [data_active] |
| exact marked_active x ky hxn (t+1) ho' |
| have hz:(d t ω).data.zeroPotential=true:=marked_zero_flag hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t o ho hu |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1:=fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have hf:∀ i∉(d t ω).data.active,∀ r,(d t ω).data.flags i r=false:=by |
| change ∀ i∉(data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t).active,∀ r,_=false |
| simp only [data_active] |
| intro i hi r |
| change (data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) _).flags i r=false |
| rw [data_flags] |
| exact flags_supported hδ hδu P t ω i hi r |
| have hg:∀ i∉(d (t+1) ω).data.active,∀ r,(d (t+1) ω).data.flags i r=false:=by |
| change ∀ i∉(data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1)).active,∀ r,_=false |
| simp only [data_active] |
| intro i hi r |
| change (data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) _).flags i r=false |
| rw [data_flags] |
| exact flags_supported hδ hδu P (t+1) ω i hi r |
| have hcoeff:∀ b,b∈ChangingDomains.simplex (d (t+1) ω).data.active→∀ ir,|coefficient C ell (d (t+1) ω).data b ir|≤13*C*ell := by |
| intro b hb |
| have hm:(d (t+1) ω).data.active=activeSet (x (t+1)):=data_active hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) |
| exact ScheduledSlope.actual_bound hδ hδu hC hct hctu hk P key hs (t+1) ω b (hm ▸ hb) |
| have hb: (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (point o)=0 := |
| marked_point_value hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) o ho' _ |
| have ha:a t ω∈ChangingDomains.simplex (d t ω).data.active:=CausalSimplex.run_mem C ell d t ω |
| have hpay:=old_singleton (by positivity : 0≤13*C*ell) (d t ω) (d (t+1) ω) o hA hoB he hz _ hp hf hg hb hcoeff _ ha |
| have hsuc:a (t+1) ω=(family C ell).update (d (t+1) ω).data (d (t+1) ω).ranks |
| (CausalSimplex.mass (d (t+1) ω)) |
| (CausalSimplex.move C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks (a t ω)) := |
| CausalSimplex.run_successor C ell d t ω |
| rw [hsuc] |
| have hf0:(d t ω).data.flags=StarSimplex.flags P ω t:=data_flags hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t |
| have hf1:(d (t+1) ω).data.flags=StarSimplex.flags P ω (t+1):=data_flags hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) |
| simpa only [CausalSimplex.mass,hf0,hf1] using hpay |
| |
| |
| lemma ordinary_new_zero {δ 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:ℕ) (ω:Ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) (o:J) |
| (ho:EpochSchedule.dominant (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t)=some o) |
| (hu:0<sideRatio δ (vector cutoff δ P ω) (fun s=>key s ω) t) |
| (hu':sideRatio δ (vector cutoff δ P ω) (fun s=>key s ω) (t+1)=0) : |
| let ell:=1+Real.log (k+1) |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+ |
| (13*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) := by |
| intro ell d a |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| let h:=weight δ x ky t |
| let u:=sideRatio δ x ky t |
| let f:=StarSimplex.flags P ω t |
| let g:=StarSimplex.flags P ω (t+1) |
| let A:=activeSet (x t) |
| have hxn:=vector_nonneg cutoff δ P ω |
| have hel:0<ell:=by have hlog:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| change EpochSchedule.dominant (EpochSchedule.run x ky t)=some o at ho |
| have ho':EpochSchedule.dominant (EpochSchedule.run x ky (t+1))=some o:= |
| (ScheduleEdits.ordinary_mark x ky t he).trans ho |
| have hA:o∈A:=marked_active x ky hxn t ho |
| have hB:activeSet (x (t+1))={o}:=marked_zero_singleton hδ x ky hxn (t+1) ho' hu' |
| have hh:∀ i≠o,1≤h i:=fun i hi=>weight_regular_one δ x ky t i (by rw [ho]; simpa [eq_comm] using hi) |
| have heta:∀ i,ct*h i/ell∈Set.Icc 0 1:=eta_bound hδ hδu hct.le hctu hk P key hs t ω |
| have hu1:u≤1:=(side_ratio_upper hδ hδu x ky hxn t ho).trans (by norm_num) |
| have how:h o=u:=marked_weight δ x ky t o ho |
| have hside:∀ i∈A,i≠o→(1/2:ℝ)*(1+Real.log (1/u))≤h i:= |
| fun i hi hio=>weight_side_lower hδ hδu x ky hxn t ho hi hio hu |
| have ht:=side_exp_sum hδ hδu x ky hxn t ho |
| have hgp:2*((25*(1/2:ℝ)+2+32*2)/(1/2))*(1+1)<C*ct:=by linarith |
| have hold:(d t ω).data=marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh := |
| marked_data hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) t o ho hu hu1 hh |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1:=fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have hf:∀ i∉A,∀ r,f i r=false:=fun i hi r=>flags_supported hδ hδu P t ω i hi r |
| have hg:∀ i∉({o}:Finset J),∀ r,g i r=false:=by |
| rw [←hB] |
| exact fun i hi r=>flags_supported hδ hδu P (t+1) ω i hi r |
| have ha:a t ω∈ChangingDomains.simplex A:=StarSimplex.proportion_mem hδ hδu C ell ct P key t ω |
| have ha':a (t+1) ω∈ChangingDomains.simplex {o}:=by |
| rw [←hB] |
| exact StarSimplex.proportion_mem hδ hδu C ell ct P key (t+1) ω |
| have hae:a (t+1) ω=point o:=singleton_eq ha' |
| have hpay:=new_singleton hA f g h hu hu1 how hh hC hel hct heta |
| (fun i _=>(heta i).2) (by norm_num : (0:ℝ)≤2) (by norm_num : (0:ℝ)<1/2) |
| (by norm_num) hside ht hgp (d (t+1) ω).ranks hp hf hg (a t ω) ha |
| dsimp only at hpay |
| have hv0:(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)= |
| potential C ell (marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh) |
| (core (marked A f o h (fun i=>ct*h i/ell) u hu hu1 hh) (d (t+1) ω).ranks) (a t ω) := by |
| rw [hold] |
| exact value_eq C ell _ _ _ ha |
| have hv1:(family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)=0:= |
| zero_value C ell _ _ _ (marked_zero_flag hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) o ho' hu') |
| have hm:CausalSimplex.mass (d (t+1) ω)=∑ i,ChangingDomains.core g (fun i r=>(d (t+1) ω).ranks (i,r)) i := by |
| have hgf:(d (t+1) ω).data.flags=g:=data_flags hδ hδu C ell ct x ky hxn (StarSimplex.flags P ω) (t+1) |
| simp only [CausalSimplex.mass,core,hgf,ChangingDomains.core] |
| rw [hv0,hv1,sub_zero,hae,hm] |
| exact hpay |
| |
| end KServer.ScheduledPayment |
| |
| end |
| |
| |
| /-! The complete ordinary/wholesale simplex payment for the literal schedule. |
| All charges below are computed by the actual switches, never supplied by a |
| finite-law hypothesis. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ScheduledPayment |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule |
| open SimplexFamilies AdaptiveAllocation ScheduleShape SingletonPayment |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w : Ω→ℝ} |
| |
| omit [Fintype Ω] [DecidableEq J] [Fintype R] in |
| lemma empty_total (x:J→ℝ) (hx:∀ i,0≤x i) (hA:¬(activeSet x).Nonempty) : EpochSchedule.total x=0 := by |
| apply sum_eq_zero |
| intro i _ |
| apply le_antisymm _ (hx i) |
| by_contra hn |
| exact hA ⟨i,(mem_activeSet x i).mpr (lt_of_not_ge hn)⟩ |
| |
| omit [Fintype Ω] [DecidableEq J] [Fintype R] in |
| lemma positive_active (x:J→ℝ) (hx:∀ i,0≤x i) (hp:0<EpochSchedule.total x) : (activeSet x).Nonempty := by |
| by_contra hn |
| rw [empty_total x hx hn] at hp |
| exact (lt_irrefl _ hp) |
| |
| omit [Fintype Ω] [DecidableEq J] [Fintype R] in |
| lemma ordinary_nonempty (x:ℕ→J→ℝ) (key:ℕ→K) (hx:∀ t i,0≤x t i) (t:ℕ) |
| (he:epoch x key t=epoch x key (t+1)) : |
| (activeSet (x t)).Nonempty ↔ (activeSet (x (t+1))).Nonempty := by |
| have hm:=ScheduleEdits.ordinary_mass x key t he |
| constructor |
| · intro ha |
| have h:=ScheduledSimplex.nonempty_mass x key hx t ha |
| have hb:=(mass_accuracy x key hx (t+1)).1 |
| rw [hm] at hb |
| exact positive_active _ (hx (t+1)) (by linarith) |
| · intro hb |
| have h:=ScheduledSimplex.nonempty_mass x key hx (t+1) hb |
| rw [hm] at h |
| have ha:=(mass_accuracy x key hx t).1 |
| exact positive_active _ (hx t) (by linarith) |
| |
| omit [Fintype Ω] [DecidableEq J] in |
| lemma flags_nonneg (f g:J→R→Bool) : 0≤ChangingDomains.changedFlags f g := by |
| apply sum_nonneg |
| intro i _ |
| apply sum_nonneg |
| intro r _ |
| split_ifs <;> norm_num |
| |
| omit [Fintype Ω] [Fintype R] [DecidableEq J] in |
| lemma side_charge_nonneg (δ:ℝ) (x:ℕ→J→ℝ) (key:ℕ→K) (hx:∀ t i,0≤x t i) (t:ℕ) : |
| 0≤CoarseSide.charge δ (CoarseSide.sideInput x key) (CoarseSide.epochReset x key) t := by |
| unfold CoarseSide.charge |
| split_ifs |
| · exact add_nonneg (CoarseSide.side_nonneg (hx t) _) (CoarseSide.side_nonneg (hx (t+1)) _) |
| · rfl |
| |
| def expense (C ell δ:ℝ) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : ℝ := |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| (26*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 320*C*ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))+ |
| 2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t+ |
| (520*C*ell+80)*EpochSchedule.wholesale (x t) (x (t+1)) (ky t) (ky (t+1)) (EpochSchedule.run x ky t) |
| |
| omit [DecidableEq J] in |
| lemma expense_nonneg {C ell:ℝ} (hC:0≤C) (hel:0≤ell) (δ:ℝ) (P:J→R→FilteredRanks w) |
| (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : 0≤expense C ell δ P key t ω := by |
| have hf:=flags_nonneg (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) |
| have hc:0≤∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)):= |
| sum_nonneg fun i _=>charge_nonneg (active_valid cutoff δ (P i) ω t) (active_valid cutoff δ (P i) ω (t+1)) |
| have hu:=side_charge_nonneg δ (vector cutoff δ P ω) (fun s=>key s ω) (vector_nonneg cutoff δ P ω) t |
| have hw:0≤EpochSchedule.wholesale (vector cutoff δ P ω t) (vector cutoff δ P ω (t+1)) (key t ω) (key (t+1) ω) |
| (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t) := by |
| unfold EpochSchedule.wholesale |
| split_ifs |
| · exact add_nonneg (EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω t)) |
| (EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω (t+1))) |
| · rfl |
| unfold expense |
| positivity |
| |
| lemma mass_bound {δ:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (C ell ct:ℝ) (P:J→R→FilteredRanks w) |
| (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : |
| CausalSimplex.mass (StarSimplex.input hδ hδu C ell ct P key t ω)≤40*EpochSchedule.total (vector cutoff δ P ω t) := by |
| simp only [CausalSimplex.mass,core,StarSimplex.input,data_flags,StarSimplex.flags] |
| change (∑ i,∑ r,if CoreFlags.flag (P i r) t ω then (P i r).p t ω else 0)≤40*(∑ i,vector cutoff δ P ω t i) |
| rw [mul_sum] |
| exact sum_le_sum fun i _=>ScheduleEdits.raw_core_bound hδ hδu (P i) t ω |
| (fun r=>(P i r).p t ω) (fun r=>(P i r).range t ω) |
| |
| lemma wholesale_payment {δ 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:ℕ) (ω:Ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t≠ |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) : |
| let ell:=1+Real.log (k+1) |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+expense C ell δ P key t ω := by |
| intro ell d a |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| have hel:0≤ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| have ha:=StarSimplex.proportion_mem hδ hδu C ell ct P key t ω |
| have ha':=StarSimplex.proportion_mem hδ hδu C ell ct P key (t+1) ω |
| have hm:=mass_bound hδ hδu C ell ct P key (t+1) ω |
| have hmove: CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤80*EpochSchedule.total (x (t+1)) := by |
| have hn:0≤CausalSimplex.mass (d (t+1) ω):=by |
| apply sum_nonneg |
| intro i _ |
| apply sum_nonneg |
| intro r _ |
| split_ifs |
| · exact ((P i r).range (t+1) ω).1 |
| · rfl |
| have hh:=mul_le_mul_of_nonneg_left (ChangingDomains.simplex_variation ha' ha) hn |
| nlinarith |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1:=fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have h₀:=neg_le_of_abs_le (ScheduledEndpoint.actual_bound hδ hδu hC hct hctu hk P key hs t ω _ hp _ ha) |
| have h₁:=le_of_abs_le (ScheduledEndpoint.actual_bound hδ hδu hC hct hctu hk P key hs (t+1) ω _ hp _ ha') |
| have hn:CoarseSide.epochReset x ky t:=Classical.not_not.mp (fun hh=>he ((epoch_same_iff x ky t).mpr hh)) |
| have wh:EpochSchedule.wholesale (x t) (x (t+1)) (ky t) (ky (t+1)) (EpochSchedule.run x ky t)= |
| EpochSchedule.total (x t)+EpochSchedule.total (x (t+1)):=ite_eq_left hn |
| have hcharges:0≤(26*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 320*C*ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))+ |
| 2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t := by |
| have hf:=flags_nonneg (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) |
| have hc:0≤∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)):= |
| sum_nonneg fun i _=>charge_nonneg (active_valid cutoff δ (P i) ω t) (active_valid cutoff δ (P i) ω (t+1)) |
| have hu:=side_charge_nonneg δ x ky (vector_nonneg cutoff δ P ω) t |
| positivity |
| unfold expense |
| change _≤_+(_+(_)*EpochSchedule.wholesale (x t) (x (t+1)) (ky t) (ky (t+1)) (EpochSchedule.run x ky t)) |
| rw [wh] |
| have hx0:0≤EpochSchedule.total (x t):=EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω t) |
| nlinarith |
|
|
| omit [DecidableEq J] in |
| lemma expense_lower {C ell:ℝ} (hC:0≤C) (hel:0≤ell) (δ:ℝ) (P:J→R→FilteredRanks w) |
| (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : |
| (26*C*ell+4)*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 320*C*ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))+ |
| 2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput (vector cutoff δ P ω) (fun s=>key s ω)) |
| (CoarseSide.epochReset (vector cutoff δ P ω) (fun s=>key s ω)) t ≤ expense C ell δ P key t ω := by |
| have hw:0≤EpochSchedule.wholesale (vector cutoff δ P ω t) (vector cutoff δ P ω (t+1)) (key t ω) (key (t+1) ω) |
| (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t) := by |
| unfold EpochSchedule.wholesale |
| split_ifs |
| · exact add_nonneg (EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω t)) |
| (EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω (t+1))) |
| · rfl |
| exact le_add_of_nonneg_right (mul_nonneg (by positivity) hw) |
|
|
| lemma payment {δ C ct k:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) |
| (hC:0<C) (hct:0<ct) (hctu:ct*20002≤1) (hgap:700<C*ct) (hk:1≤k) |
| (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) : |
| let ell:=1+Real.log (k+1) |
| let d:=StarSimplex.input hδ hδu C ell ct P key |
| let a:=StarSimplex.proportion hδ hδu C ell ct P key |
| CausalSimplex.mass (d (t+1) ω)*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+expense C ell δ P key t ω := by |
| intro ell d a |
| let x:=vector cutoff δ P ω |
| let ky:=fun s=>key s ω |
| have hx:=vector_nonneg cutoff δ P ω |
| have hel:0≤ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| by_cases he:epoch x ky t=epoch x ky (t+1) |
| · have hf:=flags_nonneg (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) |
| have hc:0≤∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)):= |
| sum_nonneg fun i _=>charge_nonneg (active_valid cutoff δ (P i) ω t) (active_valid cutoff δ (P i) ω (t+1)) |
| have hu:=side_charge_nonneg δ x ky hx t |
| have hl:=expense_lower hC.le hel δ P key t ω |
| have hcn:0≤C*ell:=mul_nonneg hC.le hel |
| by_cases hA:(activeSet (x t)).Nonempty |
| · have hB:=(ordinary_nonempty x ky hx t he).mp hA |
| cases ho:EpochSchedule.dominant (EpochSchedule.run x ky t) with |
| | none => |
| have hp:=ordinary_regular hδ hδu hC hct hctu hgap hk P key hs t ω he hA hB ho |
| change _≤(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_+_ at hp |
| change _+_+2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t≤_ at hl |
| nlinarith [mul_nonneg hcn hf,mul_nonneg hcn hu] |
| | some o => |
| by_cases hu0:sideRatio δ x ky t=0 |
| · have hp:=ordinary_old_zero hδ hδu hC.le hct.le hctu hk P key hs t ω he o ho hu0 |
| change _≤(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_ at hp |
| change _+_+2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t≤_ at hl |
| nlinarith [mul_nonneg hcn hf,mul_nonneg hcn hc,mul_nonneg hcn hu] |
| · have hup:0<sideRatio δ x ky t:=lt_of_le_of_ne (side_ratio_nonneg δ x ky hx t) (Ne.symm hu0) |
| by_cases hu1:sideRatio δ x ky (t+1)=0 |
| · have hp:=ordinary_new_zero hδ hδu hC hct hctu hgap hk P key hs t ω he o ho hup hu1 |
| change _≤(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_ at hp |
| change _+_+2976*C*ell*CoarseSide.charge δ (CoarseSide.sideInput x ky) (CoarseSide.epochReset x ky) t≤_ at hl |
| nlinarith [mul_nonneg hcn hf,mul_nonneg hcn hc,mul_nonneg hcn hu] |
| · have hup':0<sideRatio δ x ky (t+1):=lt_of_le_of_ne (side_ratio_nonneg δ x ky hx (t+1)) (Ne.symm hu1) |
| have hp:=ordinary_marked hδ hδu hC hct hctu hgap hk P key hs t ω he o ho hup hup' |
| have hs' : (∑ i∈univ.erase o,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))≤ |
| ∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)):= |
| sum_le_sum_of_subset_of_nonneg (erase_subset _ _) (fun i _ _=>charge_nonneg (active_valid cutoff δ (P i) ω t) (active_valid cutoff δ (P i) ω (t+1))) |
| have hmul:=mul_le_mul_of_nonneg_left hs' (show 0≤320*C*ell by positivity) |
| change _≤(family C ell).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family C ell).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_+_+_ at hp |
| linarith |
| · have hB:¬(activeSet (x (t+1))).Nonempty:=fun hh=>hA ((ordinary_nonempty x ky hx t he).mpr hh) |
| have hz (s:ℕ) (hn:¬(activeSet (x s)).Nonempty) : (d s ω).data.zeroPotential=true := by |
| change (data hδ hδu C ell ct x ky hx (StarSimplex.flags P ω) s).zeroPotential=true |
| unfold data |
| dsimp only |
| rw [ite_eq_right hn] |
| rfl |
| have hm:CausalSimplex.mass (d (t+1) ω)=0 := by |
| have hm:=mass_bound hδ hδu C ell ct P key (t+1) ω |
| rw [empty_total _ (hx (t+1)) hB,mul_zero] at hm |
| apply le_antisymm hm |
| apply sum_nonneg |
| intro i _ |
| exact ChangingDomains.core_nonneg (fun i r=>((P i r).range (t+1) ω).1) _ |
| rw [hm,zero_mul,zero_value C ell _ _ _ (hz t hA),zero_value C ell _ _ _ (hz (t+1) hB),sub_self,zero_add] |
| exact expense_nonneg hC.le hel δ P key t ω |
| · exact wholesale_payment hδ hδu hC.le hct.le hctu hk P key hs t ω he |
|
|
| end KServer.ScheduledPayment |
|
|
| end |
|
|
|
|
| /-! Literal coarse schedule bills and their finite-experiment budgets. The |
| right sides use drift after conditioning, never raw posterior variation. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ActualCharges |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar |
| variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ} |
|
|
| def drift (P:R→ FilteredRanks w) (N:ℕ):ℝ:= |
| ∑ t∈range N,avg w (fun ω=>∑ r,|(P r).p (t+1) ω-(P r).before (t+1) ω|) |
| def inventory (P:R→ FilteredRanks w) (N:ℕ):ℝ:=drift P N+Fintype.card R |
| def flat (P:J→ R→ FilteredRanks w):J×R→ FilteredRanks w:=fun ir=> P ir.1 ir.2 |
|
|
| def flags (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω):ℝ:= |
| ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) |
| def active (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω):ℝ:= |
| ∑ i,CoarseSchedule.charge (CoarseProcess.active cutoff ds (P i) ω t) |
| (CoarseProcess.active cutoff ds (P i) ω (t+1)) |
| def parentCharge (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):ℝ:= |
| CoarseProcess.relativeCharge dp (clipped cutoff dp Q) t ω |
| def wholesale (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):ℝ:= |
| EpochSchedule.wholesale (vector cutoff ds P ω t) (vector cutoff ds P ω (t+1)) |
| (key Q t ω) (key Q (t+1) ω) (EpochSchedule.run (vector cutoff ds P ω) (fun s=> key Q s ω) t) |
| def sideRefresh (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):ℝ:= |
| CoarseSide.charge ds (CoarseSide.sideInput (vector cutoff ds P ω) (fun s=> key Q s ω)) |
| (CoarseSide.epochReset (vector cutoff ds P ω) (fun s=> key Q s ω)) t |
|
|
| def activeConstant:ℝ:=CoarseSchedule.factor ds*(5*(4/3:ℝ)^2/ds+1) |
| def parentConstant:ℝ:=CoarseSchedule.factor dp*(5*(4/3:ℝ)^2/dp) |
| def flagConstant:ℝ:=(CoreFlags.tolerance^2)⁻¹ |
|
|
| lemma constants_nonneg:0≤ activeConstant ∧ 0≤ parentConstant ∧ 0≤ flagConstant:=by |
| norm_num [activeConstant,parentConstant,flagConstant,CoarseSchedule.factor,ds,dp,lb,cb,CoreFlags.tolerance] |
| lemma inventory_nonneg (hw:∀ ω,0≤ w ω) (P:R→ FilteredRanks w) (N:ℕ):0≤ inventory P N:=by |
| apply add_nonneg _ (Nat.cast_nonneg _) |
| unfold drift |
| exact sum_nonneg fun t _=>sum_nonneg fun ω _=>mul_nonneg (hw ω) |
| (sum_nonneg fun r _=>abs_nonneg _) |
| lemma flags_nonneg (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω):0≤ flags P t ω:= |
| ScheduledPayment.flags_nonneg _ _ |
| lemma active_nonneg (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω):0≤ active P t ω:=by |
| apply sum_nonneg |
| intro i _ |
| exact CoarseProcess.charge_nonneg (active_valid cutoff ds (P i) ω t) (active_valid cutoff ds (P i) ω (t+1)) |
| lemma parent_nonneg (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):0≤ parentCharge Q t ω:=by |
| unfold parentCharge relativeCharge |
| split_ifs |
| · rfl |
| · exact add_nonneg (CoarseEpoch.parent_nonneg (by norm_num [cutoff]) dp Q t ω) |
| (CoarseEpoch.parent_nonneg (by norm_num [cutoff]) dp Q (t+1) ω) |
| lemma wholesale_nonneg (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):0≤ wholesale P Q t ω:=by |
| unfold wholesale EpochSchedule.wholesale |
| split_ifs |
| · exact add_nonneg (EpochSchedule.total_nonneg (vector_nonneg cutoff ds P ω t)) |
| (EpochSchedule.total_nonneg (vector_nonneg cutoff ds P ω (t+1))) |
| · rfl |
| lemma sideRefresh_nonneg (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω):0≤ sideRefresh P Q t ω:= |
| ScheduledPayment.side_charge_nonneg ds _ _ (vector_nonneg cutoff ds P ω) t |
|
|
| lemma flags_eq (P:J→ R→ FilteredRanks w) (t:ℕ) (ω:Ω): |
| flags P t ω=∑ ir:J×R,CoreFlags.change (P ir.1 ir.2) t ω:=by |
| unfold flags ChangingDomains.changedFlags |
| rw [Fintype.sum_prod_type] |
| apply sum_congr rfl |
| intro i _ |
| apply sum_congr rfl |
| intro r _ |
| unfold StarSimplex.flags CoreFlags.change |
| by_cases he:CoreFlags.flag (P i r) t ω=CoreFlags.flag (P i r) (t+1) ω |
| · simp only [he,ite_true] |
| · simp only [he,Ne.symm he,ite_false] |
|
|
| lemma flags_budget (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (N:ℕ): |
| (∑ t∈range N,avg w (flags P t))≤ flagConstant*inventory (flat P) N:=by |
| have h:=CoreFlags.core_change_budget hw hw1 (flat P) N |
| change (∑ t∈range N,avg w (fun ω=>∑ ir:J×R,CoreFlags.change (P ir.1 ir.2) t ω))≤_ at h |
| simpa only [←flags_eq,flagConstant,inventory,drift] using h |
|
|
| lemma inventory_flat (P:J→ R→ FilteredRanks w) (N:ℕ): |
| inventory (flat P) N=∑ i,inventory (P i) N:=by |
| simp only [inventory,drift,flat,Fintype.sum_prod_type,avg_sum,sum_add_distrib,sum_const,nsmul_eq_mul, |
| Fintype.card_prod,Nat.cast_mul,card_univ] |
| rw [sum_comm] |
|
|
| lemma active_budget (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (N:ℕ): |
| (∑ t∈range N,avg w (active P t))≤ activeConstant*inventory (flat P) N:=by |
| have hb (i:J): (∑ t∈range N,avg w (fun ω=> CoarseSchedule.charge |
| (CoarseProcess.active cutoff ds (P i) ω t) (CoarseProcess.active cutoff ds (P i) ω (t+1))))≤ |
| activeConstant*inventory (P i) N:=by |
| have h:=CoarseProcess.active_budget (by norm_num [cutoff] : 0< cutoff) |
| (by norm_num [ds] : 0< ds) (by norm_num [ds] : ds≤1/1000) hw hw1 (P i) N |
| have hd:0≤ drift (P i) N:=by |
| unfold drift avg |
| exact sum_nonneg fun t _=>sum_nonneg fun ω _=>mul_nonneg (hw ω) |
| (sum_nonneg fun r _=>abs_nonneg _) |
| have hf:0≤ CoarseSchedule.factor ds:=by norm_num [CoarseSchedule.factor,ds] |
| rw [sum_comm] at h |
| simp only [←avg_sum] at h |
| change _≤ CoarseSchedule.factor ds*(5*(4/3:ℝ)^2/ds)*drift (P i) N+ |
| activeConstant*Fintype.card R at h |
| dsimp only [activeConstant,inventory] at ⊢ |
| dsimp only [activeConstant] at h |
| nlinarith [mul_nonneg hf hd] |
| change (∑ t∈range N,avg w (fun ω=>∑ i,CoarseSchedule.charge |
| (CoarseProcess.active cutoff ds (P i) ω t) (CoarseProcess.active cutoff ds (P i) ω (t+1))))≤_ |
| simp only [avg_sum] |
| rw [sum_comm,inventory_flat,mul_sum] |
| exact sum_le_sum fun i _=> hb i |
|
|
| lemma parent_budget (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (Q:R→ FilteredRanks w) (N:ℕ): |
| (∑ t∈range N,avg w (parentCharge Q t))≤ parentConstant*inventory Q N:=by |
| have h:=CoarseEpoch.parent_budget (by norm_num [cutoff] : 0≤ cutoff) |
| (by norm_num [dp,lb,cb] : 0< dp) (by norm_num [dp,lb,cb] : dp≤1/3) hw hw1 Q N |
| rw [sum_comm] at h |
| change (∑ t∈range N,avg w (CoarseProcess.relativeCharge dp (clipped cutoff dp Q) t))≤_ |
| simpa only [←avg_sum,parentConstant,inventory,drift] using h |
|
|
| lemma wholesale_budget (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ) (ω:Ω): |
| (∑ t∈range N,wholesale P Q t ω)≤203*(∑ t∈range N,active P t ω)+ |
| 2*(∑ t∈range N,parentCharge Q t ω):=by |
| exact CoarseEpoch.wholesale_budget (by norm_num [cutoff]) (by norm_num [ds]) (by norm_num [ds]) |
| (by norm_num [dp,lb,cb]) (by norm_num [dp,lb,cb]) P Q hs id ω N |
|
|
| lemma sideRefresh_budget (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ) (ω:Ω): |
| (∑ t∈range N,sideRefresh P Q t ω)≤ CoarseSide.C ds*(∑ t∈range N,active P t ω):=by |
| exact (CoarseSide.side_budget (by norm_num [ds] : 0< ds) (vector cutoff ds P ω) |
| (fun s=> key Q s ω) (vector_nonneg cutoff ds P ω) N).trans |
| (mul_le_mul_of_nonneg_left (sum_le_sum fun t _=> vector_variation cutoff ds P ω t) |
| (CoarseSide.C_nonneg (by norm_num [ds]))) |
| end KServer.ActualCharges |
|
|
| end |
|
|
|
|
| /-! Uniform coarse accounting for the actual local star. The only variable |
| right-hand side is the sum of true drift and one fixed rank inventory. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ActualCharges |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar |
| variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ} |
|
|
| def total (w:Ω→ℝ) (N:ℕ) (f:ℕ→Ω→ℝ):ℝ:=∑ t∈range N,avg w (f t) |
| def stock (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ):ℝ:= |
| inventory (flat P) N+inventory Q N |
|
|
| def wholesaleConstant:ℝ:=203*activeConstant+2*parentConstant |
| def scaleConstant:ℝ:=80/ds+flagConstant+41*wholesaleConstant |
| def sideRefreshConstant:ℝ:=CoarseSide.C ds*activeConstant |
|
|
| lemma total_mono (hw:∀ ω,0≤ w ω) {N:ℕ} {f g:ℕ→Ω→ℝ} (h:∀ t ω,f t ω≤ g t ω): |
| total w N f≤ total w N g:=sum_le_sum fun t _=> avg_mono hw (h t) |
| lemma total_nonneg (hw:∀ ω,0≤ w ω) {N:ℕ} {f:ℕ→Ω→ℝ} (h:∀ t ω,0≤ f t ω): |
| 0≤ total w N f:=sum_nonneg fun t _=> sum_nonneg fun ω _=> mul_nonneg (hw ω) (h t ω) |
| lemma total_add (N:ℕ) (f g:ℕ→Ω→ℝ): |
| total w N (fun t ω=> f t ω+g t ω)=total w N f+total w N g:=by |
| simp only [total,avg_add,sum_add_distrib] |
| lemma total_mul (N:ℕ) (c:ℝ) (f:ℕ→Ω→ℝ): |
| total w N (fun t ω=> c*f t ω)=c*total w N f:=by |
| simp only [total,avg_mul,←mul_sum] |
| lemma stock_nonneg (hw:∀ ω,0≤ w ω) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| 0≤ stock P Q N:=add_nonneg (inventory_nonneg hw _ _) (inventory_nonneg hw _ _) |
| lemma inventory_child_le (hw:∀ ω,0≤ w ω) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| inventory (flat P) N≤ stock P Q N:=le_add_of_nonneg_right (inventory_nonneg hw _ _) |
| lemma inventory_parent_le (hw:∀ ω,0≤ w ω) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| inventory Q N≤ stock P Q N:=le_add_of_nonneg_left (inventory_nonneg hw _ _) |
| lemma more_constants_nonneg:0≤ wholesaleConstant ∧ 0≤ scaleConstant ∧ 0≤ sideRefreshConstant:=by |
| rcases constants_nonneg with ⟨ha,hp,hf⟩ |
| have hc:=CoarseSide.C_nonneg (by norm_num [ds]:0< ds) |
| have hd:0≤80/ds:=by norm_num [ds] |
| dsimp only [wholesaleConstant,scaleConstant,sideRefreshConstant] |
| constructor |
| · positivity |
| constructor <;> positivity |
|
|
| lemma flags_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| total w N (flags P)≤ flagConstant*stock P Q N:= |
| (flags_budget hw hw1 P N).trans (mul_le_mul_of_nonneg_left (inventory_child_le hw P Q N) constants_nonneg.2.2) |
| lemma active_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| total w N (ActualCharges.active P)≤ activeConstant*stock P Q N:= |
| (active_budget hw hw1 P N).trans (mul_le_mul_of_nonneg_left (inventory_child_le hw P Q N) constants_nonneg.1) |
| lemma parent_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| total w N (parentCharge Q)≤ parentConstant*stock P Q N:= |
| (parent_budget hw hw1 Q N).trans (mul_le_mul_of_nonneg_left (inventory_parent_le hw P Q N) constants_nonneg.2.1) |
| lemma wholesale_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ): |
| total w N (wholesale P Q)≤ wholesaleConstant*stock P Q N:=by |
| have h:=avg_mono hw (wholesale_budget P Q hs N) |
| simp only [avg_add,avg_mul,←CoarseProcess.avg_range] at h |
| change total w N (wholesale P Q)≤203*total w N (ActualCharges.active P)+2*total w N (parentCharge Q) at h |
| have ha:=active_bound hw hw1 P Q N |
| have hp:=parent_bound hw hw1 P Q N |
| dsimp only [wholesaleConstant] |
| nlinarith |
| lemma sideRefresh_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (N:ℕ): |
| total w N (sideRefresh P Q)≤ sideRefreshConstant*stock P Q N:=by |
| have h:=avg_mono hw (sideRefresh_budget P Q N) |
| simp only [avg_mul,←CoarseProcess.avg_range] at h |
| change total w N (sideRefresh P Q)≤ CoarseSide.C ds*total w N (ActualCharges.active P) at h |
| exact h.trans (by simpa only [sideRefreshConstant,mul_assoc] using |
| mul_le_mul_of_nonneg_left (active_bound hw hw1 P Q N) (CoarseSide.C_nonneg (by norm_num [ds]))) |
|
|
| lemma scale_eq (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω): |
| ActualOutput.D P Q t ω=CoarseScale.scale ds P t ω |
| (EpochSchedule.run (vector cutoff ds P ω) (fun s=> key Q s ω) t):=by |
| unfold ActualOutput.D StarSide.scale StarSide.mark CoarseScale.scale |
| cases EpochSchedule.dominant (EpochSchedule.run (vector cutoff ds P ω) (fun s=> key Q s ω) t) <;> rfl |
|
|
| lemma scale_bound (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ): |
| total w N (fun t ω=>|ActualOutput.D P Q (t+1) ω-ActualOutput.D P Q t ω|)≤ scaleConstant*stock P Q N:=by |
| have hc:=CoarseScale.scale_budget (by norm_num [cutoff]:0< cutoff) (by norm_num [ds]:0< ds) |
| (by norm_num [ds]:ds≤1/1000) hw hw1 P (fun ω t=> key Q t ω) N |
| have hd:(∑ i,∑ r,∑ t∈range N,avg w (fun ω=>|(P i r).p (t+1) ω-(P i r).before (t+1) ω|))=drift (flat P) N:=by |
| simp only [drift,flat,Fintype.sum_prod_type,avg_sum] |
| symm |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro i _ |
| exact sum_comm |
| simp only [hd,←scale_eq] at hc |
| have hi:drift (flat P) N+(Fintype.card J:ℝ)*(Fintype.card R:ℝ)=inventory (flat P) N:=by |
| simp only [inventory,Fintype.card_prod,Nat.cast_mul] |
| rw [hi] at hc |
| change total w N (fun t ω=>|ActualOutput.D P Q (t+1) ω-ActualOutput.D P Q t ω|)≤ |
| (80/ds+flagConstant)*inventory (flat P) N+41*total w N (wholesale P Q) at hc |
| have hwc:=wholesale_bound hw hw1 P Q hs N |
| have hci:=inventory_child_le hw P Q N |
| have hcc:0≤80/ds+flagConstant:=by have h:=constants_nonneg.2.2; norm_num [ds]; positivity |
| have hb:=mul_le_mul_of_nonneg_left hci hcc |
| dsimp only [scaleConstant] |
| nlinarith |
| end KServer.ActualCharges |
|
|
| end |
|
|
|
|
| /-! Deterministic payment for the literal side state, with only actual edits |
| on the right hand side. Parent parameters are held through an ordinary epoch. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SidePayment |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule StarSide |
| open SideFamilies |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w:Ω→ℝ} |
|
|
| lemma pre_actual {δ cw ell:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) |
| (hcw:0<cw) (hel:1≤ell) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) |
| (t:ℕ) (ω:Ω) (hb:0≤b t ω) |
| (hM:∀ i,b t ω+cw*logs δ P key t ω i/ell≤5) (hbe:b t ω=b (t+1) ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) : |
| let hp:0<ell:=lt_of_lt_of_le zero_lt_one hel |
| let d:=input hcw hp δ P key b |
| let a:=proportion hcw hp δ P key b t ω |
| |(family 40).value (prepareData (d t ω).data (d (t+1) ω).data) (d (t+1) ω).ranks a- |
| (family 40).value (d t ω).data (d (t+1) ω).ranks a|≤ |
| SideEdits.L cw ell*|scale δ P key (t+1) ω-scale δ P key t ω|+ |
| SideEdits.Q cw ell*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1)) := by |
| intro hp d a |
| have hh:=SideEdits.pre_edit hcw hel (sides δ P key t ω) (sides δ P key (t+1) ω) |
| (sideFlags δ P key t ω) (sideFlags δ P key (t+1) ω) |
| (logs δ P key t ω) (logs δ P key (t+1) ω) (fun i=>le_max_left _ _) (fun i=>le_max_left _ _) |
| hb hM (d (t+1) ω).ranks (fun ir=>(P ir.1 ir.2).range (t+1) ω) |
| (SideActualEdits.flags_supported δ P key t ω) (SideActualEdits.flags_supported δ P key (t+1) ω) |
| a (proportion_mem hcw hp δ P key b t ω) (D:=scale δ P key t ω) (E:=scale δ P key (t+1) ω) |
| have hd1:(d (t+1) ω).data=fromLog (sides δ P key (t+1) ω) (sideFlags δ P key (t+1) ω) |
| 16 (b t ω) (scale δ P key (t+1) ω) cw ell (logs δ P key (t+1) ω) |
| (by norm_num) hcw hp (fun i=>le_max_left _ _):=by dsimp [d,input]; rw [hbe] |
| rw [hd1] |
| exact hh.trans (add_le_add le_rfl (mul_le_mul_of_nonneg_left |
| (SideActualEdits.flags_change hδ hδu P key t ω he) (SideEdits.Q_nonneg hcw hp.le))) |
|
|
| lemma post_actual {δ cw ell:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) |
| (hcw:0<cw) (hel:1≤ell) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) |
| (t:ℕ) (ω:Ω) (hb:1≤b t ω) |
| (hM:∀ s i,b t ω+cw*logs δ P key s ω i/ell≤5) (hbe:b t ω=b (t+1) ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) : |
| let hp:0<ell:=lt_of_lt_of_le zero_lt_one hel |
| let d:=input hcw hp δ P key b |
| let a:=proportion hcw hp δ P key b t ω |
| let z:=SideFamilies.transport 40 (d t ω).data (d (t+1) ω).data (d (t+1) ω).ranks a |
| |(family 40).value (d (t+1) ω).data (d (t+1) ω).ranks z- |
| (family 40).value (prepareData (d t ω).data (d (t+1) ω).data) (d (t+1) ω).ranks z|≤ |
| SideEdits.K cw ell*(40*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1)))) := by |
| intro hp d a z |
| have hh:=SideEdits.post_edit hcw hel (sides δ P key t ω) (sides δ P key (t+1) ω) |
| (sideFlags δ P key t ω) (sideFlags δ P key (t+1) ω) |
| (logs δ P key t ω) (logs δ P key (t+1) ω) (fun i=>le_max_left _ _) (fun i=>le_max_left _ _) |
| hb (hM t) (hM (t+1)) (scale_nonneg δ P key (t+1) ω) (d (t+1) ω).ranks |
| (fun ir=>((P ir.1 ir.2).range (t+1) ω).1) a (proportion_mem hcw hp δ P key b t ω) |
| (D:=scale δ P key t ω) |
| have hd1:(d (t+1) ω).data=fromLog (sides δ P key (t+1) ω) (sideFlags δ P key (t+1) ω) |
| 16 (b t ω) (scale δ P key (t+1) ω) cw ell (logs δ P key (t+1) ω) |
| (by norm_num) hcw hp (fun i=>le_max_left _ _):=by dsimp [d,input]; rw [hbe] |
| dsimp only at hh |
| rw [←hd1] at hh |
| have hK:0≤SideEdits.K cw ell:=by |
| unfold SideEdits.K |
| have hl:=Real.log_nonneg (show (1:ℝ)≤17 by norm_num) |
| positivity |
| exact hh.trans (mul_le_mul_of_nonneg_left (SideActualEdits.logs_charge hδ hδu hcw hp P key b t ω |
| (d (t+1) ω).ranks (fun ir=>(P ir.1 ir.2).range (t+1) ω) he) hK) |
|
|
| end KServer.SidePayment |
|
|
| end |
|
|
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace KServer.SideFixed |
| open SideFamilies |
| attribute [local instance] Classical.decEq |
| variable {Ω J R:Type} [Fintype J] [Fintype R] |
| lemma payment (d:ℕ→Ω→CausalSide.Input J R) (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≤5) |
| (hW:10<(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:=CausalSide.run 40 d t ω |
| new.D*ChangingDomains.variation (CausalSide.run 40 d (t+1) ω) a≤ |
| (family 40).value old p a-(family 40).value new p (CausalSide.run 40 d (t+1) ω)+ |
| |(family 40).value (prepareData old new) p a-(family 40).value old p a|+ |
| |(family 40).value new p (SideFamilies.transport 40 old new p a)- |
| (family 40).value (prepareData old new) p (SideFamilies.transport 40 old new p a)| := by |
| have hh:=CausalSide.ordinary_payment d (M:=5) t ω he hWW hb hD hM (by norm_num; exact hW) hp |
| simpa only [show (8:ℝ)*5=40 by norm_num] using hh |
| lemma payment_of_edits (d:ℕ→Ω→CausalSide.Input J R) (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≤5) |
| (hW:10<(d t ω).data.W) (hp:∀ ir,0≤(d (t+1) ω).ranks ir) (u v:ℝ) |
| (hpre: |(family 40).value (prepareData (d t ω).data (d (t+1) ω).data) |
| (d (t+1) ω).ranks (CausalSide.run 40 d t ω)- |
| (family 40).value (d t ω).data (d (t+1) ω).ranks (CausalSide.run 40 d t ω)|≤u) |
| (hpost: |(family 40).value (d (t+1) ω).data (d (t+1) ω).ranks |
| (SideFamilies.transport 40 (d t ω).data (d (t+1) ω).data (d (t+1) ω).ranks (CausalSide.run 40 d t ω))- |
| (family 40).value (prepareData (d t ω).data (d (t+1) ω).data) (d (t+1) ω).ranks |
| (SideFamilies.transport 40 (d t ω).data (d (t+1) ω).data (d (t+1) ω).ranks (CausalSide.run 40 d t ω))|≤v) : |
| (d (t+1) ω).data.D*ChangingDomains.variation (CausalSide.run 40 d (t+1) ω) (CausalSide.run 40 d t ω)≤ |
| (family 40).value (d t ω).data (d (t+1) ω).ranks (CausalSide.run 40 d t ω)- |
| (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (CausalSide.run 40 d (t+1) ω)+u+v := by |
| exact (payment d t ω he hWW hb hD hM hW hp).trans (add_le_add (add_le_add le_rfl hpre) hpost) |
|
|
| end KServer.SideFixed |
|
|
| end |
|
|
|
|
| /-! Deterministic payment for the literal side state, with only actual edits |
| on the right hand side. Parent parameters are held through an ordinary epoch. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SidePayment |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule StarSide |
| open SideFamilies |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [Fintype R] |
| variable {w:Ω→ℝ} |
|
|
| lemma ordinary {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k) |
| (hcw:0<cw) (hcwu:cw*20002≤1) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) |
| (hb:1≤b t ω) (hbu:b t ω≤4) (hbe:b t ω=b (t+1) ω) |
| (he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1)) : |
| let ell:=1+Real.log (k+1) |
| let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| let d:=input hcw hel δ P key b |
| let a:=proportion hcw hel δ P key b |
| scale δ P key (t+1) ω*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+ |
| SideEdits.L cw ell*|scale δ P key (t+1) ω-scale δ P key t ω|+ |
| SideEdits.Q cw ell*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 40*SideEdits.K cw ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) := by |
| intro ell hel d a |
| have hell:1≤ell:=by dsimp [ell]; linarith [Real.log_nonneg (show 1≤k+1 by linarith)] |
| have hM (s:ℕ) (i:J):b t ω+cw*logs δ P key s ω i/ell≤5:=by |
| have h:=SideActualEdits.theta_bound hδ hδu hk hcw hcwu P key hs s ω i |
| change cw*logs δ P key s ω i/ell≤1 at h |
| linarith |
| have hp:∀ ir,(d (t+1) ω).ranks ir∈Set.Icc 0 1:=fun ir=>(P ir.1 ir.2).range (t+1) ω |
| have hpre:=pre_actual hδ hδu hcw hell P key b t ω (by linarith) (hM t) hbe he |
| have hpost:=post_actual hδ hδu hcw hell P key b t ω hb hM hbe he |
| have hpst : |(family 40).value (d (t+1) ω).data (d (t+1) ω).ranks |
| (SideFamilies.transport 40 (d t ω).data (d (t+1) ω).data (d (t+1) ω).ranks (a t ω))- |
| (family 40).value (prepareData (d t ω).data (d (t+1) ω).data) (d (t+1) ω).ranks |
| (SideFamilies.transport 40 (d t ω).data (d (t+1) ω).data (d (t+1) ω).ranks (a t ω))|≤ |
| 40*SideEdits.K cw ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) := by |
| simpa only [mul_left_comm,mul_assoc] using hpost |
| have hpay:=SideFixed.payment_of_edits d t ω he rfl hb (scale_nonneg δ P key (t+1) ω) |
| (fun i _=>hM t i) (by norm_num : (10:ℝ)<16) (fun ir=>(hp ir).1) _ _ hpre hpst |
| dsimp only [a,proportion,d] at * |
| simpa only [input,fromLog,add_assoc] using hpay |
|
|
| end KServer.SidePayment |
|
|
| end |
|
|
|
|
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SideActualBounds |
| attribute [local instance] Classical.propDecidable |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule StarSide |
| open SideFamilies |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [DecidableEq J] [Fintype R] |
| variable {w:Ω→ℝ} |
|
|
| omit [DecidableEq J] in |
| lemma scale_bound {δ:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) |
| (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : |
| StarSide.scale δ P key t ω≤41*EpochSchedule.total (vector cutoff δ P ω t) := by |
| have h:=CoarseScale.scale_bound (by norm_num [cutoff] : 0<cutoff) hδ hδu P t ω |
| (EpochSchedule.run (vector cutoff δ P ω) (fun s=>key s ω) t) |
| (EpochSchedule.run_valid (vector cutoff δ P ω) (fun s=>key s ω) (vector_nonneg cutoff δ P ω) t) |
| change CoarseScale.scale δ P t ω _≤_ at h |
| unfold CoarseScale.scale at h |
| unfold StarSide.scale mark |
| cases hm : EpochSchedule.dominant (EpochSchedule.run (vector cutoff δ P ω) (fun s => key s ω) t) <;> |
| simpa only [hm, Option.elim,CoarseScale.noncore,coarseFlex] using h |
|
|
| lemma core_bound {δ cw ell:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hcw:0<cw) (hel:0<ell) |
| (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) (t:ℕ) (ω:Ω) |
| (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) : |
| (∑ i,core (input hcw hel δ P key b t ω).data p i)≤40*EpochSchedule.total (vector cutoff δ P ω t) := by |
| unfold EpochSchedule.total |
| rw [mul_sum] |
| apply sum_le_sum |
| intro i _ |
| apply le_trans _ (ScheduleEdits.count_bound hδ hδu (P i) t ω) |
| apply sum_le_sum |
| intro r _ |
| change (if sideFlags δ P key t ω i r then p (i,r) else 0)≤ |
| (if CoreFlags.flag (P i r) t ω then 1 else 0) |
| by_cases hf:CoreFlags.flag (P i r) t ω=true |
| · simp only [sideFlags,hf,ite_true] |
| split_ifs <;> first | exact (hp (i,r)).2 | norm_num |
| · simp [sideFlags,hf] |
|
|
| lemma endpoint {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k) |
| (hcw:0<cw) (hcwu:cw*20002≤1) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) (hb:0≤b t ω) (hbu:b t ω≤4) |
| (p:J×R→ℝ) (hp:∀ ir,p ir∈Set.Icc 0 1) : |
| let ell:=1+Real.log (k+1) |
| let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| let d:=input hcw hel δ P key b |
| let a:=proportion hcw hel δ P key b |
| |(family 40).value (d t ω).data p (a t ω)|≤ |
| 200000*(1/cw+1)*ell*EpochSchedule.total (vector cutoff δ P ω t) := by |
| intro ell hel d a |
| have hell:1≤ell:=by dsimp [ell]; linarith [Real.log_nonneg (show 1≤k+1 by linarith)] |
| have hM (i:J):b t ω+cw*logs δ P key t ω i/ell≤5:=by |
| have h:=SideActualEdits.theta_bound hδ hδu hk hcw hcwu P key hs t ω i |
| change cw*logs δ P key t ω i/ell≤1 at h |
| linarith |
| have h:=SideProfile.endpoint hcw hell (sides δ P key t ω) (sideFlags δ P key t ω) |
| (logs δ P key t ω) (fun i=>le_max_left _ _) hb hM (scale_nonneg δ P key t ω) |
| p (fun ir=>(hp ir).1) (a t ω) (proportion_mem hcw hel δ P key b t ω) |
| change |(family 40).value (d t ω).data p (a t ω)|≤ |
| 640*(1/cw+1)*ell*scale δ P key t ω+(3600/cw*ell)*(∑ i,core (d t ω).data p i) at h |
| have hD:=mul_le_mul_of_nonneg_left (scale_bound hδ hδu P key t ω) |
| (show 0≤640*(1/cw+1)*ell by positivity) |
| have hB:=mul_le_mul_of_nonneg_left (core_bound hδ hδu hcw hel P key b t ω p hp) |
| (show 0≤3600/cw*ell by positivity) |
| have hn:=EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω t) |
| have he:0≤ell*EpochSchedule.total (vector cutoff δ P ω t):=mul_nonneg hel.le hn |
| have hc:0≤1/cw*(ell*EpochSchedule.total (vector cutoff δ P ω t)):=by positivity |
| change (3600/cw*ell)*(∑ i,core (d t ω).data p i)≤_ at hB |
| simp only [div_eq_mul_inv,one_mul] at h hD hB he hc ⊢ |
| nlinarith only [h,hD,hB,he,hc] |
|
|
| lemma variation_bound {cw ell:ℝ} (hcw:0<cw) (hel:0<ell) (δ:ℝ) |
| (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) (t:ℕ) (ω:Ω) : |
| ChangingDomains.variation (proportion hcw hel δ P key b (t+1) ω) (proportion hcw hel δ P key b t ω)≤32 := by |
| have ha:=proportion_mem hcw hel δ P key b t ω |
| have ha':=proportion_mem hcw hel δ P key b (t+1) ω |
| calc _≤∑ i,(proportion hcw hel δ P key b (t+1) ω i+proportion hcw hel δ P key b t ω i) := by |
| exact sum_le_sum fun i _=>(abs_sub _ _).trans_eq (by rw [abs_of_nonneg (ha'.1 i),abs_of_nonneg (ha.1 i)]) |
| _≤32 := by rw [sum_add_distrib]; linarith [ha.2.1,ha'.2.1] |
| |
| end KServer.SideActualBounds |
| |
| end |
| |
| |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.SidePayment |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking RankFunctions CoarseEpoch CoarseProcess StarProfile AllocationSchedule StarSide SideFamilies |
| variable {Ω J R K : Type} [Fintype Ω] [Fintype J] [Fintype R] |
| variable {w:Ω→ℝ} |
| |
| def expense (cw ell δ:ℝ) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (t:ℕ) (ω:Ω) : ℝ := |
| if epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1) then |
| SideEdits.L cw ell*|scale δ P key (t+1) ω-scale δ P key t ω|+ |
| SideEdits.Q cw ell*ChangingDomains.changedFlags (StarSimplex.flags P ω t) (StarSimplex.flags P ω (t+1))+ |
| 40*SideEdits.K cw ell*(∑ i,CoarseSchedule.charge (active cutoff δ (P i) ω t) (active cutoff δ (P i) ω (t+1))) |
| else 300000*(1/cw+1)*ell*(EpochSchedule.total (vector cutoff δ P ω t)+EpochSchedule.total (vector cutoff δ P ω (t+1))) |
| |
| lemma payment {δ k cw:ℝ} (hδ:0<δ) (hδu:δ≤1/1000) (hk:1≤k) |
| (hcw:0<cw) (hcwu:cw*20002≤1) (P:J→R→FilteredRanks w) (key:ℕ→Ω→K) (b:ℕ→Ω→ℝ) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤k) (t:ℕ) (ω:Ω) |
| (hb:∀ s,1≤b s ω) (hbu:∀ s,b s ω≤4) |
| (hbe: key t ω=key (t+1) ω→b t ω=b (t+1) ω) : |
| let ell:=1+Real.log (k+1) |
| let hel:0<ell:=by have h:=Real.log_nonneg (show 1≤k+1 by linarith); dsimp [ell]; linarith |
| let d:=input hcw hel δ P key b |
| let a:=proportion hcw hel δ P key b |
| scale δ P key (t+1) ω*ChangingDomains.variation (a (t+1) ω) (a t ω)≤ |
| (family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+expense cw ell δ P key t ω := by |
| intro ell hel d a |
| by_cases he:epoch (vector cutoff δ P ω) (fun s=>key s ω) t= |
| epoch (vector cutoff δ P ω) (fun s=>key s ω) (t+1) |
| · have hp:=ordinary hδ hδu hk hcw hcwu P key b hs t ω (hb t) (hbu t) |
| (hbe (SideActualEdits.ordinary_key (vector cutoff δ P ω) (fun s=>key s ω) t he)) he |
| change _≤(family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)- |
| (family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)+_+_+_ at hp |
| simpa only [expense,ite_eq_left he,add_assoc] using hp |
| · have h0:=SideActualBounds.endpoint hδ hδu hk hcw hcwu P key b hs t ω |
| (by linarith [hb t] : 0≤b t ω) (hbu t) (d (t+1) ω).ranks (fun ir=>(P ir.1 ir.2).range (t+1) ω) |
| have h1:=SideActualBounds.endpoint hδ hδu hk hcw hcwu P key b hs (t+1) ω |
| (by linarith [hb (t+1)] : 0≤b (t+1) ω) (hbu (t+1)) (d (t+1) ω).ranks (fun ir=>(P ir.1 ir.2).range (t+1) ω) |
| change |(family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)|≤_ at h0 |
| change |(family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)|≤_ at h1 |
| have hv:=SideActualBounds.variation_bound hcw hel δ P key b t ω |
| change ChangingDomains.variation (a (t+1) ω) (a t ω)≤32 at hv |
| have hmv:=mul_le_mul_of_nonneg_left hv (scale_nonneg δ P key (t+1) ω) |
| have hD:=SideActualBounds.scale_bound hδ hδu P key (t+1) ω |
| have hel1:1≤ell:=by dsimp [ell]; linarith [Real.log_nonneg (show 1≤k+1 by linarith)] |
| have hold:=EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω t) |
| have hnew:=EpochSchedule.total_nonneg (vector_nonneg cutoff δ P ω (t+1)) |
| have hc:1≤(1/cw+1)*ell:=by |
| have hc:0≤1/cw:=by positivity |
| nlinarith only [hel1,hc] |
| have hcost:=mul_le_mul_of_nonneg_right hc hnew |
| have hor:0≤(1/cw+1)*ell*EpochSchedule.total (vector cutoff δ P ω t):=by positivity |
| rw [expense,ite_eq_right he] |
| have hlo:=neg_abs_le ((family 40).value (d t ω).data (d (t+1) ω).ranks (a t ω)) |
| have hhi:=le_abs_self ((family 40).value (d (t+1) ω).data (d (t+1) ω).ranks (a (t+1) ω)) |
| dsimp only [ell] at * |
| nlinarith only [h0,h1,hmv,hD,hcost,hor,hlo,hhi,hnew] |
| |
| end KServer.SidePayment |
| |
| end |
| |
| |
| /-! Fixed absolute coefficients for actual simplex/side edits. -/ |
| noncomputable section |
| open scoped BigOperators |
| open Finset |
| namespace KServer.ActualCharges |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| open RankTracking RankFunctions CoarseProcess CoarseEpoch StarProfile AllocationSchedule LocalConstants ActualStar |
| variable {Ω J R:Type} [Fintype Ω] [Fintype J] [Fintype R] {w:Ω→ℝ} |
| |
| def simplexConstant:ℝ:=(26*C+4)*flagConstant+320*C*activeConstant+ |
| 2976*C*sideRefreshConstant+(520*C+80)*wholesaleConstant |
| def sideConstant:ℝ:=SideEdits.L cw 1*scaleConstant+SideEdits.Q cw 1*flagConstant+ |
| 40*SideEdits.K cw 1*activeConstant+300000*(1/cw+1)*wholesaleConstant |
| lemma edit_constants_nonneg:0≤ simplexConstant ∧ 0≤ sideConstant:=by |
| rcases constants_nonneg with ⟨ha,hp,hf⟩ |
| rcases more_constants_nonneg with ⟨hh,hs,hr⟩ |
| have hC:0< C:=positive.2.2.2.2.1 |
| have hc:0< cw:=positive.2.2.2.1 |
| have hl:0≤ Real.log 17:=Real.log_nonneg (by norm_num) |
| dsimp only [simplexConstant,sideConstant,SideEdits.L,SideEdits.Q,SideEdits.K] |
| constructor <;> positivity |
| |
| lemma simplex_expense (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) {ell:ℝ} (hell:1≤ ell) |
| (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ): |
| total w N (ScheduledPayment.expense C ell ds P (key Q))≤ simplexConstant*ell*stock P Q N:=by |
| have he:total w N (ScheduledPayment.expense C ell ds P (key Q))= |
| (26*C*ell+4)*total w N (flags P)+320*C*ell*total w N (ActualCharges.active P)+ |
| 2976*C*ell*total w N (sideRefresh P Q)+(520*C*ell+80)*total w N (wholesale P Q):=by |
| change total w N (fun t ω=>(26*C*ell+4)*flags P t ω+320*C*ell*ActualCharges.active P t ω+ |
| 2976*C*ell*sideRefresh P Q t ω+(520*C*ell+80)*wholesale P Q t ω)=_ |
| rw [total_add,total_add,total_add,total_mul,total_mul,total_mul,total_mul] |
| have hf:=flags_bound hw hw1 P Q N |
| have ha:=active_bound hw hw1 P Q N |
| have hr:=sideRefresh_bound hw hw1 P Q N |
| have hh:=wholesale_bound hw hw1 P Q hs N |
| have hC:=positive.2.2.2.2.1 |
| have hstock:=stock_nonneg hw P Q N |
| have hflag:=mul_nonneg constants_nonneg.2.2 hstock |
| have hwhole:=mul_nonneg more_constants_nonneg.1 hstock |
| have hb:total w N (ScheduledPayment.expense C ell ds P (key Q))≤ |
| (26*C*ell+4)*(flagConstant*stock P Q N)+320*C*ell*(activeConstant*stock P Q N)+ |
| 2976*C*ell*(sideRefreshConstant*stock P Q N)+(520*C*ell+80)*(wholesaleConstant*stock P Q N):=by |
| rw [he] |
| gcongr |
| dsimp only [simplexConstant] |
| nlinarith [mul_nonneg (sub_nonneg.mpr hell) hflag,mul_nonneg (sub_nonneg.mpr hell) hwhole] |
| |
| lemma side_expense_step {ell:ℝ} (hell:0≤ ell) (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) (t:ℕ) (ω:Ω): |
| SidePayment.expense cw ell ds P (key Q) t ω≤ |
| SideEdits.L cw ell*|ActualOutput.D P Q (t+1) ω-ActualOutput.D P Q t ω|+ |
| SideEdits.Q cw ell*flags P t ω+40*SideEdits.K cw ell*ActualCharges.active P t ω+ |
| 300000*(1/cw+1)*ell*wholesale P Q t ω:=by |
| have hc:0< cw:=positive.2.2.2.1 |
| have hl:0≤ Real.log 17:=Real.log_nonneg (by norm_num) |
| have hf:=flags_nonneg P t ω |
| have ha:=active_nonneg P t ω |
| have hd:=abs_nonneg (ActualOutput.D P Q (t+1) ω-ActualOutput.D P Q t ω) |
| have hw:=wholesale_nonneg P Q t ω |
| unfold SidePayment.expense |
| split_ifs |
| · change _≤ SideEdits.L cw ell*|StarSide.scale ds P (key Q) (t+1) ω-StarSide.scale ds P (key Q) t ω|+ |
| SideEdits.Q cw ell*flags P t ω+40*SideEdits.K cw ell*ActualCharges.active P t ω+_ |
| exact le_add_of_nonneg_right (by positivity) |
| · have he:EpochSchedule.reset (vector cutoff ds P ω t) (vector cutoff ds P ω (t+1)) |
| (key Q t ω) (key Q (t+1) ω) (EpochSchedule.run (vector cutoff ds P ω) (fun s=> key Q s ω) t):=by |
| exact not_not.mp (fun hn=> by rename_i hh; exact hh ((epoch_same_iff _ _ t).mpr hn)) |
| rw [wholesale,EpochSchedule.wholesale,ite_eq_left he] |
| dsimp only [SideEdits.L,SideEdits.Q,SideEdits.K] |
| have h1:0≤ SideEdits.L cw ell*|ActualOutput.D P Q (t+1) ω-ActualOutput.D P Q t ω|:=by |
| dsimp only [SideEdits.L]; positivity |
| have h2:0≤ SideEdits.Q cw ell*flags P t ω:=by dsimp only [SideEdits.Q]; positivity |
| have h3:0≤40*SideEdits.K cw ell*ActualCharges.active P t ω:=by dsimp only [SideEdits.K]; positivity |
| dsimp only [SideEdits.L,SideEdits.Q,SideEdits.K] at h1 h2 h3 |
| linarith |
| |
| lemma side_expense (hw:∀ ω,0≤ w ω) (hw1:∑ ω,w ω=1) {ell:ℝ} (hell:0≤ ell) |
| (P:J→ R→ FilteredRanks w) (Q:R→ FilteredRanks w) |
| (hs:∀ t ω,(∑ i,size (P i) t ω)≤ size Q t ω) (N:ℕ): |
| total w N (SidePayment.expense cw ell ds P (key Q))≤ sideConstant*ell*stock P Q N:=by |
| have h:=total_mono hw (N:=N) (side_expense_step hell P Q) |
| rw [total_add,total_add,total_add,total_mul,total_mul,total_mul,total_mul] at h |
| have hD:=scale_bound hw hw1 P Q hs N |
| have hf:=flags_bound hw hw1 P Q N |
| have ha:=active_bound hw hw1 P Q N |
| have hh:=wholesale_bound hw hw1 P Q hs N |
| have hc:0< cw:=positive.2.2.2.1 |
| have hl:0≤ Real.log 17:=Real.log_nonneg (by norm_num) |
| calc _≤ _:=h |
| _≤ SideEdits.L cw ell*(scaleConstant*stock P Q N)+SideEdits.Q cw ell*(flagConstant*stock P Q N)+ |
| 40*SideEdits.K cw ell*(activeConstant*stock P Q N)+300000*(1/cw+1)*ell*(wholesaleConstant*stock P Q N):=by |
| dsimp only [SideEdits.L,SideEdits.Q,SideEdits.K] |
| gcongr |
| _= _:=by dsimp only [sideConstant,SideEdits.L,SideEdits.Q,SideEdits.K]; ring |
| end KServer.ActualCharges |
| |
| end |
| |
| end OAI |
| |
