| import OAI.Analysis.IntegralMeans.CriticalPoint | |
| namespace OAI | |
| noncomputable section | |
| open Set MeasureTheory Filter Function InnerProductSpace | |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical | |
| open MeasureTheory Function | |
| open Set Filter | |
| open Set MeasureTheory Filter Function | |
| open Set MeasureTheory Filter Function InnerProductSpace | |
| open TopologicalSpace | |
| open scoped CompactlySupported | |
| open scoped ENNReal | |
| open scoped Manifold | |
| open scoped Topology CompactlySupported ComplexConjugate | |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical | |
| open scoped Topology ENNReal NNReal | |
| namespace Brennan | |
| lemma HasLogIncrement.path_trans {a b c : ℂ} {γ : Path a b} {η : Path b c} | |
| {p q : ℂ} (hγ : HasLogIncrement γ.toContinuousMap p) | |
| (hη : HasLogIncrement η.toContinuousMap q) : | |
| HasLogIncrement (γ.trans η).toContinuousMap (p+q) := by | |
| obtain ⟨A,hA,hp⟩ := hγ | |
| obtain ⟨B,hB,hq⟩ := hη | |
| let α : Path (A 0) (A 1) := ⟨A,rfl,rfl⟩ | |
| let β : Path (A 1) (B 1+A 1-B 0) := | |
| ⟨⟨fun t => B t+A 1-B 0, by fun_prop⟩, by simp, rfl⟩ | |
| refine ⟨(α.trans β).toContinuousMap, ?_, ?_⟩ | |
| · intro t | |
| change Complex.exp ((α.trans β) t) = (γ.trans η) t | |
| rw [Path.trans_apply,Path.trans_apply] | |
| split_ifs with h | |
| · exact hA _ | |
| · dsimp only [β,ContinuousMap.coe_mk,Path.coe_mk_mk] | |
| have heA : Complex.exp (A 1) = b := (hA 1).trans γ.target | |
| have heB : Complex.exp (B 0) = b := (hB 0).trans η.source | |
| have hb : b ≠ 0 := heB ▸ Complex.exp_ne_zero (B 0) | |
| rw [Complex.exp_sub,Complex.exp_add,heA,heB,hB] | |
| exact mul_div_cancel_right₀ _ hb | |
| · change (α.trans β) 1-(α.trans β) 0=p+q | |
| simp only [Path.target,Path.source] | |
| linear_combination hp+hq | |
| lemma HasLogIncrement.path_symm {a b : ℂ} {γ : Path a b} {q : ℂ} | |
| (hγ : HasLogIncrement γ.toContinuousMap q) : | |
| HasLogIncrement γ.symm.toContinuousMap (-q) := by | |
| obtain ⟨A,hA,hq⟩ := hγ | |
| refine ⟨⟨fun t => A (unitInterval.symm t), by fun_prop⟩, ?_, ?_⟩ | |
| · exact fun t => hA (unitInterval.symm t) | |
| · simp only [ContinuousMap.coe_mk,unitInterval.symm_one,unitInterval.symm_zero] | |
| linear_combination -hq | |
| lemma exists_path_logIncrement {a b : ℂ} (γ : Path a b) (hn : ∀ t, γ t ≠ 0) : | |
| ∃ q, HasLogIncrement γ.toContinuousMap q := by | |
| let := (convex_Icc (𝕜 := ℝ) (0 : ℝ) 1).contractibleSpace | |
| (show (Icc (0 : ℝ) 1).Nonempty from ⟨0,by simp⟩) | |
| let := (convex_Icc (𝕜 := ℝ) (0 : ℝ) 1).locallyPathConnectedSpace | |
| obtain ⟨A,hA⟩ := exists_log_lift_of_simplyConnected (0 : unitInterval) γ.toContinuousMap hn | |
| exact ⟨A 1-A 0,A,hA,rfl⟩ | |
| lemma HasLogIncrement.of_slit (γ : C(unitInterval,ℂ)) | |
| (hγ : ∀ t, γ t ∈ Complex.slitPlane) : | |
| HasLogIncrement γ (Complex.log (γ 1)-Complex.log (γ 0)) := by | |
| exact ⟨⟨fun t => Complex.log (γ t),γ.continuous.clog hγ⟩, | |
| fun t => Complex.exp_log (Complex.slitPlane_ne_zero (hγ t)),rfl⟩ | |
| lemma HasLogIncrement.of_neg_slit (γ : C(unitInterval,ℂ)) | |
| (hγ : ∀ t, -γ t ∈ Complex.slitPlane) : | |
| HasLogIncrement γ (Complex.log (-γ 1)-Complex.log (-γ 0)) := by | |
| refine ⟨⟨fun t => Complex.log (-γ t)+(Real.pi : ℂ)*Complex.I, | |
| ((γ.continuous.neg).clog hγ).add continuous_const⟩,?_,?_⟩ | |
| · intro t | |
| simp only [ContinuousMap.coe_mk,Complex.exp_add,Complex.exp_pi_mul_I] | |
| rw [Complex.exp_log (Complex.slitPlane_ne_zero (hγ t))] | |
| ring | |
| · dsimp only [ContinuousMap.coe_mk] | |
| ring | |
| lemma log_neg_of_im_neg {z : ℂ} (hi : z.im < 0) : | |
| Complex.log (-z) = Complex.log z+(Real.pi : ℂ)*Complex.I := by | |
| apply Complex.ext | |
| · simp [Complex.log_re,norm_neg] | |
| · simpa [Complex.log_im] using Complex.arg_neg_eq_arg_add_pi_of_im_neg hi | |
| lemma log_neg_of_im_pos {z : ℂ} (hi : 0 < z.im) : | |
| Complex.log (-z) = Complex.log z-(Real.pi : ℂ)*Complex.I := by | |
| apply Complex.ext | |
| · simp [Complex.log_re,norm_neg] | |
| · simpa [Complex.log_im] using Complex.arg_neg_eq_arg_sub_pi_of_im_pos hi | |
| def rectPath (r h : ℝ) : Path ((-r : ℂ)-(h : ℂ)*Complex.I) | |
| ((-r : ℂ)-(h : ℂ)*Complex.I) := | |
| (((Path.segment ((-r : ℂ)-(h : ℂ)*Complex.I) ((r : ℂ)-(h : ℂ)*Complex.I)).trans | |
| (Path.segment ((r : ℂ)-(h : ℂ)*Complex.I) ((r : ℂ)+(h : ℂ)*Complex.I))).trans | |
| (Path.segment ((r : ℂ)+(h : ℂ)*Complex.I) ((-r : ℂ)+(h : ℂ)*Complex.I))).trans | |
| (Path.segment ((-r : ℂ)+(h : ℂ)*Complex.I) ((-r : ℂ)-(h : ℂ)*Complex.I)) | |
| lemma rectPath_logIncrement {r h : ℝ} (hr : 0 < r) (hh : 0 < h) : | |
| HasLogIncrement (rectPath r h).toContinuousMap (2*Real.pi*Complex.I) := by | |
| let a : ℂ := (-r : ℂ)-(h : ℂ)*Complex.I | |
| let b : ℂ := (r : ℂ)-(h : ℂ)*Complex.I | |
| let c : ℂ := (r : ℂ)+(h : ℂ)*Complex.I | |
| let d : ℂ := (-r : ℂ)+(h : ℂ)*Complex.I | |
| have hab (t : unitInterval) : (Path.segment a b) t ∈ Complex.slitPlane := by | |
| apply Complex.mem_slitPlane_iff.mpr | |
| right | |
| simp only [Path.segment_apply,AffineMap.lineMap_apply_module,a,b,Complex.add_im, | |
| Complex.sub_im,Complex.real_smul,Complex.mul_im,Complex.ofReal_re, | |
| Complex.ofReal_im,Complex.I_re,Complex.I_im,Complex.neg_im] | |
| nlinarith | |
| have hbc (t : unitInterval) : (Path.segment b c) t ∈ Complex.slitPlane := by | |
| apply Complex.mem_slitPlane_iff.mpr | |
| left | |
| simp only [Path.segment_apply,AffineMap.lineMap_apply_module,b,c,Complex.add_re, | |
| Complex.sub_re,Complex.real_smul,Complex.mul_re,Complex.ofReal_re, | |
| Complex.ofReal_im,Complex.I_re,Complex.I_im] | |
| nlinarith | |
| have hcd (t : unitInterval) : (Path.segment c d) t ∈ Complex.slitPlane := by | |
| apply Complex.mem_slitPlane_iff.mpr | |
| right | |
| simp only [Path.segment_apply,AffineMap.lineMap_apply_module,c,d,Complex.add_im, | |
| Complex.real_smul,Complex.mul_im,Complex.ofReal_re, | |
| Complex.ofReal_im,Complex.I_re,Complex.I_im,Complex.neg_im] | |
| nlinarith | |
| have hda (t : unitInterval) : -(Path.segment d a) t ∈ Complex.slitPlane := by | |
| apply Complex.mem_slitPlane_iff.mpr | |
| left | |
| simp only [Path.segment_apply,AffineMap.lineMap_apply_module,d,a,Complex.add_re, | |
| Complex.sub_re,Complex.real_smul,Complex.mul_re,Complex.ofReal_re, | |
| Complex.ofReal_im,Complex.I_re,Complex.I_im,Complex.neg_re] | |
| nlinarith | |
| have h₁ := HasLogIncrement.of_slit (Path.segment a b).toContinuousMap hab | |
| have h₂ := HasLogIncrement.of_slit (Path.segment b c).toContinuousMap hbc | |
| have h₃ := HasLogIncrement.of_slit (Path.segment c d).toContinuousMap hcd | |
| have h₄ := HasLogIncrement.of_neg_slit (Path.segment d a).toContinuousMap hda | |
| have he := ((h₁.path_trans h₂).path_trans h₃).path_trans h₄ | |
| have ha : a.im < 0 := by simpa [a] using hh | |
| have hd : 0 < d.im := by simpa [d] using hh | |
| have hla := log_neg_of_im_neg ha | |
| have hld := log_neg_of_im_pos hd | |
| convert he using 1 | |
| · rfl | |
| · simp only [Path.coe_toContinuousMap,Path.target,Path.source] | |
| rw [hla,hld] | |
| ring | |
| lemma rectPath_winding {r h : ℝ} (hr : 0 < r) (hh : 0 < h) : | |
| windingNumber (rectPath r h).toContinuousMap = 1 := by | |
| apply windingNumber_eq_of_logIncrement ((rectPath r h).target.trans (rectPath r h).source.symm) | |
| simpa only [Int.cast_one,one_mul] using rectPath_logIncrement hr hh | |
| lemma windingNumber_path_symm {a b : ℂ} (γ : Path a b) | |
| (hc : γ 1 = γ 0) (hn : ∀ t, γ t ≠ 0) : | |
| windingNumber γ.symm.toContinuousMap = -windingNumber γ.toContinuousMap := by | |
| apply windingNumber_eq_of_logIncrement (by simpa using hc.symm) | |
| convert (windingNumber_spec γ.toContinuousMap hc hn).path_symm using 1 | |
| push_cast | |
| ring | |
| lemma windingNumber_four_paths {a b c d : ℂ} | |
| (α : Path a b) (β : Path b c) (χ : Path c d) (δ : Path d a) | |
| (hβc : β 1 = β 0) (hδc : δ 1 = δ 0) | |
| (hχ : χ.toContinuousMap = α.symm.toContinuousMap) | |
| (hα : ∀ t, α t ≠ 0) (hβ : ∀ t, β t ≠ 0) (hδ : ∀ t, δ t ≠ 0) : | |
| windingNumber (((α.trans β).trans χ).trans δ).toContinuousMap = | |
| windingNumber β.toContinuousMap + windingNumber δ.toContinuousMap := by | |
| obtain ⟨p,hp⟩ := exists_path_logIncrement α hα | |
| have hq := windingNumber_spec β.toContinuousMap hβc hβ | |
| have hr := windingNumber_spec δ.toContinuousMap hδc hδ | |
| have hs : HasLogIncrement χ.toContinuousMap (-p) := hχ ▸ hp.path_symm | |
| apply windingNumber_eq_of_logIncrement | |
| ((((α.trans β).trans χ).trans δ).target.trans | |
| (((α.trans β).trans χ).trans δ).source.symm) | |
| convert ((hp.path_trans hq).path_trans hs).path_trans hr using 1 | |
| push_cast | |
| ring | |
| lemma windingNumber_rect_map (H : ℂ → ℂ) (hH : Continuous H) (r h : ℝ) | |
| (hp : ∀ x : ℝ, H ((x : ℂ)+(h : ℂ)*Complex.I) = | |
| H ((x : ℂ)-(h : ℂ)*Complex.I)) | |
| (hn : ∀ z ∈ range (rectPath r h), H z ≠ 0) : | |
| windingNumber (((rectPath r h).map hH).toContinuousMap) = | |
| windingNumber (((Path.segment ((r : ℂ)-(h : ℂ)*Complex.I) | |
| ((r : ℂ)+(h : ℂ)*Complex.I)).map hH).toContinuousMap) - | |
| windingNumber (((Path.segment ((-r : ℂ)-(h : ℂ)*Complex.I) | |
| ((-r : ℂ)+(h : ℂ)*Complex.I)).map hH).toContinuousMap) := by | |
| let a : ℂ := (-r : ℂ)-(h : ℂ)*Complex.I | |
| let b : ℂ := (r : ℂ)-(h : ℂ)*Complex.I | |
| let c : ℂ := (r : ℂ)+(h : ℂ)*Complex.I | |
| let d : ℂ := (-r : ℂ)+(h : ℂ)*Complex.I | |
| let α := (Path.segment a b).map hH | |
| let β := (Path.segment b c).map hH | |
| let χ := (Path.segment c d).map hH | |
| let δ := (Path.segment d a).map hH | |
| have hpc : H c = H b := hp r | |
| have hpa : H d = H a := by simpa only [Complex.ofReal_neg] using hp (-r) | |
| have hβc : β 1 = β 0 := β.target.trans (hpc.trans β.source.symm) | |
| have hδc : δ 1 = δ 0 := δ.target.trans (hpa.symm.trans δ.source.symm) | |
| have hχ : χ.toContinuousMap = α.symm.toContinuousMap := by | |
| ext t | |
| simp only [Path.coe_toContinuousMap,χ,α,Path.map_coe,Function.comp_apply,Path.symm_apply, | |
| Path.segment_apply,AffineMap.lineMap_apply_module] | |
| have he₁ : (1-(t:ℝ)) • c + (t:ℝ) • d = | |
| (((1-(t:ℝ))*r+(t:ℝ)*(-r):ℝ):ℂ)+(h:ℂ)*Complex.I := by | |
| simp [c,d,Complex.real_smul] | |
| ring | |
| have he₂ : (1-(unitInterval.symm t:ℝ)) • a+(unitInterval.symm t:ℝ) • b = | |
| (((1-(t:ℝ))*r+(t:ℝ)*(-r):ℝ):ℂ)-(h:ℂ)*Complex.I := by | |
| simp [a,b,Complex.real_smul] | |
| ring | |
| rw [he₁,he₂] | |
| exact hp _ | |
| have hsub : range (Path.segment a b) ∪ range (Path.segment b c) ∪ | |
| range (Path.segment c d) ∪ range (Path.segment d a) ⊆ range (rectPath r h) := by | |
| intro z hz | |
| change z ∈ range ((((Path.segment a b).trans (Path.segment b c)).trans | |
| (Path.segment c d)).trans (Path.segment d a)) | |
| simpa only [Path.trans_range] using hz | |
| have hα : ∀ t, α t ≠ 0 := fun t => hn _ (hsub (Or.inl (Or.inl (Or.inl ⟨t,rfl⟩)))) | |
| have hβ : ∀ t, β t ≠ 0 := fun t => hn _ (hsub (Or.inl (Or.inl (Or.inr ⟨t,rfl⟩)))) | |
| have hδ : ∀ t, δ t ≠ 0 := fun t => hn _ (hsub (Or.inr ⟨t,rfl⟩)) | |
| have hi := windingNumber_four_paths α β χ δ hβc hδc hχ hα hβ hδ | |
| have hs := windingNumber_path_symm δ hδc hδ | |
| have he : δ.symm.toContinuousMap = ((Path.segment a d).map hH).toContinuousMap := by | |
| ext t | |
| simp [δ,Path.segment_symm] | |
| rw [he] at hs | |
| have hg : (((rectPath r h).map hH).toContinuousMap) = | |
| (((α.trans β).trans χ).trans δ).toContinuousMap := by | |
| simp only [rectPath,Path.map_trans] | |
| rfl | |
| rw [hg,hi] | |
| change windingNumber β.toContinuousMap + windingNumber δ.toContinuousMap = | |
| windingNumber β.toContinuousMap - windingNumber ((Path.segment a d).map hH).toContinuousMap | |
| rw [hs] | |
| omega | |
| lemma transverse_hasFDerivAt {γ : ℝ → ℂ} {d : ℂ} (hd : HasDerivAt γ d 0) : | |
| HasFDerivAt (fun w : ℂ => γ w.im-γ 0-w.re • (Complex.I*d)) | |
| ((-Complex.I*d) • ContinuousLinearMap.id ℝ ℂ) 0 := by | |
| have h := ((hd.hasFDerivAt.comp (0 : ℂ) (Complex.imCLM.hasFDerivAt)).sub_const | |
| (γ 0)).sub (Complex.reCLM.hasFDerivAt.smul_const (Complex.I*d)) | |
| have he : ContinuousLinearMap.toSpanSingleton ℝ d ∘L Complex.imCLM - | |
| Complex.reCLM.smulRight (Complex.I*d) = | |
| (-Complex.I*d) • ContinuousLinearMap.id ℝ ℂ := by | |
| ext z | |
| apply Complex.ext <;> simp [Complex.real_smul] <;> ring | |
| rw [he] at h | |
| exact h | |
| lemma det_transverse_pos {d : ℂ} (hd : d ≠ 0) : | |
| 0 < LinearMap.det (((-Complex.I*d) • ContinuousLinearMap.id ℝ ℂ).toLinearMap) := by | |
| rw [det_complex_smul] | |
| simp only [ContinuousLinearMap.coe_id,LinearMap.det_id,mul_one] | |
| exact sq_pos_of_pos (norm_pos_iff.mpr (mul_ne_zero (neg_ne_zero.mpr Complex.I_ne_zero) hd)) | |
| lemma periodic_simple_zero {γ : ℝ → ℂ} (hp : Function.Periodic γ 1) | |
| (hinj : InjOn γ (Ico (0 : ℝ) 1)) {t : ℝ} (ht : t ∈ Icc (-(1/2 : ℝ)) (1/2)) | |
| (he : γ t = γ 0) : t = 0 := by | |
| by_cases hn : 0 ≤ t | |
| · exact hinj ⟨hn,by linarith [ht.2]⟩ ⟨le_rfl,by norm_num⟩ he | |
| · have hne : t+1 = 0 := hinj ⟨by linarith [ht.1],by linarith⟩ | |
| ⟨le_rfl,by norm_num⟩ ((hp t).trans he) | |
| linarith [ht.1] | |
| lemma transverse_unique_zero_strip {γ : ℝ → ℂ} (hc : Continuous γ) | |
| (hp : Function.Periodic γ 1) (hinj : InjOn γ (Ico (0 : ℝ) 1)) | |
| {d : ℂ} (hd : HasDerivAt γ d 0) (hdn : d ≠ 0) : | |
| ∃ δ : ℝ, 0 < δ ∧ ∀ w : ℂ, |w.re| ≤ δ → |w.im| ≤ 1/2 → | |
| (γ w.im-γ 0-w.re • (Complex.I*d) = 0 ↔ w = 0) := by | |
| let H : ℂ → ℂ := fun w => γ w.im-γ 0-w.re • (Complex.I*d) | |
| have hH0 : H 0 = 0 := by simp [H] | |
| obtain ⟨_,r,hr,hlocal⟩ := exists_slit_radius_pos hH0 (transverse_hasFDerivAt hd) | |
| (det_transverse_pos hdn) | |
| let η := min (r/2) (1/4 : ℝ) | |
| have hη : 0 < η := lt_min (by linarith) (by norm_num) | |
| let K : Set ℝ := Icc (-(1/2 : ℝ)) (1/2) ∩ {t | η ≤ |t|} | |
| have hK : IsCompact K := isCompact_Icc.inter_right | |
| (isClosed_le continuous_const continuous_abs) | |
| obtain ⟨m,hm,hbound⟩ := hK.exists_forall_le' ((hc.sub continuous_const).norm.continuousOn) | |
| (a := (0 : ℝ)) (fun t ht => norm_pos_iff.mpr (sub_ne_zero.mpr (by | |
| intro he | |
| have he0 := periodic_simple_zero hp hinj ht.1 he | |
| have hb : η ≤ |t| := ht.2 | |
| simp only [he0,abs_zero] at hb | |
| exact (not_le.mpr hη) hb))) | |
| let δ := min (r/2) (m/(2*‖d‖)) | |
| have hδ : 0 < δ := lt_min (by linarith) (div_pos hm (by positivity)) | |
| refine ⟨δ,hδ,?_⟩ | |
| intro w hre him | |
| constructor | |
| · intro hz | |
| by_contra hwn | |
| by_cases hi : |w.im| < η | |
| · have hn : ‖w-0‖ < 2*r := by | |
| simpa only [sub_zero] using calc | |
| ‖w‖ ≤ |w.re|+|w.im| := Complex.norm_le_abs_re_add_abs_im w | |
| _ < r/2+r/2 := by | |
| have hδr := min_le_left (r/2) (m/(2*‖d‖)) | |
| have hηr := min_le_left (r/2) (1/4 : ℝ) | |
| dsimp only [δ] at hre | |
| dsimp only [η] at hi | |
| linarith | |
| _ < 2*r := by linarith | |
| have hnon := Complex.slitPlane_ne_zero (hlocal w hn hwn) | |
| apply hnon | |
| simp only [H,hz,zero_div] | |
| · have hb := hbound w.im ⟨abs_le.mp him,not_lt.mp hi⟩ | |
| change m ≤ ‖γ w.im-γ 0‖ at hb | |
| have he : γ w.im-γ 0 = w.re • (Complex.I*d) := sub_eq_zero.mp hz | |
| have hnorm : ‖γ w.im-γ 0‖ = |w.re| *‖d‖ := by | |
| rw [he,norm_smul,Real.norm_eq_abs,norm_mul,Complex.norm_I,one_mul] | |
| have hδm : δ*‖d‖ ≤ m/2 := by | |
| have h := min_le_right (r/2) (m/(2*‖d‖)) | |
| have hn := norm_pos_iff.mpr hdn | |
| dsimp only [δ] | |
| apply (le_div_iff₀ hn).mp | |
| convert h using 1; field_simp | |
| have : |w.re| *‖d‖ ≤ m/2 := (mul_le_mul_of_nonneg_right hre (norm_nonneg d)).trans hδm | |
| linarith | |
| · rintro rfl | |
| simp | |
| def rectRegion (r h : ℝ) : Set ℂ := {z | |z.re| ≤ r ∧ |z.im| ≤ h} | |
| lemma convex_rectRegion (r h : ℝ) : Convex ℝ (rectRegion r h) := by | |
| have he : rectRegion r h = (Complex.reCLM ⁻¹' Icc (-r) r) ∩ | |
| (Complex.imCLM ⁻¹' Icc (-h) h) := by | |
| ext z | |
| simp [rectRegion,abs_le] | |
| rw [he] | |
| exact ((convex_Icc (-r) r).linear_preimage Complex.reCLM.toLinearMap).inter | |
| ((convex_Icc (-h) h).linear_preimage Complex.imCLM.toLinearMap) | |
| lemma rectPath_mem {r h : ℝ} (hr : 0 ≤ r) (hh : 0 ≤ h) (t : unitInterval) : | |
| rectPath r h t ∈ rectRegion r h := by | |
| have hs (a b : ℂ) (ha : a ∈ rectRegion r h) (hb : b ∈ rectRegion r h) : | |
| range (Path.segment a b) ⊆ rectRegion r h := by | |
| rintro _ ⟨s,rfl⟩ | |
| simpa only [Path.segment_apply,AffineMap.lineMap_apply_module] using | |
| (convex_rectRegion r h) ha hb (sub_nonneg.mpr s.2.2) s.2.1 (by ring) | |
| have h₁ : ((-r : ℂ)-(h : ℂ)*Complex.I) ∈ rectRegion r h := by | |
| simp [rectRegion,abs_of_nonneg hr,abs_of_nonneg hh] | |
| have h₂ : ((r : ℂ)-(h : ℂ)*Complex.I) ∈ rectRegion r h := by | |
| simp [rectRegion,abs_of_nonneg hr,abs_of_nonneg hh] | |
| have h₃ : ((r : ℂ)+(h : ℂ)*Complex.I) ∈ rectRegion r h := by | |
| simp [rectRegion,abs_of_nonneg hr,abs_of_nonneg hh] | |
| have h₄ : ((-r : ℂ)+(h : ℂ)*Complex.I) ∈ rectRegion r h := by | |
| simp [rectRegion,abs_of_nonneg hr,abs_of_nonneg hh] | |
| have hb : range (rectPath r h) ⊆ rectRegion r h := by | |
| simp only [rectPath,Path.trans_range] | |
| exact union_subset (union_subset (union_subset (hs _ _ h₁ h₂) (hs _ _ h₂ h₃)) | |
| (hs _ _ h₃ h₄)) (hs _ _ h₄ h₁) | |
| exact hb ⟨t,rfl⟩ | |
| lemma rectPath_ne_zero {r h : ℝ} (hr : 0 < r) (hh : 0 < h) (t : unitInterval) : | |
| rectPath r h t ≠ 0 := by | |
| obtain ⟨T,hT,_⟩ := rectPath_logIncrement hr hh | |
| exact (hT t ▸ Complex.exp_ne_zero (T t)) | |
| lemma winding_jump_centred {γ : ℝ → ℂ} (hc : Continuous γ) | |
| (hp : Function.Periodic γ 1) (hinj : InjOn γ (Ico (0 : ℝ) 1)) | |
| {d : ℂ} (hd : HasDerivAt γ d 0) (hdn : d ≠ 0) : | |
| ∃ δ : ℝ, 0 < δ ∧ ∀ r : ℝ, 0 < r → r ≤ δ → | |
| loopIndex ⟨fun t : unitInterval => γ ((t : ℝ)-1/2), | |
| hc.comp (continuous_subtype_val.sub continuous_const)⟩ | |
| (γ 0+r • (Complex.I*d)) - | |
| loopIndex ⟨fun t : unitInterval => γ ((t : ℝ)-1/2), | |
| hc.comp (continuous_subtype_val.sub continuous_const)⟩ | |
| (γ 0-r • (Complex.I*d)) = 1 := by | |
| let H : C(ℂ,ℂ) := ⟨fun w => γ w.im-γ 0-w.re • (Complex.I*d), | |
| ((hc.comp Complex.continuous_im).sub continuous_const).sub | |
| (Complex.continuous_re.smul continuous_const)⟩ | |
| let A : ℂ →L[ℝ] ℂ := (-Complex.I*d) • ContinuousLinearMap.id ℝ ℂ | |
| obtain ⟨δ,hδ,hzero⟩ := transverse_unique_zero_strip hc hp hinj hd hdn | |
| refine ⟨δ,hδ,?_⟩ | |
| intro r hr hrd | |
| let p := rectPath r (1/2) | |
| have hp0 : ∀ t, p t ≠ 0 := rectPath_ne_zero hr (by norm_num) | |
| have hmem : ∀ t, p t ∈ rectRegion r (1/2) := rectPath_mem hr.le (by norm_num) | |
| have hz : ∀ z ∈ rectRegion r (1/2), H z = 0 ↔ z ∈ ({0} : Finset ℂ) := by | |
| intro z hz | |
| simpa only [Finset.mem_singleton,H,ContinuousMap.coe_mk] using hzero z (hz.1.trans hrd) hz.2 | |
| have hn : ∀ t, H (p t) ≠ 0 := by | |
| intro t ht | |
| exact hp0 t (Finset.mem_singleton.mp ((hz _ (hmem t)).mp ht)) | |
| have hi := windingNumber_finite_regular_zeros (convex_rectRegion r (1/2)) {0} H | |
| (fun _ => A) (by intro z hz; simpa [Finset.mem_singleton,rectRegion] using | |
| (show |z.re| ≤ r ∧ |z.im| ≤ 1/2 from by simpa [Finset.mem_singleton.mp hz] using | |
| (show (0 : ℝ) ≤ r ∧ (0 : ℝ) ≤ 1/2 from ⟨hr.le,by norm_num⟩))) hz | |
| (by intro z hz; have he := Finset.mem_singleton.mp hz; subst z | |
| exact ⟨transverse_hasFDerivAt hd,ne_of_gt (det_transverse_pos hdn)⟩) | |
| p.toContinuousMap (p.target.trans p.source.symm) hmem hn | |
| have hindex : planeIndex A = 1 := by | |
| simp only [A,planeIndex,ite_eq_left (det_transverse_pos hdn)] | |
| have hpindex : loopIndex p.toContinuousMap 0 = 1 := by | |
| change windingNumber (⟨fun t => p t-0,by fun_prop⟩ : C(unitInterval,ℂ)) = 1 | |
| have he : (⟨fun t => p t-0,by fun_prop⟩ : C(unitInterval,ℂ)) = p.toContinuousMap := by | |
| ext t; simp | |
| rw [he] | |
| exact rectPath_winding hr (by norm_num) | |
| simp only [Finset.sum_singleton,hindex,hpindex,mul_one] at hi | |
| have hperiod : ∀ x : ℝ, H ((x : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I) = | |
| H ((x : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I) := by | |
| intro x | |
| change γ (((x : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I).im)-γ 0- | |
| (((x : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I).re) • (Complex.I*d) = _ | |
| have he : γ (1/2) = γ (-(1/2)) := by | |
| convert hp (-(1/2)) using 1; norm_num | |
| simpa only [H,ContinuousMap.coe_mk,Complex.add_im,Complex.sub_im,Complex.add_re, | |
| Complex.sub_re,Complex.mul_im,Complex.mul_re,Complex.ofReal_im,Complex.ofReal_re, | |
| Complex.I_re,Complex.I_im,zero_mul,mul_zero,mul_one,sub_zero,add_zero,zero_add, | |
| zero_sub] using congrArg (fun z : ℂ => z-γ 0-x • (Complex.I*d)) he | |
| have hstrip := windingNumber_rect_map H H.continuous r (1/2) hperiod (by | |
| rintro _ ⟨t,rfl⟩; exact hn t) | |
| have hcomp : ((rectPath r (1/2)).map H.continuous).toContinuousMap = | |
| H.comp p.toContinuousMap := rfl | |
| rw [hcomp,hi] at hstrip | |
| have hright : ((Path.segment ((r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I) | |
| ((r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).map H.continuous).toContinuousMap = | |
| (⟨fun t : unitInterval => γ ((t : ℝ)-1/2), | |
| hc.comp (continuous_subtype_val.sub continuous_const)⟩ : C(unitInterval,ℂ)) - | |
| ContinuousMap.const _ (γ 0+r • (Complex.I*d)) := by | |
| ext t | |
| simp only [Path.coe_toContinuousMap,Path.map_coe,Function.comp_apply, | |
| Path.segment_apply,AffineMap.lineMap_apply_module,H,ContinuousMap.coe_mk, | |
| ContinuousMap.sub_apply,ContinuousMap.const_apply] | |
| have hre : ((1-(t : ℝ)) • ((r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I)+ | |
| (t : ℝ) • ((r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).re = r := by | |
| simp [Complex.real_smul]; ring | |
| have him : ((1-(t : ℝ)) • ((r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I)+ | |
| (t : ℝ) • ((r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).im = (t : ℝ)-1/2 := by | |
| simp [Complex.real_smul]; ring | |
| rw [hre,him]; abel | |
| have hleft : ((Path.segment ((-r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I) | |
| ((-r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).map H.continuous).toContinuousMap = | |
| (⟨fun t : unitInterval => γ ((t : ℝ)-1/2), | |
| hc.comp (continuous_subtype_val.sub continuous_const)⟩ : C(unitInterval,ℂ)) - | |
| ContinuousMap.const _ (γ 0-r • (Complex.I*d)) := by | |
| ext t | |
| simp only [Path.coe_toContinuousMap,Path.map_coe,Function.comp_apply, | |
| Path.segment_apply,AffineMap.lineMap_apply_module,H,ContinuousMap.coe_mk, | |
| ContinuousMap.sub_apply,ContinuousMap.const_apply] | |
| have hre : ((1-(t : ℝ)) • ((-r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I)+ | |
| (t : ℝ) • ((-r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).re = -r := by | |
| simp [Complex.real_smul]; ring | |
| have him : ((1-(t : ℝ)) • ((-r : ℂ)-((1/2 : ℝ) : ℂ)*Complex.I)+ | |
| (t : ℝ) • ((-r : ℂ)+((1/2 : ℝ) : ℂ)*Complex.I)).im = (t : ℝ)-1/2 := by | |
| simp [Complex.real_smul]; ring | |
| rw [hre,him,neg_smul]; abel | |
| rw [hright,hleft] at hstrip | |
| exact hstrip.symm | |
| end Brennan | |
| end | |
| end OAI | |