| import OAI.Analysis.FourierLLogL.Paths.Flash |
| import OAI.Analysis.FourierLLogL.Paths.Wager |
| /-! # The uniform output path -/ |
|
|
| open Function Set Filter |
| open scoped Topology BigOperators ComplexConjugate |
| noncomputable section |
|
|
| namespace OAI |
|
|
| namespace FourierLLogL.Dyadic.Procedure.Paths |
| open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal Wire Pulse Thread Capture Chart Snapshot |
| variable {M j J : ℕ} {s q : Scene M} {f : Grid M → ℝ} |
| open scoped Classical |
|
|
|
|
| namespace Run |
| open Beam Lamp Desk |
|
|
| structure Streak (M : ℕ) where |
| i : ℕ |
| u : Grid M |
|
|
| namespace Streak |
| def b (e : Streak M) := side e.i |
| def thick (e : Streak M) := Real.sqrt e.b |
| def rogue (e : Streak M) (s : Scene M) := 0 < e.i ∧ hazard s true (e.i-1) |
| def every (e : Streak M) (s : Scene M) (L : ℝ) := |
| ∀ i, energy (s.smaller i) e.u ≤ L*e.b^2 |
| def outer (e : Streak M) (s : Scene M) := e.rogue s ∨ e.every s 256 |
| def innerV (e : Streak M) (s : Scene M) := e.rogue s ∨ e.every s 64 |
| def flag (e : Streak M) (s : Scene M) := if e.rogue s then (1:ℝ) else 0 |
| def flagged (e : Streak M) (l : Path M) := subtotal (fun b => flag e b.post) l |
| def showers (e : Streak M) (l : Path M) := subtotal (fun b => shower e.u b.post) l |
|
|
| lemma rate (e : Streak M) : 0 < e.b ∧ e.b ≤ 1 := ⟨side_pos _,side_le _⟩ |
| lemma thick_rate (e : Streak M) : 0 < e.thick ∧ e.thick ≤ 1 ∧ e.thick^2=e.b := |
| ⟨sqrt_pos.2 e.rate.1,by unfold thick; simpa using Real.sqrt_le_sqrt e.rate.2, |
| sq_sqrt e.rate.1.le⟩ |
| lemma flag_nonneg (e : Streak M) (s : Scene M) : 0 ≤ flag e s := by unfold flag; split <;> norm_num |
| lemma flagged_pos {l : Path M} {x : Grid M} (e : Streak M) (h : Trip x s l) : 0 ≤ flagged e l := |
| trip_nonneg h (fun b _ => flag_nonneg e b.post) |
| lemma showers_pos {l : Path M} {x : Grid M} (e : Streak M) (h : Trip x s l) : 0 ≤ showers e l := |
| trip_nonneg h (fun _ H => shower_nonneg H.climb) |
| lemma inner_outer (e : Streak M) (s : Scene M) (h : innerV e s) : outer e s := |
| h.elim Or.inl fun H => Or.inr fun i => by nlinarith [H i] |
|
|
| def rain (e : Streak M) : Desk M Unit where |
| stake _ _ s := if e.rogue s then 0 else -gust s e.u/(10^5 * e.b) |
| stepAt _ _ := () |
|
|
| lemma cave (e : Streak M) (b : Beat M) (hp : Ideal b.pre b.post) (hv : e.outer b.post) : |
| let u := e.u |
| shower u b.post/2 ≤ energy (winds b) u-energy b.pre u+8*killed b+4*flag e b.post+ |
| e.b*fax b.post+10^5*e.b*((rain e).pay () b) := by |
| intro u |
| rw [winds,wet_walk _ hp.climb] |
| let s := b.post; let x := e.b; let y := gust s u |
| let a : ℝ := 10^5*x |
| have hx : 0 < x := e.rate.1; have he : x ≤ 1 := e.rate.2 |
| have hr : 0 < a := by unfold a; positivity |
| have hT := (abs_le.mp (energy_drain hp u)).2 |
| have hJ : 0 ≤ fax s := (fax_floor hp.climb).1 |
| have hG : 0 ≤ shower u s := shower_nonneg hp.climb |
| change shower u s /2 ≤ energy s u+shower u s+curl b.bit*y - energy b.pre u+ |
| 8*killed b+4*flag e s+x*fax s+a*(rain e).pay () b |
| by_cases h : e.rogue b.post |
| · rw [show flag e s=1 from ite_eq_left h] |
| have H : (rain e).pay () b=0 := by simp [rain,pay,h,single] |
| have HV (i) : 0 ≤ energy (s.smaller i) u ∧ energy (s.smaller i) u ≤ 4 := |
| let H := energy_small (hp.climb.child i) u |
| ⟨H.1,H.2.trans (hp.climb.child i).lift⟩ |
| have hY : |curl b.bit*y| ≤ 4 := by |
| rw [abs_mul,curl_unit,one_mul,abs_le]; unfold y gust |
| constructor <;> linarith [(HV false).1,(HV true).1,(HV true).2,(HV false).2] |
| rw [H,mul_zero]; unfold s at *; nlinarith [(abs_le.mp hY).1] |
| · rw [show flag e s=0 from ite_eq_right h] |
| have H : a*(rain e).pay () b= -curl b.bit*y-y^2/(2*a) := by |
| have HE : (rain e).stake () b.pre b.post = -y/a := by unfold rain; simp [h]; rfl |
| rw [pay,HE,single]; field_simp |
| have he₁ : y^2 ≤ 100*(256*x^2)*(fax s+shower u s) := |
| sky_variance s hp.climb u _ (hv.resolve_left h) |
| have hx' : y^2/(2*a) ≤ x/2*(fax s+shower u s) := by |
| apply (div_le_iff₀ (by positivity)).mpr |
| unfold a; nlinarith [mul_nonneg (sq_nonneg x) (add_nonneg hJ hG)] |
| rw [H] |
| unfold s at * |
| nlinarith |
|
|
| lemma cave_whole (e : Streak M) {l : Path M} {x : Grid M} (h : Trip x s l) |
| (hh : ∀ b∈l,e.outer b.post) : |
| let u := e.u |
| showers e l/2 ≤ 4-energy s u + 8*fullKills l+4*flagged e l+e.b*fullFax l+ |
| 10^5*e.b*((rain e).tally () l) := by |
| intro u |
| induction l generalizing s with |
| | nil => |
| have H := trip_head h |
| have HH := (energy_small H.1 u).2.trans H.1.lift |
| change 0/2 ≤ 4-_+_*0+_*0+_*0+_*0 |
| linarith |
| | cons b l ih => |
| obtain ⟨rfl,ha,hb⟩ := h |
| have H := e.cave b ha (hh b (List.mem_cons_self)) |
| change shower u b.post /2 ≤ _ at H |
| have hi := ih hb (fun b hi => hh b (List.mem_cons_of_mem _ hi)) |
| change (shower u b.post+showers e l)/2 ≤ 4-energy b.pre u+ |
| 8*(killed b+fullKills l)+4*(flag e b.post+flagged e l)+ |
| _*(fax b.post+fullFax l)+_*((rain e).pay () b+(rain e).tally () l) |
| linarith |
|
|
| def aimed (e : Streak M) (W : Paths.Vector M) (s : Scene M) : Lamp M := ⟨e.u,e.thick,W,s⟩ |
| lemma lit_upper (e : Streak M) (W : Paths.Vector M) (t : Scene M) (h : Climb s) (hp : e.outer s) : |
| let a := e.thick |
| lit (e.aimed W t) s ≤ 300*(a*fax s+flag e s+shower e.u s) := by |
| intro a |
| let J := fax s; let q := shower e.u s; let g := energy s e.u; let r := e.b |
| have hJ : 0 ≤ J ∧ J ≤ 2 := fax_floor h |
| have hq : 0 ≤ q := shower_nonneg h |
| have hα : 0 < a ∧ a ≤ 1 ∧ a^2=r := e.thick_rate |
| have hr : 0 < r ∧ r ≤ 1 := e.rate |
| change (g+a^2)*J+q ≤ 300*(a*J+flag e s+q) |
| by_cases hh : rogue e s |
| · have hg : g ≤ 4 := (energy_small h.fit e.u).2.trans h.fit.lift |
| rw [flag,ite_eq_left hh]; nlinarith |
| · have HE : g ≤ 256*r^2 := by |
| have HV := hp.resolve_left hh |
| have H : g+q=(energy (s.smaller false) e.u+energy (s.smaller true) e.u)/2 := |
| (wet_average s h e.u).symm |
| unfold r; linarith [HV true,HV false] |
| have hx : r^2 ≤ a := by nlinarith |
| have Hx : g+a^2 ≤ 257*a := by nlinarith |
| rw [flag,ite_eq_right hh]; nlinarith |
|
|
| inductive Tray (M : ℕ) where |
| | sleep |
| | bare (W : Paths.Vector M) |
| | lite (e : Lamp M) (r : Bool) |
| open Tray |
|
|
| def dealer (e : Streak M) : Desk M (Tray M) where |
| stake z _ q := match z with |
| | sleep => 0 |
| | bare W => start (aimed e W q)/e.thick |
| | lite s r => delayed s r q/e.thick |
| stepAt z b := match z with |
| | sleep => bare 0 |
| | bare W => lite (aimed e W b.post) b.bit |
| | lite s r => bare (carry s r b.bit) |
|
|
| def beamRent (e : Streak M) (b : Beat M) := |
| let s := b.post |
| 10^6*(fax s+(killed b+flag e s+shower e.u s)/e.thick) |
| lemma rent_nonneg (e : Streak M) (b : Beat M) (hp : Ideal b.pre b.post) : |
| 0 ≤ beamRent e b := mul_nonneg (by norm_num) |
| (add_nonneg (fax_floor hp.climb).1 (div_nonneg |
| (add_nonneg (add_nonneg hp.kill_nonneg (flag_nonneg e _)) (shower_nonneg hp.climb)) e.thick_rate.1.le)) |
| lemma rent_total (e : Streak M) (l : Path M) : |
| subtotal (beamRent e) l=10^6*(fullFax l+(fullKills l+flagged e l+showers e l)/e.thick) := by |
| induction l with |
| | nil => change (0:ℝ)=10^6*(0+(0+0+0)/_); ring |
| | cons b l ih => |
| rw [subtotal_cons,ih] |
| change 10^6*(fax b.post+(killed b+flag e b.post+shower e.u b.post)/e.thick)+ |
| 10^6*(fullFax l+(fullKills l+flagged e l+showers e l)/e.thick)= |
| 10^6*((fax b.post+fullFax l)+(killed b+fullKills l+(flag e b.post+flagged e l)+ |
| (shower e.u b.post+showers e l))/e.thick) |
| ring |
|
|
| lemma light_bill (e : Streak M) (w : Paths.Vector M) |
| (b c : Beat M) (hb : Ideal b.pre b.post) (hc : Ideal c.pre c.post) |
| (hh : c.pre=winds b) (hp : e.outer b.post) (he : e.outer c.post) : |
| let r := aimed e w b.post |
| let v := dealer e |
| let a := e.thick |
| watt (winds c) e.u (carry r b.bit c.bit) a ≤ watt b.pre e.u w a + |
| a*(v.pay (bare w) b+v.pay (v.stepAt (bare w) b) c)+beamRent e b+beamRent e c := by |
| intro r v a |
| let x := start r; let y := delayed r b.bit c.post |
| have ha : 0 < a := e.thick_rate.1 |
| have hi : a ≤ 1 := e.thick_rate.2.1 |
| have HE : curl b.bit*x+curl c.bit*y= |
| a*(v.pay (bare w) b+v.pay (v.stepAt (bare w) b) c)+(x^2+y^2)/(2*a) := by |
| change curl _*_+curl _ *_ = a*(single (x/a) b.bit+single (y/a) c.bit)+_ |
| unfold single; field_simp; ring |
| let J (b : Beat M) := fax b.post; let G (b : Beat M) := shower e.u b.post |
| let Q (b : Beat M) := flag e b.post |
| have H1 : x^2 ≤ 30000*(a*J b+Q b+G b) := by |
| have H : x^2 ≤ 100*lit r b.post := start_cost r hb.climb ha.le |
| have H' : lit r b.post ≤ 300*(a*J b+Q b+G b) := lit_upper e w b.post hb.climb hp |
| linarith |
| have H2 : y^2 ≤ 30000*((a*J b+Q b+G b)+(a*J c+Q c+G c)) := by |
| have H : y^2 ≤ 100*(lit r b.post+lit r c.post) := delayed_cost r hb.climb hc.climb ha.le b.bit |
| have Hx : lit r b.post ≤ 300*(a*J b+Q b+G b) := lit_upper e w b.post hb.climb hp |
| have Hy : lit r c.post ≤ 300*(a*J c+Q c+G c) := lit_upper e w b.post hc.climb he |
| linarith |
| let K (b : Beat M) := killed b |
| let A := J b+J c |
| let B := Q b+Q c |
| let C := G b+G c |
| have HG (b : Beat M) (hb : Ideal b.pre b.post) : |
| 0 ≤ J b ∧ 0 ≤ Q b ∧ 0 ≤ G b ∧ 0 ≤ K b := |
| ⟨(fax_floor hb.climb).1,flag_nonneg _ _, shower_nonneg hb.climb,hb.kill_nonneg⟩ |
| obtain ⟨h1,h2,h3,h4⟩ := HG b hb |
| obtain ⟨h5,h6,h7,h8⟩ := HG c hc |
| have HX : (x^2+y^2)/(2*a) ≤ 10^5*(A+(B+C)/a) := by |
| apply (div_le_iff₀ (by positivity)).mpr |
| rw [show 10^5*(A+(B+C)/a)*(2*a)=200000*(a*A+B+C) by field_simp; ring] |
| unfold A B C; nlinarith |
| have hH := flash r hb.climb b.bit c hh hc ha hi |
| change watt (winds c) e.u (carry r b.bit c.bit) a ≤ watt b.post e.u w a+ |
| curl b.bit*x+curl c.bit*y+ 2*K c+4*(20*A+400*((K c+G b+G c)/a)) at hH |
| have HF : 2*K b+2*K c+4*(20*A+400*((K c+G b+G c)/a))+10^5*(A+(B+C)/a) ≤ |
| beamRent e b+beamRent e c := by |
| change _ ≤ 10^6*(J b+(K b+Q b+G b)/a)+10^6*(J c+(K c+Q c+G c)/a) |
| have hz : 1 ≤ a⁻¹ := (one_le_inv₀ ha).mpr hi |
| unfold A B C |
| simp_rw [div_eq_mul_inv] |
| nlinarith |
| linarith [watt_slide hb e.u w a ha.le hi] |
|
|
| end Streak |
| end Run |
|
|
|
|
| end FourierLLogL.Dyadic.Procedure.Paths |
|
|
| end OAI |
|
|
