| import OAI.Analysis.FourierLLogL.Procedure.Play |
|
|
| 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 |
|
|
| variable {M J j : ℕ} {s : Scene M} |
| open scoped Classical |
|
|
| lemma top_avg {E : Type*} [AddCommMonoid E] [MulAction ℝ E] (f : Grid M → E) : |
| root.avg f = expU f := by |
| rw [avg_sum, group_top,len_top,inv_one,one_smul] |
| rfl |
|
|
| lemma lose_eq (u : Update j M s.here) (x : Grid M) : |
| (lose s u).wage x = if u.take s.fund.mood x then 0 else s.wage x := by |
| by_cases H : u.take s.fund.mood x <;> simp [lose,Set.indicator,H] |
| lemma win_eq (u : Update j M s.here) (x : Grid M) : |
| (win s u).wage x = if u.take s.fund.mood x then s.wage x else 0 := by |
| by_cases H : u.take s.fund.mood x <;> simp [win,Set.indicator,H] |
| |
| lemma split_pos (u : Update j M s.here) (h : 0 ≤ s.wage) : |
| (0 ≤ (lose s u).wage ∧ (lose s u).wage ≤ s.wage) ∧ |
| (0 ≤ (win s u).wage ∧ (win s u).wage ≤ s.wage) := by |
| refine ⟨⟨?_,?_⟩,?_,?_⟩ |
| all_goals |
| intro i |
| dsimp only [Pi.zero_apply] |
| first | rw [lose_eq] | rw [win_eq] |
| split_ifs <;> first | exact h i | exact le_rfl |
| |
| private def bonus (s : Scene M) : ℕ := |
| (if s.live then 2 else 0)+(if s.enter then 1 else 0) |
| private def playing (s : Scene M) := |
| Finset.univ.filter fun x => 0 < s.wage x |
|
|
| private def totalUse (j : ℕ) := Nat.ceil (capA*H j) |
| private def stage (j : ℕ) (s : Scene M) : ℕ := |
| ((totalUse j-s.fund.uses) * (Fintype.card (Grid M)+1)+(playing s).card)*4+bonus s |
|
|
| private lemma begin_ok : |
| ∀ᶠ j : ℕ in atTop, ∀ M J : ℕ, ∀ (f : Grid M → ℝ) (b : Bool), 0 ≤ f → expU f ≤ 2 → |
| (beginPlay f b).Safe j J f := by |
| filter_upwards [Fund.fund_est] with j hj |
| intro M J f b hp h |
| refine ⟨root_ok _,Nat.zero_le _,(hj M).1,le_rfl,hp,le_rfl,?_⟩ |
| change root.avg f ≤ _ |
| rw [top_avg] |
| unfold cutoff; have hi := Nat.cast_nonneg (α:=ℝ) j |
| have h1 : 1 ≤ ((j:ℝ)+1)^3 := one_le_pow₀ (by linarith) |
| linarith |
|
|
| theorem plant : |
| ∀ᶠ j : ℕ in atTop, ∀ M J : ℕ, J ≤ M → ∀ f : Grid M → ℝ, |
| 0 ≤ f → expU f ≤ 2 → (∀ x, f x ≤ exp (height j)) → |
| ∀ b : Bool, ∃ t : Play j M (beginPlay f b), t.Follows J f := by |
| classical |
| filter_upwards [begin_ok, Fund.fund_est, make_update capA cap_ok] with j hb hK hM |
| intro M J hJ f h0 ht he b |
| let OK (s : Scene M) := ∃ t : Play j M s, t.Follows J f |
| suffices HH : ∀ k : ℕ, ∀ s : Scene M, s.here.lev+k=J → |
| s.Safe j J f → OK s by |
| exact HH J _ (by simp [beginPlay,root]) (hb M J f b h0 ht) |
| intro k; induction k using Nat.strong_induction_on with |
| | h k ih => |
| intro s hi hy |
| suffices IH : ∀ n : ℕ, ∀ s : Scene M, s.here.lev+k=J → |
| s.Safe j J f → stage j s=n → OK s from IH _ s hi hy rfl |
| intro n; induction n using Nat.strong_induction_on with |
| | h n Now => |
| intro s hi hy hn |
| subst n |
| by_cases ho : openHere s j J f |
| case neg => exact ⟨Play.rest s, hy, ho⟩ |
| have hh1 := hy.positive |
| have hm : 0 < s.mass := ho.2.2 |
| have hL : s.here.lev < J := ho.1 |
| have hR : s.here.lev < M := hL.trans_le hJ |
| have hp : s.here.valid := hy.within.1 |
| by_cases h : retire s j |
| · have hq : s.out.Safe j J f := by |
| obtain ⟨a,b,c,d,e,f,g⟩ := hy |
| exact ⟨a,b,c,le_rfl,e,f,g⟩ |
| obtain ⟨t,h1⟩ := Now _ (show stage j s.out < _ by |
| have heq : playing s.out = playing s := rfl |
| have hmass : 0 < s.here.avg s.wage := hm |
| have hbonusOut : bonus s.out = 1 := by simp [bonus,out,enter,mass,hmass] |
| have hbonusS : 2 ≤ bonus s := by simp [bonus,h.1] |
| have hfund : s.out.fund.uses = s.fund.uses := rfl |
| rw [stage,stage,heq,hfund] |
| rw [hbonusOut] |
| omega) |
| s.out hi hq rfl |
| exact ⟨Play.freeze s t, hy,ho,h,h1⟩ |
| by_cases ha : enter s |
| · have ha' : ¬ enter s.reset := by unfold enter reset; change ¬ 2*s.mass<s.mass; linarith |
| have hq : s.reset.Safe j J f := by |
| obtain ⟨a,b,c,d,e,f,g⟩ := hy |
| exact ⟨a,b,c,hm.le,e,f,g⟩ |
| obtain ⟨t,h1⟩ := Now _ (show stage j s.reset < _ by |
| have heq : playing s.reset = playing s := rfl |
| have hbonus : bonus s.reset + 1 = bonus s := by |
| unfold bonus |
| rw [ite_eq_right ha', ite_eq_left ha] |
| rfl |
| have hfund : s.reset.fund.uses = s.fund.uses := rfl |
| rw [stage,stage,heq,hfund] |
| omega) s.reset hi hq rfl |
| exact ⟨Play.ticket s t, hy,ho,h,ha,h1⟩ |
| by_cases HH : settled s j |
| · have hE (b : Bool) : OK (s.smaller b) := by |
| have H : (s.smaller b).here.lev = s.here.lev+1 := by cases b <;> rfl |
| apply ih (k-1) (by omega) |
| · omega |
| refine ⟨s.here.child_ok hp hR b,by rw [H]; exact hL, |
| hy.capital.restrict (s.here.child_below _), hy.norm_ok, hh1,hy.sub,?_⟩ |
| have H1 := avg_nonneg s.here.L (f:=f) fun x _ => h0 x |
| have H2 := avg_nonneg s.here.R (f:=f) fun x _ => h0 x |
| have H3 := ho.2.1 |
| rw [avg_split_real s.here] at H3 |
| cases b |
| · change s.here.L.avg f ≤ _; linarith |
| · change s.here.R.avg f ≤ _; linarith |
| obtain ⟨l,hl⟩ := hE false |
| obtain ⟨r,hr⟩ := hE true |
| exact ⟨Play.jump s l r,hy,⟨ho,h,ha⟩,HH,hl,hr⟩ |
| unfold settled at HH; push Not at HH |
| obtain ⟨hl,i,HH',HE⟩ := HH |
| have hb : ¬ breached j s.fund := fun he => h ⟨hl,Or.inl he⟩ |
| have hx : exp (-height j) ≤ s.mass := by |
| apply le_of_not_gt; exact fun hi => h ⟨hl,Or.inr hi⟩ |
| have hW := ((hK M).2 s.fund s.here hy.capital).2 hb hy.within |
| have hV := actor_def hy.within hy.positive hm |
| unfold enter at ha |
| obtain ⟨u,rfl,hu⟩ := hM _ _ _ hR hW.1 s.wage hh1 |
| (fun x => le_trans (hy.sub x) (he x)) hx _ _ hV |
| (by linarith) (le_of_not_gt ha) i HH' HE |
| have h₁ := split_pos u hh1 |
| have h₂ : ∀ s : Scene M, bonus s ≤ 3 := fun s => by unfold bonus; split_ifs <;> omega |
| have hY₁ : Safe (s.lose u) j J f := |
| ⟨hy.within,hy.depth_ok,hy.capital,hy.norm_ok,h₁.1.1,h₁.1.2.trans hy.sub,hy.cut⟩ |
| have hY₂ : Safe (s.win u) j J f := |
| ⟨hy.within,hy.depth_ok,hW.2.2 u _ hu,le_rfl,h₁.2.1,h₁.2.2.trans hy.sub,hy.cut⟩ |
| have hww : stage j (s.win u) < stage j s := by |
| let N := totalUse j |
| have h4 : s.fund.uses+1 ≤ N := by |
| have HH := (Nat.le_ceil (capA*H j)) |
| have He : ((s.fund.uses+1:ℕ):ℝ) ≤ ↑N := by push_cast; exact hW.2.1.trans HH |
| exact_mod_cast He |
| have h3 := h₂ (s.win u) |
| let L := Fintype.card (Grid M)+1 |
| have h5 : (s.win u).fund.uses = s.fund.uses+1 := rfl |
| have h6 : (playing (s.win u)).card < L := Nat.lt_succ_of_le (Finset.card_le_univ _) |
| unfold stage; rw [h5,show totalUse j - s.fund.uses= N-(s.fund.uses+1)+1 by omega]; simp only [add_mul, one_mul] |
| dsimp only [N,L] at *; omega |
| have hll : stage j (s.lose u) < stage j s := by |
| have h4 : (playing (s.lose u)).card < (playing s).card := by |
| apply Finset.card_lt_card |
| refine Finset.ssubset_iff_of_subset (s₁:=playing (s.lose u)) ?_ |>.mpr ?_ |
| · intro x hx |
| simp only [playing,Finset.mem_filter,Finset.mem_univ,true_and] at * |
| exact lt_of_lt_of_le hx (h₁.1.2 _) |
| have HE := lt_of_lt_of_le (show 0 < beta u.ix /2 from by have := beta_pos u.ix; positivity) hu.bias |
| obtain ⟨x,hx,hx'⟩ := (prob_pos_iff _ _).mp HE |
| have hf : 0 < s.wage x := by |
| by_contra! H |
| have hh := H.antisymm (hh1 x) |
| rw [hV _,wt,hh,mul_zero,zero_div] at hx' |
| exact lt_irrefl _ hx' |
| refine ⟨x,?_,?_⟩ <;> simp [playing,hf,lose_eq, hx] |
| unfold stage |
| rw [show (s.lose u).fund=s.fund from rfl] |
| have hh := h₂ (s.lose u); omega |
| obtain ⟨l,hl'⟩ := Now _ hll (s.lose u) hi hY₁ rfl |
| obtain ⟨r,hr'⟩ := Now _ hww (s.win u) hi hY₂ rfl |
| exact ⟨Play.attempt s u l r, hy, ⟨ho,h,ha⟩,hl,hu,hl',hr'⟩ |
|
|
| end FourierLLogL.Dyadic.Procedure |
|
|
| end OAI |
|
|
