Download data/lean/OAI/Geometry/BallPacking/Rigidity/AngularPoles.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Rigidity/AngularPoles.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Rigidity/AngularPoles.lean
-
curl -L -o AngularPoles.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Rigidity/AngularPoles.lean
31.4 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Rigidity.Correction | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem planarCurl_congr {Ξ± Ξ² : Plane β Plane βL[β] β} {z : Plane} | |
| (he : Ξ± =αΆ [π z] Ξ²) : planarCurl Ξ± z = planarCurl Ξ² z := by | |
| simp only [planarCurl,he.fderiv_eq] | |
| theorem planarCurl_sub {Ξ± Ξ² : Plane β Plane βL[β] β} {z : Plane} | |
| (hΞ± : DifferentiableAt β Ξ± z) (hΞ² : DifferentiableAt β Ξ² z) : | |
| planarCurl (fun y => Ξ± y - Ξ² y) z = planarCurl Ξ± z - planarCurl Ξ² z := by | |
| simp only [planarCurl,fderiv_fun_sub hΞ± hΞ²,sub_apply] | |
| ring | |
| theorem planarCurl_const_smul (Ξ± : Plane β Plane βL[β] β) (c : β) (z : Plane) : | |
| planarCurl (fun y => c β’ Ξ± y) z = c * planarCurl Ξ± z := by | |
| have he : fderiv β (fun y => c β’ Ξ± y) z = c β’ fderiv β Ξ± z := | |
| congrFun (fderiv_const_smul_field (π := β) (f := Ξ±) c) z | |
| simp only [planarCurl,he,smul_apply,smul_eq_mul] | |
| ring | |
| theorem planarCurl_sum {ΞΉ : Type*} (P : Finset ΞΉ) {Ξ± : ΞΉ β Plane β Plane βL[β] β} {z : Plane} | |
| (hΞ± : β i β P, DifferentiableAt β (Ξ± i) z) : | |
| planarCurl (fun y => β i β P, Ξ± i y) z = β i β P, planarCurl (Ξ± i) z := by | |
| rw [planarCurl,fderiv_fun_sum hΞ±] | |
| simp only [sum_apply,planarCurl] | |
| simp only [Finset.sum_sub_distrib] | |
| theorem planarCurl_translate {Ξ± : Plane β Plane βL[β] β} (p z : Plane) | |
| (hΞ± : DifferentiableAt β Ξ± (z-p)) : | |
| planarCurl (fun y => Ξ± (y-p)) z = planarCurl Ξ± (z-p) := by | |
| have hh := hΞ±.hasFDerivAt.comp z ((hasFDerivAt_id z).sub_const p) | |
| change HasFDerivAt (fun y => Ξ± (y-p)) _ z at hh | |
| simp only [planarCurl,hh.fderiv,ContinuousLinearMap.comp_id] | |
| theorem angularOneForm_curl {z : Plane} (hz : z β 0) : planarCurl angularOneForm z = 0 := by | |
| have h := cutoffAngular_curl (point := z) (differentiableAt_const (1:β)) (radiusSq_pos hz).ne' | |
| simpa only [one_smul,deriv_const,mul_zero] using h | |
| def angularPole (p : Plane) (z : Plane) : Plane βL[β] β := angularOneForm (z-p) | |
| theorem angularPole_smoothAt {p z : Plane} (hz : z β p) : ContDiffAt β β (angularPole p) z := | |
| (angularOneForm_contDiffAt (radiusSq_pos (sub_ne_zero.mpr hz)).ne').comp z | |
| (contDiffAt_id.sub contDiffAt_const) | |
| theorem angularPole_curl {p z : Plane} (hz : z β p) : planarCurl (angularPole p) z = 0 := by | |
| unfold angularPole | |
| rw [planarCurl_translate p z | |
| ((angularOneForm_contDiffAt (radiusSq_pos (sub_ne_zero.mpr hz)).ne').differentiableAt (by simp))] | |
| exact angularOneForm_curl (sub_ne_zero.mpr hz) | |
| theorem angularOneForm_rotation {z : Plane} (hz : z β 0) : | |
| angularOneForm z (planeRotation z) = 1 := by | |
| change (radiusSq z)β»ΒΉ * (z.1*z.1-z.2*(-z.2)) = 1 | |
| have he : z.1*z.1-z.2*(-z.2) = radiusSq z := by unfold radiusSq; ring | |
| rw [he,inv_mul_cancelβ (radiusSq_pos hz).ne'] | |
| theorem angularPole_tendsto_fixed (p v : Plane) : | |
| Tendsto (fun z => angularPole p z v) (cocompact Plane) (π 0) := by | |
| have ht : Tendsto (fun z : Plane => Complex.equivRealProdCLM.symm (z-p)) | |
| (cocompact Plane) (cocompact β) := | |
| Complex.equivRealProdCLM.symm.toHomeomorph.isClosedEmbedding.tendsto_cocompact.comp | |
| (Homeomorph.subRight p).isClosedEmbedding.tendsto_cocompact | |
| have hi : Tendsto (fun z : β => zβ»ΒΉ) (cocompact β) (π 0) := by | |
| simpa only [βMetric.cobounded_eq_cocompact] using (tendsto_invβ_cobounded (Ξ± := β)) | |
| have hl : Tendsto (fun z : Plane => | |
| ((Complex.equivRealProdCLM.symm (z-p))β»ΒΉ * Complex.equivRealProdCLM.symm v).im) | |
| (cocompact Plane) (π 0) := by | |
| simpa only [zero_mul,Complex.zero_im,Function.comp_def] using | |
| (Complex.continuous_im.continuousAt.tendsto.comp ((hi.comp ht).mul_const | |
| (Complex.equivRealProdCLM.symm v))) | |
| apply hl.congr' | |
| filter_upwards [(isCompact_singleton (x := p)).compl_mem_cocompact] with z hz | |
| have hz' : z β p := hz | |
| exact complex_winding_eq_angular (sub_ne_zero.mpr hz') v | |
| theorem angularPole_tendsto_rotation (p : Plane) : | |
| Tendsto (fun z => angularPole p z (planeRotation z)) (cocompact Plane) (π 1) := by | |
| have hl : Tendsto (fun z => 1 + angularPole p z (planeRotation p)) (cocompact Plane) (π 1) := by | |
| simpa using (angularPole_tendsto_fixed p (planeRotation p)).const_add 1 | |
| apply hl.congr' | |
| filter_upwards [(isCompact_singleton (x := p)).compl_mem_cocompact] with z hz | |
| have hz' : z β p := hz | |
| have he : planeRotation z = planeRotation (z-p) + planeRotation p := by | |
| ext <;> simp [planeRotation] | |
| ring | |
| rw [he,map_add] | |
| change 1 + angularOneForm (z-p) (planeRotation p) = | |
| angularOneForm (z-p) (planeRotation (z-p)) + angularOneForm (z-p) (planeRotation p) | |
| rw [angularOneForm_rotation (sub_ne_zero.mpr hz')] | |
| def poleSum (P : Finset Plane) (c : Plane β β) (z : Plane) : Plane βL[β] β := | |
| β p β P, c p β’ angularPole p z | |
| theorem poleSum_smoothAt {P : Finset Plane} (c : Plane β β) {z : Plane} (hz : z β P) : | |
| ContDiffAt β β (poleSum P c) z := by | |
| apply ContDiffAt.sum | |
| intro p hp | |
| exact (contDiffAt_const (c := c p)).smul (angularPole_smoothAt (by rintro rfl; exact hz hp)) | |
| theorem poleSum_curl {P : Finset Plane} (c : Plane β β) {z : Plane} (hz : z β P) : | |
| planarCurl (poleSum P c) z = 0 := by | |
| unfold poleSum | |
| rw [planarCurl_sum P (Ξ± := fun p z => c p β’ angularPole p z) (fun p hp => | |
| ((contDiffAt_const (c := c p)).smul (angularPole_smoothAt | |
| (by rintro rfl; exact hz hp))).differentiableAt (by simp))] | |
| apply Finset.sum_eq_zero | |
| intro p hp | |
| rw [planarCurl_const_smul,angularPole_curl (by rintro rfl; exact hz hp),mul_zero] | |
| theorem poleSum_tendsto_rotation (P : Finset Plane) (c : Plane β β) : | |
| Tendsto (fun z => poleSum P c z (planeRotation z)) (cocompact Plane) (π (β p β P, c p)) := by | |
| have hl := tendsto_finsetSum P (fun p _ => (angularPole_tendsto_rotation p).const_mul (c p)) | |
| simpa only [poleSum,sum_apply,smul_apply,smul_eq_mul,mul_one] using hl | |
| theorem smooth_fill_finite (P : Finset Plane) (Ξ± : Plane β Plane βL[β] β) | |
| (hΞ± : β z, z β P β ContDiffAt β β Ξ± z) | |
| (hlocal : β p β P, β Ξ² : Plane β Plane βL[β] β, | |
| ContDiffAt β β Ξ² p β§ Ξ± =αΆ [π[β ] p] Ξ²) : | |
| β F : Plane β Plane βL[β] β, ContDiff β β F β§ β z, z β P β F z = Ξ± z := by | |
| classical | |
| choose Ξ² hΞ²s hΞ²e using hlocal | |
| let F : Plane β Plane βL[β] β := fun z => if hz : z β P then Ξ² z hz z else Ξ± z | |
| refine β¨F,contDiff_iff_contDiffAt.mpr ?_,fun z hz => dite_eq_right hzβ© | |
| intro p | |
| by_cases hp : p β P | |
| Β· have hP : βαΆ z in π p, z β P β z = p := by | |
| have hn : p β ((P.erase p : Finset Plane) : Set Plane)αΆ := by simp | |
| filter_upwards [(P.erase p).finite_toSet.isClosed.isOpen_compl.mem_nhds hn] with z hz hzP | |
| by_contra hzp | |
| exact hz (Finset.mem_erase.mpr β¨hzp,hzPβ©) | |
| have he : F =αΆ [π p] Ξ² p hp := by | |
| filter_upwards [hP,eventually_nhdsWithin_iff.mp (hΞ²e p hp)] with z hz hez | |
| by_cases hzp : z = p | |
| Β· subst z | |
| simp only [F,dite_eq_left hp] | |
| Β· have hzP : z β P := fun h => hzp (hz h) | |
| simp only [F,dite_eq_right hzP] | |
| exact hez hzp | |
| exact (hΞ²s p hp).congr_of_eventuallyEq he | |
| Β· have he : F =αΆ [π p] Ξ± := by | |
| filter_upwards [P.finite_toSet.isClosed.isOpen_compl.mem_nhds hp] with z hz | |
| exact dite_eq_right hz | |
| exact (hΞ± p hp).congr_of_eventuallyEq he | |
| theorem finite_residues_le_infinity (P : Finset Plane) (c : Plane β β) | |
| (Ξ± : Plane β Plane βL[β] β) | |
| (hΞ± : β z, z β P β ContDiffAt β β Ξ± z) | |
| (hcurl : β z, z β P β 0 β€ planarCurl Ξ± z) | |
| (hres : β p β P, β Ξ² : Plane β Plane βL[β] β, ContDiffAt β β Ξ² p β§ | |
| Ξ± =αΆ [π[β ] p] fun z => c p β’ angularPole p z + Ξ² z) | |
| {k : β} (hlim : Tendsto (fun z => Ξ± z (planeRotation z)) (cocompact Plane) (π k)) : | |
| (β p β P, c p) β€ k := by | |
| classical | |
| let Ξ³ : Plane β Plane βL[β] β := fun z => Ξ± z - poleSum P c z | |
| have hΞ³s : β z, z β P β ContDiffAt β β Ξ³ z := fun z hz => | |
| (hΞ± z hz).sub (poleSum_smoothAt c hz) | |
| have hΞ³local : β p β P, β Ξ² : Plane β Plane βL[β] β, | |
| ContDiffAt β β Ξ² p β§ Ξ³ =αΆ [π[β ] p] Ξ² := by | |
| intro p hp | |
| obtain β¨Ξ²,hΞ²s,hΞ²eβ© := hres p hp | |
| refine β¨fun z => Ξ² z - poleSum (P.erase p) c z, | |
| hΞ²s.sub (poleSum_smoothAt c (by simp)),?_β© | |
| filter_upwards [hΞ²e] with z hz | |
| have hsum : poleSum P c z = c p β’ angularPole p z + poleSum (P.erase p) c z := | |
| (Finset.add_sum_erase P (fun q => c q β’ angularPole q z) hp).symm | |
| dsimp only [Ξ³] | |
| rw [hz,hsum] | |
| abel | |
| obtain β¨F,hFs,hFeβ© := smooth_fill_finite P Ξ³ hΞ³s hΞ³local | |
| have hFnear (z : Plane) (hz : z β P) : F =αΆ [π z] Ξ³ := by | |
| filter_upwards [P.finite_toSet.isClosed.isOpen_compl.mem_nhds hz] with y hy | |
| exact hFe y hy | |
| have hFc : β z, z β P β 0 β€ planarCurl F z := by | |
| intro z hz | |
| rw [planarCurl_congr (hFnear z hz)] | |
| change 0 β€ planarCurl (fun y => Ξ± y - poleSum P c y) z | |
| rw [planarCurl_sub ((hΞ± z hz).differentiableAt (by simp)) | |
| ((poleSum_smoothAt c hz).differentiableAt (by simp)),poleSum_curl c hz,sub_zero] | |
| exact hcurl z hz | |
| have hFcAll : β z, 0 β€ planarCurl F z := by | |
| have hd : Dense ((P : Set Plane)αΆ) := by | |
| convert dense_univ.sdiff_finset P using 1 | |
| ext z | |
| simp only [mem_compl_iff,Set.mem_sdiff,mem_univ,true_and,Finset.mem_coe] | |
| have hc : IsClosed {z : Plane | 0 β€ planarCurl F z} := | |
| isClosed_le continuous_const (planarCurl_contDiff hFs).continuous | |
| have hs : closure ((P : Set Plane)αΆ) β {z : Plane | 0 β€ planarCurl F z} := | |
| closure_minimal (fun z hz => hFc z hz) hc | |
| intro z | |
| apply hs | |
| rw [hd.closure_eq] | |
| exact mem_univ z | |
| have hFlim : Tendsto (fun z => F z (planeRotation z)) (cocompact Plane) | |
| (π (k - β p β P, c p)) := by | |
| apply (hlim.sub (poleSum_tendsto_rotation P c)).congr' | |
| filter_upwards [P.finite_toSet.isCompact.compl_mem_cocompact] with z hz | |
| rw [hFe z hz] | |
| rfl | |
| exact sub_nonneg.mp (nonneg_angular_limit_of_nonneg_curl hFs hFcAll hFlim) | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian (Plane angularOneForm) | |
| theorem realCurve_translate {n : β} (v : β β Phase n) (a : β) : | |
| realCurve (fun z => v (z+a)) = fun z => realCurve v (z+Complex.equivRealProdCLM a) := by | |
| funext z | |
| simp only [realCurve,Function.comp_def,map_add,ContinuousLinearEquiv.symm_apply_apply] | |
| theorem planarPullback_translate {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| (v : Plane β E) (Ξ± : E β E βL[β] β) (a z : Plane) : | |
| planarPullback (fun y => v (y+a)) Ξ± z = planarPullback v Ξ± (z+a) := by | |
| simp only [planarPullback,fderiv_comp_add_right] | |
| theorem tendsto_sub_punctured (p : Plane) : | |
| Tendsto (fun z : Plane => z-p) (π[β ] p) (π[β ] 0) := by | |
| apply tendsto_nhdsWithin_iff.mpr | |
| constructor | |
| Β· have ht : Tendsto (fun z : Plane => z-p) (π p) (π (p-p)) := | |
| (continuous_id.sub continuous_const).continuousAt.tendsto | |
| simpa only [sub_self] using ht.mono_left nhdsWithin_le_nhds | |
| Β· filter_upwards [self_mem_nhdsWithin] with z hz | |
| exact sub_ne_zero.mpr hz | |
| theorem blowup_branch_residue_at {n : β} {v h : β β Phase n} {m : β} {a : β} | |
| (hm : 0 < m) (hh : AnalyticAt β h a) (hh0 : h a β 0) | |
| (he : v =αΆ [π a] fun z : β => (z-a)^m β’ h z) | |
| {Ο Ο : β} (hΟ : 0 < Ο) (hΟΟ : Ο < Ο) : | |
| β Ξ² : Plane β Plane βL[β] β, ContDiffAt β β Ξ² (Complex.equivRealProdCLM a) β§ | |
| βαΆ z in π[β ] (Complex.equivRealProdCLM a), | |
| planarPullback (realCurve v) (blowupPrimitive Ο Ο) z = | |
| ((blowupSize Ο Ο * (m:β)) / (2 * Real.pi)) β’ angularPole (Complex.equivRealProdCLM a) z + Ξ² z := by | |
| have ht : Tendsto (fun z : β => z+a) (π 0) (π a) := by | |
| have ht : Tendsto (fun z : β => z+a) (π 0) (π (0+a)) := | |
| (continuous_id.add continuous_const).continuousAt.tendsto | |
| simpa only [zero_add] using ht | |
| have hh' : AnalyticAt β (fun z : β => h (z+a)) 0 := by | |
| have hh1 : AnalyticAt β h (0+a) := by simpa only [zero_add] using hh | |
| exact hh1.comp (f := fun z : β => z+a) (analyticAt_id.add analyticAt_const) | |
| have hh0' : (fun z : β => h (z+a)) 0 β 0 := by simpa using hh0 | |
| have he' : (fun z : β => v (z+a)) =αΆ [π 0] fun z : β => z^m β’ h (z+a) := by | |
| filter_upwards [ht.eventually he] with z hz | |
| simpa only [add_sub_cancel_right] using hz | |
| obtain β¨Ξ²,hΞ²s,hΞ²eβ© := blowup_branch_residue hm hh' hh0' he' hΟ hΟΟ | |
| let p := Complex.equivRealProdCLM a | |
| refine β¨fun z => Ξ² (z-p),?_,?_β© | |
| Β· have hh : ContDiffAt β β Ξ² (p-p) := by simpa only [sub_self] using hΞ²s | |
| have hs : ContDiffAt β β (fun z : Plane => z-p) p := | |
| contDiffAt_id.sub contDiffAt_const | |
| exact hh.comp p (f := fun z : Plane => z-p) hs | |
| Β· filter_upwards [(tendsto_sub_punctured p).eventually hΞ²e] with z hz | |
| rw [realCurve_translate,planarPullback_translate,sub_add_cancel] at hz | |
| exact hz | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl) | |
| def correctedPrimitive {n : β} (S T : β) (U : Fin 2 β Set (Phase n)) | |
| (f : Fin 2 β Phase n β Phase n) (Ο Ο : Fin 2 β β) (y : Phase n) : Phase n βL[β] β := | |
| radialPrimitiveCLM S T y + chartCorrection (U 0) (f 0) (Ο 0) (Ο 0) y + | |
| chartCorrection (U 1) (f 1) (Ο 1) (Ο 1) y | |
| theorem correctedPrimitive_smoothAt {n : β} {S T : β} (hST : S < T) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| {y : Phase n} (hy : β i, y β f i 0) : | |
| ContDiffAt β β (correctedPrimitive S T U f Ο Ο) y := | |
| ((radialPrimitiveCLM_smooth hST).contDiffAt.add | |
| (chartCorrection_smoothAt (hf 0) (hΟ 0) (hΟΟ 0) (hsub 0) (hy 0))).add | |
| (chartCorrection_smoothAt (hf 1) (hΟ 1) (hΟΟ 1) (hsub 1) (hy 1)) | |
| theorem chartCorrection_extDeriv_zero {n : β} {U : Set (Phase n)} | |
| {f : Phase n β Phase n} (hf : SymplecticOn U f) {Ο Ο : β} | |
| (hΟ : 0 < Ο) (hΟΟ : Ο < Ο) (hsub : closedBall n Ο β U) | |
| {y : Phase n} (hy : y β f '' closedBall n Ο) (v w : Phase n) : | |
| extDeriv (oneForm (chartCorrection U f Ο Ο)) y ![v,w] = 0 := by | |
| rw [oneForm_extDeriv_congr (chartCorrection_zero_near hf hΟ hΟΟ hsub hy)] | |
| change extDeriv (oneForm (fun _ : Phase n => (0 : Phase n βL[β] β))) y ![v,w] = 0 | |
| rw [oneForm_extDeriv_apply (differentiableAt_const _)] | |
| simp | |
| theorem correctedPrimitive_extDeriv {n : β} {S T : β} (hST : S < T) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| {y : Phase n} (hy : β i, y β f i 0) (v w : Phase n) : | |
| extDeriv (oneForm (correctedPrimitive S T U f Ο Ο)) y ![v,w] = | |
| radialForm S T y v w + | |
| extDeriv (oneForm (chartCorrection (U 0) (f 0) (Ο 0) (Ο 0))) y ![v,w] + | |
| extDeriv (oneForm (chartCorrection (U 1) (f 1) (Ο 1) (Ο 1))) y ![v,w] := by | |
| have hr := (radialPrimitiveCLM_smooth hST).differentiable (by simp) y | |
| have hc (i : Fin 2) := | |
| (chartCorrection_smoothAt (hf i) (hΟ i) (hΟΟ i) (hsub i) (hy i)).differentiableAt (by simp) | |
| unfold correctedPrimitive | |
| rw [oneForm_extDeriv_add (hr.fun_add (hc 0)) (hc 1), | |
| oneForm_extDeriv_add hr (hc 0)] | |
| have he : oneForm (@radialPrimitiveCLM n S T) = radialPrimitive S T := rfl | |
| rw [he,radialForm_extDeriv hST] | |
| theorem radialForm_adapted_nonneg {n : β} {S T : β} (hST : S < T) (hT : T < 1) | |
| {J : Phase n β End n} (hJ : β x, Compatible (J x)) | |
| (hout : β x, S < capacity x β J x = standardJ n) (x v : Phase n) : | |
| 0 β€ radialForm S T x v (J x v) := by | |
| by_cases hv : v = 0 | |
| Β· subst v | |
| simp [radialForm,standardForm,stdDot] | |
| Β· exact (radialForm_adapted_pos hST hT hJ hout x hv).le | |
| theorem correctedPrimitive_extDeriv_nonneg {n : β} {S T : β} | |
| (hST : S < T) (hT : T < 1) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| (hdis : Disjoint (f 0 '' closedBall n (Ο 0)) (f 1 '' closedBall n (Ο 1))) | |
| (hcap : β i, MapsTo (f i) (closedBall n (Ο i)) (closedBall n S)) | |
| {J : Phase n β End n} (hJ : β x, Compatible (J x)) | |
| (hout : β x, S < capacity x β J x = standardJ n) | |
| (hJi : β i, β y β f i '' closedBall n (Ο i), J y = imageJ (U i) (f i) y) | |
| {y : Phase n} (hy : β i, y β f i 0) (v : Phase n) : | |
| 0 β€ extDeriv (oneForm (correctedPrimitive S T U f Ο Ο)) y ![v,J y v] := by | |
| rw [correctedPrimitive_extDeriv hST hf hΟ hΟΟ hsub hy] | |
| have hloc (i : Fin 2) (hi : y β f i '' closedBall n (Ο i)) : | |
| radialForm S T y v (J y v) + | |
| extDeriv (oneForm (chartCorrection (U i) (f i) (Ο i) (Ο i))) y ![v,J y v] β₯ 0 := by | |
| have hU : y β f i '' U i := image_mono (hsub i) hi | |
| have hΟy : y β closedBall n S := by | |
| obtain β¨x,hx,rflβ© := hi | |
| exact hcap i hx | |
| have hx : invFunOn (f i) (U i) y β 0 := by | |
| intro he | |
| have hi := invFunOn_eq hU | |
| rw [he] at hi | |
| exact hy i hi.symm | |
| rw [radialForm_standard hST hΟy,chartCorrection_extDeriv (hf i) hU (hy i), | |
| hJi i y hi,inverse_fderiv_intertwines (hf i) hU] | |
| have hn := blowupPrimitive_extDeriv_nonneg (hΟΟ i) hx | |
| (fderiv β (invFunOn (f i) (U i)) y v) | |
| linarith only [hn] | |
| by_cases h0 : y β f 0 '' closedBall n (Ο 0) | |
| Β· have h1 : y β f 1 '' closedBall n (Ο 1) := fun h => disjoint_left.mp hdis h0 h | |
| rw [chartCorrection_extDeriv_zero (hf 1) (hΟ 1) (hΟΟ 1) (hsub 1) h1,add_zero] | |
| exact hloc 0 h0 | |
| Β· rw [chartCorrection_extDeriv_zero (hf 0) (hΟ 0) (hΟΟ 0) (hsub 0) h0,add_zero] | |
| by_cases h1 : y β f 1 '' closedBall n (Ο 1) | |
| Β· exact hloc 1 h1 | |
| Β· rw [chartCorrection_extDeriv_zero (hf 1) (hΟ 1) (hΟΟ 1) (hsub 1) h1,add_zero] | |
| exact radialForm_adapted_nonneg hST hT hJ hout y v | |
| theorem correctedCurve_curl_nonneg {n : β} {S T : β} | |
| (hST : S < T) (hT : T < 1) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| (hdis : Disjoint (f 0 '' closedBall n (Ο 0)) (f 1 '' closedBall n (Ο 1))) | |
| (hcap : β i, MapsTo (f i) (closedBall n (Ο i)) (closedBall n S)) | |
| {J : Phase n β End n} (hJ : β x, Compatible (J x)) | |
| (hout : β x, S < capacity x β J x = standardJ n) | |
| (hJi : β i, β y β f i '' closedBall n (Ο i), J y = imageJ (U i) (f i) y) | |
| {u : β β Phase n} (hu : ContDiff β β u) (hCR : β z, PseudoHolomorphicAt J u z) | |
| {z : Plane} (hz : β i, realCurve u z β f i 0) : | |
| 0 β€ planarCurl (planarPullback (realCurve u) (correctedPrimitive S T U f Ο Ο)) z := by | |
| rw [planarPullback_curlAt (realCurve_smooth hu).contDiffAt | |
| (correctedPrimitive_smoothAt hST hf hΟ hΟΟ hsub hz),realCurve_CR (hCR _)] | |
| exact correctedPrimitive_extDeriv_nonneg hST hT hf hΟ hΟΟ hsub hdis hcap hJ hout hJi hz _ | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian (Plane) | |
| theorem inversePullback_sub {n : β} (U : Set (Phase n)) (f : Phase n β Phase n) | |
| (Ξ± Ξ² : Phase n β Phase n βL[β] β) (y : Phase n) : | |
| inversePullback U f (fun x => Ξ± x - Ξ² x) y = | |
| inversePullback U f Ξ± y - inversePullback U f Ξ² y := by | |
| simp only [inversePullback,ContinuousLinearMap.sub_comp] | |
| theorem correctedPrimitive_centre_remainder {n : β} {S T : β} (hST : S < T) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| (hne : f 0 0 β f 1 0) (i : Fin 2) : | |
| β Ξ³ : Phase n β Phase n βL[β] β, ContDiffAt β β Ξ³ (f i 0) β§ | |
| correctedPrimitive S T U f Ο Ο =αΆ [π (f i 0)] | |
| fun y => inversePullback (U i) (f i) (blowupPrimitive (Ο i) (Ο i)) y + Ξ³ y := by | |
| have h0 (j : Fin 2) : (0 : Phase n) β U j := hsub j (by simpa [closedBall,capacity] using (hΟ j).le) | |
| have hmem (j : Fin 2) : f j 0 β f j '' U j := mem_image_of_mem _ (h0 j) | |
| have hs (j : Fin 2) : ContDiffAt β β (inversePullback (U j) (f j) stdPrimitive) (f j 0) := | |
| inversePullback_smoothAt (hf j) (hmem j) (stdPrimitive_smooth n).contDiffAt | |
| fin_cases i | |
| Β· refine β¨fun y => radialPrimitiveCLM S T y + chartCorrection (U 1) (f 1) (Ο 1) (Ο 1) y - | |
| inversePullback (U 0) (f 0) stdPrimitive y,?_,?_β© | |
| Β· exact ((radialPrimitiveCLM_smooth hST).contDiffAt.add | |
| (chartCorrection_smoothAt (hf 1) (hΟ 1) (hΟΟ 1) (hsub 1) hne)).sub (hs 0) | |
| Β· filter_upwards [chartCorrection_eq_near (hf 0) (hmem 0) (Ο 0) (Ο 0)] with y hy | |
| simp only [Fin.mk_zero,correctedPrimitive,hy,inversePullback_sub] | |
| ext w | |
| simp only [add_apply,sub_apply] | |
| ring | |
| Β· refine β¨fun y => radialPrimitiveCLM S T y + chartCorrection (U 0) (f 0) (Ο 0) (Ο 0) y - | |
| inversePullback (U 1) (f 1) stdPrimitive y,?_,?_β© | |
| Β· exact ((radialPrimitiveCLM_smooth hST).contDiffAt.add | |
| (chartCorrection_smoothAt (hf 0) (hΟ 0) (hΟΟ 0) (hsub 0) hne.symm)).sub (hs 1) | |
| Β· filter_upwards [chartCorrection_eq_near (hf 1) (hmem 1) (Ο 1) (Ο 1)] with y hy | |
| simp only [Fin.mk_one,correctedPrimitive,hy,inversePullback_sub] | |
| ext w | |
| simp only [add_apply,sub_apply] | |
| ring | |
| theorem planarPullback_inverse {n : β} {U : Set (Phase n)} | |
| {f : Phase n β Phase n} (hf : SymplecticOn U f) | |
| {u : β β Phase n} {z : Plane} (hu : DifferentiableAt β (realCurve u) z) | |
| (hz : realCurve u z β f '' U) (Ξ± : Phase n β Phase n βL[β] β) : | |
| planarPullback (realCurve u) (inversePullback U f Ξ±) z = | |
| planarPullback (realCurve (invFunOn f U β u)) Ξ± z := by | |
| have hd := ((symplecticOn_inverse_smooth hf).contDiffAt | |
| ((symplecticOn_open_image hf).mem_nhds hz)).differentiableAt (by simp) | |
| have hc : realCurve (invFunOn f U β u) = invFunOn f U β realCurve u := rfl | |
| rw [hc] | |
| unfold planarPullback inversePullback | |
| rw [fderiv_comp z hd hu] | |
| rfl | |
| theorem planarPullback_add {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| (v : Plane β E) (Ξ± Ξ² : E β E βL[β] β) (z : Plane) : | |
| planarPullback v (fun y => Ξ± y + Ξ² y) z = planarPullback v Ξ± z + planarPullback v Ξ² z := by | |
| simp only [planarPullback,ContinuousLinearMap.add_comp] | |
| theorem correctedPrimitive_centre_residue {n : β} {S T : β} (hST : S < T) | |
| {U : Fin 2 β Set (Phase n)} {f : Fin 2 β Phase n β Phase n} {Ο Ο : Fin 2 β β} | |
| (hf : β i, SymplecticOn (U i) (f i)) (hΟ : β i, 0 < Ο i) | |
| (hΟΟ : β i, Ο i < Ο i) (hsub : β i, closedBall n (Ο i) β U i) | |
| (hne : f 0 0 β f 1 0) | |
| {J : Phase n β End n} {p q : Phase n} {u : β β Phase n} | |
| (hu : AffineLineCurve J p q u) | |
| (hJ : β i, βαΆ y in π (f i 0), J y = imageJ (U i) (f i) y) | |
| (i : Fin 2) {a : β} (ha : u a = f i 0) : | |
| β m : β, 0 < m β§ β Ξ² : Plane β Plane βL[β] β, | |
| ContDiffAt β β Ξ² (Complex.equivRealProdCLM a) β§ | |
| βαΆ z in π[β ] (Complex.equivRealProdCLM a), | |
| planarPullback (realCurve u) (correctedPrimitive S T U f Ο Ο) z = | |
| ((blowupSize (Ο i) (Ο i) * (m:β)) / (2 * Real.pi)) β’ | |
| angularPole (Complex.equivRealProdCLM a) z + Ξ² z := by | |
| have hΟ (j : Fin 2) : 0 < Ο j := (hΟ j).trans (hΟΟ j) | |
| have h0 (j : Fin 2) : (0 : Phase n) β U j := hsub j (by simpa [closedBall,capacity] using (hΟ j).le) | |
| obtain β¨m,v,hm,hvs,hv0,hveβ© := chart_centre_positive_order (hf i) (h0 i) hu.2.1 | |
| (hu.not_constant _) (hJ i) ha | |
| obtain β¨Ξ²,hΞ²s,hΞ²eβ© := blowup_branch_residue_at hm hvs hv0 hve (hΟ i) (hΟΟ i) | |
| obtain β¨Ξ³,hΞ³s,hΞ³eβ© := correctedPrimitive_centre_remainder hST hf hΟ hΟΟ hsub hne i | |
| let b := Complex.equivRealProdCLM a | |
| have hb : realCurve u b = f i 0 := by | |
| change u (Complex.equivRealProdCLM.symm (Complex.equivRealProdCLM a)) = f i 0 | |
| rw [ContinuousLinearEquiv.symm_apply_apply] | |
| exact ha | |
| have hus := realCurve_smooth hu.1 | |
| have hpbΞ³ : ContDiffAt β β (planarPullback (realCurve u) Ξ³) b := | |
| planarPullback_smoothAt hus.contDiffAt (hb.symm βΈ hΞ³s) | |
| refine β¨m,hm,fun z => Ξ² z + planarPullback (realCurve u) Ξ³ z,hΞ²s.add hpbΞ³,?_β© | |
| have hut : Tendsto (realCurve u) (π b) (π (f i 0)) := hb βΈ hus.continuous.tendsto b | |
| have him : βαΆ z in π b, realCurve u z β f i '' U i := hut.eventually | |
| ((symplecticOn_open_image (hf i)).mem_nhds (mem_image_of_mem _ (h0 i))) | |
| filter_upwards [hΞ²e,(hut.eventually hΞ³e).filter_mono nhdsWithin_le_nhds, | |
| him.filter_mono nhdsWithin_le_nhds] with z hzz hΞ³z hiz | |
| have he : planarPullback (realCurve u) (correctedPrimitive S T U f Ο Ο) z = | |
| planarPullback (realCurve u) (inversePullback (U i) (f i) (blowupPrimitive (Ο i) (Ο i))) z + | |
| planarPullback (realCurve u) Ξ³ z := by | |
| unfold planarPullback | |
| rw [hΞ³z,ContinuousLinearMap.add_comp] | |
| rw [he,planarPullback_inverse (hf i) (hus.differentiable (by simp) z) hiz,hzz] | |
| abel | |
| end | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian (Plane) | |
| theorem complex_inv_fderiv_real {z : β} (hz : z β 0) (w : β) : | |
| fderiv β (fun y : β => yβ»ΒΉ) z w = -(z^2)β»ΒΉ * w := by | |
| rw [((hasDerivAt_inv hz).hasFDerivAt.restrictScalars β).fderiv] | |
| change w * (-(z^2)β»ΒΉ) = _ | |
| ring | |
| theorem infinity_curve_fderiv {n : β} {h : β β Phase n} {z : β} | |
| (hz : z β 0) (hh : DifferentiableAt β h zβ»ΒΉ) (w : β) : | |
| fderiv β (fun y : β => y β’ h yβ»ΒΉ) z w = | |
| w β’ h zβ»ΒΉ + z β’ fderiv β h zβ»ΒΉ (-(z^2)β»ΒΉ * w) := by | |
| have hi : DifferentiableAt β (fun y : β => yβ»ΒΉ) z := | |
| (hasDerivAt_inv hz).differentiableAt.restrictScalars β | |
| have hid : DifferentiableAt β (fun y : β => y) z := differentiableAt_id | |
| have hcomp : DifferentiableAt β (fun y : β => h yβ»ΒΉ) z := hh.comp z hi | |
| rw [fderiv_fun_smul hid hcomp] | |
| simp only [add_apply,smul_apply,ContinuousLinearMap.smulRight_apply,fderiv_fun_id, | |
| ContinuousLinearMap.id_apply] | |
| have hder : HasFDerivAt (fun y : β => h yβ»ΒΉ) | |
| ((fderiv β h zβ»ΒΉ).comp (fderiv β (fun y : β => yβ»ΒΉ) z)) z := | |
| hh.hasFDerivAt.comp z hi.hasFDerivAt | |
| rw [hder.fderiv,ContinuousLinearMap.comp_apply,complex_inv_fderiv_real hz] | |
| module | |
| theorem normalizedPrimitive_infinity_curve {n : β} {h : β β Phase n} {z : β} | |
| (hz : z β 0) (hh : DifferentiableAt β h zβ»ΒΉ) (hh0 : h zβ»ΒΉ β 0) : | |
| normalizedPrimitive (z β’ h zβ»ΒΉ) (fderiv β (fun y : β => y β’ h yβ»ΒΉ) z (Complex.I*z)) = | |
| 1 / (2 * Real.pi) + | |
| normalizedPrimitive (h zβ»ΒΉ) (fderiv β h zβ»ΒΉ (-Complex.I*zβ»ΒΉ)) := by | |
| rw [infinity_curve_fderiv hz hh,normalizedPrimitive_smul hz hh0] | |
| have h1 : zβ»ΒΉ * (Complex.I*z) = Complex.I := by field_simp | |
| have h2 : -(z^2)β»ΒΉ * (Complex.I*z) = -Complex.I*zβ»ΒΉ := by field_simp | |
| rw [h1,h2,Complex.I_im] | |
| theorem infinityGerm_curve_eventuallyEq {n : β} (u : β β Phase n) (v : Phase n) : | |
| u =αΆ [cocompact β] fun z : β => z β’ infinityGerm u v zβ»ΒΉ := by | |
| filter_upwards [(isCompact_singleton (x := (0:β))).compl_mem_cocompact] with z hz | |
| have hz' : z β 0 := hz | |
| simp only [infinityGerm,inv_ne_zero hz',ite_false,inv_inv,smul_smul, | |
| mul_inv_cancelβ hz',one_smul] | |
| theorem normalizedPrimitive_infinity_limit {n : β} {u : β β Phase n} {v : Phase n} | |
| (hv : v β 0) (hh : AnalyticAt β (infinityGerm u v) 0) : | |
| Tendsto (fun z : β => normalizedPrimitive (u z) (fderiv β u z (Complex.I*z))) | |
| (cocompact β) (π (1 / (2 * Real.pi))) := by | |
| let h := infinityGerm u v | |
| have hh0 : h 0 β 0 := by simpa [h,infinityGerm] using hv | |
| have hi : Tendsto (fun z : β => zβ»ΒΉ) (cocompact β) (π 0) := by | |
| simpa only [βMetric.cobounded_eq_cocompact] using (tendsto_invβ_cobounded (Ξ± := β)) | |
| have hc : ContDiffAt β β h 0 := hh.contDiffAt.restrict_scalars β | |
| have hdh : Tendsto (fun z : β => fderiv β h zβ»ΒΉ) (cocompact β) (π (fderiv β h 0)) := | |
| (hc.fderiv_right (m := 0) (by simp)).continuousAt.tendsto.comp hi | |
| have harg : Tendsto (fun z : β => -Complex.I*zβ»ΒΉ) (cocompact β) (π 0) := by | |
| simpa using hi.const_mul (-Complex.I) | |
| have hvec : Tendsto (fun z : β => fderiv β h zβ»ΒΉ (-Complex.I*zβ»ΒΉ)) | |
| (cocompact β) (π 0) := by | |
| simpa only [Function.comp_def,map_zero] using (continuous_fst.clm_apply continuous_snd).continuousAt.tendsto.comp (hdh.prodMk_nhds harg) | |
| have hprim : Tendsto (fun z : β => normalizedPrimitive (h zβ»ΒΉ)) | |
| (cocompact β) (π (normalizedPrimitive (h 0))) := | |
| (normalizedPrimitive_smoothAt hh0).continuousAt.tendsto.comp (hc.continuousAt.tendsto.comp hi) | |
| have hl : Tendsto (fun z : β => 1 / (2 * Real.pi) + | |
| normalizedPrimitive (h zβ»ΒΉ) (fderiv β h zβ»ΒΉ (-Complex.I*zβ»ΒΉ))) | |
| (cocompact β) (π (1 / (2 * Real.pi))) := by | |
| simpa only [Function.comp_def,map_zero,add_zero] using ((continuous_fst.clm_apply continuous_snd).continuousAt.tendsto.comp (hprim.prodMk_nhds hvec)).const_add (1 / (2 * Real.pi)) | |
| apply hl.congr' | |
| have he := infinityGerm_curve_eventuallyEq u v | |
| have hnear : βαΆ z in cocompact β, u =αΆ [π z] fun y : β => y β’ h yβ»ΒΉ := by | |
| filter_upwards [(isCompact_singleton (x := (0:β))).compl_mem_cocompact] with z hz | |
| filter_upwards [isClosed_singleton.isOpen_compl.mem_nhds hz] with y hy | |
| have hy' : y β 0 := hy | |
| simp only [h,infinityGerm,inv_ne_zero hy',ite_false,inv_inv,smul_smul, | |
| mul_inv_cancelβ hy',one_smul] | |
| have hn : βαΆ w in π (0:β), h w β 0 := | |
| hc.continuousAt.eventually (isClosed_singleton.isOpen_compl.mem_nhds hh0) | |
| have hd : βαΆ w in π (0:β), DifferentiableAt β h w := | |
| hh.eventually_analyticAt.mono fun _ hx => hx.differentiableAt.restrictScalars β | |
| filter_upwards [hnear,hi.eventually hn,hi.eventually hd, | |
| (isCompact_singleton (x := (0:β))).compl_mem_cocompact] with z hez hnz hdz hz | |
| rw [hez.self_of_nhds,hez.fderiv_eq] | |
| exact (normalizedPrimitive_infinity_curve hz hdz hnz).symm | |
| theorem equivRealProd_rotation (z : Plane) : | |
| Complex.equivRealProdCLM.symm (planeRotation z) = | |
| Complex.I * Complex.equivRealProdCLM.symm z := by | |
| apply Complex.ext <;> simp [planeRotation,Complex.equivRealProdCLM_symm_apply] | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |