| import OAI.Computability.Logspace.ProbabilityAtoms |
|
|
| namespace OAI |
|
|
| /-! |
| Row compression, shutdown thresholds, and accumulated approximation error. |
|
|
| From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*. |
| -/ |
|
|
| set_option autoImplicit true |
|
|
| section |
|
|
| /-! Scalar, entry and row helpers for the full-array compression. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| /- scalar helpers -/ |
| lemma maxnear {x a y b t : ℝ} |
| (h:|x-y| ≤ t) (e:|a-b|≤t) : |max x a-max y b| ≤ t := by |
| rw [abs_le] at * |
| grind |
| lemma minnear {x a y b t : ℝ} |
| (h:|x-y| ≤ t) (e:|a-b|≤t) : |min x a-min y b| ≤ t := by |
| rw [abs_le] at * |
| grind |
| lemma absnear {x y t : ℝ} (h : |x-y|≤t) : |(|x|-|y|)|≤t := by |
| exact le_trans (abs_abs_sub_abs_le ..) h |
| lemma addnear {x x' y y' a b:ℝ} (h : |x-x'|≤a) (e : |y-y'|≤b) : |
| |x+y-(x'+y')|≤a+b := by |
| rw [show x+y-(x'+y')=(x-x')+(y-y') by ring] |
| exact (abs_add_le ..).trans (add_le_add h e) |
| lemma subnear {x x' y y' a b:ℝ} (h : |x-x'|≤a) (e : |y-y'|≤b) : |
| |(x-y)-(x'-y')| ≤ a+b := by |
| have hi : |(-y)-(-y')| ≤ b := by rw [show -y - -y'=-(y-y') by ring,abs_neg]; exact e |
| simpa only [sub_eq_add_neg] using addnear h hi |
| lemma sat_near {x y a b c d:ℝ} (h:|x-y|≤c) (e:|a-b|≤d) : |
| |sat a x-sat b y|≤c+d := by |
| have ha:=abs_nonneg (a-b); have hy:=abs_nonneg (x-y) |
| have hc : 0≤c := le_trans hy h |
| have hd : 0≤d := le_trans ha e |
| have he := show |a-b|≤c+d by linarith |
| apply minnear he |
| apply maxnear _ (le_trans h (by linarith)) |
| rw [show -a - -b=-(a-b) by ring,abs_neg]; exact he |
| lemma sat_id {x u:ℝ} (h:|x|≤u) : sat u x=x := by |
| obtain ⟨h,e⟩:=abs_le.1 h; simp [sat,clip,h,e] |
| lemma sat_eq_min {x u:ℝ} (h: -u ≤ x) : sat u x = min u x := by simp [sat,clip,h] |
| lemma sat_abs {x u:ℝ} (h:0≤u) : |sat u x| = min u |x| := by |
| rcases le_total 0 x with h0|h0 |
| · have he := le_trans (neg_nonpos.2 h) h0 |
| rw [sat_eq_min he,abs_of_nonneg (le_min h h0),abs_of_nonneg h0] |
| rw [abs_of_nonpos h0]; unfold sat clip |
| rw [min_eq_right (max_le (by linarith) (by linarith))] |
| rw [abs_of_nonpos (max_le (by linarith) h0)]; grind |
| lemma sat_between {x u:ℝ} (h : 0≤u) : min 0 x ≤ sat u x ∧ sat u x≤ max 0 x := by |
| unfold sat clip; grind |
| lemma sat_size {u:ℝ} (h:0≤u) (x : ℝ) : |sat u x| ≤ u := by rw [sat_abs h]; exact min_le_left .. |
| lemma sat_add {r h d x y : ℝ} (hh:|d|+r≤h) (he : sat h x=sat h y) (hg: 0≤r) : |
| sat r (x+d)=sat r (y+d) := by |
| unfold sat clip at he |
| have h1:=le_abs_self d; have h2:=neg_le_abs d |
| unfold sat clip |
| grind |
|
|
| /-- Compression coordinate binary vector helpers. -/ |
| abbrev Row := ℕ → Pt |
| def ht (p : Pt) := max |p.1| |p.2| |
| lemma ht_nn (p) : 0 ≤ ht p := le_trans (abs_nonneg _) (le_max_left ..) |
| def near (c : ℝ) (v w : Pt) := |v.1-w.1|≤c ∧ |v.2-w.2|≤c |
| def clp (r : ℝ) (p : Pt) : Pt := (sat r p.1, sat r p.2) |
| lemma ht_clp {p r} (h:0≤r) : ht (clp r p) = min r (ht p) := by |
| simp only [clp,ht,sat_abs h]; grind |
| lemma near_ht {v w c} (h:near c v w) : |ht v-ht w|≤c := maxnear (absnear h.1) (absnear h.2) |
| lemma ht_near (x : ℝ) (p : Pt) : ht p≤x ↔ near x p 0 := by simp [ht,near] |
| lemma near_self {c p} (h:0≤c) : near c p p := by simp [near,h] |
| lemma near_le {v w c d} (h:near c v w) (e:c≤d) : near d v w := ⟨h.1.trans e,h.2.trans e⟩ |
| lemma near_add {v w p q c d} (h:near c v w) (e:near d p q) : |
| near (c+d) (v+p) (w+q) := ⟨addnear h.1 e.1,addnear h.2 e.2⟩ |
| lemma near_sub {v w p q c d} (h:near c v w) (e:near d p q) : |
| near (c+d) (v-p) (w-q) := ⟨subnear h.1 e.1,subnear h.2 e.2⟩ |
| lemma ht_add (p q) : ht (p+q)≤ ht p+ht q := by |
| have e := near_add ((ht_near (ht p) p).1 le_rfl) ((ht_near (ht q) q).1 le_rfl) |
| rw [add_zero] at e; exact (ht_near ..).2 e |
| lemma ht_sub (v w c) : ht (v-w)≤c ↔ near c v w := by simp [ht,near] |
|
|
| abbrev line (z : ℝ) : Pt := (z,0) |
| lemma ht_line {z} (h:0≤z) : ht (line z)=z := by simp [ht,h] |
|
|
| def suit (S : Domain) (a : ℝ) (w v : Blob) := |
| |w.base-v.base|≤a ∧ ∀ i∈S, near a (w.ts i) (v.ts i) |
| lemma suit_self (S B b) (h : 0≤b) : suit S b B B := ⟨by simpa,fun _ _=>near_self h⟩ |
| lemma suit0 {S v w} (h : suit S 0 v w) : |
| v.base=w.base ∧ ∀ i∈S, v.ts i=w.ts i := by |
| constructor |
| · have := h.1 |
| exact sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm this (abs_nonneg _))) |
| intro i hi |
| have ⟨hx,hy⟩:=h.2 i hi |
| exact Prod.ext (sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hx (abs_nonneg _)))) |
| (sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hy (abs_nonneg _)))) |
| lemma suit_rk {S b v w} (h:suit S b v w) (K : ℕ) : |
| |v.rk S K-w.rk S K|≤b := |
| maxnear (rank_lip (le_trans (abs_nonneg _) h.1) (fun i hi=>(h.2 i hi).1)) h.1 |
| lemma suit_val {t C f S b v w} (h:TS t C f) (e:suit S b v w) (K) {i} (hi:i∈S) : |
| |fourth (v.val S K f i)-fourth (w.val S K f i)|≤3*C^3*b := |
| h.comparison (e.2 i hi).1 (suit_rk e K) (e.2 i hi).2 |
|
|
| lemma rank_min {α : Type} (S : Finset α) (f : α→ ℝ) (K u) (h:0≤ u) : |
| rank S (fun i=>min u (f i)) K=min u (rank S f K) := by |
|
|
| have he1:=rank_nn S f K; have he2:=rank_nn S (fun i=>min u (f i)) K |
| have he3 := le_min h he1 |
| rcases lt_trichotomy (rank S (fun i=>min u (f i)) K) (min u (rank S f K)) with hs|hs|hs |
| · let r:=rank S (fun i=>min u (f i)) K |
| have ht := (rank_gt he2).mp (lt_of_lt_of_le hs (min_le_right ..)) |
| have hh : r < u := lt_of_lt_of_le hs (min_le_left ..) |
| refine False.elim (lt_irrefl r ((rank_gt he2).mpr ?_)) |
| simpa only [lt_min_iff,show rank S (fun i=>min u (f i)) K < u from hh,true_and] |
| · exact hs |
| · apply False.elim |
| let v:=min u (rank S f K) |
| have he := (rank_gt he3).mp hs |
| rcases le_total u (rank S f K) with h|h |
| · rw [min_eq_left h] at he; simp at he |
| · rw [min_eq_right h] at he |
| refine lt_irrefl _ ((rank_gt he1).mpr (lt_of_lt_of_le he (card_le_card ?_))) |
| intro i hi; obtain ⟨hi,hh⟩:=mem_filter.mp hi |
| exact mem_filter.2 ⟨hi,lt_of_lt_of_le hh (min_le_right ..)⟩ |
|
|
| lemma rank_sat {α : Type} (S : Finset α) (f : α→ℝ) (K u) (h:0≤u) : |
| rank S (fun i=> sat u (f i)) K = min u (rank S f K) := by |
| unfold sat clip; rw [rank_min S _ K u h] |
| have he : rank S (fun i=>max (-u) (f i)) K=rank S f K := by |
| have hl:= rank_nn S f K; have hv :=rank_nn S (fun i=>max (-u) (f i)) K |
| have hk (v) (he:0≤v) (i) : (v< max (-u) (f i))=(v<f i) := by grind |
| rcases lt_trichotomy (rank S (fun i=>max (-u) (f i)) K) (rank S f K) with he|he|he |
| · refine False.elim (lt_irrefl _ ((rank_gt hv).mpr ?_)) |
| simp_rw [hk _ hv]; exact (rank_gt hv).mp he |
| · exact he |
| · have hu := (rank_gt hl).mp he |
| simp_rw [hk _ hl] at hu |
| exact False.elim (lt_irrefl _ ((rank_gt hl).mpr hu)) |
| rw [he] |
|
|
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| /-! Row update with thresholds capped at 4. While the gate is below |
| permanent shutdown this cap has no effect on the exceptional representation; |
| the actual calculation can use a buffered shutdown test emptying its real |
| slots on detecting u > 2. Our analysis uses the full map before that emptying. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| structure Params where |
| S : Domain |
| K : ℕ |
| n : ℕ |
| rho : ℝ |
|
|
| namespace Params |
| variable (p : Params) |
| def U (v : Blob) := min 4 (max p.rho (max v.base (rank p.S (fun i=> ht (v.ts i)) p.n))) |
| def Z (v : Blob) := min 4 (max (p.U v) (min (v.rk p.S p.K) (3*p.U v))) |
|
|
| lemma U_nn (v : Blob) : 0 ≤ p.U v := by unfold U; have :=rank_nn p.S (fun i=> ht (v.ts i)) p.n; grind |
| lemma U_four (v : Blob) : p.U v ≤ 4 := min_le_left .. |
| lemma U_old {v : Blob} (h : v.base ≤ 4) : v.base ≤ p.U v := by unfold U; grind |
| lemma U_rho (v : Blob) (h : p.rho ≤ 4) : p.rho ≤ p.U v := by unfold U; grind |
| lemma Z_w (v : Blob) : p.U v≤p.Z v∧ p.Z v≤3*p.U v ∧ p.Z v≤4 := by |
| have h:=p.U_nn v; have e:=p.U_four v |
| unfold Z; grind |
| lemma Z_nn (v : Blob) : 0≤p.Z v := (p.U_nn v).trans (p.Z_w v).1 |
|
|
| def push (v : Blob) : Blob := |
| let u:=p.U v |
| let z:=p.Z v |
| ⟨z,fun i=> |
| let r:=v.ts i |
| let b:=line z |
| b + clp (7*max 0 (ht r-2*u)) (r-b)⟩ |
|
|
| lemma base_push (v : Blob) : (p.push v).base=p.Z v := rfl |
|
|
| lemma nearbase {v : Blob} {i} (h: ht (v.ts i)≤2*p.U v) : |
| (p.push v).ts i = line (p.Z v) := by |
| have H x : sat 0 x=0 := by unfold sat clip; grind |
| dsimp only [push] |
| rw [max_eq_left (show ht (v.ts i)-2*p.U v≤0 from by linarith)] |
| simp [clp,H] |
| lemma offbase {v : Blob} {i} (h : 3*p.U v ≤ ht (v.ts i)) : |
| (p.push v).ts i=v.ts i := by |
| have h1:=p.U_nn v; obtain ⟨h2,h3,-⟩:=p.Z_w v; let z:=line (p.Z v) |
| let m:=ht (v.ts i) |
| have hx : ht (-z)=p.Z v := by simp [ht,z,p.Z_nn] |
| have e : ht (v.ts i-z)≤ m+3*p.U v := by |
| rw [sub_eq_add_neg] |
| apply le_trans (ht_add _ _) |
| rw [hx]; linarith |
| have hh : ht (v.ts i-z) ≤7*max 0 (ht (v.ts i)-2*p.U v) := by |
| unfold m at e; have H:=le_max_right 0 (ht (v.ts i)-2*p.U v) |
| linarith |
| obtain ⟨a,b⟩:=max_le_iff.mp hh |
| have ht : clp (7*max 0 (ht (v.ts i)-2*p.U v)) (v.ts i-z)=v.ts i-z := |
| Prod.ext (sat_id a) (sat_id b) |
| unfold push; change z+clp _ (_-z)=_ |
| rw [ht]; abel |
|
|
| def Between (x y z : ℝ) := min x z ≤ y ∧ y ≤ max x z |
| lemma middle {v : Blob} {i} : |
| Between (p.Z v) ((p.push v).ts i).1 (v.ts i).1 ∧ |
| Between 0 ((p.push v).ts i).2 (v.ts i).2 := by |
| let u:=7*max 0 (ht (v.ts i)-2*p.U v) |
| have h : 0 ≤ u := by dsimp [u]; positivity |
| have H (x b : ℝ) : Between b (b+sat u (x-b)) x := by |
| have := sat_between (x:=x-b) h; unfold Between |
| grind |
| exact ⟨H _ _,H _ _⟩ |
|
|
| lemma perturb (v : Blob) (i) : near (6*p.U v) ((p.push v).ts i) (v.ts i) := by |
| have h:=p.U_nn v; obtain ⟨h2,h3,h4⟩:=p.Z_w v |
| rcases le_total (3*p.U v) (ht (v.ts i)) with hh|hh |
| · rw [p.offbase hh]; exact near_self (by linarith) |
| obtain ⟨a1,a2⟩:=max_le_iff.mp hh |
| obtain ⟨a,b⟩:=p.middle (v:=v) (i:=i) |
| unfold near Between at * |
| rw [abs_le] at a1 a2; rw [abs_le,abs_le] |
| grind |
|
|
| lemma U_near {v w b} (h:suit p.S b v w) : |
| |p.U v-p.U w|≤b := by |
| have hs : 0≤b := le_trans (abs_nonneg _) h.1 |
| apply minnear (by simpa) |
| apply maxnear (by simpa) |
| apply maxnear h.1 |
| exact rank_lip hs fun i hi=>near_ht (h.2 i hi) |
| lemma Z_near {v w b} (h:suit p.S b v w) : |
| |p.Z v-p.Z w|≤ 3*b := by |
| have hs : 0≤b := le_trans (abs_nonneg _) h.1 |
| have hu:=p.U_near h |
| apply minnear (by simp; linarith) |
| apply maxnear (by linarith) |
| apply minnear (le_trans (suit_rk h _) (by linarith)) |
| rw [← mul_sub,abs_mul,abs_of_nonneg (show (0:ℝ)≤3 by norm_num)] |
| linarith |
| lemma smooth_push {v w b} (h:suit p.S b v w) : |
| suit p.S (30*b) (p.push v) (p.push w) := by |
| have hu:=p.U_near h; have hz:=p.Z_near h |
| have hs : 0≤ b:=le_trans (abs_nonneg _) h.1 |
| refine ⟨le_trans hz (by linarith),fun i hi=>?_⟩ |
| have he:=h.2 i hi |
| have htt := near_ht he |
| let r (v:Blob):=7*max 0 (ht (v.ts i)-2*p.U v) |
| have hr : |r v-r w|≤21*b := by |
| have h1 : |2*p.U v-2*p.U w|≤2*b := by rw [← mul_sub,abs_mul,abs_of_nonneg (by norm_num)]; linarith |
| have h2 := subnear htt h1 |
| have h3 := maxnear (show |(0:ℝ)-0|≤b+2*b by simp; linarith) h2 |
| unfold r; rw [← mul_sub,abs_mul,abs_of_nonneg (by norm_num)] |
| linarith |
| have hh : near (3*b) (line (p.Z v)) (line (p.Z w)) := ⟨hz,show |(0:ℝ)-0|≤3*b from by simp; linarith⟩ |
| have hl := near_sub he hh |
| have hq := near_add hh (show near (b+3*b+21*b) |
| (clp (r v) (v.ts i-line (p.Z v))) |
| (clp (r w) (w.ts i-line (p.Z w))) from |
| ⟨sat_near hl.1 hr,sat_near hl.2 hr⟩) |
| exact near_le hq (by linarith) |
|
|
| end Params |
|
|
| def struck (L : ℝ) (v : Blob) : Blob := ⟨v.base,fun i=>clp L (v.ts i)⟩ |
|
|
| lemma strike_U (p : Params) (v : Blob) (L : ℝ) (hh:4≤L) : |
| p.U (struck L v)=p.U v := by |
| unfold Params.U struck; have hL : 0≤L := by linarith |
| simp_rw [ht_clp hL,rank_min _ _ _ L hL]; grind |
|
|
| lemma strike_rk (S : Domain) (K) (v : Blob) (L) (h : v.base≤L) (hh:0≤L) : |
| (struck L v).rk S K = min L (v.rk S K) := by |
| unfold struck Blob.rk clp; simp_rw [rank_sat _ _ _ _ hh]; grind |
|
|
| lemma strike_Z (p : Params) (v : Blob) (L) (hh:12≤L) (h:v.base≤4) : |
| p.Z (struck L v)=p.Z v := by |
| unfold Params.Z |
| rw [strike_U p v _ (by linarith),strike_rk _ _ _ _ (by linarith) (by linarith)] |
| have he := p.U_four v; grind |
|
|
| lemma strike_push (p : Params) (v : Blob) (L) (hh:12≤L) (h:v.base≤4) : |
| struck L (p.push v)= p.push (struck L v) := by |
| have he:=strike_U p v L (by linarith) |
| have hZ := strike_Z p v L hh h |
| have hu:=p.U_four v |
| have H (i) : clp L ((p.push v).ts i)=(p.push (struck L v)).ts i := by |
| have h0 : 0≤L:=by linarith |
| rcases le_total (3*p.U v) (ht (v.ts i)) with hv|hv |
| · rw [Params.offbase p hv,Params.offbase p] |
| · rfl |
| rw [he] |
| change 3*p.U v≤ht (clp L (v.ts i)) |
| rw [ht_clp h0]; exact le_min (by linarith) hv |
| obtain ⟨hx,hy⟩:=max_le_iff.mp hv |
| have hg1 : |(v.ts i).1|≤L := by linarith |
| have hg2 : |(v.ts i).2|≤L := by linarith |
| have hg : (struck L v).ts i=v.ts i := Prod.ext (sat_id hg1) (sat_id hg2) |
| rw [show (p.push (struck L v)).ts i=(p.push v).ts i from ?_] |
| · obtain ⟨h1,h2⟩:=Params.middle p (v:=v) (i:=i) |
| obtain ⟨h1a,h1b⟩:=h1; obtain ⟨h2a,h2b⟩:=h2 |
| obtain ⟨hp,hp'⟩:=abs_le.1 hg1; obtain ⟨hq,hq'⟩:=abs_le.1 hg2 |
| obtain hh' :=p.Z_nn v; obtain hh'' := (p.Z_w v).2.2 |
| exact Prod.ext (sat_id (by rw [abs_le]; grind)) (sat_id (by rw [abs_le]; grind)) |
| dsimp only [Params.push]; rw [he,hZ,hg] |
| cases H1:struck L (p.push v) with |
| | mk base ts => |
| cases H2:p.push (struck L v) with |
| | mk b f => |
| have h1 : base=b := calc |
| _ = (struck L (p.push v)).base := by rw [H1] |
| _ = (p.push (struck L v)).base := hZ.symm |
| _ = b := by rw [H2] |
| have h2 : ts=f := calc |
| _ = (struck L (p.push v)).ts := by rw [H1] |
| _ = (p.push (struck L v)).ts := funext H |
| _ = _:= by rw [H2] |
| rw [h1,h2] |
| lemma strike_val {theta C f} {v:Blob} (h:TS theta C f) (S : Domain) (K i L) (he:C≤L) |
| (hh:v.base≤L) : |
| (struck L v).val S K f i=v.val S K f i := by |
| have hg:= h.extend he |
| have hl:=h.start.one |
| unfold Blob.val |
| rw [strike_rk _ _ _ _ hh (by linarith)] |
| have hk : sat L (v.rk S K)=min L (v.rk S K) := sat_eq_min (by |
| unfold Blob.rk; have :=rank_nn S (fun i=>(v.ts i).1) K; grind) |
| rw [← hk]; exact hg.flat _ _ _ |
|
|
| /-- At gate-close baseline, any arrays represent zero row outputs. -/ |
| lemma closed {theta C f} {v:Blob} (h:TS theta C f) (he : theta/40 ≤ v.base) |
| (S : Domain) (K i) : v.val S K f i=0 := by |
| unfold Blob.val Trio.eval |
| rw [h.off (v.rk S K) (he.trans (le_max_right ..))]; ring |
|
|
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| /-! Compression remaining stationary on a nearly nonnegative reference array. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| abbrev mist := 10*At.small |
| lemma smallp : 0<At.small := by norm_num [At.small,delta,A] |
| lemma mistp : 0< mist := by have :=smallp; unfold mist; linarith |
| lemma mist1 : mist<1 := by norm_num [mist,At.small,delta,A] |
| lemma mist_eta {theta} (h : delta≤theta) : mist < eta theta := by |
| unfold mist At.small eta; unfold delta A at *; linarith |
| lemma mist_shut {theta} (h : delta≤theta) : 3*mist<theta/8 := by |
| have := mist_eta h; have he:=dp; unfold eta at *; linarith |
|
|
| def Calm (S : Domain) (v : Blob) : Prop := |
| 0 ≤ v.base ∧ v.base≤4 ∧ ∀ i∈S, -mist ≤ (v.ts i).1 ∧ |(v.ts i).2|≤ mist |
|
|
| namespace Params |
| variable (p : Params) |
| lemma still_calm {v} (h : Calm p.S v) : Calm p.S (p.push v) := by |
| refine ⟨p.Z_nn v,(p.Z_w v).2.2,fun i hi=>?_⟩ |
| obtain ⟨hl,ht⟩:= h.2.2 i hi |
| obtain ⟨⟨hx,hy⟩,hg,hg'⟩:=p.middle (v:=v) (i:=i) |
| have he := p.Z_nn v; have hp:=mistp |
| rw [abs_le] at ht ⊢ |
| grind |
|
|
| lemma toprank {q : ℝ} {v} (he:0≤q) (hh:v.rk p.S p.K≤q) (hz:p.Z v ≤ q) : |
| (p.push v).rk p.S p.K≤q := by |
| have hc : rank p.S (fun i=>(v.ts i).1) p.K ≤ q := |
| le_trans (le_max_left ..) hh |
| unfold Blob.rk |
| apply max_le _ hz |
| by_contra! h |
| have ht := (rank_gt he).1 h |
| have he1 := (rank_gt (K:=p.K) (f:=fun i=>(v.ts i).1) (s:=p.S) he).not.mpr |
| have hi : (p.S.filter fun i=>q<((p.push v).ts i).1) ⊆ p.S.filter (fun i=>q<(v.ts i).1) := by |
| intro i hg; obtain ⟨hj,hk⟩:=mem_filter.mp hg |
| obtain ⟨hx,hy⟩:=(p.middle (i:=i) (v:=v)).1 |
| exact mem_filter.mpr ⟨hj,by grind⟩ |
| exact not_lt_of_ge hc ((rank_gt he).mpr (lt_of_lt_of_le ht (card_le_card hi))) |
|
|
| lemma hold_U {q v} (h: Calm p.S v) (hq: mist≤ q) (he:v.rk p.S p.K ≤ q) |
| (hs : p.rho ≤ mist) (hk : p.K≤p.n) : p.U v ≤ q := by |
| have hq0 : 0 ≤ q := by linarith [mistp] |
| have hb : v.base ≤ q := le_trans (le_max_right ..) he |
| have hp : rank p.S (fun i=>(v.ts i).1) p.K ≤ q := le_trans (le_max_left ..) he |
| have hh : rank p.S (fun i=>ht (v.ts i)) p.n ≤ q := by |
| by_contra! e |
| have he := lt_of_le_of_lt hk ((rank_gt hq0).1 e) |
| have ht : p.S.filter (fun i=>q<ht (v.ts i)) ⊆ p.S.filter (fun i=>q<(v.ts i).1) := by |
| intro i hi; obtain ⟨h1,h2⟩:=mem_filter.1 hi |
| obtain ⟨hy,hz⟩:=h.2.2 i h1 |
| apply mem_filter.2 ⟨h1,?_⟩; unfold ht at h2; grind |
| exact not_lt_of_ge hp ((rank_gt hq0).2 (lt_of_lt_of_le he (card_le_card ht))) |
| unfold U; grind |
| lemma hold_Z {q v} (h:v.rk p.S p.K ≤ q) (he:p.U v≤q) : |
| p.Z v≤q := by unfold Z; grind |
|
|
| lemma raising_rank {q : ℝ} {v : Blob} (h:Calm p.S v) (hz:0<q) |
| (he:q≤v.rk p.S p.K) (hq:q≤4) : q≤(p.push v).rk p.S p.K := by |
| rcases le_total q (p.Z v) with hb|hb |
| · exact le_trans hb (le_max_right ..) |
| by_contra! hc |
| have hh : p.Z v < q := lt_of_le_of_lt (le_max_right ..) hc |
| have hh1 : 3*p.U v < q := by unfold Z at hh; grind |
| have htt : v.base < q := |
| lt_of_le_of_lt ((p.U_old h.2.1).trans (p.Z_w v).1) hh |
| have he1 : q≤rank p.S (fun i=>(v.ts i).1) p.K := by unfold Blob.rk at he; grind |
| have hs := (rank_ge hz).1 he1 |
| have hx : p.S.filter (fun i=>q≤(v.ts i).1) ⊆ p.S.filter (fun i=>q≤((p.push v).ts i).1) := by |
| intro i hi; obtain ⟨h1,h2⟩:=mem_filter.mp hi |
| have h3 : 3*p.U v≤ht (v.ts i) := by unfold ht; grind |
| apply mem_filter.mpr ⟨h1,?_⟩; rw [p.offbase h3]; exact h2 |
| have hu : q ≤ (p.push v).rk p.S p.K := |
| le_trans ((rank_ge hz).mpr (lt_of_lt_of_le hs (card_le_card hx))) (le_max_left ..) |
| linarith |
|
|
| lemma same {theta C v f r} (h : TS theta C f) (ht:0<theta) |
| (he : f.row (v.rk p.S p.K)=f.row ((p.push v).rk p.S p.K)) |
| (hs : 3*r ≤ theta/8) (hx : p.U v≤r) (i) : |
| v.val p.S p.K f i = (p.push v).val p.S p.K f i := by |
| rcases le_total (3*p.U v) (Buf.ht (v.ts i)) with h1|h1 |
| · unfold Blob.val Trio.eval; rw [p.offbase h1,he] |
| have hp := (p.Z_w v).2.1 |
| have h2:= (p.middle (i:=i) (v:=v)).1.2 |
| have h3 : (v.ts i).1 ≤ theta/8 := by unfold Buf.ht at *; grind |
| have h4 : ((p.push v).ts i).1 ≤ theta/8 := by grind |
| unfold Blob.val Trio.eval |
| rw [h.shut _ h3,h.shut _ h4]; ring |
|
|
| lemma motionless {theta C f} (h : TS theta C f) (ht:delta≤theta) (hc:theta≤1) |
| {v} (hv:Calm p.S v) (hz:p.rho≤ mist) (hk:p.K≤p.n) (i) : |
| (p.push v).val p.S p.K f i=v.val p.S p.K f i := by |
| have ht0 : 0<theta := dp.trans_le ht |
| let q := v.rk p.S p.K |
| rcases le_total q mist with hq|hq |
| · have hu:=p.hold_U hv le_rfl hq hz hk |
| have hZ := p.toprank (le_of_lt mistp) hq (p.hold_Z hq hu) |
| have H := le_of_lt (mist_eta ht) |
| apply Eq.symm (p.same h ht0 _ (le_of_lt (mist_shut ht)) hu i) |
| rw [h.full _ (le_trans hq H),h.full _ (le_trans hZ H)] |
| rcases le_total q 4 with hh|hh |
| · have hu := p.hold_U hv hq le_rfl hz hk |
| have h0 : 0<q := lt_of_lt_of_le mistp hq |
| have h1 : (p.push v).rk p.S p.K=q := le_antisymm |
| (p.toprank h0.le le_rfl (p.hold_Z le_rfl hu)) (p.raising_rank hv h0 le_rfl hh) |
| have hL : f.row (v.rk p.S p.K)=f.row ((p.push v).rk p.S p.K) := by rw [h1] |
| rcases le_total (theta/40) q with h2|h2 |
| · unfold Blob.val Trio.eval; rw [h1,h.off _ h2]; ring |
| · exact Eq.symm (p.same h ht0 hL (by linarith : 3*q ≤ theta/8) hu i) |
| have h1 := p.raising_rank hv (by norm_num : (0:ℝ)<4) hh le_rfl |
| unfold Blob.val Trio.eval |
| have h2 : theta/40 ≤ 4 := by linarith |
| rw [h.off _ (h2.trans h1),h.off (v.rk p.S p.K) (h2.trans hh)]; ring |
|
|
| end Params |
|
|
| def trim (F : Domain) (v:Blob) : Blob := |
| ⟨0,fun i=>if i∈F then v.ts i else 0⟩ |
|
|
| /-- Positions with their first entry below mist are below sensitivity. |
| Drop them to compare only the other positions. -/ |
| lemma trim_safe {theta C f} (h : TS theta C f) (ht: delta ≤ theta) |
| (S F : Domain) {v:Blob} (he:v.base≤ mist) |
| (hh : ∀ i∈S,i∉F → (v.ts i).1≤ mist) (K) {i} (hi:i∈S) : |
| v.val S K f i=(trim F v).val S K f i := by |
| let w:= trim F v |
| have hu (q : ℝ) (hz:mist ≤ q) : |
| q<v.rk S K ↔ q<w.rk S K := by |
| have hg := lt_of_lt_of_le mistp hz |
| have hs : (S.filter fun i=>q<(v.ts i).1) = S.filter (fun i=>q<(w.ts i).1) := by |
| ext i; unfold w trim; by_cases hi:i∈F |
| · simp [hi] |
| by_cases he:i∈S |
| · have hx : (v.ts i).1≤q:=(hh i he hi).trans hz; simp [hi,not_lt_of_ge hx,not_lt_of_ge hg.le] |
| · simp [he] |
| unfold Blob.rk |
| have h1 : v.base ≤ q := he.trans hz |
| have h2 : w.base ≤ q := hg.le |
| rw [lt_max_iff,lt_max_iff,rank_gt hg.le,rank_gt hg.le,hs] |
| grind |
| have ht0 := le_of_lt (mist_eta ht) |
| have hw : f.row (v.rk S K)=f.row (w.rk S K) := by |
| by_cases hp: mist<v.rk S K |
| · have hh1 := (hu mist le_rfl).1 hp |
| have hr : v.rk S K=w.rk S K := by |
| rcases lt_trichotomy (v.rk S K) (w.rk S K) with hs|hs|hs |
| · exact False.elim (lt_irrefl _ ((hu _ hp.le).mpr hs)) |
| · exact hs |
| · exact False.elim (lt_irrefl _ ((hu _ hh1.le).mp hs)) |
| rw [hr] |
| have hh1 : w.rk S K≤ mist:=le_of_not_gt (fun e=> hp ((hu mist le_rfl).2 e)) |
| rw [h.full _ ((le_of_not_gt hp).trans ht0),h.full _ (hh1.trans ht0)] |
| by_cases hb:i∈F |
| · unfold Blob.val Trio.eval; rw [hw] |
| simp only [w,trim,ite_eq_left hb] |
| have hp : mist≤theta/8 := by linarith [mistp,mist_shut ht] |
| unfold Blob.val Trio.eval |
| rw [h.shut _ (le_trans (hh i hi hb) hp),h.shut _ (show ((trim F v).ts i).1≤theta/8 from ?_)] |
| · ring |
| simp only [trim,hb,ite_false]; change 0≤_ |
| linarith [mistp] |
|
|
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| /-! Compression run, preloss and beginning of the comparison. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| structure Run where |
| L : ℕ |
| S : Domain |
| K : ℕ |
| n : ℕ→ℕ |
| rho : ℕ→ℝ |
| inc : ℕ→Row |
| aim : Row |
|
|
| namespace Run |
| variable (r : Run) |
| abbrev pm (i : ℕ) : Params := ⟨r.S,r.K,r.n i,r.rho i⟩ |
|
|
| def pile (r:Run) : ℕ→Row |
| | 0=>0 |
| | i+1=>r.pile i+r.inc i |
| def shifted (i : ℕ) (v : Blob) : Blob := ⟨v.base,v.ts+r.inc i⟩ |
| def mid (r:Run) : ℕ→Blob |
| | 0=>⟨0,0⟩ |
| | i+1=>(r.pm i).push (r.shifted i (r.mid i)) |
| def enter (i) := r.shifted i (r.mid i) |
| lemma mid_succ (i) : r.mid (i+1)=(r.pm i).push (r.enter i) := rfl |
| def loss (i) := (r.mid i).ts-r.pile i |
| lemma total_enter (i x : ℕ) : |
| (r.enter i).ts x=r.pile (i+1) x+r.loss i x := by |
| simp only [enter,shifted,pile,loss,Pi.add_apply,Pi.sub_apply] |
| abel |
| lemma iter_loss (i x) : |
| r.loss (i+1) x=r.loss i x+((r.mid (i+1)).ts x-(r.enter i).ts x) := by |
| rw [r.total_enter]; unfold loss; simp only [Pi.sub_apply]; abel |
|
|
| def epi (i x : ℕ) := |
| let p:=r.aim x |
| let q:=r.pile (i+1) x |
| min 1 (max (|q.1-p.1|/(1+p.1)) |q.2-p.2|) |
| def bad (i) := rank r.S (r.epi i) 0 |
| lemma epi_nn (i x) : 0≤r.epi i x := le_min zero_le_one (le_trans (abs_nonneg _) (le_max_right ..)) |
| lemma bad_epi (i) {x} (h:x∈r.S) : r.epi i x ≤ r.bad i := by |
| obtain he|he:=(r.epi_nn i x).eq_or_lt |
| · rw [← he]; apply rank_nn |
| · apply (rank_ge he).2 |
| exact card_pos.mpr ⟨x,mem_filter.2 ⟨h,le_rfl⟩⟩ |
| lemma bad_nn (i) : 0≤r.bad i := rank_nn .. |
|
|
| def dust (j) := ∑ i ∈ range j, 6*r.rho i |
| def rain (j) := ∑ i ∈ range j, 24/small*r.rho i*r.bad i |
| def overflow (i : ℕ) : Prop := r.rho i < (r.pm i).U (r.enter i) |
| def pre (i : ℕ) := ∀ j< i,¬r.overflow j |
|
|
| structure Good (r:Run) : Prop where |
| pos : ∀ i < r.L, 0<r.rho i |
| tiny : r.dust r.L≤ small |
| ahead : ∀ i<r.L, r.dust i≤r.rho i/100 |
| cap : ∀ i<r.L, r.K ≤ r.n i |
| target_nn : ∀ i∈r.S, 0≤(r.aim i).1 |
| target_s : ∀ i∈r.S, |(r.aim i).2|≤zeta |
| target_flat : ∀ i∈r.S, (r.aim i).1≤ small → (r.aim i).2=0 |
|
|
| lemma base_mid (i) : 0≤(r.mid i).base ∧ (r.mid i).base≤4 := by |
| cases i with |
| | zero=>simp [mid] |
| | succ i=>exact ⟨Params.Z_nn ..,(Params.Z_w ..).2.2⟩ |
| lemma dust_nn (h:r.Good) {i} (he:i≤r.L) : 0 ≤ r.dust i := |
| sum_nonneg fun j hj=>mul_nonneg (by norm_num) (le_of_lt (h.pos _ (lt_of_lt_of_le (mem_range.1 hj) he))) |
| lemma rain_nn (h:r.Good) {i} (he:i≤r.L) : 0 ≤ r.rain i := |
| sum_nonneg fun j hj=>by |
| have ha:=h.pos _ (lt_of_lt_of_le (mem_range.1 hj) he) |
| have he:=r.bad_nn j; have hs:=smallp |
| positivity |
| lemma dust_le (h:r.Good) {i} (he:i≤r.L) : r.dust i≤ small := by |
| apply le_trans _ h.tiny; unfold dust |
| exact sum_le_sum_of_subset_of_nonneg (range_mono he) fun j hj _=> |
| mul_nonneg (by norm_num) (h.pos _ (mem_range.1 hj)).le |
| lemma dust_next (i) : r.dust (i+1)=r.dust i+6*r.rho i := sum_range_succ .. |
| lemma rain_next (i) : r.rain (i+1)=r.rain i+24/small*r.rho i*r.bad i := |
| sum_range_succ .. |
|
|
| lemma rho_dust (h:r.Good) {i} (he:i<r.L) : 6*r.rho i≤ small := by |
| have hh := r.dust_le h (i:=i+1) he |
| have hl := r.dust_nn h he.le |
| rw [r.dust_next] at hh; linarith |
| lemma rho_mist (h:r.Good) {i} (he:i<r.L) : r.rho i ≤ mist := by |
| have ht:=h.pos i he; have hu := r.rho_dust h he |
| unfold Buf.mist; linarith |
|
|
| lemma literal (h:r.Good) {i x} (he:x∈r.S) (hx:r.bad i < 1) : |
| |(r.pile (i+1) x).1-(r.aim x).1|≤(1+(r.aim x).1)*r.bad i ∧ |
| |(r.pile (i+1) x).2-(r.aim x).2|≤r.bad i := by |
| have hg:=r.bad_epi i he |
| dsimp only [epi] at hg |
| have hs: 0<1+(r.aim x).1 := by linarith [h.target_nn _ he] |
| constructor |
| · rw [mul_comm]; apply (div_le_iff₀ hs).1; grind |
| · grind |
|
|
| /-- preloss biggest bound, until the first overflow -/ |
| lemma pre_head (h:r.Good) {i} (hh:i≤r.L) (hp:r.pre i) : |
| (r.mid i).base≤r.dust i ∧ ∀ x∈r.S, ht (r.loss i x) ≤ r.dust i := by |
| induction i with |
| | zero=>simp [mid,dust,ht,loss,pile] |
| | succ i ih=> |
| obtain ⟨hb,hx⟩:= ih (by omega) (fun j hj=>hp j (by omega)) |
| have he : (r.pm i).U (r.enter i)≤r.rho i := |
| le_of_not_gt (hp i (Nat.lt_add_one _)) |
| rw [r.dust_next] |
| constructor |
| · rw [r.mid_succ]; change (r.pm i).Z _≤_ |
| have hp : 0≤r.rho i := (h.pos _ hh).le |
| have hh1:= ((r.pm i).Z_w (r.enter i)).2.1 |
| have hh2:=r.dust_nn h (i:=i) (by omega) |
| linarith |
| · intro x hi |
| have hp := hx x hi |
| rw [r.iter_loss] |
| apply (ht_add ..).trans |
| apply add_le_add hp |
| rw [r.mid_succ] |
| apply (ht_sub ..).2 |
| exact near_le (Params.perturb ..) (by linarith) |
|
|
| /-- At a significant position changed during preloss, the prefix made |
| definite relative error. -/ |
| lemma flag (h:r.Good) {i x} (hi:i<r.L) (hp:r.pre i) (hx:x∈r.S) |
| (hs:¬r.overflow i) (hh:4*small≤(r.aim x).1) |
| (he : (r.mid (i+1)).ts x ≠ (r.enter i).ts x) : |
| small/4 ≤ r.bad i := by |
| let p:=r.enter i |
| let z:=r.aim x |
| let w:=r.pile (i+1) x |
| have hv : ht (p.ts x) <3*r.rho i := by |
| by_contra! hl |
| exact he ((r.pm i).offbase (v:=p) (by |
| have e : (r.pm i).U p≤r.rho i:=le_of_not_gt hs |
| linarith)) |
| have hl:= le_trans ((r.pre_head h hi.le hp).2 x hx) (r.dust_le h hi.le) |
| have hk:= r.rho_dust h hi |
| have h0 := (r.total_enter i x) |
| have h1 : w.1≤ 2*small := by |
| have hu : |(p.ts x).1|≤ht (p.ts x):=le_max_left .. |
| have htt : p.ts x=w+r.loss i x:=h0 |
| obtain ⟨hy,hx'⟩ :=abs_le.1 (le_trans (show |(r.loss i x).1|≤Buf.ht (r.loss i x) from le_max_left ..) hl) |
| rw [htt] at hu hv; simp only [Prod.fst_add] at hu |
| have hf := le_abs_self (w.1+(r.loss i x).1) |
| linarith [smallp] |
| refine le_trans ?_ (r.bad_epi i hx) |
| apply le_min |
| · have :=mist1; unfold mist at *; linarith |
| apply le_trans _ (le_max_left ..) |
| change small/4≤ |w.1-z.1|/(1+z.1) |
| have hz1: 4*small≤z.1:= hh |
| have hp : 0< z.1 := by linarith [smallp] |
| have hl1 : small ≤ 1 := by linarith [show 10*small<1 from mist1] |
| rw [le_div_iff₀ (by linarith)] |
| unfold small delta A at *; linarith [neg_le_abs (w.1-z.1)] |
|
|
| lemma pre_marks (h:r.Good) {i} (hh:i≤r.L) (hp:r.pre i) {x} (hx:x∈r.S) |
| (he:4*small≤(r.aim x).1) : |
| ht (r.loss i x)≤r.rain i := by |
| induction i with |
| | zero=>simp [ht,rain,loss,mid,pile] |
| | succ i ih=> |
| have hz : r.pre i:=fun j hj=>hp _ (by omega) |
| have he1:=ih (by omega) hz |
| have hs : ¬r.overflow i:=hp _ (by omega) |
| rw [r.iter_loss,r.rain_next] |
| apply le_trans (ht_add ..) |
| apply add_le_add he1 |
| have h0:= h.pos i hh |
| by_cases hn : (r.mid (i+1)).ts x=(r.enter i).ts x |
| · rw [hn, sub_self] |
| have hb := r.bad_nn i; have hh := smallp |
| simp [ht]; positivity |
| have hf:=r.flag h hh hz hx hs he hn |
| have h2 : (r.pm i).U (r.enter i)≤r.rho i := le_of_not_gt hs |
| apply le_trans (b:=6*r.rho i) |
| · rw [r.mid_succ, ht_sub]; exact near_le (Params.perturb ..) (by linarith) |
| · have hp:=smallp |
| rw [div_mul_eq_mul_div,div_mul_eq_mul_div, le_div_iff₀ hp] |
| have :=mul_le_mul_of_nonneg_left hf h0.le; unfold small delta A at *; linarith |
|
|
| def origin : Blob := ⟨0,r.aim⟩ |
| def corrected (i : ℕ) : Blob := ⟨(r.mid i).base,r.aim+r.loss i⟩ |
| lemma start_calm (h:r.Good) {i} (he : i≤r.L) (hp:r.pre i) : |
| Calm r.S (r.corrected i) := by |
| refine ⟨(r.base_mid i).1,(r.base_mid i).2,fun j hj=>?_⟩ |
| have hh := h.target_nn j hj; have hz := h.target_s j hj |
| have hl := r.pre_head h he hp |>.2 j hj |
| obtain ⟨h1,h2⟩:=max_le_iff.mp (le_trans hl (r.dust_le h he)) |
| simp only [corrected,Pi.add_apply,Prod.fst_add,Prod.snd_add] |
| have hu:= (abs_le.mp h1).1 |
| have hp:=smallp |
| constructor |
| · unfold mist; linarith |
| · refine le_trans (abs_add_le ..) ?_ |
| unfold zeta at hz; unfold mist; unfold small delta A at *; linarith |
|
|
| lemma rain_effect {theta C f} (h:r.Good) (he:TS theta C f) (hz:delta≤theta) |
| {i} (hi : i≤r.L) (hp:r.pre i) {x} (hx:x∈r.S) : |
| |fourth ((r.corrected i).val r.S r.K f x)-fourth (r.origin.val r.S r.K f x)| ≤ |
| 3*C^3*r.rain i := by |
| let F:=r.S.filter fun x=> 4*small≤(r.aim x).1 |
| have hh (x) (hx:x∈r.S) (he:x∉F) : (r.aim x).1< 4*small := |
| lt_of_not_ge fun hn=> he (mem_filter.2 ⟨hx,hn⟩) |
| have hk := r.pre_head h hi hp |
| have hv:=r.dust_le h hi; have hs:=smallp |
| have he1 (j) (he:j∈r.S) : ht (r.loss i j)≤ small := le_trans (hk.2 _ he) hv |
| have HF : suit r.S (r.rain i) (trim F (r.corrected i)) (trim F r.origin) := by |
| have h0 :=r.rain_nn h hi |
| refine ⟨by simp [trim,h0],fun j hj=>?_⟩ |
| by_cases hb:j∈F |
| · simp only [trim,hb,ite_true,corrected,origin] |
| rw [← ht_sub]; simp only [Pi.add_apply,add_sub_cancel_left] |
| exact r.pre_marks h hi hp hj (mem_filter.1 hb).2 |
| simp only [trim,hb,ite_false]; exact near_self h0 |
| rw [trim_safe he hz _ F (v:=r.corrected i) ?_ ?_ _ hx,trim_safe he hz _ F (v:=r.origin) ?_ ?_ _ hx] |
| · refine suit_val he HF _ hx |
| · exact show 0≤ mist from mistp.le |
| · intro i hj hi |
| have := hh i hj hi; change (r.aim i).1≤ mist |
| unfold mist; linarith |
| · change (r.mid i).base≤ mist; unfold mist; linarith [hk.1] |
| · intro j hj hi |
| change ((r.aim+r.loss i) j).1≤ mist |
| simp only [Pi.add_apply,Prod.fst_add] |
| have h2 := le_trans (le_trans (le_abs_self _) (show |(r.loss i j).1|≤ht (r.loss i j) from le_max_left ..)) (he1 j hj) |
| unfold mist; linarith [hh j hj hi] |
|
|
| end Run |
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| /-! Clamped row run. Since U is capped, the actual row is allowed a |
| shutdown test, discarding the real slots upon detecting U>1. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| lemma suit_map {S L R v w} (_ : 0≤L) (he : L≤R) |
| (h:suit S 0 (struck R v) (struck R w)) : |
| suit S 0 (struck L v) (struck L w) := by |
| obtain ⟨hs,ht⟩:=suit0 h |
| refine ⟨by change |v.base-w.base|≤0; change v.base=w.base at hs; rw [hs]; simp,fun i hi=>?_⟩ |
| have hc := ht _ hi |
| have hz {p} : clp L (clp R p)=clp L p := by |
| apply Prod.ext <;> |
| exact sandwich (by linarith) he _ |
| change clp R (v.ts i)=clp R (w.ts i) at hc |
| change near _ (clp L _) (clp L _) |
| rw [← hz (p:=v.ts i),← hz (p:=w.ts i),hc]; exact near_self le_rfl |
|
|
| lemma suit_idem (S : Domain) (v : Blob) (L R : ℝ) (he:L≤R) : |
| suit S 0 (struck L (struck R v)) (struck L v) := by |
| refine ⟨by change |v.base-v.base|≤0; simp, fun i hi=>?_⟩ |
| have hh (p:Pt) : clp L (clp R p)=clp L p := by apply Prod.ext <;> exact sandwich (by linarith) he _ |
| change near _ (clp L (clp R _)) _ |
| rw [hh]; exact near_self le_rfl |
|
|
| lemma suit0_trans {S u v w} (h:suit S 0 u v) (e:suit S 0 v w) : suit S 0 u w := by |
| obtain ⟨hb,ht⟩:=suit0 h; obtain ⟨he,hf⟩:=suit0 e |
| refine ⟨by rw [hb,he]; simp,fun i hi=>?_⟩ |
| rw [ht _ hi,hf _ hi]; exact near_self le_rfl |
| lemma suit0_symm {S u v} (h:suit S 0 u v) : suit S 0 v u := by |
| obtain ⟨hb,ht⟩:=suit0 h |
| refine ⟨by rw [hb]; simp,fun i hi=>?_⟩ |
| rw [ht _ hi]; exact near_self le_rfl |
|
|
| namespace Run |
| variable (r : Run) |
| def die (v : Blob) : Blob := ⟨v.base,fun _=>line v.base⟩ |
| def actual (r : Run) (R : ℕ→ℝ) (kap : ℕ→Bool) : ℕ→Blob |
| | 0=>r.mid 0 |
| | i+1=> |
| let w:=struck (R i) ((r.pm i).push (r.shifted i (r.actual R kap i))) |
| if kap i then die w else w |
| abbrev taken (i : ℕ) (v : Blob) (R:ℝ) (b:Bool) := |
| let w:=struck R ((r.pm i).push (r.shifted i v)) |
| if b then die w else w |
| lemma actual_push (R kap i) : r.actual R kap (i+1)=r.taken i (r.actual R kap i) (R i) (kap i) := rfl |
| lemma actual_base (R kap i) : |
| (r.actual R kap (i+1)).base=(r.pm i).Z (r.shifted i (r.actual R kap i)) := by |
| rw [r.actual_push]; unfold taken; split <;> rfl |
| lemma actual_closed (R kap i) : |
| 0≤(r.actual R kap i).base ∧ (r.actual R kap i).base≤4 := by |
| cases i with |
| | zero=>exact r.base_mid _ |
| | succ i=>rw [r.actual_base]; exact ⟨Params.Z_nn ..,(Params.Z_w ..).2.2⟩ |
|
|
| def bridged (L:ℝ) (v w:Blob) := |
| suit r.S 0 (struck L v) (struck L w) ∨ 1≤v.base∧ 1≤w.base |
|
|
| lemma cross_zero {L H i v w} (h:suit r.S 0 (struck H v) (struck H w)) |
| (hp : 0≤L) (he:∀ j∈r.S, ht (r.inc i j)+L ≤ H) : |
| suit r.S 0 (struck L (r.shifted i v)) (struck L (r.shifted i w)) := by |
| refine ⟨h.1,fun j hj=>?_⟩ |
| have hf := (suit0 h).2 j hj |
| have hx := he j hj |
| let d:=r.inc i j; change ht d+L≤H at hx |
| have ha : sat H (v.ts j).1=sat H (w.ts j).1:=congrArg Prod.fst hf |
| have hb : sat H (v.ts j).2=sat H (w.ts j).2:=congrArg Prod.snd hf |
| have hg : clp L (v.ts j+d)=clp L (w.ts j+d) := |
| Prod.ext (sat_add (by unfold ht at hx; grind) ha hp) (sat_add (by unfold ht at hx; grind) hb hp) |
| change near _ (clp L (v.ts j+d)) (clp L (w.ts j+d)) |
| rw [hg]; exact near_self le_rfl |
|
|
| lemma next_bridge {R kap i L H} (h: r.bridged H (r.mid i) (r.actual R kap i)) |
| (hs : 12≤L) (hh : L≤R i) (he:∀ j∈r.S,ht (r.inc i j) + L≤H) |
| (hp : kap i=true → 1≤(r.pm i).U (r.shifted i (r.actual R kap i))) : |
| r.bridged L (r.mid (i+1)) (r.actual R kap (i+1)) := by |
| rcases h with h|⟨h,h'⟩ |
| · let p:=r.pm i; let v:=r.enter i; let w:=r.shifted i (r.actual R kap i) |
| have hz := r.cross_zero h (by linarith) he |
| change suit r.S 0 (struck L v) (struck L w) at hz |
| have h1:=Params.smooth_push (r.pm i) hz |
| have hv : v.base ≤4:=(r.base_mid i).2 |
| have hw : w.base ≤4:=(r.actual_closed R kap i).2 |
| rw [← strike_push p v L hs hv, ← strike_push p w L hs hw] at h1 |
| have hC : suit r.S 0 (struck L (r.mid (i+1))) (struck L (p.push w)) := |
| by rw [mul_zero] at h1; rw [r.mid_succ]; exact h1 |
| by_cases hd:kap i=true |
| · right |
| rw [r.actual_base]; change 1≤(r.mid (i+1)).base ∧ 1≤p.Z w |
| have hs1 : 1≤p.Z w:=le_trans (hp hd) (p.Z_w w).1 |
| have hs2 : (r.mid (i+1)).base=p.Z w:=(suit0 hC).1 |
| rw [hs2]; exact ⟨hs1,hs1⟩ |
| left |
| rw [r.actual_push]; dsimp only [taken]; rw [ite_eq_right hd] |
| exact suit0_trans hC (suit0_symm (suit_idem _ _ _ _ hh)) |
| · right |
| rw [r.actual_base,r.mid_succ] |
| let p:=r.pm i |
| refine ⟨le_trans ?_ (p.Z_w _).1,le_trans ?_ (p.Z_w _).1⟩ |
| · exact h.trans (p.U_old (v:=r.enter i) (r.base_mid i).2) |
| exact h'.trans (p.U_old (v:=r.shifted i (r.actual R kap i)) (r.actual_closed R kap i).2) |
|
|
| theorem clamped {R kap theta C f} (h:TS theta C f) (he:theta≤1) |
| (H : ℕ→ℝ) (hb : ∀ j≤r.L,C≤ H j ∧12 ≤ H j) |
| (hz : ∀ i<r.L,H (i+1)≤R i) |
| (hh : ∀ i<r.L,∀ j∈r.S, ht (r.inc i j) + H (i+1) ≤ H i) |
| (hp : ∀ i<r.L,kap i=true → 1≤(r.pm i).U (r.shifted i (r.actual R kap i))) |
| {i} (hi:i∈r.S) : |
| (r.actual R kap r.L).val r.S r.K f i=(r.mid r.L).val r.S r.K f i := by |
| have h1 (j) (he:j≤r.L) : r.bridged (H j) (r.mid j) (r.actual R kap j) := by |
| induction j with |
| | zero=> exact Or.inl (suit_self _ _ _ le_rfl) |
| | succ j ih=> |
| exact r.next_bridge (ih (by omega)) (hb _ he).2 |
| (hz j he) (hh j he) (hp j he) |
| obtain ⟨h2,h3⟩:=hb r.L le_rfl |
| rcases h1 r.L le_rfl with hs|⟨hs,hk⟩ |
| · obtain ⟨hV,ht⟩:=suit0 hs |
| have hU:=suit_rk hs r.K |
| let L:=H r.L |
| have hv : (r.actual R kap r.L).base≤ H r.L := by linarith [(r.actual_closed R kap r.L).2] |
| have hw : (r.mid r.L).base≤ H r.L := by linarith [(r.base_mid r.L).2] |
| have hg := sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hU (abs_nonneg _))) |
| rw [← strike_val h _ _ _ L h2 hv,← strike_val h _ _ _ L h2 hw] |
| unfold Blob.val; dsimp only [L]; rw [hg,ht _ hi] |
| · rw [closed h (show theta/40≤ (r.actual R kap r.L).base from by linarith), |
| closed h (show theta/40≤(r.mid r.L).base from by linarith)] |
|
|
| end Run |
|
|
| namespace Params |
| variable (p : Params) |
|
|
| lemma enough {B : Domain} {v : Blob} (h:p.U v<4) (hh:B⊆p.S) |
| (hs : ∀ i∈B,p.U v<ht (v.ts i)) : |
| B.card ≤ p.n := by |
| have he : rank p.S (fun i=>ht (v.ts i)) p.n ≤ p.U v := by unfold U at *; grind |
| by_contra! hn |
| have hg : B⊆ p.S.filter (fun i=>p.U v<ht (v.ts i)) := |
| fun i hi => mem_filter.2 ⟨hh hi,hs i hi⟩ |
| exact not_lt_of_ge he ((rank_gt (p.U_nn v)).2 (lt_of_lt_of_le hn (card_le_card hg))) |
|
|
| lemma listed {B : Domain} {v : Blob} (L : ℝ) (hl:4≤L) |
| (hh : ∀ i∈p.S,2*p.U v<ht (v.ts i) → i∈B) |
| {i} (hi:i∈p.S) (hj:i∉B) : |
| (struck L (p.push v)).ts i=line ((struck L (p.push v)).base) := by |
| have hs : ht (v.ts i) ≤2*p.U v:=le_of_not_gt fun e=>hj (hh _ hi e) |
| have hp :=(p.Z_w v).2.2; have hn :=p.Z_nn v |
| change clp L ((p.push v).ts i)=line (p.Z v) |
| rw [p.nearbase hs] |
| exact Prod.ext (sat_id (x:=p.Z v) (by rw [abs_of_nonneg hn]; linarith)) (sat_id (x:=0) (by rw [abs_zero]; linarith)) |
|
|
| end Params |
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| lemma Blobext {v w : Blob} (h:v.base=w.base) (g:∀ i,v.ts i=w.ts i) : v=w := by |
| cases v; cases w |
| simp only [Blob.mk.injEq]; exact ⟨h,funext g⟩ |
|
|
| /-- A comparison replacing very positive first coordinates by a bounded |
| comparison sentinel. -/ |
| def ears (F : Domain) (L : ℝ) (v : Blob) : Blob := |
| ⟨v.base, fun x=> if x∈F then (L,(v.ts x).2) else v.ts x⟩ |
| def tall (F : Domain) (L : ℝ) (v : Blob) := ∀ i∈F,L≤(v.ts i).1 |
|
|
| lemma tower_struck {F L v} (h:tall F L v) (hh:0≤L) : |
| struck L (ears F L v)=struck L v := by |
| refine Blobext (v:=struck L (ears F L v)) (w:=struck L v) rfl ?_ |
| intro i |
| unfold struck ears |
| by_cases hi:i∈F |
| · have hv:=h i hi |
| have h1 : -L ≤ (v.ts i).1 := by linarith |
| have h2 : sat L (v.ts i).1=L:=by unfold sat clip; grind |
| have hs : sat L L=L := sat_id (le_of_eq (abs_of_nonneg hh)) |
| simp [clp,h2,hi,hs] |
| simp [hi] |
| lemma towering {F L v} (h:tall F L v) (hh : 12≤L) (p : Params) |
| {i} (hi:i∈F) : (p.push v).ts i=v.ts i := by |
| apply p.offbase |
| have hu:=p.U_four v |
| have hv := h i hi |
| unfold ht; grind |
| lemma tower_push {F L v} (h:tall F L v) (hh:12≤L) (hv:v.base≤4) (p : Params) : |
| p.push (ears F L v)=ears F L (p.push v) := by |
| let u:=ears F L v |
| have h0:=tower_struck h (by linarith) |
| have hb : u.base ≤4:=hv |
| have heZ : p.Z u=p.Z v := calc |
| _ = _ := (strike_Z p u _ hh hb).symm |
| _ = p.Z v := by change p.Z (struck L (ears F L v))=p.Z v; rw [h0,strike_Z p v _ hh hv] |
| have heU : p.U u=p.U v := calc |
| _ = _ := (strike_U p u L (by linarith)).symm |
| _ = p.U v := by change p.U (struck L (ears F L v))=p.U v; rw [h0,strike_U p v L (by linarith)] |
| have ht:tall F L u:= by intro i hi; simp [u,ears,hi] |
| apply Blobext heZ |
| intro i; change (p.push u).ts i=_ |
| by_cases hi:i∈F |
| · rw [towering ht hh _ hi] |
| simp only [u,ears,hi,ite_true,towering h hh _ hi] |
| have hg : u.ts i=v.ts i:=by simp [u,ears,hi] |
| change (p.push u).ts i = if _ then _ else _ |
| rw [ite_eq_right hi] |
| dsimp only [Params.push] |
| rw [heZ,heU,hg] |
| lemma tower_val {F L v theta C f} (h:tall F L v) (hh:12≤L) |
| (hv:v.base≤4) (hs:TS theta C f) (he:C≤L) (S K i) : |
| (ears F L v).val S K f i=v.val S K f i := by |
| have hh1 : v.base≤L:= by linarith |
| rw [← strike_val hs S K i L he (show (ears F L v).base≤L from hh1),tower_struck h (by linarith), |
| strike_val hs S K i L he hh1] |
|
|
| namespace Run |
| variable (r : Run) |
| def wide (B : ℝ) : Domain := r.S.filter fun x=>4*B < (r.aim x).1 |
|
|
| def steady (r : Run) (j : ℕ) : ℕ → Blob |
| | 0=> r.corrected j |
| | i+1=> if j≤ i then (r.pm i).push (r.steady j i) else r.corrected j |
| lemma steady_zero (j) : r.steady j j=r.corrected j := by cases j <;> simp [steady] |
| lemma steady_push {i j} (he : j≤ i) : |
| r.steady j (i+1) = (r.pm i).push (r.steady j i) := by rw [steady,ite_eq_left he] |
|
|
| lemma still_here_c (h:r.Good) {i j} (hi : j≤ i) (hj:i≤r.L) (hp:r.pre j) : |
| Calm r.S (r.steady j i) := by |
| induction i,hi using Nat.le_induction with |
| | base=> rw [r.steady_zero]; exact r.start_calm h hj hp |
| | succ i hi ih=> rw [r.steady_push hi]; exact (r.pm i).still_calm (ih (by omega)) |
|
|
| lemma still_here {theta C f} (h:r.Good) (ht:TS theta C f) (hs: delta≤theta) |
| (hh:theta≤1) {j i} (hi:j≤ i) (he:i≤r.L) (hp:r.pre j) (x) : |
| (r.steady j i).val r.S r.K f x=(r.corrected j).val r.S r.K f x := by |
| induction i,hi using Nat.le_induction with |
| | base=>rw [r.steady_zero] |
| | succ i hi ih=> |
| have ht1:=ih (by omega) |
| rw [r.steady_push hi, ← ht1] |
| exact (r.pm i).motionless ht hs hh (r.still_here_c h hi (by omega) hp) |
| (r.rho_mist h he) (h.cap i he) x |
|
|
| lemma still_hi (h:r.Good) {j i B} (hi:j≤ i) (he:i≤r.L) (hp:r.pre j) (hh:12≤B) : |
| tall (r.wide B) B (r.steady j i) := by |
| induction i,hi using Nat.le_induction with |
| | base=> |
| rw [r.steady_zero]; intro i hi |
| obtain ⟨ha,hb⟩:=mem_filter.1 hi |
| have he1:= le_trans ((r.pre_head h he hp).2 i ha) (r.dust_le h he) |
| have hp := show small ≤ 1 from by linarith [show 10*small<1 from mist1] |
| have hs := (abs_le.1 (max_le_iff.mp he1).1).1 |
| simp only [corrected,Pi.add_apply,Prod.fst_add] |
| linarith |
| | succ i hi ih=> |
| rw [r.steady_push hi] |
| intro t ht; rw [towering (ih (by omega)) hh _ ht] |
| exact ih (by omega) t ht |
|
|
| /-- Known large first values don't cross the capped thresholds when |
| relative prefix errors are small. Keep track of the discrepancy from |
| the raw prefix at such locations. -/ |
| def Mild (j) := ∀ i, j≤ i → i<r.L → r.bad i≤1/4 |
|
|
| lemma enter_tall (h:r.Good) {j i B} (hi : j≤ i) (he:i<r.L) (hp:r.pre j) |
| (hh:12 ≤ B) (hm:r.Mild j) : |
| tall (r.wide B) B (r.enter i) ∧ ∀ x∈r.wide B,r.loss i x=r.loss j x := by |
| have up (k) (hs:j≤k) (hi:k<r.L) {x} (hx:x∈r.wide B) (ht:r.loss k x=r.loss j x) : |
| B ≤ ((r.enter k).ts x).1 := by |
| obtain ⟨ha,hb⟩:=mem_filter.1 hx |
| have hL := le_trans ((r.pre_head h (i:=j) (by omega) hp).2 x ha) (r.dust_le h (by omega)) |
| have h0 := hm k hs hi |
| have hl:= r.literal h (i:=k) ha (by linarith) |
| have h1 := show small≤1 from by linarith [show 10*small<1 from mist1] |
| have hz := (abs_le.mp hl.1).1 |
| rw [r.total_enter,ht] |
| have hv := (abs_le.mp (max_le_iff.mp hL).1).1 |
| simp only [Prod.fst_add] |
| nlinarith [mul_le_mul_of_nonneg_left h0 (show 0≤(1+(r.aim x).1) from by linarith)] |
| induction i,hi using Nat.le_induction with |
| | base=> exact ⟨fun _ hx=> up j le_rfl he hx rfl,fun _ _=>rfl⟩ |
| | succ i hi ih=> |
| obtain ⟨ha,hb⟩:=ih (by omega) |
| have hc (x) (hx:x∈r.wide B) : r.loss (i+1) x=r.loss j x := by |
| rw [r.iter_loss, r.mid_succ,towering ha hh _ hx,sub_self,add_zero,hb x hx] |
| exact ⟨fun x hx=>up (i+1) (by omega) he hx (hc x hx),hc⟩ |
|
|
| end Run |
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| /-! Comparison using the relative prefix errors, beginning at group j. -/ |
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| def hood (F : Domain) (v : Row) : Row := |
| fun i=>if i∈F then (0,(v i).2) else v i |
| def blast (F : Domain) (i : ℕ) (t : Pt) : Pt := |
| if i∈F then (0,t.2) else t |
| lemma blast_apply (F v i) : hood F v i = blast F i (v i) := rfl |
| lemma blast_add (F i x y) : blast F i (x+y)=blast F i x+blast F i y := by |
| by_cases h:i∈F <;> simp [blast,h] |
| lemma blast_sub (F i x y) : blast F i (x-y)=blast F i x-blast F i y := by |
| by_cases h:i∈F <;> simp [blast,h] |
| lemma hooded {F L v w i} : |
| (ears F L v).ts i - (ears F L w).ts i = blast F i (v.ts i-w.ts i) := by |
| by_cases h:i∈F |
| · simp [ears,h,blast] |
| · simp [ears,h,blast] |
|
|
| namespace Run |
| variable (r : Run) |
|
|
| /-- Absolute bounds when ears are sentinels. -/ |
| abbrev wideK (B : ℝ) := 1+4*B |
| lemma hood_at (h:r.Good) {j B i} (he : j≤ i) (hi : i<r.L) |
| (hh:12≤B) (hm:r.Mild j) {x} (hx:x∈r.S) : |
| ht (blast (r.wide B) x (r.pile (i+1) x-r.aim x)) ≤ wideK B*r.bad i := by |
| have hb:= hm i he hi |
| obtain ⟨hp,hq⟩:= r.literal h (i:=i) hx (by linarith) |
| have hr:=r.bad_nn i |
| have ht1 : r.bad i ≤ wideK B*r.bad i := by unfold wideK; nlinarith |
| by_cases hz:x∈r.wide B |
| · unfold blast; rw [ite_eq_left hz]; change max |(0:ℝ)| |_-_| ≤ _ |
| rw [max_le_iff] |
| exact ⟨by rw [abs_zero]; linarith,hq.trans ht1⟩ |
| have hu : (r.aim x).1≤4*B := le_of_not_gt fun e=>hz (mem_filter.2 ⟨hx,e⟩) |
| unfold blast; rw [ite_eq_right hz,ht_sub] |
| exact ⟨hp.trans (mul_le_mul_of_nonneg_right (by unfold wideK; grind) hr),hq.trans ht1⟩ |
|
|
| lemma hood_prev (h:r.Good) {j B i} (he : j≤ i) (hi : i+1<r.L) |
| (hh:12≤B) (hm:r.Mild j) {x} (hx:x∈r.S) : |
| ht (blast (r.wide B) x (r.inc (i+1) x)) ≤ wideK B*(r.bad i + r.bad (i+1)) := by |
| have hd : r.inc (i+1) x=(r.pile (i+1+1) x-r.aim x)-(r.pile (i+1) x-r.aim x) := by |
|
|
| rw [show r.pile (i+1+1) x=r.pile (i+1) x+r.inc (i+1) x from rfl]; abel |
| have hp := r.hood_at h he (by omega) hh hm hx |
| have hv := r.hood_at h (i:=i+1) (by omega) hi hh hm hx |
| have hg := near_sub ((ht_near ..).1 hv) ((ht_near ..).1 hp) |
| rw [hd, blast_sub,add_comm (r.bad i),mul_add] |
| exact (ht_near ..).2 (by simpa only [sub_zero] using hg) |
|
|
| lemma hood_init (h:r.Good) {j B} (he : j<r.L) (hh:12≤B) (hm:r.Mild j) : |
| suit r.S (wideK B*r.bad j) |
| (ears (r.wide B) B (r.enter j)) |
| (ears (r.wide B) B (r.steady j j)) := by |
| rw [r.steady_zero]; have hb:=r.bad_nn j |
| have hK : 0<wideK B := by unfold wideK; linarith |
| refine ⟨?_,fun x hx=>?_⟩ |
| · change |(r.mid j).base-(r.mid j).base| ≤ _ |
| simp; positivity |
| · rw [← ht_sub,hooded,r.total_enter] |
| simp only [corrected,Pi.add_apply,add_sub_add_right_eq_sub] |
| exact r.hood_at h le_rfl he hh hm hx |
|
|
| lemma hood_link {j B v w b c i} (_:i=j) |
| (h : suit r.S b (ears (r.wide B) B v) (ears (r.wide B) B w)) |
| (hc:0≤c) (e : ∀ x∈r.S,ht (blast (r.wide B) x (r.inc i x))≤c) : |
| suit r.S (b+c) (ears (r.wide B) B (r.shifted i v)) |
| (ears (r.wide B) B w) := by |
| refine ⟨le_trans h.1 (by linarith),fun x hx=>?_⟩ |
| have hs:= (ht_sub ..).mpr (h.2 x hx) |
| rw [hooded] at hs |
| rw [← ht_sub,hooded] |
| simp only [shifted,Pi.add_apply] |
| rw [show v.ts x+r.inc i x-w.ts x=(v.ts x-w.ts x)+r.inc i x by abel,blast_add] |
| exact le_trans (ht_add ..) (add_le_add hs (e x hx)) |
|
|
| /-- Envelope for propagation coefficient. -/ |
| def cloud (j i) := ∑ k ∈ Ico j (i+1),(32:ℝ)^(i-k)*r.bad k |
| def tail (j) := ∑ k ∈ Ico j r.L,(32:ℝ)^(r.L-k)*r.bad k |
| lemma cloud_adj {i j} (_:j≤ i) : |
| (∑ k ∈ Ico j (i+1),(32:ℝ)^(i+1-k)*r.bad k) = 32*r.cloud j i := by |
| unfold cloud; rw [mul_sum] |
| apply sum_congr rfl; intro k hk |
| have he : i+1-k=i-k+1 := by obtain ⟨a,b⟩:=mem_Ico.mp hk; omega |
| rw [he,pow_succ]; ring |
| lemma cloud0 (j) : r.cloud j j=r.bad j := by simp [cloud] |
| lemma cloud_step {j i} (h : j≤ i) : r.cloud j (i+1)=32*r.cloud j i+r.bad (i+1) := by |
| rw [cloud,sum_Ico_succ_top (a:=j) (b:=i+1) (by omega),r.cloud_adj h] |
| simp |
| lemma cloud_bad {j i} (he : j≤ i) : r.bad i≤r.cloud j i := by |
| have ht : ∀ k : ℕ,0≤(32:ℝ)^(i-k)*r.bad k:=fun k=>mul_nonneg (by positivity) (r.bad_nn _) |
| unfold cloud |
| simpa using (single_le_sum (fun k (_ : k∈Ico j (i+1))=>ht k) (mem_Ico.mpr ⟨he,Nat.lt_succ_self i⟩)) |
| lemma tail_bad {j i} (he:j≤ i) (hh:i<r.L) : r.bad i≤r.tail j := by |
| have ht : ∀ k : ℕ,0≤(32:ℝ)^(r.L-k)*r.bad k:=fun k=>mul_nonneg (by positivity) (r.bad_nn _) |
| have h0 : 1 ≤ (32:ℝ)^(r.L-i) := one_le_pow₀ (by norm_num) |
| apply le_trans (b:=(32:ℝ)^(r.L-i)*r.bad i) |
| · nlinarith [r.bad_nn i] |
| exact single_le_sum (fun k hi=>ht k) (mem_Ico.mpr ⟨he,hh⟩) |
|
|
| lemma hood_cmp (h:r.Good) {i j B} (he:j≤ i) (hL:i<r.L) |
| (hh:12≤B) (hp:r.pre j) (hm:r.Mild j) : |
| suit r.S (wideK B*r.cloud j i) (ears (r.wide B) B (r.enter i)) |
| (ears (r.wide B) B (r.steady j i)) := by |
| have hz : 0<wideK B:=by unfold wideK; linarith |
| induction i,he using Nat.le_induction with |
| | base=>rw [r.cloud0]; exact r.hood_init h hL hh hm |
| | succ i hi ih=> |
|
|
| have he1 : i < r.L := by omega |
| have h1:=ih he1 |
| let p:=r.pm i; let u:=r.enter i; let v:=r.steady j i |
| have h2:=Params.smooth_push p h1 |
| have ht0: u.base≤4 := r.base_mid i |>.2 |
| have ht1: v.base≤4 := r.still_here_c h hi he1.le hp |>.2.1 |
| rw [tower_push (r.enter_tall h hi he1 hp hh hm).1 hh ht0 p, |
| tower_push (r.still_hi h hi he1.le hp hh) hh ht1 p] at h2 |
| rw [r.steady_push hi]; unfold enter |
| rw [r.mid_succ] |
| have hn := r.bad_nn i; have hn2 := r.bad_nn (i+1) |
| have hb := r.hood_link (i:=i+1) rfl h2 |
| (show 0≤wideK B*(r.bad i+r.bad (i+1)) from by positivity) |
| (fun x hx=> r.hood_prev h hi hL hh hm hx) |
| have hz : 30*(wideK B*r.cloud j i)+wideK B*(r.bad i+r.bad (i+1))≤wideK B*r.cloud j (i+1) := by |
| rw [r.cloud_step hi] |
| nlinarith [mul_le_mul_of_nonneg_left (r.cloud_bad hi) hz.le] |
| exact ⟨le_trans hb.1 hz,fun x hx=>near_le (hb.2 x hx) hz⟩ |
|
|
| /-- Final pointwise estimate after starting before group j. -/ |
| abbrev charge (C : ℝ) := 16*C^3 * wideK (C+12) |
| set_option maxHeartbeats 500000 in |
| lemma wave {theta C f} (h:r.Good) (ht:TS theta C f) (hz:delta≤theta) |
| (hc:theta≤1) {j} (he:j<r.L) (hp:r.pre j) {x} (hx:x∈r.S) : |
| |fourth ((r.mid r.L).val r.S r.K f x)-fourth (r.origin.val r.S r.K f x)| ≤ |
| charge C*(r.rain j+r.tail j) := by |
| let B:=C+12 |
| have hC:= ht.start.one |
| have h0 : 12≤B := by dsimp [B]; linarith |
| have hC0 : C≤B := by dsimp [B]; linarith |
| have hC3 : 0<C^3 := pow_pos (by linarith) _ |
| have hwp : 1 ≤ wideK B := by unfold wideK; linarith |
| have hz0 : 4*C^3 ≤ charge C := by change 4*C^3 ≤ 16*C^3*wideK B; nlinarith |
| have hRain :=r.rain_nn h he.le |
| rcases le_total (r.tail j) (1/4) with hu|hu |
| · have hm : r.Mild j:= fun i hi hh=>le_trans (r.tail_bad hi hh) hu |
| let i:=r.L-1 |
| have he0 : r.L=i+1:=by unfold i; omega |
| have hi0 : j≤ i:=by omega |
| have hi : i<r.L:=by omega |
| let p:=r.pm i |
| have hh:=Params.smooth_push p (r.hood_cmp h hi0 hi h0 hp hm) |
| obtain ⟨ha,_⟩:=r.enter_tall h hi0 hi hp h0 hm |
| have hb:=r.still_hi h hi0 hi.le hp h0 |
| have hb1 := (r.still_here_c h hi0 hi.le hp).2.1 |
| rw [tower_push ha h0 (r.base_mid i).2 p, tower_push hb h0 hb1 p] at hh |
| have Hg (v : Blob) (h:tall (r.wide B) B v) : |
| (ears (r.wide B) B (p.push v)).val r.S r.K f x = (p.push v).val r.S r.K f x := |
| tower_val (fun i hi=>by rw [towering h h0 p hi]; apply h i hi) |
| h0 (p.Z_w v).2.2 ht hC0 _ _ _ |
| have h1:= suit_val ht hh r.K hx |
| rw [Hg _ ha,Hg _ hb,show p.push (r.enter i)=r.mid (i+1) from (r.mid_succ i).symm, |
| show p.push (r.steady j i)=r.steady j (i+1) from (r.steady_push hi0).symm, |
| ← he0,r.still_here h ht hz hc he.le le_rfl hp] at h1 |
| have he2 : r.tail j=32*r.cloud j i := by |
| unfold tail; conv_lhs => rw [he0] |
| exact r.cloud_adj hi0 |
| have h2:= r.rain_effect h ht hz he.le hp hx |
| have h3 := le_trans (abs_sub_le ((fourth ((r.mid r.L).val r.S r.K f x))) |
| (fourth ((r.corrected j).val r.S r.K f x)) |
| (fourth (r.origin.val r.S r.K f x))) (add_le_add h1 h2) |
| have hcn := le_trans (r.bad_nn i) (r.cloud_bad hi0) |
| rw [he2]; apply le_trans h3 |
| rw [mul_add] |
| change _≤16*C^3*wideK B*(r.rain j)+16*C^3*wideK B*(32*r.cloud j i) |
| rw [add_comm (16*C^3*wideK B*(r.rain j))] |
| apply add_le_add |
| · have hx : 0≤C^3*wideK B*r.cloud j i := mul_nonneg (mul_nonneg hC3.le (by linarith)) hcn |
| linarith |
| · exact mul_le_mul_of_nonneg_right (by change _≤charge C; linarith) hRain |
| · have hl (v : Blob) : 0≤fourth (v.val r.S r.K f x) ∧ fourth (v.val r.S r.K f x)≤C^3 := |
| ⟨fourth_nn _, ht.rootub ..⟩ |
| obtain ⟨hl1,hl2⟩:=hl (r.mid r.L); obtain ⟨hh1,hh2⟩:=hl r.origin |
| apply le_trans (b:=C^3) |
| · rw [abs_le]; constructor <;> linarith |
| nlinarith |
|
|
| end Run |
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| section |
|
|
| namespace ExactDerandomization.Buf |
| noncomputable section |
| open Analysis At Hie Finset |
|
|
| namespace Run |
| variable (r : Run) |
| def fatties (j : ℕ) := r.S.filter (fun x=> r.rho j/4<(r.aim x).1) |
| def binge (j : ℕ) : Prop := r.n j ≤ 2*(r.fatties j).card |
| def hap (j : ℕ) : Prop := r.pre j∧r.overflow j |
|
|
| lemma fake (h:r.Good) {j} (hi:j<r.L) (hp:r.hap j) (hh:¬r.binge j) : |
| (r.n j:ℝ)/2*(r.rho j/8)^4 ≤ ∑ i∈r.S,(r.epi j i)^4 := by |
| let u:=r.rho j |
| have hu : 0<u := h.pos j hi |
| have hu1 : u≤1 := le_trans (r.rho_mist h hi) mist1.le |
| let v:=r.enter j |
| obtain ⟨hp,hm⟩:=hp |
| let F:=r.S.filter (fun x=>u<ht (v.ts x)) |
| let T:=F\r.fatties j |
| obtain ⟨hs,hl⟩:=r.pre_head h hi.le hp |
| have hq := h.ahead j hi |
| have hx : v.base<u := by |
| change (r.mid j).base<r.rho j |
| change 0<r.rho j at hu; linarith |
| have hk : r.n j<F.card := by |
| apply (rank_gt hu.le).1 |
| change u<(r.pm j).U v at hm |
| unfold Params.U at hm |
| change u< min 4 (max u (max v.base (rank r.S (fun x=>ht (v.ts x)) (r.n j)))) at hm |
| grind |
| have he : F ⊆ T ∪ r.fatties j := by |
| intro i hi; by_cases he:i∈r.fatties j |
| · exact mem_union_right _ he |
| · exact mem_union_left _ (mem_sdiff.mpr ⟨hi,he⟩) |
| have he1 : r.n j ≤ 2*T.card := by |
| have hd := (card_le_card he).trans (card_union_le ..) |
| unfold binge at hh; omega |
| have he2 : T⊆r.S:= fun i hi =>(mem_filter.mp (mem_sdiff.mp hi).1).1 |
| have hf {x} (hg:x∈T) : u/8 ≤ r.epi j x := by |
| obtain ⟨hz1,hz2⟩:= mem_sdiff.1 hg |
| obtain ⟨hv,hv'⟩:= mem_filter.mp hz1 |
| let d:=r.aim x |
| let w:=r.pile (j+1) x |
| have hs : d.1≤u/4 := le_of_not_gt fun he=> hz2 (mem_filter.2 ⟨hv,he⟩) |
| have ht0 := r.rho_dust h hi |
| have hz : u/4≤ small := by change 6*u≤ small at ht0; exact le_trans (by linarith : u/4≤6*u) ht0 |
| have hs1 : d.2=0 := h.target_flat _ hv (le_trans hs hz) |
| have hs0 : 0≤d.1 := h.target_nn _ hv |
| have hx1 : ht (v.ts x) ≤ ht w + u/100 := by |
| change ht ((r.enter j).ts x) ≤_ |
| rw [r.total_enter] |
| exact le_trans (ht_add ..) (add_le_add_right (le_trans (hl _ hv) hq) _) |
| change u/8≤ min 1 (max (|w.1-d.1|/(1+d.1)) |w.2-d.2|) |
| apply le_min (by linarith) |
| by_contra! hn |
| obtain ⟨ha,hb⟩:=max_lt_iff.mp hn |
| change ht (v.ts x) ≤ max |w.1| |w.2| + u/100 at hx1 |
| rw [hs1,sub_zero] at hb |
| rw [div_lt_iff₀ (by linarith)] at ha |
| have he := (abs_add_le (w.1-d.1) d.1) |
| rw [sub_add_cancel,abs_of_nonneg hs0] at he |
| have hg : ht (v.ts x)>u := hv' |
| have he2 : u/8*(1+d.1)≤u/4 := by nlinarith |
| rcases le_total |w.1| |w.2| with hz|hz |
| · rw [max_eq_right hz] at hx1; linarith |
| · rw [max_eq_left hz] at hx1; linarith |
| have huR : (r.n j:ℝ)≤2*(T.card:ℝ) := by exact_mod_cast he1 |
| calc _ ≤ (T.card:ℝ)*(u/8)^4 := |
| mul_le_mul_of_nonneg_right (by linarith) (by positivity) |
| _ = ∑ i∈T,(u/8)^4 := by simp |
| _ ≤ ∑ i∈T,r.epi j i^4 := |
| sum_le_sum fun i hi=>pow_le_pow_left₀ (by linarith) (hf hi) 4 |
| _ ≤ _ := sum_le_sum_of_subset_of_nonneg he2 (fun _ _ _=>by positivity) |
|
|
| lemma earliest (h:0<r.L) : ∃ j<r.L,r.pre j∧(r.L=j+1 ∨ r.overflow j) := by |
| classical |
| by_cases he:∃ j<r.L,r.overflow j |
| · obtain ⟨ha,hb⟩:=Nat.find_spec he |
| exact ⟨_,ha,fun j hj hs=>Nat.find_min he hj ⟨hj.trans ha,hs⟩,Or.inr hb⟩ |
| refine ⟨r.L-1,by omega,fun i hi h=>he ⟨i,by omega,h⟩,Or.inl (by omega)⟩ |
|
|
| end Run |
| end |
| end ExactDerandomization.Buf |
|
|
| end |
|
|
| end OAI |
|
|
