| import OAI.Analysis.FourierLLogL.Paths.Ribbon |
| /-! |
|
|
| 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 |
|
|
|
|
| /-! # Expected forward sums of marked jump quantities -/ |
| open Beam Run Run.Streak |
|
|
| /-- A local bit-Fisher budget -/ |
| def caveat (s : Scene M) (j : ℕ) := |
| share s*(deficit s (channel (dye s))+(minimumT j)⁻¹) |
|
|
| lemma caveat_pos (s : Scene M) (j : ℕ) (h : Fit s) : 0 ≤ caveat s j := by |
| have he : 0 ≤ s.mass := avg_nonneg _ fun x _ => h.ready.2 _ |
| unfold caveat |
| rcases eq_or_lt_of_le he with he|he |
| · unfold share; rw [← he,zero_div,zero_mul] |
| exact mul_nonneg (div_nonneg he.le h.pos.le) |
| (add_nonneg (deficit_nonneg s h.ready.1 h.ready.2 he _) |
| (inv_nonneg.mpr (minimum_pos j).le)) |
| |
| lemma caveat_step {s q : Scene M} {l} (h : Following j J f (ran s q l)) (hh : Ideal s q) : |
| (uniform Bool).Ex (fun b => caveat (q.smaller b) j) + (1/4:ℝ)*fax q ≤ caveat s j := by |
| let U := (step q).probs; let v := (keep s q).snip; let Q := v.probs |
| let Z := channel (dye q); let H (x) := deficit x Z; let a := (minimumT j)⁻¹ |
| have hm := pre_pos h |
| have HE : Q.entropy ≤ a*Q false := debt_at h |
| obtain ⟨hh1,hh2,h3⟩ := hh |
| obtain ⟨ha,hb,hv,hp',ht,hs⟩ := h |
| have hR : q.here.lev < M := (rooted _ (hs false)).within.2 |
| have hS : ReadyAt s := ⟨ha.within,ha.positive⟩; have hS' : ReadyAt q := ⟨hv.within,hv.positive⟩ |
| have hd := hh1.pos |
| have hQ := hp'.1.2.2; have hZ := hh2.fit.pos |
| have hM := keep_true hb.1 hS hS' hm |
| have h₂ : Q true*(H q+a) ≤ H s+a := by |
| have hi (b : Bool) : levels (v.dst b)=levels s := by |
| unfold levels; rw [show (v.dst b).here=s.here from keep_here hb.1 _] |
| have hz : Q.Ex (fun b => H (v.dst b)) ≤ H s+Q.entropy := by |
| have hh := old_entropy_cost v Z |
| have hh' := conditioned_balance Z v hM |
| unfold H deficit; simp_rw [hi,Ex_sub (f:=fun _ => levels s),Ex_const] |
| change v.probs.Ex _+ _ = s.actor.privateH Z at hh' |
| unfold Q; linarith |
| have hZ : 0 ≤ Q false * H (v.dst false) := by |
| rcases eq_or_lt_of_le (Q.nonneg false) with h|h |
| · rw [← h,zero_mul] |
| have HH := other_ok hb.1 hS |
| exact mul_nonneg h.le (deficit_nonneg (v.dst false) HH.1 HH.2 ((true_mass hM).mp h) Z) |
| have ht₁ : Q true + Q false = 1 := by simpa only [Fintype.sum_bool] using Q.total |
| rw [Ex,Fintype.sum_bool] at hz |
| rw [show v.dst true=q from rfl] at hz |
| nlinarith [show a*(Q true+Q false)=a by rw [ht₁]; ring] |
| have ht₁ := space_deficit q Z hv.within.1 hR hv.positive hQ hZ |
| let D (b : Bool) := H (q.smaller b)+a |
| have h₁ : |
| (uniform Bool).Ex (fun b => caveat (q.smaller b) j) = |
| share q * U.Ex D := by |
| have HI (b : Bool) : caveat (q.smaller b) j = |
| (q.smaller b).mass * (q.norm⁻¹ * D b) := by unfold caveat D H; simp only [smaller]; unfold share Z dye a; dsimp; ring |
| simp_rw [HI] |
| rw [← output_split _ hv.within.1 hR hv.positive hQ (fun b => q.norm⁻¹*D b), |
| Ex_lmul] |
| unfold share U; ring |
| have HZ : share q * ((1/4:ℝ)*(q.norm/q.mass)*fax q)=1/4*fax q := by |
| unfold share; field_simp |
| have hEq : share q = share s * Q true := by |
| have H := kept_mass hb.1 hS hS' hm |
| unfold share |
| nth_rw 1 [H,hb.1.flat] |
| unfold Q v; ring |
| rw [h₁,← HZ,← mul_add] |
| unfold D; rw [Ex_add (g:=fun b => a),Ex_const] |
| have hDC : caveat s j=share s*(H s+a) := by unfold caveat H Z dye a; rw [hb.1.fund] |
| have hsq : 0 ≤ share q := div_nonneg hQ.le hZ.le |
| calc |
| _ ≤ share q*(H q+a) := by |
| apply mul_le_mul_of_nonneg_left _ hsq |
| change U.Ex (fun i => H (q.smaller i))+(1/4:ℝ)*(q.norm/q.mass)*fax q ≤ H q at ht₁ |
| linarith |
| _ ≤ _ := by |
| rw [hEq,mul_assoc,hDC] |
| exact mul_le_mul_of_nonneg_left h₂ (div_nonneg hm.le hd.le) |
|
|
| /-- average of forward statistics under uniform output path -/ |
| def stats {s : Scene M} (t : Thread M s) (L : Path M → ℝ) := |
| (s.here.dice M).Ex (fun x => L (t.stream x)) |
|
|
| lemma stats_cons {s q : Scene M} {k} (h : Following j J f (ran s q k)) (F : Path M → ℝ) : |
| stats (ran s q k) F = |
| (uniform Bool).Ex (fun b => stats (k b) (fun l => F (⟨s,q,b⟩::l))) := |
| stream_branch k h (fun l _ => F l) |
|
|
| lemma stat_pay (s : Scene M) (t : Thread M s) (g : Beat M → ℝ) : |
| stats t (subtotal g)=Thread.fee t g := rfl |
| lemma stats_nil (s : Scene M) (F : Path M → ℝ) : stats (blank s) F=F [] := by simp [stats,stream,Ex_const] |
| lemma stats_plus {s : Scene M} (t : Thread M s) (f g : Path M → ℝ) : |
| stats t (fun l => f l+g l)=stats t f+stats t g := |
| Ex_add _ (f:=fun _ => f _) (g:=fun _ => g _) |
| lemma stats_fix {s : Scene M} (t : Thread M s) (r : ℝ) : stats t (fun _ => r)=r := |
| Ex_const _ _ |
|
|
| lemma caveat_total {s : Scene M} (t : Thread M s) (h : Following j J f t) (hp : Fit s) : |
| stats t fullFax ≤ 4*caveat s j := by |
| change t.fee billFax ≤ _ |
| induction t with |
| | blank s => |
| change stats (blank s) fullFax ≤ _ |
| rw [stats_nil, show fullFax (M:=M) [] = 0 from rfl] |
| linarith [caveat_pos s j hp] |
| | ran s q k ih => |
| have hx := jump_ideal h hp.lift |
| have HH := caveat_step h hx |
| rw [fee_ran _ h,Ex_add,show (uniform Bool).Ex (fun b : Bool => billFax ⟨s,q,b⟩) = fax q from by unfold billFax; exact Ex_const (uniform Bool) (fax q)] |
| apply le_trans (b:=fax q+(uniform Bool).Ex fun b => 4*caveat (q.smaller b) j) |
| · gcongr |
| apply Ex_mono |
| intro b |
| exact ih b (h.2.2.2.2.2 b) (hx.climb.child b) |
| rw [Ex_lmul]; linarith |
| |
| lemma showers_total (e : Streak M) |
| {s : Scene M} (t : Thread M s) (h : Following j J f t) (hp : Fit s) : |
| stats t e.showers ≤ 4-energy s e.u+8*stats t fullKills := by |
| let g (b : Beat M) := shower e.u b.post |
| change t.fee g ≤ 4-energy s e.u+8*t.fee killed |
| induction t with |
| | blank s => |
| have Hh := (energy_small hp e.u).2.trans hp.lift |
| simp [Thread.fee,stream,Ex_const]; linarith |
| | ran s q k ih => |
| let U := uniform Bool |
| have H := jump_ideal h hp.lift |
| have HE (b : Bool) := ih b (h.2.2.2.2.2 b) (H.climb.child _) |
| rw [fee_ran _ h,fee_ran _ h] |
| simp_rw [Ex_add] |
| rw [Ex_const U (shower e.u q)] |
| have HH : U.Ex (fun b => energy (q.smaller b) e.u) = energy q e.u+shower e.u q := by |
| rw [show U=uniform Bool from rfl,fair_av]; exact wet_average q H.climb e.u |
| have HF := (energy_drain (b:=⟨s,q,false⟩) H e.u) |
| let K := killed (Thread.Beat.mk s q false) |
| have HR : (uniform Bool).Ex (fun b => killed ⟨s,q,b⟩) = K := Ex_const U K |
| have HT := U.Ex_mono HE |
| rw [Ex_add,Ex_lmul,Ex_sub (f:=fun _=> 4),Ex_const,HH] at HT |
| rw [HR] |
| change |energy s _-energy q _| ≤ 8*K at HF |
| change shower e.u q + U.Ex _ ≤ _ +8*(K+U.Ex _) |
| linarith [(abs_le.mp HF).2] |
|
|
| lemma flag_point (s : Scene M) (e : Streak M) : |
| e.b^2* e.flag s ≤ 128*surcharge s true (e.i-1) := by |
| unfold Streak.flag |
| split_ifs with h |
| · rw [surcharge,ite_eq_left h.2] |
| apply le_trans (b:=128*gateWidth true (e.i-1)) |
| · change side e.i^2*1 ≤ 128*(side (e.i-1)^2 / 128) |
| have hh : side e.i ≤ side (e.i-1) := |
| pow_le_pow_of_le_one (by norm_num) (by norm_num) (by omega) |
| nlinarith [side_pos e.i] |
| · exact mul_le_mul_of_nonneg_left h.2 (by norm_num) |
| rw [mul_zero] |
| exact mul_nonneg (by norm_num) (surcharge_nonneg s true _) |
|
|
| lemma flag_total (e : Streak M) {s : Scene M} (t : Thread M s) : |
| e.b^2 * stats t e.flagged ≤ |
| 128 * Thread.fee t (fun b => surcharge b.post true (e.i-1)) := by |
| change e.b^2 * t.fee _ ≤ _ |
|
|
| unfold Thread.fee |
| rw [← Ex_lmul,← Ex_lmul] |
| apply Ex_mono; intro x |
| generalize t.stream x = l |
| induction l with |
| | nil => change _*0 ≤ _*0; exact le_of_eq (by ring) |
| | cons b l ih => |
| rw [List.map_cons,List.sum_cons,List.map_cons,List.sum_cons] |
| linarith [flag_point b.post e] |
| |
| lemma sum_budget_run : |
| ∀ᶠ j : ℕ in atTop, |
| ∀ M J : ℕ, ∀ f : Grid M → ℝ, ∀ s q : Scene M, ∀ k, |
| Following j J f (.ran s q k) → Fit s → q.live=true → |
| (∀ x, f x ≤ exp (height j)) → |
| ∀ e : Streak M, |
| let v := ran s q k |
| stats v fullKills ≤ 4 ∧ stats v e.showers ≤ 36 ∧ |
| stats v fullFax ≤ 10^26*height j ∧ e.b^2 * stats v e.flagged ≤ 10^6*height j := by |
| filter_upwards [segment_cost,side_deficit, hpoly 12800 32] with j h1 h2 ht |
| M J f s q k h hh hx hF e v |
| have hk := jump_ideal h hh.lift |
| have hq := pre_pos h |
| have hR : q.mass ≤ s.mass := hk.lower.mass_le hh.ready.2 hh.ready.1 |
| have hT := h.2.2.2.1.2.1 |
| let d := height j |
| have hM : exp (-d) ≤ q.mass := le_of_not_gt (fun H => hT ⟨hx,Or.inr H⟩) |
| have hE : -d ≤ log s.mass := by |
| rw [←log_exp (-d)] |
| exact log_le_log (exp_pos _) (hM.trans hR) |
| have he : (minimumT j)⁻¹ ≤ height j := by unfold minimumT; rw [one_div,inv_inv]; exact ht |
| have HP : stats v fullKills ≤ 4 := |
| le_trans (deaths v h hh.pos) hh.lift |
| refine ⟨HP, le_trans (showers_total e v h hh) |
| (by linarith [(energy_small hh e.u).1]),le_trans (caveat_total v h hh) ?_, |
| le_trans (flag_total e v) ?_⟩ |
| · have HL := h2 M J s f (rooted _ h) hF hq |
| have HJ : 0 ≤ share s ∧ share s ≤ 4 := ⟨share_pos' _ hh.ready hh.pos.le,hh.lift⟩ |
| have HY : 0 ≤ deficit s (channel (dye s)) := deficit_nonneg s hh.ready.1 hh.ready.2 hq _ |
| unfold caveat |
| have h₃ : deficit s (channel (dye s)) + (minimumT j)⁻¹ ≤ 10^23*d+d+d := by |
| change deficit s _ ≤ _ at HL; unfold dye d at *; linarith |
| have h₄ : 0 ≤ d := (d_pos j).le |
| change _ ≤ 10^26*d |
| nlinarith |
| · have H₁ := h1 M J s f v h hF hq hh.pos (fun _ => e.i-1) true |
| have H₂ : 0 ≤ s.mass/s.norm := div_nonneg hq.le hh.pos.le |
| have H₃ : s.mass/s.norm ≤ 4 := hh.lift |
| have H₄ : 128*(2*height j-log s.mass) ≤ 384*d := by unfold d at *; linarith |
| have h₄ : 0 ≤ d := (d_pos j).le |
| nlinarith |
|
|
|
|
|
|
| end FourierLLogL.Dyadic.Procedure.Paths |
|
|
| end OAI |
|
|
