| import OAI.Analysis.FourierLLogL.Capture.MaskKernel |
| import OAI.Analysis.FourierLLogL.Finite.Tail |
| open Function Set Filter |
| open scoped Topology BigOperators ComplexConjugate |
| noncomputable section |
|
|
| namespace OAI |
|
|
| namespace FourierLLogL.Dyadic.Procedure.Capture |
| open Law Node Real Period Compress.Params Thermal Fund Scene Fork Road Event Journal Wire Pulse |
| variable {p : Node} {M : ℕ} |
| open scoped Classical |
|
|
| lemma margins (p : Node) (hp : p.valid) : 0 ≤ p.a ∧ p.a+p.len ≤ 1 := by |
| unfold a |
| have he : 0 < p.len := p.len_pos |
| refine ⟨by positivity,?_⟩ |
| calc |
| _ = ↑(p.ix+1)*p.len := by push_cast; ring |
| _ ≤ ↑(2^p.lev:ℕ)*p.len := |
| mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hp) he.le |
| _ = _ := by unfold len; push_cast; rw [mul_comm,side_card] |
| |
| lemma inner_strip (p : Node) (b : Bool) (i : ℕ) (x : Grid M) |
| (hx : x∈(child p b).block M) (hh : ¬ flanked p i x) : |
| let q := child p b; let r := p.len*side (reach i) |
| q.a+r ≤ pos x ∧ pos x < q.a+q.len-r := by |
| intro q r |
| have hi (c : Bool) : ¬ (x∈(strip p i b c).block M) := |
| fun h => hh ⟨_,_,h⟩ |
| have h1 : (strip p i b false).a=q.a := extreme_left q _ |
| have h2 (c : Bool) : (strip p i b c).len=r := strip_length _ _ _ _ |
| have h3 : (strip p i b true).a + r=q.a+q.len := by |
| rw [← h2 true]; exact extreme_right _ _ |
| have Hp : x∈q.block M:=hx |
| constructor |
| · by_contra! h |
| apply hi false |
| change pos x∈Ico _ _ |
| rw [h1,h2] |
| exact ⟨Hp.1,h⟩ |
| · by_contra! h |
| apply hi true |
| change pos x∈Ico _ _ |
| rw [h2,h3]; exact ⟨by linarith,Hp.2⟩ |
| |
| lemma circle_near (p : Node) (hp : p.valid) (x y : Grid M) (r : ℝ) |
| (hr : 0 < r) (hx : p.a+r ≤ pos x) (he : pos x ≤ p.a+p.len-r) |
| (hy : Dyadic.diam (x-y)<r) : y∈p.block M := by |
| have hp' := margins _ hp |
| change p.a ≤ pos y ∧ pos y < p.a+p.len |
| by_cases H : x-y=0 |
| · have h := sub_eq_zero.mp H; subst y; constructor <;> linarith |
| rw [diam_min,min_lt_iff,pos_neg H] at hy |
| rcases le_total x.val y.val with h|h |
| · have h1 := pos_sub_val h |
| rw [show y-x= -(x-y) by ring,pos_neg H] at h1 |
| rcases hy with hy|hy <;> constructor <;> linarith [pos_lt y,pos_lt (x-y),pos_nonneg y] |
| have h1 := pos_sub_val h |
| rcases hy with hy|hy <;> constructor <;> linarith [pos_nonneg y,pos_lt y,pos_nonneg (x-y)] |
| |
| private def inland (p : Node) (r : ℝ) (x : Grid M) := ∀ y, Dyadic.diam (x-y)<r → y∈p.block M |
|
|
| private lemma limit_full {f : Grid M → ℝ} (s : ℝ) (h : 2^M ≤ s) : limitR f s := by |
| intro x hx |
| have H := rad_le_val x |
| have hh : (x.val:ℝ) < 2^M := by exact_mod_cast ZMod.val_lt x |
| linarith |
|
|
| private lemma smoothing_limit (P : Law (Grid M)) (q : Grid M → Prop) (r : ℝ) |
| (h : limitR P r) : limitR (fun x => P.prob fun y => q (x-y)) r := by |
| have He (x : Grid M) : |
| P.prob (fun y => q (x-y)) = ∑ y, (if q y then P (x-y) else 0) := by |
| rw [prob_eq] |
| apply Fintype.sum_equiv ((Equiv.neg _).trans (Equiv.addLeft x)) |
| intro i |
| have HH : x-i=x+ -i := sub_eq_add_neg x i |
| change (if q (x-i) then P i else 0) = if q (x+ -i) then P (x-(x+ -i)) else 0; rw [← HH,sub_sub_self] |
| unfold limitR limit; intro i hi |
| simp_rw [He,Complex.ofReal_sum] |
| rw [fc_sum _ (fun y x => (↑(if q y then P (x-y) else 0):ℂ))] |
| apply Finset.sum_eq_zero; intro x hx |
| by_cases H : q x |
| · simp only [H,ite_true] |
| rw [fc_right_translate (fun x => (P x:ℂ)) x i, h _ hi,mul_zero] |
| · simp only [H,ite_false,fc, Complex.ofReal_zero,zero_mul,expU,Finset.sum_const_zero,smul_zero] |
|
|
| def band (p : Node) (i j : ℕ) : ℝ := (2:ℝ)^(p.lev+reach i+10)*(2*(j+10)) |
|
|
| lemma make_mask (p : Node) (h : p.valid) (hp : p.lev < M) (b : Bool) (i j : ℕ) : |
| let q := p.child b |
| ∃ f : Grid M → ℝ, limitR f (band p i j) ∧ (∀ x, 0 ≤ f x ∧ f x ≤ 1) ∧ |
| (∀ x, x∈p.block M → ¬ (lanes p i M ∧ flanked p i x) → |
| |(if x∈q.block M then (1:ℝ) else 0)-f x| ≤ side j) ∧ |
| expU (fun x => if x∈p.block M then 0 else f x) ≤ p.len*side j := by |
| classical |
| let s : ℝ := p.len*side (reach i) |
| intro q |
| have Hq := child_ok p h hp b |
| have hpq := block_of_below (child_below p b) M |
| let D := 2^(p.lev+reach i+10) |
| have hD : 0<D := by unfold D; positivity |
| have hD' : (0:ℝ) < D := Nat.cast_pos.mpr hD |
| have hS : 0 < s := mul_pos p.len_pos (side_pos _) |
| have He : band p i j = (D:ℝ)*(2*(j+10)) := by unfold D band; push_cast; rfl |
| by_cases H : D ≤ 2^M |
| case neg => |
| let f (x : Grid M) := if x∈q.block M then (1:ℝ) else 0 |
| have hj := side_pos j |
| refine ⟨f,limit_full _ ?_, fun x => by unfold f; split_ifs <;> norm_num,fun x _ _ => by unfold f; simp [hj.le],?_⟩ |
| · rw [He]; have hx : (2:ℝ)^M ≤ D := by exact_mod_cast le_of_not_ge H |
| nlinarith [Nat.cast_nonneg (α:=ℝ) j] |
| have HE (x : Grid M) : (if x∈p.block M then 0 else f x) = 0 := by |
| unfold f |
| split_ifs with h hq |
| · rfl |
| · exact (h (hpq hq)).elim |
| rfl |
| simp_rw [HE,expU,Finset.sum_const_zero,smul_zero]; exact (mul_pos p.len_pos hj).le |
| |
| obtain ⟨P,hP,hT⟩ := boosted M D j hD H |
| let r : ℝ := 16/D |
| have hr : 0<r := div_pos (by norm_num) hD' |
| have hb : lanes p i M := by |
| have HE : p.lev+reach i+10 ≤ M := |
| (Nat.pow_le_pow_iff_right (by omega : 1 < 2)).mp H |
| unfold lanes; omega |
| have hrS : 2*r ≤ s := by |
| have he : s * D = 2^10 := by |
| unfold D s len; push_cast |
| rw [side_pow_two,side_pow_two,pow_add,pow_add]; field_simp |
| unfold r; rw [← mul_div_assoc]; apply (div_le_iff₀ hD').mpr; rw [he]; norm_num |
| let g (x : Grid M) := inland q r x |
| let f (x : Grid M) := P.prob (fun i => g (x-i)) |
| have hHi (x : Grid M) (hx : g x) : x∈q.block M := by |
| apply hx x |
| simpa only [sub_self,diam,rad, neg_zero,ZMod.val_zero,min_self,Nat.cast_zero,mul_zero] using hr |
| refine ⟨f,smoothing_limit _ _ _ ?_,fun x => ⟨prob_nonneg _ _,prob_le_one _ _⟩,?_,?_⟩ |
| · rw [He,show (D:ℝ)*(2*(j+10))=2*(D:ℝ)*(j+10) by ring] |
| exact hP |
| · intro x hx hE |
| have hv : ¬ flanked p i x := fun hh => hE ⟨hb,hh⟩ |
| by_cases HH : x∈q.block M |
| · have hi := inner_strip p b i x HH hv |
| have hi (v : Grid M) (hv : Dyadic.diam v<r) : g (x-v) := by |
| intro y hy |
| refine circle_near q Hq.1 x y s hS hi.1 hi.2.le ?_ |
| have H := diam_add v (x-v-y) |
| rw [show v+(x-v-y)=x-y by ring] at H; linarith |
| rw [ite_eq_left HH, abs_of_nonneg (sub_nonneg.mpr (prob_le_one _ _))] |
| rw [← prob_compl] |
| refine (prob_mono _ _ _ fun i hv => ?_).trans hT |
| exact le_of_not_gt (fun h => hv (hi i h)) |
| rw [ite_eq_right HH,zero_sub,abs_neg,abs_of_nonneg (prob_nonneg _ _)] |
| apply le_trans _ hT |
| refine prob_mono _ _ _ fun i hi => ?_ |
| apply le_of_not_gt; intro hi' |
| apply HH |
| apply hi x; rw [sub_sub_cancel_left,diam_even]; exact hi' |
| rw [expU_ex] |
| let U := uniform (Grid M) |
| let G (x i : Grid M) := if x∈p.block M then (0:ℝ) else if g (x-i) then 1 else 0 |
| have heq (x : Grid M) : (if x∈p.block M then 0 else f x) = P.Ex (G x) := by |
| unfold f prob G; split_ifs with hx |
| rw [Ex_const] |
| rfl |
| have hg1 : U.prob g ≤ p.len := by |
| rw [← prob_block (M:=M) (p:=p) ⟨h,hp.le⟩] |
| apply prob_mono _ _ _ (fun i hi => hpq (hHi _ hi)) |
| have heq' (i : Grid M) : U.Ex (fun x => G x i) ≤ p.len*(if r ≤ Dyadic.diam i then 1 else 0) := by |
| split_ifs with H |
| · rw [mul_one] |
| apply le_trans (b:=U.prob fun x => g (x-i)) |
| · unfold prob G; apply Ex_mono; intro x; split_ifs <;> norm_num |
| rw [prob_translate g]; exact hg1 |
| have he (x : Grid M) : G x i=0 := by |
| unfold G; split_ifs with h h' |
| · rfl |
| · refine (h (hpq (h' x ?_))).elim |
| rw [sub_sub_cancel_left,diam_even] |
| exact not_le.mp H |
| rfl |
| rw [funext he,Ex_const,mul_zero] |
| simp_rw [heq,Ex_swap (uniform (Grid M)) P] |
| apply le_trans (Ex_mono P heq') |
| rw [Ex_lmul] |
| apply mul_le_mul_of_nonneg_left _ p.len_pos.le |
| apply le_trans _ hT |
| |
| rw [prob_eq] |
| unfold Ex r |
| simp |
| |
| end FourierLLogL.Dyadic.Procedure.Capture |
| |
| end OAI |
| |
