| import OAI.Analysis.IntegralMeans.Winding |
|
|
| 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 |
|
|
| def periodicLoop {γ : ℝ → ℂ} (hc : Continuous γ) (s : ℝ) : C(unitInterval,ℂ) := |
| ⟨fun t => γ ((t : ℝ)+s),hc.comp (continuous_subtype_val.add continuous_const)⟩ |
|
|
| lemma periodicLoop_closed {γ : ℝ → ℂ} (hc : Continuous γ) |
| (hp : Function.Periodic γ 1) (s : ℝ) : |
| periodicLoop hc s 1 = periodicLoop hc s 0 := by |
| simpa only [periodicLoop,ContinuousMap.coe_mk,show ((1 : unitInterval) : ℝ) = 1 from rfl,show ((0 : unitInterval) : ℝ) = 0 from rfl, |
| zero_add,add_zero,add_comm] using hp s |
|
|
| lemma periodicLoop_range {γ : ℝ → ℂ} (hc : Continuous γ) |
| (hp : Function.Periodic γ 1) (s : ℝ) : range (periodicLoop hc s) = range γ := by |
| apply Subset.antisymm |
| · rintro _ ⟨t,rfl⟩; exact ⟨(t : ℝ)+s,rfl⟩ |
| · rintro _ ⟨t,rfl⟩ |
| obtain ⟨u,hu,he⟩ := hp.exists_mem_Ico (by norm_num) t s |
| refine ⟨⟨u-s,⟨by linarith [hu.1],by linarith [hu.2]⟩⟩,?_⟩ |
| simpa only [periodicLoop,ContinuousMap.coe_mk,sub_add_cancel] using he.symm |
|
|
| lemma loopIndex_periodic_shift {γ : ℝ → ℂ} (hc : Continuous γ) |
| (hp : Function.Periodic γ 1) {a : ℂ} (ha : a ∉ range γ) (s : ℝ) : |
| loopIndex (periodicLoop hc s) a = loopIndex (periodicLoop hc 0) a := by |
| let H : C(unitInterval × unitInterval,ℂ) := |
| ⟨fun p => γ ((p.2 : ℝ)+(p.1 : ℝ)*s)-a,by fun_prop⟩ |
| have hi := windingNumber_homotopy H (by |
| intro p; exact sub_ne_zero.mpr (fun he => ha ⟨_,he⟩)) (by |
| intro t |
| change γ (1+(t:ℝ)*s)-a = γ (0+(t:ℝ)*s)-a |
| simpa only [zero_add,add_zero,add_comm] using congrArg (fun z : ℂ => z-a) (hp ((t:ℝ)*s))) |
| simpa only [H,loopIndex,periodicLoop,show ((1 : unitInterval) : ℝ) = 1 from rfl,show ((0 : unitInterval) : ℝ) = 0 from rfl, |
| ContinuousMap.coe_mk,one_mul,zero_mul] using hi |
|
|
| lemma transverse_displacement_not_mem {γ : ℝ → ℂ} (hp : Function.Periodic γ 1) |
| {d : ℂ} {δ : ℝ} |
| (hz : ∀ w : ℂ, |w.re| ≤ δ → |w.im| ≤ 1/2 → |
| (γ w.im-γ 0-w.re • (Complex.I*d) = 0 ↔ w = 0)) |
| {r : ℝ} (hr : r ≠ 0) (hrd : |r| ≤ δ) : |
| γ 0+r • (Complex.I*d) ∉ range γ := by |
| rintro ⟨t,ht⟩ |
| obtain ⟨u,hu,he⟩ := hp.exists_mem_Ico (by norm_num) t (-(1/2)) |
| have hui : |u| ≤ 1/2 := abs_le.mpr ⟨hu.1,by linarith [hu.2]⟩ |
| let w : ℂ := (r : ℂ)+(u : ℂ)*Complex.I |
| have hre : w.re = r := by simp [w] |
| have him : w.im = u := by simp [w] |
| have hw : w = 0 := (hz w (hre ▸ hrd) (him ▸ hui)).mp (by |
| rw [hre,him,← he,ht]; abel) |
| have h := congrArg Complex.re hw |
| exact hr (by simpa only [hre,Complex.zero_re] using h) |
|
|
| lemma winding_jump {γ : ℝ → ℂ} (hc : Continuous γ) |
| (hp : Function.Periodic γ 1) (hinj : InjOn γ (Ico (0 : ℝ) 1)) |
| {d : ℂ} (hd : HasDerivAt γ d 0) (hdn : d ≠ 0) : |
| ∃ δ : ℝ, 0 < δ ∧ ∀ r : ℝ, 0 < r → r ≤ δ → |
| γ 0+r • (Complex.I*d) ∉ range γ ∧ γ 0-r • (Complex.I*d) ∉ range γ ∧ |
| loopIndex (periodicLoop hc 0) (γ 0+r • (Complex.I*d)) - |
| loopIndex (periodicLoop hc 0) (γ 0-r • (Complex.I*d)) = 1 := by |
| obtain ⟨δ,hδ,hjump⟩ := winding_jump_centred hc hp hinj hd hdn |
| obtain ⟨ε,hε,hzero⟩ := transverse_unique_zero_strip hc hp hinj hd hdn |
| refine ⟨min δ ε,lt_min hδ hε,?_⟩ |
| intro r hr hre |
| have hn₁ := transverse_displacement_not_mem hp hzero hr.ne' |
| (show |r| ≤ ε from (abs_of_pos hr).symm ▸ hre.trans (min_le_right _ _)) |
| have hn₂ : γ 0-r • (Complex.I*d) ∉ range γ := by |
| simpa only [neg_smul,sub_eq_add_neg] using transverse_displacement_not_mem hp hzero |
| (neg_ne_zero.mpr hr.ne') (show |-r| ≤ ε by |
| rw [abs_neg,abs_of_pos hr]; exact hre.trans (min_le_right _ _)) |
| refine ⟨hn₁,hn₂,?_⟩ |
| have hj := hjump r hr (hre.trans (min_le_left _ _)) |
| change loopIndex (periodicLoop hc (-(1/2))) (γ 0+r • (Complex.I*d))- |
| loopIndex (periodicLoop hc (-(1/2))) (γ 0-r • (Complex.I*d)) = 1 at hj |
| rwa [loopIndex_periodic_shift hc hp hn₁,loopIndex_periodic_shift hc hp hn₂] at hj |
|
|
| lemma loopIndex_zero_of_re_lt (γ : C(unitInterval,ℂ)) (hloop : γ 1 = γ 0) |
| {a : ℂ} (ha : ∀ t, a.re < (γ t).re) : loopIndex γ a = 0 := by |
| apply windingNumber_eq_of_logIncrement (by simp [hloop]) |
| have h := HasLogIncrement.of_slit (⟨fun t => γ t-a,by fun_prop⟩ : C(unitInterval,ℂ)) |
| (fun t => Complex.mem_slitPlane_iff.mpr (Or.inl (by simpa using sub_pos.mpr (ha t)))) |
| simpa only [ContinuousMap.coe_mk,hloop,sub_self,Int.cast_zero,zero_mul] using h |
|
|
| lemma winding_leftmost_normal {γ : ℝ → ℂ} (hc : Continuous γ) |
| (hp : Function.Periodic γ 1) (hinj : InjOn γ (Ico (0 : ℝ) 1)) |
| {d : ℂ} (hd : HasDerivAt γ d 0) (hdi : d.im < 0) |
| (hmin : ∀ t, (γ 0).re ≤ (γ t).re) : |
| ∃ δ : ℝ, 0 < δ ∧ ∀ r : ℝ, 0 < r → r ≤ δ → |
| γ 0+r • (Complex.I*d) ∉ range γ ∧ |
| loopIndex (periodicLoop hc 0) (γ 0+r • (Complex.I*d)) = 1 := by |
| have hdn : d ≠ 0 := by intro he; simp only [he,Complex.zero_im] at hdi; linarith |
| obtain ⟨δ,hδ,hj⟩ := winding_jump hc hp hinj hd hdn |
| refine ⟨δ,hδ,?_⟩ |
| intro r hr hrd |
| obtain ⟨hn,_,hjump⟩ := hj r hr hrd |
| have hzero : loopIndex (periodicLoop hc 0) (γ 0-r • (Complex.I*d)) = 0 := |
| loopIndex_zero_of_re_lt _ (periodicLoop_closed hc hp 0) (by |
| intro t |
| change (γ 0-r • (Complex.I*d)).re < (γ ((t:ℝ)+0)).re |
| simp only [Complex.sub_re,Complex.smul_re,Complex.mul_re,Complex.I_re,zero_mul, |
| Complex.I_im,one_mul,zero_sub,smul_eq_mul] |
| nlinarith [hmin ((t:ℝ)+0)]) |
| rw [hzero,sub_zero] at hjump |
| exact ⟨hn,hjump⟩ |
|
|
| lemma isMIntegralCurve_iff_hasDerivAt {γ : ℝ → ℂ} {v : ℂ → ℂ} : |
| IsMIntegralCurve (I := 𝓘(ℝ,ℂ)) γ v ↔ ∀ t, HasDerivAt γ (v (γ t)) t := by |
| constructor |
| · intro h t |
| have ht : HasFDerivAt γ ((1 : ℝ →L[ℝ] ℝ).smulRight (v (γ t))) t := |
| hasMFDerivAt_iff_hasFDerivAt.mp (h t) |
| simpa only [ContinuousLinearMap.smulRight_apply, one_apply_eq_self, one_smul] using ht.hasDerivAt |
| · intro h t |
| apply hasMFDerivAt_iff_hasFDerivAt.mpr |
| convert (h t).hasFDerivAt using 1 |
| rfl |
|
|
| lemma exists_global_curve {v : ℂ → ℂ} (hv : ContDiff ℝ 1 v) |
| (hc : HasCompactSupport v) (x : ℂ) : |
| ∃ γ : ℝ → ℂ, γ 0 = x ∧ ∀ t, HasDerivAt γ (v (γ t)) t := by |
| obtain ⟨K, hK⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hc hv (by simp) |
| obtain ⟨B, hB⟩ := hc.exists_bound_of_continuous hv.continuous |
| let L : ℝ≥0 := ⟨max B 0, le_max_right _ _⟩ |
| have hL : ∀ z, ‖v z‖ ≤ (L : ℝ) := fun z => (hB z).trans (le_max_left _ _) |
| have hm : ContMDiff 𝓘(ℝ,ℂ) (𝓘(ℝ,ℂ)).tangent 1 |
| (fun z => (⟨z,v z⟩ : TangentBundle 𝓘(ℝ,ℂ) ℂ)) := |
| contMDiff_vectorSpace_iff_contDiff.mpr hv |
| have he : ∀ z : ℂ, ∃ γ : ℝ → ℂ, γ 0 = z ∧ |
| IsMIntegralCurveOn (I := 𝓘(ℝ,ℂ)) γ v (Ioo (-1) 1) := by |
| intro z |
| have hi : IsPicardLindelof (fun _ : ℝ => v) |
| (⟨0, by norm_num⟩ : Icc (-1 : ℝ) 1) z L 0 L K := by |
| refine ⟨fun _ _ => hK.lipschitzOnWith, fun _ _ => continuousOn_const, |
| fun _ _ w _ => hL w, ?_⟩ |
| simp |
| obtain ⟨γ,hγ0,hγ⟩ := hi.exists_eq_forall_mem_Icc_hasDerivWithinAt₀ |
| refine ⟨γ,hγ0,fun t ht => ?_⟩ |
| exact ((hγ t ⟨ht.1.le,ht.2.le⟩).hasDerivAt (Icc_mem_nhds ht.1 ht.2)).hasFDerivAt.hasMFDerivAt.hasMFDerivWithinAt |
| obtain ⟨γ,hγ0,hγ⟩ := exists_isMIntegralCurve_of_isMIntegralCurveOn hm (by norm_num : (0:ℝ)<1) he x |
| exact ⟨γ,hγ0,isMIntegralCurve_iff_hasDerivAt.mp hγ⟩ |
|
|
| def transverseCoordinate (p : ℂ →L[ℝ] ℝ) : ℂ →L[ℝ] ℝ := |
| (-p Complex.I) • Complex.reCLM + (p 1) • Complex.imCLM |
|
|
| def levelChartDerivative (p : ℂ →L[ℝ] ℝ) : ℂ →L[ℝ] ℂ := |
| Complex.ofRealCLM.comp p + Complex.I • (Complex.ofRealCLM.comp (transverseCoordinate p)) |
|
|
| lemma realFunctional_decomposition (p : ℂ →L[ℝ] ℝ) (w : ℂ) : |
| p w = w.re * p 1 + w.im * p Complex.I := by |
| have hw : w = w.re • (1 : ℂ) + w.im • Complex.I := by |
| simp [Complex.real_smul, Complex.re_add_im] |
| conv_lhs => rw [hw, map_add, map_smul, map_smul] |
| simp only [smul_eq_mul] |
|
|
| lemma levelChartDerivative_det (p : ℂ →L[ℝ] ℝ) : |
| LinearMap.det (levelChartDerivative p).toLinearMap = (p 1)^2 + (p Complex.I)^2 := by |
| rw [determinant_complex_real] |
| simp [levelChartDerivative, transverseCoordinate, Complex.mul_re, Complex.mul_im] |
| ring |
|
|
| lemma levelChartDerivative_det_pos {p : ℂ →L[ℝ] ℝ} (hp : p ≠ 0) : |
| 0 < LinearMap.det (levelChartDerivative p).toLinearMap := by |
| rw [levelChartDerivative_det] |
| have hn : p 1 ≠ 0 ∨ p Complex.I ≠ 0 := by |
| by_contra h |
| push Not at h |
| apply hp |
| ext w |
| rw [realFunctional_decomposition, h.1, h.2] |
| simp |
| rcases hn with hn|hn |
| · nlinarith [sq_pos_of_ne_zero hn, sq_nonneg (p Complex.I)] |
| · nlinarith [sq_pos_of_ne_zero hn, sq_nonneg (p 1)] |
|
|
| lemma exists_regular_level_chart {f : ℂ → ℝ} {z : ℂ} |
| (hf : ContDiffAt ℝ 1 f z) (hp : fderiv ℝ f z ≠ 0) : |
| ∃ e : OpenPartialHomeomorph ℂ ℂ, z ∈ e.source ∧ |
| (∀ w, (e w).re = f w) ∧ |
| (∀ w, (e w).im = transverseCoordinate (fderiv ℝ f z) w) := by |
| let p := fderiv ℝ f z |
| let Φ : ℂ → ℂ := fun w => (f w : ℂ) + Complex.I * (transverseCoordinate p w : ℂ) |
| have hc : ContDiffAt ℝ 1 Φ z := |
| (Complex.ofRealCLM.contDiff.contDiffAt.comp z hf).add |
| (contDiffAt_const.mul ((Complex.ofRealCLM.comp (transverseCoordinate p)).contDiff.contDiffAt)) |
| have hd : HasFDerivAt Φ (levelChartDerivative p) z := by |
| exact (Complex.ofRealCLM.hasFDerivAt.comp z (hf.differentiableAt (by simp)).hasFDerivAt).add |
| (((Complex.ofRealCLM.comp (transverseCoordinate p)).hasFDerivAt).const_mul Complex.I) |
| let A : ℂ ≃L[ℝ] ℂ := (LinearMap.equivOfIsUnitDet |
| (isUnit_iff_ne_zero.mpr (ne_of_gt (levelChartDerivative_det_pos hp)))).toContinuousLinearEquiv |
| have hA : (A : ℂ →L[ℝ] ℂ) = levelChartDerivative p := by |
| ext w |
| exact LinearMap.equivOfIsUnitDet_apply _ w |
| rw [← hA] at hd |
| refine ⟨hc.toOpenPartialHomeomorph Φ hd (by simp), |
| hc.mem_toOpenPartialHomeomorph_source hd (by simp), ?_, ?_⟩ |
| · intro w |
| change (Φ w).re = f w |
| simp [Φ] |
| · intro w |
| change (Φ w).im = transverseCoordinate p w |
| simp [Φ] |
|
|
| lemma curve_local_level_cover {f : ℂ → ℝ} {γ : ℝ → ℂ} {t : ℝ} {v : ℂ} |
| (hf : ContDiffAt ℝ 1 f (γ t)) (hp : fderiv ℝ f (γ t) ≠ 0) |
| (hγ : ContDiffAt ℝ 1 γ t) (hd : HasDerivAt γ v t) (hv : v ≠ 0) |
| (hc : ∀ s, f (γ s) = f (γ t)) {U : Set ℝ} (hU : U ∈ 𝓝 t) : |
| ∀ᶠ w in 𝓝 (γ t), f w = f (γ t) → w ∈ γ '' U := by |
| let p := fderiv ℝ f (γ t) |
| let q := transverseCoordinate p |
| have hfd := (hf.differentiableAt (by simp)).hasFDerivAt |
| have hpv : p v = 0 := by |
| have hh := hfd.comp_hasDerivAt t hd |
| have he : (f ∘ γ) = fun _ => f (γ t) := funext hc |
| rw [he] at hh |
| exact hh.unique (hasDerivAt_const t _) |
| have hqv : q v ≠ 0 := by |
| intro hq |
| have hA : IsUnit (LinearMap.det (levelChartDerivative p).toLinearMap) := |
| isUnit_iff_ne_zero.mpr (ne_of_gt (levelChartDerivative_det_pos hp)) |
| let A := LinearMap.equivOfIsUnitDet hA |
| have hz : A v = A 0 := by |
| rw [show A v = levelChartDerivative p v from LinearMap.equivOfIsUnitDet_apply _ v, |
| show A 0 = levelChartDerivative p 0 from LinearMap.equivOfIsUnitDet_apply _ 0] |
| simp [levelChartDerivative, hpv, show transverseCoordinate p v = 0 from hq] |
| exact hv (A.injective hz) |
| let ψ : ℝ → ℝ := fun s => q (γ s) |
| have hψ : HasStrictDerivAt ψ (q v) t := |
| (q.contDiff.contDiffAt.comp t hγ).hasStrictDerivAt' |
| (q.hasFDerivAt.comp_hasDerivAt t hd) (by simp) |
| let σ := hψ.localInverse ψ (q v) t hqv |
| have hσ : σ (ψ t) = t := hψ.eventually_left_inverse hqv |>.self_of_nhds |
| have hσc : Tendsto σ (𝓝 (ψ t)) (𝓝 t) := by |
| have ht : Tendsto σ (𝓝 (ψ t)) (𝓝 (σ (ψ t))) := |
| (hψ.to_localInverse hqv).hasDerivAt.continuousAt.tendsto |
| rwa [hσ] at ht |
| obtain ⟨e,het,her,hei⟩ := exists_regular_level_chart hf hp |
| have hw : ∀ᶠ w in 𝓝 (γ t), w ∈ e.source := e.open_source.mem_nhds het |
| have hqc : Tendsto q (𝓝 (γ t)) (𝓝 (ψ t)) := q.continuous.continuousAt.tendsto |
| have hi : ∀ᶠ w in 𝓝 (γ t), ψ (σ (q w)) = q w := |
| hqc.eventually (hψ.eventually_right_inverse hqv) |
| have hu : ∀ᶠ w in 𝓝 (γ t), σ (q w) ∈ U := (hσc.comp hqc).eventually hU |
| have hs : ∀ᶠ w in 𝓝 (γ t), γ (σ (q w)) ∈ e.source := |
| (hγ.continuousAt.tendsto.comp (hσc.comp hqc)).eventually hw |
| filter_upwards [hw,hi,hu,hs] with w hw hi hu hs hfwe |
| refine ⟨σ (q w),hu, e.injOn hs hw ?_⟩ |
| apply Complex.ext |
| · rw [her,her,hc,hfwe] |
| · rw [hei,hei] |
| exact hi |
| |
| lemma integral_curve_contDiff_one {v : ℂ → ℂ} {γ : ℝ → ℂ} |
| (hv : Continuous v) (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) : |
| ContDiff ℝ 1 γ := by |
| apply contDiff_one_iff_deriv.mpr |
| have hc : Continuous γ := continuous_iff_continuousAt.mpr fun t => (hγ t).continuousAt |
| refine ⟨fun t => (hγ t).differentiableAt, ?_⟩ |
| have he : deriv γ = v ∘ γ := funext fun t => (hγ t).deriv |
| rw [he] |
| exact hv.comp hc |
| |
| lemma integral_curve_first_integral {f : ℂ → ℝ} {v : ℂ → ℂ} {γ : ℝ → ℂ} |
| (hf : Differentiable ℝ f) (horth : ∀ z, fderiv ℝ f z (v z) = 0) |
| (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) (s t : ℝ) : f (γ s) = f (γ t) := by |
| have hd (t : ℝ) : HasDerivAt (fun t => f (γ t)) 0 t := by |
| convert (hf (γ t)).hasFDerivAt.comp_hasDerivAt t (hγ t) using 1 <;> |
| first | rfl | simp only [horth] |
| exact is_const_of_deriv_eq_zero (fun t => (hd t).differentiableAt) |
| (fun t => (hd t).deriv) s t |
| |
| lemma integral_curves_shift_eq {v : ℂ → ℂ} {γ κ : ℝ → ℂ} |
| (hv : ContDiff ℝ 1 v) |
| (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) |
| (hκ : ∀ t, HasDerivAt κ (v (κ t)) t) |
| {a b : ℝ} (he : γ a = κ b) (s : ℝ) : γ (s+a) = κ (s+b) := by |
| have hm : ContMDiff 𝓘(ℝ,ℂ) (𝓘(ℝ,ℂ)).tangent 1 |
| (fun z => (⟨z,v z⟩ : TangentBundle 𝓘(ℝ,ℂ) ℂ)) := |
| contMDiff_vectorSpace_iff_contDiff.mpr hv |
| have hh := isMIntegralCurve_Ioo_eq_of_contMDiff_boundaryless (t₀ := 0) hm |
| ((isMIntegralCurve_iff_hasDerivAt.mpr hγ).comp_add a) |
| ((isMIntegralCurve_iff_hasDerivAt.mpr hκ).comp_add b) (by simpa using he) |
| exact congrFun hh s |
| |
| lemma curve_isOpenMap_level {f : ℂ → ℝ} {γ : ℝ → ℂ} {c : ℝ} |
| (hf : ContDiff ℝ 1 f) (hp : ∀ z, f z = c → fderiv ℝ f z ≠ 0) |
| (hγ : ContDiff ℝ 1 γ) (hn : ∀ t, deriv γ t ≠ 0) |
| (hc : ∀ t, f (γ t) = c) : |
| IsOpenMap (fun t => (⟨γ t,hc t⟩ : {z : ℂ | f z = c})) := by |
| intro U hU |
| apply isOpen_iff_mem_nhds.mpr |
| rintro _ ⟨t,ht,rfl⟩ |
| have hh := curve_local_level_cover hf.contDiffAt (hp _ (hc t)) hγ.contDiffAt |
| (hγ.differentiable (by simp) t).hasDerivAt (hn t) |
| (fun s => (hc s).trans (hc t).symm) (hU.mem_nhds ht) |
| have hm : Tendsto (Subtype.val : {z : ℂ | f z = c} → ℂ) |
| (𝓝 ⟨γ t,hc t⟩) (𝓝 (γ t)) := continuous_subtype_val.continuousAt.tendsto |
| have he := hm.eventually hh |
| filter_upwards [he] with w hw |
| obtain ⟨s,hs,heq⟩ := hw (w.property.trans (hc t).symm) |
| exact ⟨s,hs,Subtype.ext heq⟩ |
| |
| lemma compact_regular_level_periodic {f : ℂ → ℝ} {v : ℂ → ℂ} {c : ℝ} |
| (hf : ContDiff ℝ 1 f) (hv : ContDiff ℝ 1 v) (hvc : HasCompactSupport v) |
| (horth : ∀ z, fderiv ℝ f z (v z) = 0) |
| (hp : ∀ z, f z = c → fderiv ℝ f z ≠ 0) |
| (hn : ∀ z, f z = c → v z ≠ 0) |
| (hK : IsCompact {z : ℂ | f z = c}) {γ : ℝ → ℂ} |
| (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) (hγ0 : f (γ 0) = c) : |
| ∃ T > 0, Periodic γ T := by |
| let K := {z : ℂ | f z = c} |
| have hc (t : ℝ) : f (γ t) = c := |
| (integral_curve_first_integral (hf.differentiable (by simp)) horth hγ t 0).trans hγ0 |
| let Γ : ℝ → K := fun t => ⟨γ t,hc t⟩ |
| have hγc := integral_curve_contDiff_one hv.continuous hγ |
| have hΓo : IsOpenMap Γ := curve_isOpenMap_level hf hp hγc |
| (fun t => by rw [(hγ t).deriv]; exact hn _ (hc t)) hc |
| have hΓc : Continuous Γ := hγc.continuous.subtype_mk _ |
| have hclosed : IsClosed (range Γ) := by |
| apply isOpen_compl_iff.mp |
| apply isOpen_iff_mem_nhds.mpr |
| intro w hw |
| obtain ⟨κ,hκ0,hκ⟩ := exists_global_curve hv hvc w.val |
| have hκc (s : ℝ) : f (κ s) = c := by |
| rw [integral_curve_first_integral (hf.differentiable (by simp)) horth hκ s 0, hκ0] |
| exact w.property |
| let Δ : ℝ → K := fun s => ⟨κ s,hκc s⟩ |
| have hΔo : IsOpenMap Δ := curve_isOpenMap_level hf hp |
| (integral_curve_contDiff_one hv.continuous hκ) |
| (fun s => by rw [(hκ s).deriv]; exact hn _ (hκc s)) hκc |
| have hwΔ : w ∈ range Δ := ⟨0,Subtype.ext hκ0⟩ |
| apply mem_of_superset (hΔo.isOpen_range.mem_nhds hwΔ) |
| rintro y ⟨s,rfl⟩ ⟨t,ht⟩ |
| apply hw |
| have he : γ t = κ s := congrArg Subtype.val ht |
| refine ⟨-s+t,Subtype.ext ?_⟩ |
| have hh := integral_curves_shift_eq hv hγ hκ he (-s) |
| simpa only [neg_add_cancel,hκ0] using hh |
| have hcompact : IsCompact (range Γ) := by |
| have : CompactSpace K := isCompact_iff_compactSpace.mp hK |
| exact hclosed.isCompact |
| have hnotinj : ¬ Injective γ := by |
| intro hi |
| have hΓi : Injective Γ := fun a b h => hi (congrArg Subtype.val h) |
| have he := Topology.IsOpenEmbedding.of_continuous_injective_isOpenMap hΓc hΓi hΓo |
| apply noncompact_univ ℝ |
| apply he.isEmbedding.isCompact_iff.mpr |
| simpa only [image_univ] using hcompact |
| have hm : ContMDiff 𝓘(ℝ,ℂ) (𝓘(ℝ,ℂ)).tangent 1 |
| (fun z => (⟨z,v z⟩ : TangentBundle 𝓘(ℝ,ℂ) ℂ)) := |
| contMDiff_vectorSpace_iff_contDiff.mpr hv |
| exact (xor_iff_iff_not.mp |
| ((isMIntegralCurve_iff_hasDerivAt.mpr hγ).periodic_xor_injective hm)).mpr hnotinj |
| |
| lemma curve_locally_injective {γ : ℝ → ℂ} {t : ℝ} |
| (hγ : ContDiffAt ℝ 1 γ t) (hn : deriv γ t ≠ 0) : |
| ∃ ε > 0, InjOn γ (Metric.ball t ε) := by |
| obtain ⟨p,hp⟩ : ∃ p : ℂ →L[ℝ] ℝ, p (deriv γ t) ≠ 0 := by |
| by_cases hr : (deriv γ t).re = 0 |
| · refine ⟨Complex.imCLM,fun hi => hn (Complex.ext hr hi)⟩ |
| · exact ⟨Complex.reCLM,hr⟩ |
| have hd : HasStrictDerivAt (fun s => p (γ s)) (p (deriv γ t)) t := |
| (p.contDiff.contDiffAt.comp t hγ).hasStrictDerivAt' |
| (p.hasFDerivAt.comp_hasDerivAt t |
| (hγ.differentiableAt (by simp)).hasDerivAt) (by simp) |
| obtain ⟨ε,hε,hsub⟩ := Metric.mem_nhds_iff.mp (hd.eventually_left_inverse hp) |
| refine ⟨ε,hε,fun a ha b hb he => ?_⟩ |
| have h₁ := hsub ha |
| have h₂ := hsub hb |
| change HasStrictDerivAt.localInverse (fun s => p (γ s)) (p (deriv γ t)) t hd hp (p (γ a)) = a at h₁ |
| change HasStrictDerivAt.localInverse (fun s => p (γ s)) (p (deriv γ t)) t hd hp (p (γ b)) = b at h₂ |
| rw [he] at h₁ |
| exact h₁.symm.trans h₂ |
|
|
| lemma integral_curve_simple_period {v : ℂ → ℂ} {γ : ℝ → ℂ} |
| (hv : ContDiff ℝ 1 v) (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) |
| (hn : v (γ 0) ≠ 0) (hper : ∃ T > 0, Periodic γ T) : |
| ∃ T > 0, Periodic γ T ∧ InjOn γ (Ico 0 T) := by |
| have hγc := integral_curve_contDiff_one hv.continuous hγ |
| obtain ⟨ε,hε,hεinj⟩ := curve_locally_injective (t := 0) hγc.contDiffAt |
| (by rw [(hγ 0).deriv]; exact hn) |
| have hlow : ∀ t, 0 < t → γ t = γ 0 → ε ≤ t := by |
| intro t ht he |
| by_contra hh |
| have hlt : t < ε := lt_of_not_ge hh |
| have hmem : t ∈ Metric.ball (0 : ℝ) ε := by |
| simpa [Metric.mem_ball, Real.dist_eq, abs_of_pos ht] using hlt |
| have hz := hεinj hmem (Metric.mem_ball_self hε) he |
| linarith |
| obtain ⟨T,hT,hpT⟩ := hper |
| have hTr : γ T = γ 0 := by simpa using hpT 0 |
| let S := Icc ε T ∩ {t | γ t = γ 0} |
| have hS : IsCompact S := isCompact_Icc.inter_right |
| (isClosed_eq hγc.continuous continuous_const) |
| obtain ⟨P,hP,hmin⟩ := hS.exists_isMinOn ⟨T,⟨⟨hlow T hT hTr,le_rfl⟩,hTr⟩⟩ |
| continuousOn_id |
| have hPpos : 0 < P := hε.trans_le hP.1.1 |
| have hleast : ∀ t, 0 < t → γ t = γ 0 → P ≤ t := by |
| intro t ht he |
| by_cases hle : t ≤ T |
| · exact hmin ⟨⟨hlow t ht he,hle⟩,he⟩ |
| · exact hP.1.2.trans (le_of_not_ge hle) |
| have hm : ContMDiff 𝓘(ℝ,ℂ) (𝓘(ℝ,ℂ)).tangent 1 |
| (fun z => (⟨z,v z⟩ : TangentBundle 𝓘(ℝ,ℂ) ℂ)) := |
| contMDiff_vectorSpace_iff_contDiff.mpr hv |
| have hi := isMIntegralCurve_iff_hasDerivAt.mpr hγ |
| have hPP : Periodic γ P := by simpa using hi.periodic_of_eq hm hP.2 |
| refine ⟨P,hPpos,hPP,fun a ha b hb he => ?_⟩ |
| rcases lt_trichotomy a b with hab|hab|hab |
| · have hper := hi.periodic_of_eq hm he.symm |
| have hret : γ (b-a) = γ 0 := by simpa using hper 0 |
| have hh := hleast (b-a) (sub_pos.mpr hab) hret |
| linarith [ha.1,hb.2] |
| · exact hab |
| · have hper := hi.periodic_of_eq hm he |
| have hret : γ (a-b) = γ 0 := by simpa using hper 0 |
| have hh := hleast (a-b) (sub_pos.mpr hab) hret |
| linarith [hb.1,ha.2] |
|
|
| lemma integral_curves_range_eq {v : ℂ → ℂ} {γ κ : ℝ → ℂ} |
| (hv : ContDiff ℝ 1 v) |
| (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) |
| (hκ : ∀ t, HasDerivAt κ (v (κ t)) t) |
| {a b : ℝ} (he : γ a = κ b) : range γ = range κ := by |
| apply Subset.antisymm |
| · rintro _ ⟨s,rfl⟩ |
| refine ⟨s-a+b, ?_⟩ |
| have hh := integral_curves_shift_eq hv hγ hκ he (s-a) |
| simpa only [sub_add_cancel] using hh.symm |
| · rintro _ ⟨s,rfl⟩ |
| refine ⟨s-b+a, ?_⟩ |
| have hh := integral_curves_shift_eq hv hκ hγ he.symm (s-b) |
| simpa only [sub_add_cancel] using hh.symm |
|
|
| lemma compact_regular_level_finite_curves {f : ℂ → ℝ} {v : ℂ → ℂ} {c : ℝ} |
| (hf : ContDiff ℝ 1 f) (hv : ContDiff ℝ 1 v) (hvc : HasCompactSupport v) |
| (horth : ∀ z, fderiv ℝ f z (v z) = 0) |
| (hp : ∀ z, f z = c → fderiv ℝ f z ≠ 0) |
| (hn : ∀ z, f z = c → v z ≠ 0) |
| (hK : IsCompact {z : ℂ | f z = c}) : |
| ∃ C : Finset (Set ℂ), (⋃ S ∈ C, S) = {z : ℂ | f z = c} ∧ |
| (∀ S ∈ C, ∀ T ∈ C, S ≠ T → Disjoint S T) ∧ |
| ∀ S ∈ C, ∃ γ : ℝ → ℂ, ∃ P > 0, |
| range γ = S ∧ (∀ t, HasDerivAt γ (v (γ t)) t) ∧ |
| Periodic γ P ∧ InjOn γ (Ico 0 P) := by |
| classical |
| let K := {z : ℂ | f z = c} |
| have hE : ∀ z : K, ∃ γ : ℝ → ℂ, γ 0 = z.val ∧ |
| ∀ t, HasDerivAt γ (v (γ t)) t := fun z => exists_global_curve hv hvc z.val |
| choose γ hγ0 hγ using hE |
| have hc (z : K) (t : ℝ) : f (γ z t) = c := by |
| rw [integral_curve_first_integral (hf.differentiable (by simp)) horth (hγ z) t 0, |
| hγ0 z] |
| exact z.property |
| let Γ (z : K) : ℝ → K := fun t => ⟨γ z t,hc z t⟩ |
| have hΓo (z : K) : IsOpenMap (Γ z) := curve_isOpenMap_level hf hp |
| (integral_curve_contDiff_one hv.continuous (hγ z)) |
| (fun t => by rw [(hγ z t).deriv]; exact hn _ (hc z t)) (hc z) |
| have : CompactSpace K := isCompact_iff_compactSpace.mp hK |
| obtain ⟨s,hs⟩ := isCompact_univ.elim_finite_subcover (fun z : K => range (Γ z)) |
| (fun z => (hΓo z).isOpen_range) (by |
| intro z _ |
| exact mem_iUnion.mpr ⟨z,0,Subtype.ext (hγ0 z)⟩) |
| let C := s.image (fun z => range (γ z)) |
| refine ⟨C,?_,?_,?_⟩ |
| · ext w |
| constructor |
| · intro hw |
| obtain ⟨S,hS,hw⟩ := mem_iUnion₂.mp hw |
| obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hS |
| obtain ⟨t,rfl⟩ := hw |
| exact hc z t |
| · intro hw |
| obtain ⟨z,hz,t,ht⟩ := mem_iUnion₂.mp (hs (mem_univ (⟨w,hw⟩ : K))) |
| refine mem_iUnion₂.mpr ⟨range (γ z),Finset.mem_image.mpr ⟨z,hz,rfl⟩,t,?_⟩ |
| exact congrArg Subtype.val ht |
| · intro S hS T hT hne |
| obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hS |
| obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp hT |
| apply disjoint_left.mpr |
| rintro a ⟨s,hs⟩ ⟨t,ht⟩ |
| exact hne (integral_curves_range_eq hv (hγ z) (hγ w) (hs.trans ht.symm)) |
| · intro S hS |
| obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hS |
| obtain ⟨P,hP,hper,hinj⟩ := integral_curve_simple_period hv (hγ z) |
| (hn _ (hc z 0)) |
| (compact_regular_level_periodic hf hv hvc horth hp hn hK (hγ z) (hc z 0)) |
| exact ⟨γ z,P,hP,rfl,hγ z,hper,hinj⟩ |
|
|
| lemma integral_curve_contDiff_two {v : ℂ → ℂ} {γ : ℝ → ℂ} |
| (hv : ContDiff ℝ 1 v) (hγ : ∀ t, HasDerivAt γ (v (γ t)) t) : |
| ContDiff ℝ 2 γ := by |
| have hc := integral_curve_contDiff_one hv.continuous hγ |
| rw [show (2 : WithTop ℕ∞) = 1+1 from rfl, contDiff_succ_iff_deriv] |
| refine ⟨fun t => (hγ t).differentiableAt, by simp, ?_⟩ |
| have he : deriv γ = v ∘ γ := funext (fun t => (hγ t).deriv) |
| rw [he] |
| exact hv.comp hc |
|
|
| end Brennan |
|
|
| end |
|
|
| end OAI |
|
|
