| import Mathlib |
| import OAI.Probability.BinarySweep.GridBounds.EmptyGrid |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped Topology |
| open Set Complex Complex.HadamardThreeLines |
|
|
| namespace BinaryCoordinateSweeps |
|
|
| lemma cosh_norm_le (z : ℂ) : ‖Complex.cosh z‖ ≤ Real.cosh z.re := by |
| rw [Complex.cosh, norm_div] |
| norm_num only [Complex.norm_ofNat] |
| rw [Real.cosh_eq] |
| have h := norm_add_le (Complex.exp z) (Complex.exp (-z)) |
| rw [Complex.norm_exp,Complex.norm_exp,Complex.neg_re] at h |
| linarith |
|
|
| def ellipseMap (v : ℝ) (z : ℂ) : ℂ := (v:ℂ)/2*(Complex.cosh z+1) |
|
|
| lemma ellipseMap_norm {v L : ℝ} (hv : 0 ≤ v) (hL : 0 ≤ L) (z : ℂ) |
| (hz : z ∈ verticalClosedStrip 0 L) : |
| ‖ellipseMap v z‖ ≤ v/2*(Real.cosh L+1) := by |
| change 0 ≤ z.re ∧ z.re ≤ L at hz |
| have hc : Real.cosh z.re ≤ Real.cosh L := by |
| rw [Real.cosh_le_cosh,abs_of_nonneg hz.1,abs_of_nonneg hL] |
| exact hz.2 |
| have hn : ‖Complex.cosh z+1‖ ≤ Real.cosh L+1 := by |
| have := norm_add_le (Complex.cosh z) (1:ℂ) |
| norm_num only [norm_one] at this |
| linarith [cosh_norm_le z] |
| simpa only [ellipseMap,norm_mul,norm_div,Complex.norm_real,Real.norm_eq_abs, |
| abs_of_nonneg hv,Complex.norm_ofNat] using mul_le_mul_of_nonneg_left hn (by positivity : 0 ≤ v/2) |
|
|
| lemma ellipseMap_left {v : ℝ} (hv : 0 ≤ v) (z : ℂ) (hz : z.re=0) : |
| ∃ t : ℝ, 0 ≤ t ∧ t ≤ v ∧ ellipseMap v z=(t:ℂ) := by |
| have he : z=(z.im:ℂ)*Complex.I := by apply Complex.ext <;> simp [hz] |
| refine ⟨v/2*(Real.cos z.im+1),?_,?_,?_⟩ |
| · have := Real.neg_one_le_cos z.im |
| exact mul_nonneg (div_nonneg hv (by norm_num)) (by linarith) |
| · have := Real.cos_le_one z.im |
| nlinarith |
| · have hc : Complex.cosh z=(Real.cos z.im:ℂ) := by |
| calc Complex.cosh z = Complex.cosh ((z.im:ℂ)*Complex.I) := congrArg _ he |
| _ = (Real.cos z.im:ℂ) := by rw [Complex.cosh_mul_I,Complex.ofReal_cos] |
| rw [ellipseMap,hc] |
| push_cast |
| rfl |
|
|
| theorem analytic_segment_transfer (R a : ℝ) (hR : 1 < R) (ha : 0 < a) : |
| ∃ θ : ℝ, 0 < θ ∧ θ ≤ 1 ∧ |
| ∀ E : Type*, ∀ [NormedAddCommGroup E] [NormedSpace ℂ E], |
| ∀ f : ℂ → E, Differentiable ℂ f → ∀ ε : ℝ, 0 ≤ ε → |
| (∀ z : ℂ, ‖z‖ ≤ R → ‖f z‖ ≤ 1) → |
| (∀ t : ℝ, 0 ≤ t → t ≤ a → ‖f (t:ℂ)‖ ≤ ε) → ‖f 1‖ ≤ ε^θ := by |
| let v := min a (1/2) |
| have hv : 0 < v := lt_min ha (by norm_num) |
| have hva : v ≤ a := min_le_left _ _ |
| have hv1 : v < 1 := (min_le_right _ _).trans_lt (by norm_num) |
| let x := Real.arcosh (2/v-1) |
| let L := Real.arcosh (2*R/v-1) |
| have hargx : 1 < 2/v-1 := by |
| have : (2:ℝ) < 2/v := (lt_div_iff₀ hv).mpr (by linarith) |
| linarith |
| have hargL : 2/v-1 < 2*R/v-1 := by |
| apply sub_lt_sub_right |
| apply (div_lt_div_iff_of_pos_right hv).2 |
| linarith |
| have hx : 0 < x := Real.arcosh_pos hargx |
| have hxL : x < L := (Real.arcosh_lt_arcosh (by linarith) (by linarith)).mpr hargL |
| have hL : 0 < L := hx.trans hxL |
| have hcoshx : Real.cosh x=2/v-1 := Real.cosh_arcosh hargx.le |
| have hcoshL : Real.cosh L=2*R/v-1 := Real.cosh_arcosh (hargx.trans hargL).le |
| have houter : v/2*(Real.cosh L+1)=R := by rw [hcoshL]; field_simp; ring |
| have hat : ellipseMap v (x:ℂ)=1 := by |
| rw [ellipseMap,←Complex.ofReal_cosh,hcoshx] |
| push_cast |
| have hvC : (v:ℂ) ≠ 0 := by exact_mod_cast hv.ne' |
| field_simp [hvC] |
| ring |
| refine ⟨1-x/L,by have := (div_lt_one hL).mpr hxL; linarith, |
| by have := div_nonneg hx.le hL.le; linarith,?_⟩ |
| intro E _ _ f hf ε hε hbound hsmall |
| let F : ℂ → E := fun z => f (ellipseMap v z) |
| have hmap : Differentiable ℂ (ellipseMap v) := |
| (Complex.differentiable_cosh.add_const 1).const_mul ((v:ℂ)/2) |
| have hFd : Differentiable ℂ F := hf.comp hmap |
| have hF1 : ∀z ∈ verticalClosedStrip 0 L, ‖F z‖ ≤ 1 := by |
| intro z hz |
| exact hbound _ ((ellipseMap_norm hv.le hL.le z hz).trans_eq houter) |
| have hc : BddAbove ((norm ∘ F) '' verticalClosedStrip 0 L) := by |
| use 1 |
| rintro y ⟨z,hz,rfl⟩ |
| exact hF1 z hz |
| have hleft : ∀z ∈ Complex.re ⁻¹' {(0:ℝ)}, ‖F z‖ ≤ ε := by |
| intro z hz |
| obtain ⟨t,ht,htv,he⟩ := ellipseMap_left hv.le z hz |
| dsimp [F] |
| rw [he] |
| exact hsmall t ht (htv.trans hva) |
| have hright : ∀z ∈ Complex.re ⁻¹' {L}, ‖F z‖ ≤ 1 := by |
| intro z hz |
| apply hF1 |
| change 0 ≤ z.re ∧ z.re ≤ L |
| change z.re=L at hz |
| rw [hz] |
| exact ⟨hL.le,le_rfl⟩ |
| have ht := norm_le_interp_of_mem_verticalClosedStrip' hL |
| (show (x:ℂ) ∈ verticalClosedStrip 0 L from ⟨hx.le,hxL.le⟩) |
| hFd.diffContOnCl hc hleft hright |
| simpa only [F,hat,Complex.ofReal_re,sub_zero,Real.one_rpow,mul_one] using ht |
|
|
| end BinaryCoordinateSweeps |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps |
|
|
| theorem grid_analytic_contraction : ∃ r : ℕ, 0<r ∧ ∃ g : ℝ, 0<g ∧ |
| ∀b : ℕ, 1≤b → ∀bits : Fin b → ℕ, |
| (∀j,r≤bits j ∧ bits j≤2*r) → ∀D : ℕ, |
| ∀ρ : Representation ℂ (Equiv.Perm (GridSlot bits)) (RepSpace D), |
| ρ.IsIrreducible → IsUnitaryRep ρ → |
| ‖complexGridAverage bits ρ 1‖ ≤ (D:ℝ)^(-g) := by |
| obtain ⟨r,hr,q,hq,a,ha,hreal⟩ := real_grid_bound |
| obtain ⟨R,hR,hdisk⟩ := complex_grid_disk (2*r) |
| obtain ⟨θ,hθ,hθ1,htrans⟩ := analytic_segment_transfer R a hR ha |
| refine ⟨r,hr,(c0/(2*q))*θ,mul_pos (div_pos (by norm_num [c0]) (by positivity)) hθ,?_⟩ |
| intro b hb bits hbits D ρ hi hρ |
| have := hi |
| have : Nontrivial (RepSpace D) := |
| Module.nontrivial_of_finrank_pos (Signed.irreducible_finrank_pos ρ) |
| have ht := htrans (RepSpace D →L[ℂ] RepSpace D) (complexGridAverage bits ρ) |
| (complexGridAverage_differentiable bits ρ) ((D:ℝ)^(-c0/(2*q))) (by positivity) |
| (hdisk b bits (fun j => (hbits j).2) (RepSpace D) ρ hρ) |
| (hreal b hb bits hbits D ρ hi hρ) |
| rw [←Real.rpow_mul (Nat.cast_nonneg D)] at ht |
| have he : (-c0/(2*(q:ℝ)))*θ = -(c0/(2*q)*θ) := by ring |
| simpa only [he] using ht |
|
|
| end BinaryCoordinateSweeps |
|
|
| end |
|
|
| end OAI |
|
|
