| import OAI.Analysis.FourierLLogL.Procedure.Road |
| import OAI.Analysis.FourierLLogL.Thermal.True |
|
|
| /-! |
| open Function Set Filter |
| open scoped Topology BigOperators ComplexConjugate |
| noncomputable section |
| namespace OAI |
|
|
| namespace FourierLLogL.Dyadic.Procedure |
| open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal |
| variable {M J j : ℕ} {s : Scene M} {f : Grid M → ℝ} |
| open scoped Classical |
|
|
| structure Memory (M : ℕ) where |
| profile : Profile M |
| current : Grid M |
|
|
| namespace Memory |
| def piece (A B : Form M) (w : Clutch j M) : Profile M := |
| (B,w.1) :: List.ofFn (fun i => (A,w.2 i)) |
|
|
| def stash (m : Memory M) (A B : Form M) (w : Clutch j M) : |
| Memory M := ⟨piece A B w ++ m.profile,w.1⟩ |
|
|
| structure Ready (m : Memory M) (j : ℕ) (c : Fund M) : Prop where |
| ordered : ∀ i ∈ m.profile, 0 ≤ i.1 ∧ i.1 ≤ c.mood |
| has : (c.mood, m.current)∈m.profile |
| num : m.profile.length = 1+c.uses*(1+clones j) |
|
|
|
|
| def temp (j : ℕ) := cushion j / (capA * H j) |
|
|
| def loadE (A B : Form M) (w : Clutch j M) (x : Grid M) := |
| form B (w.1-x) + ∑ i, form A (w.2 i-x) |
|
|
| lemma stash_ready (m : Memory M) {s : Scene M} (h : Ready m j s.fund) |
| (u : Update j M s.here) (hD : 0 ≤ u.changeForm) (hA : 0 ≤ s.fund.mood) (w : Clutch j M) : |
| Ready (m.stash s.fund.mood (u.next s.fund.mood) w) j (s.fund.advance s.here u) := by |
| let B := u.next s.fund.mood |
| have H : s.fund.mood ≤ B := |
| (le_add_of_nonneg_right (place_valid _ _)).trans (le_add_of_nonneg_right hD) |
| constructor |
| · intro t ht |
| simp only [stash,piece,List.mem_append,List.mem_cons,List.mem_ofFn] at ht |
| rcases ht with (he|he)|he |
| · subst t; exact ⟨hA.trans H,le_rfl⟩ |
| · obtain ⟨i,rfl⟩ := he; exact ⟨hA,H⟩ |
| obtain ⟨hl,hr⟩ := h.ordered t he |
| exact ⟨hl,hr.trans H⟩ |
| · simp [advance,stash,piece] |
| · simp only [stash,List.length_append,piece,List.length_cons,List.length_ofFn,h.num,advance] |
| ring |
|
|
| lemma stash_length_bound (m : Memory M) {s : Scene M} (h : Ready m j s.fund) |
| (hg : Safe s j J f) : |
| ↑(m.profile.length) ≤ observationBudget capA j := by |
| rw [h.num,observationBudget] |
| push_cast; gcongr |
| exact hg.capital.under |
| |
| lemma sumE_piece (A B : Form M) (w : Clutch j M) (x : Grid M) : |
| sumE (piece A B w) x = loadE A B w x := by |
| simp only [sumE,piece,List.map_cons,List.map_ofFn,Function.comp_def, |
| List.sum_cons,List.sum_ofFn,loadE] |
|
|
| lemma sumE_stash (m : Memory M) (A B : Form M) (w : Clutch j M) (x : Grid M) : |
| sumE (m.stash A B w).profile x = loadE A B w x + sumE m.profile x := by |
| rw [←sumE_piece] |
| simp only [stash,sumE,List.map_append,List.sum_append] |
|
|
| lemma form_in_past (m : Memory M) (p : Form M × Grid M) |
| (h : ∀ i∈m.profile, 0 ≤ i.1) (hp : p ∈ m.profile) (x : Grid M) : |
| form p.1 (p.2-x) ≤ sumE m.profile x := by |
| suffices HH : ∀ l : Profile M, (∀ i∈l, 0 ≤ i.1) → p∈l → |
| form p.1 (p.2-x) ≤ sumE l x from HH _ h hp |
| intro l; induction l with |
| | nil => simp |
| | cons i l ih => |
| intro h h' |
| have he : 0 ≤ i.1 := h i List.mem_cons_self |
| have hh : ∀ i∈l, 0 ≤ i.1 := fun i hi => h i (List.mem_cons_of_mem _ hi) |
| simp only [sumE,List.map_cons,List.sum_cons] |
| rcases List.mem_cons.mp h' with rfl|H |
| · apply le_add_of_nonneg_right |
| apply List.sum_nonneg |
| intro i hi |
| obtain ⟨x,hx,rfl⟩ := List.mem_map.mp hi |
| exact form_nonneg (hh _ hx) _ |
| exact (ih hh H).trans (le_add_of_nonneg_left (form_nonneg he _)) |
|
|
| def stashRate (A B : Form M) (j : ℕ) := |
| (side M*exp (F B)) * (side M*exp (F A))^(clones j) |
|
|
| lemma multiply_stash (m : Memory M) (A B : Form M) (p : Node) (x : Grid M) |
| (w : Clutch j M) : |
| prefixE m.profile p x * fresh A B j x w = |
| stashRate A B j * prefixE (m.stash A B w).profile p x := by |
| have hi (A : Form M) (v) : |
| channel A x v = (side M*exp (F A)) * exp (-form A (v-x)) := by |
| rw [ch_K,K_eq,sub_eq_add_neg,exp_add,mul_assoc] |
| have H (v : Fin (clones j) → Grid M) : |
| ∏ i, channel A x (v i) = (side M*exp (F A))^(clones j) * |
| exp (-(∑ i, form A (v i-x))) := by |
| simp_rw [hi,Finset.prod_mul_distrib,← Real.exp_sum,Finset.sum_neg_distrib] |
| simp [mul_pow,exp_nat_mul] |
| unfold prefixE |
| split_ifs with hh |
| · obtain ⟨v,c⟩ := w |
| rw [fresh,tensorP_apply,pack_apply,H,hi,stashRate] |
| simp_rw [tune,sumE_stash,loadE,neg_add,Real.exp_add] |
| ring |
| · ring |
|
|
| lemma rate_positive (j : ℕ) (A B : Form M) : 0 ≤ stashRate A B j := by |
| unfold stashRate; have := side_pos M; positivity |
| |
| lemma batch_expected (A B : Form M) (x : Grid M) (j : ℕ) : |
| (fresh A B j x).Ex (fun w => loadE A B w x) = |
| (label B).Ex (form B) + clones j * (label A).Ex (form A) := by |
| simp_rw [fresh,Ex_tensorP,loadE,Ex_add,Ex_const,Ex_finset_sum, |
| Ex_pack_proj (fun _ => channel A x) _ (fun z => form A (z-x))] |
| rw [ch_noise B (form B)] |
| simp_rw [ch_noise A (form A)] |
| simp |
|
|
| lemma batch_scale : |
| ∀ᶠ j : ℕ in atTop, ∀ M J : ℕ, ∀ s : Scene M, ∀ f : Grid M → ℝ, ∀ x : Grid M, |
| ∀ u : Update j M s.here, s.Safe j J f → (s.win u).Safe j J f → |
| let A := s.fund.mood |
| let B := u.next A |
| (fresh A B j x).prob (fun w => temp j < loadE A B w x) ≤ 1/4 := by |
| filter_upwards [h_large (100000*capA^2),hpoly (100000*capA^2) 230] with j h1 h2 M J s f x u ha hb A B |
| let T := fresh A B j x |
| have hA : 0 ≤ A := ha.capital.effects.nonneg |
| have hB : 0 ≤ B := hb.capital.effects.nonneg |
| have hT (w : Clutch j M) : 0 ≤ loadE A B w x := add_nonneg (form_nonneg hB _) |
| (Finset.sum_nonneg fun i _ => form_nonneg hA _) |
| let p (w : Clutch j M) : Prop := temp j < loadE A B w x |
| have he := upperTail T p (fun w => loadE A B w x) hT (temp j) fun _ hx => hx.le |
| let h := H j |
| have hh : 1 ≤ h := H_ge j |
| have hc := cap_ok; have hp : 0 < h := H_pos j |
| let d := height j; have hd : 0 < d := d_pos j |
| have ht : 0 < temp j := by |
| have he : 0 < capA := by linarith |
| change 0 < d/h^100/(capA*h) |
| positivity |
| let L := 2*plateErr j +100 |
| have hL : 0 ≤ L := by |
| change 0 ≤ 2*(d/h^400)+100; positivity |
| have Hx (s : Scene M) (hS : s.Safe j J f) : |
| (label s.fund.mood).Ex (form s.fund.mood) ≤ capA*h*L := |
| hS.capital.effects.energy.trans (mul_le_mul_of_nonneg_right hS.capital.under hL) |
| have hw : |
| temp j * T.prob p ≤ capA*h*L+h^120*(capA*h*L) := by |
| apply he.trans |
| unfold T; rw [batch_expected,clones_eq] |
| exact add_le_add (Hx (s.win u) hb) (mul_le_mul_of_nonneg_left (Hx s ha) (by positivity)) |
| change _ ≤ (1/4:ℝ) |
| refine le_of_mul_le_mul_left (hw.trans ?_) ht |
| have hP : 1 ≤ h^120 := one_le_pow₀ hh |
| have HC : 0 < capA := by linarith |
| change capA*h*L+h^120*(capA*h*L) ≤ d/h^100/(capA*h)*(1/4) |
| have h3 : 8*capA^2*h^222*L ≤ d := by |
| unfold L |
| change 8*capA^2*h^222*(2*(d/h^400)+100) ≤ d |
| have Hz : 100000*capA^2 ≤ h^178 := by |
| change 100000*capA^2 ≤ h at h1 |
| exact h1.trans (by simpa using pow_le_pow_right₀ hh (by omega : 1 ≤ 178)) |
| have Hi : 8*capA^2*h^222 * (2*(d/h^400)) ≤ d/2 := by |
| rw [show h^400=h^222*h^178 by ring] |
| field_simp |
| nlinarith |
| rw [mul_add] |
| change 100000*capA^2*h^230 ≤ d at h2 |
| have Hx := mul_le_mul_of_nonneg_left (pow_le_pow_right₀ hh (show 222 ≤ 230 by omega)) |
| (show 0 ≤ 100000*capA^2 by positivity) |
| nlinarith |
| calc |
| _ ≤ 2*(h^120*(capA*h*L)) := by |
| have h1 : 0 ≤ capA*h*L := by positivity |
| nlinarith [mul_le_mul_of_nonneg_right hP h1] |
| _ ≤ _ := by field_simp; nlinarith |
| |
| end Memory |
| end FourierLLogL.Dyadic.Procedure |
| |
| end OAI |
| |
