Download data/lean/OAI/Geometry/BallPacking/Necessity/Properness.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 39.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/Properness.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/Properness.lean
-
curl -L -o Properness.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/Properness.lean
39.5 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.AffineSlopes | |
| import OAI.Geometry.BallPacking.Necessity.TangentLimits | |
| namespace OAI | |
| noncomputable section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| open Set Function MeasureTheory | |
| open Set Function | |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl) | |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm radiusSq planarArea planarArea_apply) | |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm) | |
| open SymplecticBallPacking.Hamiltonian (Plane angularOneForm) | |
| open SymplecticBallPacking.Hamiltonian | |
| open SymplecticBallPacking.Hamiltonian (Plane) | |
| open Set Filter Function | |
| open Set Filter MeasureTheory | |
| open scoped Topology | |
| open Set Filter Finset | |
| open scoped ContDiff Topology Classical | |
| open Set Filter | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open Set Function Filter Topology | |
| open scoped NNReal | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Function | |
| open scoped Topology ContDiff | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| theorem projection_mean_double_bound {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) (β : Phase n βL[β] β) | |
| (hβ : β a, (β a)^2 β€ stdDot n a a) | |
| (hi : Integrable (planarDirichlet v)) {D : β} (hD : (β« z, planarDirichlet v z) β€ D) | |
| (c : Plane) {r : β} (hr : 0 < r) : | |
| |squareMean (fun z => β (v z)) c r-squareMean (fun z => β (v z)) c (2*r)| β€ | |
| 4*Real.sqrt D := by | |
| have hh : |squareMean (fun z => β (v z)) c ((2*r)/2)- | |
| squareMean (fun z => β (v z)) c (2*r)| β€ 4*Real.sqrt (squareEnergy v c (2*r)) := by | |
| apply squareMean_half_bound (β.continuous.comp hv.continuous) | |
| (β.continuous.comp (planar_partial_continuous hv (1,0))) | |
| (β.continuous.comp (planar_partial_continuous hv (0,1))) (planarDirichlet_continuous hv) | |
| Β· intro x y | |
| exact β.hasFDerivAt.comp_hasDerivAt x | |
| ((hv.differentiable (by simp) (x,y)).hasFDerivAt.comp_hasDerivAt x | |
| ((hasDerivAt_id x).prodMk (hasDerivAt_const x y))) | |
| Β· intro x y | |
| exact β.hasFDerivAt.comp_hasDerivAt y | |
| ((hv.differentiable (by simp) (x,y)).hasFDerivAt.comp_hasDerivAt y | |
| ((hasDerivAt_const y x).prodMk (hasDerivAt_id y))) | |
| Β· intro z | |
| exact (hβ _).trans (le_add_of_nonneg_right (stdDot_nonneg _)) | |
| Β· intro z | |
| exact (hβ _).trans (le_add_of_nonneg_left (stdDot_nonneg _)) | |
| Β· positivity | |
| rw [show (2*r)/2=r by ring] at hh | |
| have hb : squareEnergy v c (2*r) β€ D := | |
| (setIntegral_le_integral hi (Eventually.of_forall (planarDirichlet_nonneg v))).trans hD | |
| exact hh.trans (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hb) (by norm_num)) | |
| theorem projection_mean_grow_bound {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) (β : Phase n βL[β] β) | |
| (hβ : β a, (β a)^2 β€ stdDot n a a) | |
| (hi : Integrable (planarDirichlet v)) {D : β} (hD : (β« z, planarDirichlet v z) β€ D) | |
| (c : Plane) (k : β) : | |
| |squareMean (fun z => β (v z)) c 1-squareMean (fun z => β (v z)) c ((2:β)^k)| β€ | |
| 4*(k:β)*Real.sqrt D := by | |
| induction k with | |
| | zero => simp | |
| | succ k ih => | |
| have hh := projection_mean_double_bound hv β hβ hi hD c (show 0 < (2:β)^k by positivity) | |
| have ht := abs_sub_le (squareMean (fun z => β (v z)) c 1) | |
| (squareMean (fun z => β (v z)) c ((2:β)^k)) | |
| (squareMean (fun z => β (v z)) c ((2:β)^(k+1))) | |
| have he : (2:β)^(k+1)=2*(2:β)^k := by rw [pow_succ]; ring | |
| rw [he] at ht β’ | |
| rw [Nat.cast_add,Nat.cast_one] | |
| linarith | |
| theorem projection_error_point_bound {n : β} {u : β β Phase n} | |
| (hu : ContDiff β β u) {C : β} (hC : 0 β€ C) | |
| (hE : β z, planarDirichlet (realCurve u) z β€ C * standardForm | |
| (fderiv β (realCurve u) z (1,0)) (fderiv β (realCurve u) z (0,1))) | |
| (a : Phase n) (hi : Integrable (dirichletDensity (affineError u a))) {D : β} | |
| (hD : (β« z, dirichletDensity (affineError u a) z) β€ D) (hD0 : 0 β€ D) | |
| (β : Phase n βL[β] β) (hβ : β v, (β v)^2 β€ stdDot n v v) (c : Plane) : | |
| |β (realCurve (affineError u a) c)-squareMean (fun z => β (realCurve (affineError u a) z)) c 1| β€ | |
| morreyConstant C*(4*euclideanNorm a+2*Real.sqrt D) := by | |
| have hp := projection_point_bound (realCurve_smooth hu) hC hE β hβ c (by norm_num : (0:β)<1) | |
| have hb := sqrt_squareEnergy_le_affineError hu a hi hD hD0 c (by norm_num : (0:β)β€1) | |
| simp only [mul_one] at hb | |
| have hh := hp.trans (mul_le_mul_of_nonneg_left hb (morreyConstant_pos hC).le) | |
| rw [projection_squareMean_error hu a β c (by norm_num : (0:β)<1)] | |
| have he : β (realCurve (affineError u a) c) = β (realCurve u c)-β (realCurve (fun z : β => z β’ a) c) := | |
| β.map_sub _ _ | |
| rw [he,sub_sub_sub_cancel_right] | |
| exact hh | |
| theorem affine_error_log_bound {n : β} {u : β β Phase n} | |
| (hu : ContDiff β β u) {C : β} (hC : 0 β€ C) | |
| (hE : β z, planarDirichlet (realCurve u) z β€ C * standardForm | |
| (fderiv β (realCurve u) z (1,0)) (fderiv β (realCurve u) z (0,1))) | |
| (a : Phase n) (hi : Integrable (dirichletDensity (affineError u a))) {D : β} | |
| (hD : (β« z, dirichletDensity (affineError u a) z) β€ D) (hD0 : 0 β€ D) | |
| {p : Phase n} (hp : u 0=p) (c : Plane) (k : β) | |
| (hc1 : |c.1| β€ (2:β)^k) (hc2 : |c.2| β€ (2:β)^k) : | |
| euclideanNorm (realCurve (affineError u a) c-p) β€ | |
| 2*morreyConstant C*(4*euclideanNorm a+2*Real.sqrt D)+(8*(k:β)+4)*Real.sqrt D := by | |
| let v := realCurve (affineError u a) | |
| let β := phaseProjection (v c-p) | |
| have hβ := phaseProjection_sq_le (v c-p) | |
| have hv := realCurve_smooth (affineError_smooth hu a) | |
| have hp0 : v 0 = p := by change u 0-(0:β) β’ a=p; simpa using hp | |
| have h0p := projection_error_point_bound hu hC hE a hi hD hD0 β hβ 0 | |
| have hcp := projection_error_point_bound hu hC hE a hi hD hD0 β hβ c | |
| change |β (v 0)-squareMean (fun z => β (v z)) 0 1| β€ _ at h0p | |
| rw [hp0] at h0p | |
| have h0g := projection_mean_grow_bound hv β hβ hi hD 0 k | |
| have hcg := projection_mean_grow_bound hv β hβ hi hD c k | |
| have ht := projection_translate_bound hv β hβ hi hD c | |
| (show 0 β€ (2:β)^k by positivity) (show 0 < (2:β)^k by positivity) hc1 hc2 | |
| have hcst : 2*((2:β)^k+(2:β)^k)/(2:β)^k=4 := by | |
| have hn : (2:β)^k β 0 := by positivity | |
| field_simp | |
| ring | |
| rw [hcst] at ht | |
| have he : β (v c)-β p = euclideanNorm (v c-p) := by rw [βmap_sub]; exact phaseProjection_self _ | |
| have hh1 := (abs_le.mp h0p).1 | |
| have hh2 := (abs_le.mp hcp).2 | |
| have hh3 := (abs_le.mp h0g).1 | |
| have hh4 := (abs_le.mp hcg).2 | |
| have hh5 := (abs_le.mp ht).2 | |
| change euclideanNorm (v c-p) β€ _ | |
| linarith | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem euclideanNorm_complex_smul {n : β} (z : β) (a : Phase n) : | |
| euclideanNorm (z β’ a) = βzβ*euclideanNorm a := by | |
| change β(PiLp.continuousLinearEquiv 2 β (fun _ : Fin n => β)).symm (z β’ a)β = _ | |
| have he : (PiLp.continuousLinearEquiv 2 β (fun _ : Fin n => β)).symm (z β’ a) = | |
| z β’ (PiLp.continuousLinearEquiv 2 β (fun _ : Fin n => β)).symm a := by | |
| ext i | |
| rfl | |
| rw [he,norm_smul] | |
| rfl | |
| theorem euclideanNorm_neg {n : β} (a : Phase n) : euclideanNorm (-a) = euclideanNorm a := by | |
| simp only [euclideanNorm,map_neg,norm_neg] | |
| theorem affine_reverse_bound {n : β} (u : β β Phase n) (a p : Phase n) (z : β) : | |
| βzβ*euclideanNorm a β€ euclideanNorm (u z)+euclideanNorm (affineError u a z-p)+euclideanNorm p := by | |
| have hh := euclideanNorm_add_le (u z) (-(affineError u a z)) | |
| have he : u z + -(affineError u a z) = z β’ a := by simp only [affineError]; abel | |
| rw [he,euclideanNorm_neg,euclideanNorm_complex_smul] at hh | |
| have hh2 := euclideanNorm_add_le (affineError u a z-p) p | |
| rw [sub_add_cancel] at hh2 | |
| linarith | |
| theorem exists_linear_lt_dyadic {m : β} (hm : 0 < m) (b h : β) : | |
| β N : β, β k β₯ N, b+h*((k:β)+1) < m*(2:β)^k := by | |
| have h0 := tendsto_pow_const_div_const_pow_of_one_lt 0 (by norm_num : (1:β)<2) | |
| have h1 := tendsto_pow_const_div_const_pow_of_one_lt 1 (by norm_num : (1:β)<2) | |
| have ht : Tendsto (fun k : β => (b+h*((k:β)+1))/(2:β)^k) atTop (π 0) := by | |
| have hh := (h0.const_mul (b+h)).add (h1.const_mul h) | |
| convert hh using 1 | |
| Β· ext k | |
| simp only [pow_zero,pow_one] | |
| ring | |
| Β· simp | |
| have he : βαΆ k : β in atTop, (b+h*((k:β)+1))/(2:β)^k < m := | |
| ht.eventually (eventually_lt_nhds hm) | |
| obtain β¨N,hNβ© := eventually_atTop.mp he | |
| refine β¨N,fun k hk => ?_β© | |
| exact (div_lt_iffβ (by positivity)).mp (hN k hk) | |
| theorem homotopy_uniform_properness (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) (B : β) : | |
| β S > 0, β t β Icc (0:β) 1, β u : β β Phase n, | |
| AffineLineCurve (lineHomotopy J t) p q u β | |
| β z : β, S < βzβ β B < euclideanNorm (u z) := by | |
| obtain β¨D,hD,hDbβ© := homotopy_affine_error_energy n hn J hJs hJ hc hs p q hpq | |
| obtain β¨C,hC,hCbβ© := homotopy_standard_energy_bound hJs hJ hc | |
| obtain β¨j,hjβ© := exists_morrey_scale hC.le | |
| let L := 2*(euclideanNorm (q-p)+(1+2*(1+(1/2:β)^j)/((1/2:β)^j))*Real.sqrt D) | |
| let E := 2*morreyConstant C*(4*L+2*Real.sqrt D)+4*Real.sqrt D | |
| obtain β¨m,hm,hmbβ© := homotopy_slopes_bounded_below n hn J hJs hJ hc hs p q hpq | |
| obtain β¨N,hNβ© := exists_linear_lt_dyadic hm (B+E+euclideanNorm p) (8*Real.sqrt D) | |
| refine β¨(2:β)^N,by positivity,?_β© | |
| intro t ht u hu z hz | |
| obtain β¨a,ha,hal,hai,haDβ© := hDb t ht u hu | |
| obtain β¨a',ha',hal'β© := hmb t ht u hu | |
| have heq : a'=a := tendsto_nhds_unique hal' hal | |
| rw [heq] at ha' | |
| have hE (w : Plane) : planarDirichlet (realCurve u) w β€ C * standardForm | |
| (fderiv β (realCurve u) w (1,0)) (fderiv β (realCurve u) w (0,1)) := by | |
| change stdDot n _ _+stdDot n _ _ β€ _ | |
| rw [realCurve_CR (hu.2.1 _)] | |
| exact hCb t ht _ _ | |
| have hL : euclideanNorm a β€ L := affine_slope_bound hu.1 hC.le hE a hai haD hD.le | |
| hu.2.2.1 hu.2.2.2.1 j hj | |
| have hz1 : 1 β€ βzβ := (one_le_powβ (by norm_num : (1:β)β€2)).trans hz.le | |
| obtain β¨k,hk0,hk1β© := exists_nat_pow_near hz1 (by norm_num : (1:β)<2) | |
| have hkN : N β€ k := by | |
| by_contra hh | |
| have hh' : k+1 β€ N := Nat.succ_le_iff.mpr (Nat.lt_of_not_ge hh) | |
| have hp := pow_le_pow_rightβ (by norm_num : (1:β)β€2) hh' | |
| linarith | |
| have hc1 : |z.re| β€ (2:β)^(k+1) := z.abs_re_le_norm.trans hk1.le | |
| have hc2 : |z.im| β€ (2:β)^(k+1) := z.abs_im_le_norm.trans hk1.le | |
| have hb := affine_error_log_bound hu.1 hC.le hE a hai haD hD.le hu.2.2.1 | |
| (z.re,z.im) (k+1) hc1 hc2 | |
| have hreal : realCurve (affineError u a) (z.re,z.im) = affineError u a z := by | |
| change affineError u a (Complex.equivRealProdCLM.symm (Complex.equivRealProdCLM z)) = _ | |
| rw [ContinuousLinearEquiv.symm_apply_apply] | |
| rw [hreal,Nat.cast_add,Nat.cast_one] at hb | |
| have hb' : euclideanNorm (affineError u a z-p) β€ E+8*Real.sqrt D*((k:β)+1) := by | |
| have hM := morreyConstant_pos hC.le | |
| dsimp [E] | |
| nlinarith | |
| have hr := affine_reverse_bound u a p z | |
| have hh := hN k hkN | |
| have hmz := mul_le_mul_of_nonneg_left ha' (norm_nonneg z) | |
| have hmk := mul_le_mul_of_nonneg_left hk0 hm.le | |
| nlinarith | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem homotopy_slopes_bounded_above (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) : | |
| β L : β, β t β Icc (0:β) 1, β u : β β Phase n, | |
| AffineLineCurve (lineHomotopy J t) p q u β β a : Phase n, | |
| Tendsto (fun z : β => zβ»ΒΉ β’ u z) (cocompact β) (π a) β euclideanNorm a β€ L := by | |
| obtain β¨D,hD,hDbβ© := homotopy_affine_error_energy n hn J hJs hJ hc hs p q hpq | |
| obtain β¨C,hC,hCbβ© := homotopy_standard_energy_bound hJs hJ hc | |
| obtain β¨j,hjβ© := exists_morrey_scale hC.le | |
| refine β¨2*(euclideanNorm (q-p)+(1+2*(1+(1/2:β)^j)/((1/2:β)^j))*Real.sqrt D),?_β© | |
| intro t ht u hu a hal | |
| obtain β¨a',ha',hal',hai,haDβ© := hDb t ht u hu | |
| have heq : a'=a := tendsto_nhds_unique hal' hal | |
| subst a' | |
| have hE (w : Plane) : planarDirichlet (realCurve u) w β€ C * standardForm | |
| (fderiv β (realCurve u) w (1,0)) (fderiv β (realCurve u) w (0,1)) := by | |
| change stdDot n _ _+stdDot n _ _ β€ _ | |
| rw [realCurve_CR (hu.2.1 _)] | |
| exact hCb t ht _ _ | |
| exact affine_slope_bound hu.1 hC.le hE a hai haD hD.le hu.2.2.1 hu.2.2.2.1 j hj | |
| theorem homotopy_uniform_asymptotic (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) (Ξ΅ : β) (hΞ΅ : 0 < Ξ΅) : | |
| β S > 0, β t β Icc (0:β) 1, β u : β β Phase n, | |
| AffineLineCurve (lineHomotopy J t) p q u β β a : Phase n, | |
| Tendsto (fun z : β => zβ»ΒΉ β’ u z) (cocompact β) (π a) β | |
| β z : β, S < βzβ β euclideanNorm (zβ»ΒΉ β’ u z-a) < Ξ΅ := by | |
| obtain β¨D,hD,hDbβ© := homotopy_affine_error_energy n hn J hJs hJ hc hs p q hpq | |
| obtain β¨C,hC,hCbβ© := homotopy_standard_energy_bound hJs hJ hc | |
| obtain β¨L,hLbβ© := homotopy_slopes_bounded_above n hn J hJs hJ hc hs p q hpq | |
| let E := 2*morreyConstant C*(4*L+2*Real.sqrt D)+4*Real.sqrt D | |
| obtain β¨N,hNβ© := exists_linear_lt_dyadic hΞ΅ (E+euclideanNorm p) (8*Real.sqrt D) | |
| refine β¨(2:β)^N,by positivity,?_β© | |
| intro t ht u hu a hal z hz | |
| obtain β¨a',ha',hal',hai,haDβ© := hDb t ht u hu | |
| have heq : a'=a := tendsto_nhds_unique hal' hal | |
| subst a' | |
| have hE (w : Plane) : planarDirichlet (realCurve u) w β€ C * standardForm | |
| (fderiv β (realCurve u) w (1,0)) (fderiv β (realCurve u) w (0,1)) := by | |
| change stdDot n _ _+stdDot n _ _ β€ _ | |
| rw [realCurve_CR (hu.2.1 _)] | |
| exact hCb t ht _ _ | |
| have hL := hLb t ht u hu a hal | |
| have hz1 : 1 β€ βzβ := (one_le_powβ (by norm_num : (1:β)β€2)).trans hz.le | |
| have hz0 : z β 0 := norm_pos_iff.mp (by linarith) | |
| obtain β¨k,hk0,hk1β© := exists_nat_pow_near hz1 (by norm_num : (1:β)<2) | |
| have hkN : N β€ k := by | |
| by_contra hh | |
| have hh' : k+1 β€ N := Nat.succ_le_iff.mpr (Nat.lt_of_not_ge hh) | |
| have hp := pow_le_pow_rightβ (by norm_num : (1:β)β€2) hh' | |
| linarith | |
| have hb := affine_error_log_bound hu.1 hC.le hE a hai haD hD.le hu.2.2.1 | |
| (z.re,z.im) (k+1) (z.abs_re_le_norm.trans hk1.le) (z.abs_im_le_norm.trans hk1.le) | |
| have hreal : realCurve (affineError u a) (z.re,z.im) = affineError u a z := by | |
| change affineError u a (Complex.equivRealProdCLM.symm (Complex.equivRealProdCLM z)) = _ | |
| rw [ContinuousLinearEquiv.symm_apply_apply] | |
| rw [hreal,Nat.cast_add,Nat.cast_one] at hb | |
| have hb' : euclideanNorm (affineError u a z-p) β€ E+8*Real.sqrt D*((k:β)+1) := by | |
| have hM := morreyConstant_pos hC.le | |
| dsimp [E] | |
| nlinarith | |
| have hw := euclideanNorm_add_le (affineError u a z-p) p | |
| rw [sub_add_cancel] at hw | |
| have hh := hN k hkN | |
| have hmk := mul_le_mul_of_nonneg_left hk0 hΞ΅.le | |
| have hb'' : euclideanNorm (affineError u a z) < Ξ΅*βzβ := by linarith | |
| have he : zβ»ΒΉ β’ u z-a = zβ»ΒΉ β’ affineError u a z := by | |
| simp only [affineError,smul_sub,smul_smul,inv_mul_cancelβ hz0,one_smul] | |
| rw [he,euclideanNorm_complex_smul,norm_inv,inv_mul_eq_div] | |
| exact (div_lt_iffβ (norm_pos_iff.mpr hz0)).mpr hb'' | |
| theorem homotopy_limit_has_nonzero_asymptotic (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) | |
| (u : β β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) | |
| (v : β β Phase n) (hv : β z, Tendsto (fun j => u j z) atTop (π (v z))) : | |
| β a : Phase n, a β 0 β§ Tendsto (fun z : β => zβ»ΒΉ β’ v z) (cocompact β) (π a) := by | |
| classical | |
| choose a ha hal using fun j => (hu j).2.2.2.2 | |
| obtain β¨L,hLbβ© := homotopy_slopes_bounded_above n hn J hJs hJ hc hs p q hpq | |
| obtain β¨m,hm,hmbβ© := homotopy_slopes_bounded_below n hn J hJs hJ hc hs p q hpq | |
| have ham (j : β) : m β€ euclideanNorm (a j) := by | |
| obtain β¨a',ha',hal'β© := hmb (t j) (ht j) (u j) (hu j) | |
| have he : a'=a j := tendsto_nhds_unique hal' (hal j) | |
| simpa only [he] using ha' | |
| have haL (j : β) : euclideanNorm (a j) β€ L := hLb (t j) (ht j) (u j) (hu j) (a j) (hal j) | |
| obtain β¨b,hb,Ο,hΟ,hΟbβ© := (isCompact_closedBall (0 : EuclideanSpace β (Fin n)) L).tendsto_subseq | |
| (x := fun j => phaseEuclidean n (a j)) (fun j => by simpa only [Metric.mem_closedBall,dist_zero_right,euclideanNorm] using haL j) | |
| let aβ := (phaseEuclidean n).symm b | |
| have hΟa : Tendsto (a β Ο) atTop (π aβ) := by | |
| simpa only [Function.comp_def,ContinuousLinearEquiv.symm_apply_apply] using | |
| (phaseEuclidean n).symm.continuous.continuousAt.tendsto.comp hΟb | |
| have hma : m β€ euclideanNorm aβ := ge_of_tendsto | |
| (((phaseEuclidean n).continuous.continuousAt.tendsto.comp hΟa).norm) | |
| (Eventually.of_forall fun j => ham (Ο j)) | |
| have haβ : aβ β 0 := by | |
| intro he | |
| have hz : euclideanNorm aβ=0 := by simp [he,euclideanNorm] | |
| linarith | |
| refine β¨aβ,haβ,?_β© | |
| have htail : β Ξ΅ > 0, β S > 0, β z : β, S < βzβ β euclideanNorm (zβ»ΒΉ β’ v z-aβ) < Ξ΅ := by | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨S,hS,hSbβ© := homotopy_uniform_asymptotic n hn J hJs hJ hc hs p q hpq | |
| (Ξ΅/2) (by linarith) | |
| refine β¨S,hS,?_β© | |
| intro z hz | |
| have hconv : Tendsto (fun j => zβ»ΒΉ β’ u (Ο j) z-a (Ο j)) atTop (π (zβ»ΒΉ β’ v z-aβ)) := | |
| ((hv z).comp hΟ.tendsto_atTop).const_smul zβ»ΒΉ |>.sub hΟa | |
| have hnconv := ((phaseEuclidean n).continuous.continuousAt.tendsto.comp hconv).norm | |
| have hle : euclideanNorm (zβ»ΒΉ β’ v z-aβ) β€ Ξ΅/2 := le_of_tendsto hnconv | |
| (Eventually.of_forall fun j => (hSb (t (Ο j)) (ht (Ο j)) (u (Ο j)) (hu (Ο j)) | |
| (a (Ο j)) (hal (Ο j)) z hz).le) | |
| linarith | |
| have hconv : Tendsto (fun z : β => phaseEuclidean n (zβ»ΒΉ β’ v z)) (cocompact β) | |
| (π (phaseEuclidean n aβ)) := by | |
| apply Metric.tendsto_nhds.mpr | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨S,hS,hSbβ© := htail Ξ΅ hΞ΅ | |
| filter_upwards [tendsto_norm_cocompact_atTop.eventually (eventually_gt_atTop S)] with z hz | |
| rw [dist_eq_norm,βmap_sub] | |
| exact hSb z hz | |
| simpa only [Function.comp_def,ContinuousLinearEquiv.symm_apply_apply] using | |
| (phaseEuclidean n).symm.continuous.continuousAt.tendsto.comp hconv | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem lineMean_add_right (f : β β β) (a b d : β) : | |
| lineMean (fun x => f (x+d)) a b = lineMean f (a+d) (b+d) := by | |
| simp only [lineMean,intervalIntegral.integral_comp_add_right] | |
| congr 1 | |
| ring | |
| theorem squareMean_translate (f : Plane β β) (c d : Plane) (r : β) : | |
| squareMean (fun z => f (z+d)) c r = squareMean f (c+d) r := by | |
| simp only [squareMean,rectangleMean,Prod.fst_add,Prod.snd_add] | |
| have he (y : β) : lineMean (fun x => f ((x,y)+d)) (c.1-r) (c.1+r) = | |
| lineMean (fun x => f (x,y+d.2)) (c.1+d.1-r) (c.1+d.1+r) := by | |
| change lineMean (fun x => f (x+d.1,y+d.2)) _ _ = _ | |
| rw [lineMean_add_right (fun x => f (x,y+d.2))] | |
| congr 1 <;> ring | |
| simp_rw [he] | |
| rw [lineMean_add_right (fun y => lineMean (fun x => f (x,y)) (c.1+d.1-r) (c.1+d.1+r))] | |
| congr 1 <;> ring | |
| theorem squareMean_eq_integral {f : Plane β β} (hf : Continuous f) (c : Plane) | |
| {r : β} (hr : 0 < r) : | |
| squareMean f c r = (β« z in planeSquare c r, f z)/(4*r^2) := by | |
| rw [squareMean,rectangleMean_eq_integral hf β¨by dsimp; linarith,by dsimp; linarithβ©] | |
| congr 1 | |
| dsimp | |
| ring | |
| theorem squareIntegral_translate {f : Plane β β} (hf : Continuous f) (c d : Plane) | |
| {r : β} (hr : 0 < r) : | |
| (β« z in planeSquare c r, f (z+d)) = β« z in planeSquare (c+d) r, f z := by | |
| have he := squareMean_translate f c d r | |
| have hsh : Continuous (fun z : Plane => f (z+d)) := hf.comp (continuous_id.add continuous_const) | |
| rw [squareMean_eq_integral hsh c hr, | |
| squareMean_eq_integral hf (c+d) hr] at he | |
| exact (div_left_inj' (by positivity : (4:β)*r^2 β 0)).mp he | |
| theorem fderiv_plane_translate {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) (d z : Plane) : | |
| fderiv β (fun w => v (w+d)) z = fderiv β v (z+d) := by | |
| have ht := ((hv.differentiable (by simp) (z+d)).hasFDerivAt.comp z | |
| ((hasFDerivAt_id z).add_const d)).fderiv | |
| simpa only [Function.comp_def,id_eq,ContinuousLinearMap.comp_id] using ht | |
| theorem planarDirichlet_translate {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) (d z : Plane) : | |
| planarDirichlet (fun w => v (w+d)) z = planarDirichlet v (z+d) := by | |
| simp only [planarDirichlet,fderiv_plane_translate hv] | |
| theorem squareEnergy_translate {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) (c d : Plane) {r : β} (hr : 0 < r) : | |
| squareEnergy (fun w => v (w+d)) c r = squareEnergy v (c+d) r := by | |
| simp only [squareEnergy,planarDirichlet_translate hv] | |
| exact squareIntegral_translate (planarDirichlet_continuous hv) c d hr | |
| theorem point_distance_le_energy_zero {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) {C : β} (hC : 0 β€ C) | |
| (hE : β z, planarDirichlet v z β€ C * standardForm | |
| (fderiv β v z (1,0)) (fderiv β v z (0,1))) (c : Plane) {r : β} (hr : 0 < r) | |
| (hc1 : |c.1| β€ r) (hc2 : |c.2| β€ r) : | |
| euclideanNorm (v c-v 0) β€ (2*morreyConstant C+4)*Real.sqrt (squareEnergy v 0 (2*r)) := by | |
| let β := phaseProjection (v c-v 0) | |
| have hβ := phaseProjection_sq_le (v c-v 0) | |
| have h0 := projection_point_bound hv hC hE β hβ 0 hr | |
| have h1 := projection_point_bound hv hC hE β hβ c hr | |
| have hb0 : squareEnergy v 0 r β€ squareEnergy v 0 (2*r) := squareEnergy_mono hv 0 (by linarith) | |
| have hb1 : squareEnergy v c r β€ squareEnergy v 0 (2*r) := by | |
| simpa only [show r+r=2*r by ring] using squareEnergy_le_origin hv (r := r) hc1 hc2 | |
| have h0' := h0.trans (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hb0) (morreyConstant_pos hC).le) | |
| have h1' := h1.trans (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hb1) (morreyConstant_pos hC).le) | |
| have ht := projection_translate_local_bound hv β hβ c hr.le hr | |
| (le_refl (squareEnergy v 0 (r+r))) hc1 hc2 | |
| rw [show r+r=2*r by ring,show 2*(2*r)/r=4 by field_simp; ring] at ht | |
| have he : β (v c)-β (v 0) = euclideanNorm (v c-v 0) := by | |
| rw [βmap_sub] | |
| exact phaseProjection_self _ | |
| have h01 := (abs_le.mp h0').1 | |
| have h11 := (abs_le.mp h1').2 | |
| have ht1 := (abs_le.mp ht).2 | |
| linarith | |
| theorem point_distance_le_energy {n : β} {v : Plane β Phase n} | |
| (hv : ContDiff β β v) {C : β} (hC : 0 β€ C) | |
| (hE : β z, planarDirichlet v z β€ C * standardForm | |
| (fderiv β v z (1,0)) (fderiv β v z (0,1))) (c d : Plane) {r : β} (hr : 0 < r) | |
| (hc1 : |c.1-d.1| β€ r) (hc2 : |c.2-d.2| β€ r) : | |
| euclideanNorm (v c-v d) β€ (2*morreyConstant C+4)*Real.sqrt (squareEnergy v d (2*r)) := by | |
| have hvs : ContDiff β β (fun w => v (w+d)) := hv.comp (contDiff_id.add contDiff_const) | |
| have hEs (z : Plane) : planarDirichlet (fun w => v (w+d)) z β€ C * standardForm | |
| (fderiv β (fun w => v (w+d)) z (1,0)) (fderiv β (fun w => v (w+d)) z (0,1)) := by | |
| simp only [planarDirichlet_translate hv,fderiv_plane_translate hv] | |
| exact hE (z+d) | |
| have hh := point_distance_le_energy_zero hvs hC hEs (c-d) hr hc1 hc2 | |
| rw [squareEnergy_translate hv 0 d (by positivity),zero_add,sub_add_cancel] at hh | |
| exact hh | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem affine_pair_oscillation_dyadic {n : β} {u : β β Phase n} | |
| (hu : ContDiff β β u) {C : β} (hC : 0 β€ C) | |
| (hE : β z, planarDirichlet (realCurve u) z β€ C * standardForm | |
| (fderiv β (realCurve u) z (1,0)) (fderiv β (realCurve u) z (0,1))) | |
| (a : Phase n) (hi : Integrable (dirichletDensity (affineError u a))) {D : β} | |
| (hD : (β« z, dirichletDensity (affineError u a) z) β€ D) (hD0 : 0 β€ D) | |
| {L : β} (hL : euclideanNorm a β€ L) (c d : Plane) (k : β) | |
| (hc1 : |c.1-d.1| β€ (1/2:β)^(k+1)) (hc2 : |c.2-d.2| β€ (1/2:β)^(k+1)) : | |
| euclideanNorm (realCurve u c-realCurve u d) β€ | |
| (2*morreyConstant C+4)*(Real.sqrt (decayRatio C))^k*(4*L+2*Real.sqrt D) := by | |
| have hp := point_distance_le_energy (realCurve_smooth hu) hC hE c d | |
| (show 0 < (1/2:β)^(k+1) by positivity) hc1 hc2 | |
| have hr : 2*(1/2:β)^(k+1)=(1/2:β)^k := by rw [pow_succ]; ring | |
| rw [hr] at hp | |
| have hd := Real.sqrt_le_sqrt (square_energy_decay_dyadic (realCurve_smooth hu) hC hE d | |
| (by norm_num : (0:β)<1) k) | |
| have he (j : β) : Real.sqrt ((decayRatio C)^j) = (Real.sqrt (decayRatio C))^j := by | |
| induction j with | |
| | zero => simp | |
| | succ j ih => rw [pow_succ,Real.sqrt_mul (pow_nonneg (decayRatio_nonneg hC) j),ih,pow_succ] | |
| rw [one_mul,Real.sqrt_mul (pow_nonneg (decayRatio_nonneg hC) k),he] at hd | |
| have hb := sqrt_squareEnergy_le_affineError hu a hi hD hD0 d (by norm_num : (0:β)β€1) | |
| simp only [mul_one] at hb | |
| have hb' : Real.sqrt (squareEnergy (realCurve u) d 1) β€ 4*L+2*Real.sqrt D := hb.trans (by linarith) | |
| have hh := hd.trans (mul_le_mul_of_nonneg_left hb' (by positivity)) | |
| have hm : 0 β€ 2*morreyConstant C+4 := by have := morreyConstant_pos hC; linarith | |
| exact hp.trans (by simpa only [mul_assoc] using mul_le_mul_of_nonneg_left hh hm) | |
| theorem homotopy_uniform_modulus (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) : | |
| β Ξ΅ > 0, β Ξ΄ > 0, β t β Icc (0:β) 1, β u : β β Phase n, | |
| AffineLineCurve (lineHomotopy J t) p q u β β z w : β, | |
| βz-wβ < Ξ΄ β euclideanNorm (u z-u w) < Ξ΅ := by | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨D,hD,hDbβ© := homotopy_affine_error_energy n hn J hJs hJ hc hs p q hpq | |
| obtain β¨C,hC,hCbβ© := homotopy_standard_energy_bound hJs hJ hc | |
| obtain β¨L,hLbβ© := homotopy_slopes_bounded_above n hn J hJs hJ hc hs p q hpq | |
| have hs1 : Real.sqrt (decayRatio C) < 1 := (Real.sqrt_lt' (by norm_num)).mpr | |
| (by simpa using decayRatio_lt_one hC.le) | |
| have hlim := ((tendsto_pow_atTop_nhds_zero_of_lt_one (Real.sqrt_nonneg _) hs1).const_mul | |
| (2*morreyConstant C+4)).mul_const (4*L+2*Real.sqrt D) | |
| have hev : βαΆ k : β in atTop, | |
| (2*morreyConstant C+4)*(Real.sqrt (decayRatio C))^k*(4*L+2*Real.sqrt D) < Ξ΅ := | |
| hlim.eventually (eventually_lt_nhds (by simpa using hΞ΅)) | |
| obtain β¨k,hkβ© := hev.exists | |
| refine β¨(1/2:β)^(k+1),by positivity,?_β© | |
| intro t ht u hu z w hzw | |
| obtain β¨a,ha,hal,hai,haDβ© := hDb t ht u hu | |
| have hE (s : Plane) : planarDirichlet (realCurve u) s β€ C * standardForm | |
| (fderiv β (realCurve u) s (1,0)) (fderiv β (realCurve u) s (0,1)) := by | |
| change stdDot n _ _+stdDot n _ _ β€ _ | |
| rw [realCurve_CR (hu.2.1 _)] | |
| exact hCb t ht _ _ | |
| have hh := affine_pair_oscillation_dyadic hu.1 hC.le hE a hai haD hD.le | |
| (hLb t ht u hu a hal) (z.re,z.im) (w.re,w.im) k | |
| ((z-w).abs_re_le_norm.trans hzw.le) ((z-w).abs_im_le_norm.trans hzw.le) | |
| have hreal (ΞΆ : β) : realCurve u (ΞΆ.re,ΞΆ.im) = u ΞΆ := by | |
| change u (Complex.equivRealProdCLM.symm (Complex.equivRealProdCLM ΞΆ)) = u ΞΆ | |
| rw [ContinuousLinearEquiv.symm_apply_apply] | |
| rw [hreal,hreal] at hh | |
| exact hh.trans_lt hk | |
| theorem norm_le_euclideanNorm_constant (n : β) : | |
| β K > 0, β a : Phase n, βaβ β€ K*euclideanNorm a := by | |
| let K := max 1 β(phaseEuclidean n).symm.toContinuousLinearMapβ | |
| refine β¨K,lt_of_lt_of_le (by norm_num) (le_max_left _ _),?_β© | |
| intro a | |
| have hh := (phaseEuclidean n).symm.toContinuousLinearMap.le_opNorm (phaseEuclidean n a) | |
| simp only [ContinuousLinearEquiv.coe_coe,ContinuousLinearEquiv.symm_apply_apply] at hh | |
| exact hh.trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (euclideanNorm_nonneg a)) | |
| theorem homotopy_curves_uniformEquicontinuous (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| {ΞΉ : Type*} (t : ΞΉ β β) (ht : β j, t j β Icc (0:β) 1) | |
| (u : ΞΉ β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) : | |
| UniformEquicontinuous u := by | |
| obtain β¨K,hK,hKbβ© := norm_le_euclideanNorm_constant n | |
| apply Metric.uniformEquicontinuous_iff.mpr | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄bβ© := homotopy_uniform_modulus n hn J hJs hJ hc hs p q hpq | |
| (Ξ΅/K) (by positivity) | |
| refine β¨Ξ΄,hΞ΄,?_β© | |
| intro z w hzw j | |
| rw [dist_eq_norm] at hzw β’ | |
| have hb := hΞ΄b (t j) (ht j) (u j) (hu j) z w hzw | |
| have hh := mul_lt_mul_of_pos_left hb hK | |
| rw [mul_div_cancelβ Ξ΅ hK.ne'] at hh | |
| exact (hKb _).trans_lt hh | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| open SymplecticBallPacking.Hamiltonian | |
| theorem homotopy_C0_compactness (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) | |
| (u : β β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) : | |
| β Ο : β β β, StrictMono Ο β§ β v : β β Phase n, | |
| Continuous v β§ TendstoLocallyUniformly (fun j => u (Ο j)) v atTop β§ | |
| v 0=p β§ v 1=q β§ β a : Phase n, a β 0 β§ | |
| Tendsto (fun z : β => zβ»ΒΉ β’ v z) (cocompact β) (π a) := by | |
| classical | |
| let F : β β C(β,Phase n) := fun j => β¨u j,(hu j).1.continuousβ© | |
| have heq := (homotopy_curves_uniformEquicontinuous n hn J hJs hJ hc hs p q hpq t ht u hu).equicontinuous | |
| have heqr : Equicontinuous (fun f : Set.range F => (f.val : β β Phase n)) := by | |
| let Ο : Set.range F β β := fun f => f.property.choose | |
| have hp (f : Set.range F) : F (Ο f) = f.val := f.property.choose_spec | |
| have he : (fun f : Set.range F => (f.val : β β Phase n)) = u β Ο := by | |
| funext f z | |
| exact congrArg (fun g : C(β,Phase n) => g z) (hp f).symm | |
| rw [he] | |
| exact heq.comp Ο | |
| let : T2Space (UniformOnFun β (Phase n) {K | IsCompact K}) := | |
| UniformOnFun.t2Space_of_covering (by | |
| apply Set.eq_univ_iff_forall.mpr | |
| intro z | |
| exact mem_sUnion_of_mem (mem_singleton z) isCompact_singleton) | |
| have hcomp : IsCompact (closure (Set.range F)) := by | |
| apply ArzelaAscoli.isCompact_closure_of_isClosedEmbedding | |
| (F := fun f : C(β,Phase n) => (f : β β Phase n)) | |
| (π := {K | IsCompact K}) (fun K hK => hK) | |
| ContinuousMap.isUniformEmbedding_toUniformOnFunIsCompact.isClosedEmbedding | |
| Β· intro K hK | |
| exact heqr.equicontinuousOn K | |
| Β· intro K hK z hz | |
| obtain β¨Q,hQ,hQbβ© := homotopy_common_affine_carrier n hn J hJs hJ hc hs p q hpq | |
| (βzβ+1) (by positivity) | |
| refine β¨Q,hQ,?_β© | |
| rintro f β¨j,rflβ© | |
| exact hQb (t j) (ht j) (u j) (hu j) (by | |
| simp only [Metric.mem_ball,dist_zero_right] | |
| have := norm_nonneg z | |
| linarith) | |
| obtain β¨v,hv,Ο,hΟ,hΟvβ© := hcomp.tendsto_subseq (x := F) | |
| (fun j => subset_closure (mem_range_self j)) | |
| have hloc : TendstoLocallyUniformly (fun j => u (Ο j)) v atTop := | |
| ContinuousMap.tendsto_iff_tendstoLocallyUniformly.mp hΟv | |
| have hpw : β z, Tendsto (fun j => u (Ο j) z) atTop (π (v z)) := | |
| fun z => hloc.tendstoLocallyUniformlyOn.tendsto_at (mem_univ z) | |
| refine β¨Ο,hΟ,v,v.continuous,hloc,?_,?_,?_β© | |
| Β· exact tendsto_nhds_unique (hpw 0) (by simpa only [(hu (Ο _)).2.2.1] using | |
| (tendsto_const_nhds : Tendsto (fun _ : β => p) atTop (π p))) | |
| Β· exact tendsto_nhds_unique (hpw 1) (by simpa only [(hu (Ο _)).2.2.2.1] using | |
| (tendsto_const_nhds : Tendsto (fun _ : β => q) atTop (π q))) | |
| Β· exact homotopy_limit_has_nonzero_asymptotic n hn J hJs hJ hc hs p q hpq | |
| (t β Ο) (fun j => ht (Ο j)) (fun j => u (Ο j)) (fun j => hu (Ο j)) v hpw | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| theorem homotopy_uniform_holomorphic_exterior (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) : | |
| β S > 0, β t β Icc (0:β) 1, β u : β β Phase n, | |
| AffineLineCurve (lineHomotopy J t) p q u β | |
| DifferentiableOn β u {z : β | S < βzβ} := by | |
| obtain β¨S,hS,hSbβ© := homotopy_uniform_properness n hn J hJs hJ hc hs p q hpq 1 | |
| refine β¨S,hS,?_β© | |
| intro t ht u hu z hz | |
| have hzN := hSb t ht u hu z hz | |
| have hzC : 1 < capacity (u z) := by | |
| rw [capacity_eq_stdDot,βeuclideanNorm_sq] | |
| have hsq : 1 < (euclideanNorm (u z))^2 := by nlinarith | |
| have hpi := Real.pi_gt_three | |
| nlinarith | |
| have hnot : u z β tsupport (fun x => lineHomotopy J t x-standardJ n) := by | |
| intro hh | |
| have hh' := hs (lineHomotopy_support J ht hh) | |
| change capacity (u z) < 1 at hh' | |
| linarith | |
| have hstd : lineHomotopy J t (u z)=standardJ n := | |
| sub_eq_zero.mp (image_eq_zero_of_notMem_tsupport | |
| (f := fun x => lineHomotopy J t x-standardJ n) hnot) | |
| apply DifferentiableAt.differentiableWithinAt | |
| apply complex_differentiable_of_CR (hu.2.1 z).1 | |
| intro w | |
| rw [(hu.2.1 z).2,hstd] | |
| theorem homotopy_C0_limit_analytic_at_infinity (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) | |
| (u : β β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) | |
| (v : β β Phase n) (hv : TendstoLocallyUniformly u v atTop) : | |
| β a : Phase n, a β 0 β§ AnalyticAt β (infinityGerm v a) 0 β§ | |
| infinityGerm v a 0=a := by | |
| obtain β¨S,hS,hSbβ© := homotopy_uniform_holomorphic_exterior n hn J hJs hJ hc hs p q hpq | |
| have hU : IsOpen {z : β | S < βzβ} := isOpen_lt continuous_const continuous_norm | |
| have hhol : DifferentiableOn β v {z : β | S < βzβ} := | |
| hv.tendstoLocallyUniformlyOn.differentiableOn | |
| (Eventually.of_forall fun j => hSb (t j) (ht j) (u j) (hu j)) hU | |
| obtain β¨a,ha,halβ© := homotopy_limit_has_nonzero_asymptotic n hn J hJs hJ hc hs p q hpq | |
| t ht u hu v (fun z => hv.tendstoLocallyUniformlyOn.tendsto_at (mem_univ z)) | |
| refine β¨a,ha,infinityGerm_analyticAt ?_ hal,by simp [infinityGerm]β© | |
| filter_upwards [tendsto_norm_cocompact_atTop.eventually (eventually_gt_atTop S)] with z hz | |
| exact hhol.differentiableAt (hU.mem_nhds hz) | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| theorem homotopy_C0_smooth_limit (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) | |
| (Ο : β) (htΟ : Tendsto t atTop (π Ο)) | |
| (u : β β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) | |
| (v : β β Phase n) (hv : TendstoLocallyUniformly u v atTop) : | |
| AffineLineCurve (lineHomotopy J Ο) p q v := by | |
| have hCR (j : β) (z : β) : fderiv β (u j) z Complex.I = | |
| lineHomotopy J (t j) (u j z) (fderiv β (u j) z 1) := by | |
| simpa only [mul_one] using (hu j).2.1 z |>.2 (1:β) | |
| have hreg := FramedCR.field_C0_smooth_closure | |
| (fun y : β Γ Phase n => lineHomotopy J y.1 y.2) | |
| (fun y hy => lineHomotopy_contDiffAt hJs hJ hy) | |
| (fun y hy => compatible_standard_frame (lineHomotopy_compatible hJ hy y.2)) | |
| t ht htΟ u (fun j => (hu j).1) hCR v hv | |
| refine β¨hreg.1,(homotopy_C0_C1_CR hJs hJ t ht htΟ u (fun j => (hu j).1) | |
| (fun j => (hu j).2.1) v hv).2,?_,?_,?_β© | |
| Β· exact tendsto_nhds_unique | |
| (hv.tendstoLocallyUniformlyOn.tendsto_at (mem_univ (0:β))) | |
| (by simpa only [(hu _).2.2.1] using | |
| (tendsto_const_nhds : Tendsto (fun _ : β => p) atTop (π p))) | |
| Β· exact tendsto_nhds_unique | |
| (hv.tendstoLocallyUniformlyOn.tendsto_at (mem_univ (1:β))) | |
| (by simpa only [(hu _).2.2.2.1] using | |
| (tendsto_const_nhds : Tendsto (fun _ : β => q) atTop (π q))) | |
| Β· exact homotopy_limit_has_nonzero_asymptotic n hn J hJs hJ hc hs p q hpq | |
| t ht u hu v (fun z => hv.tendstoLocallyUniformlyOn.tendsto_at (mem_univ z)) | |
| theorem homotopy_affine_curve_compactness (n : β) (hn : 3 β€ n) | |
| (J : Phase n β End n) (hJs : ContDiff β β J) | |
| (hJ : β x, Compatible (J x)) | |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) | |
| (hs : tsupport (fun x => J x-standardJ n) β openBall n 1) | |
| (p q : Phase n) (hpq : p β q) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) | |
| (u : β β β β Phase n) | |
| (hu : β j, AffineLineCurve (lineHomotopy J (t j)) p q (u j)) : | |
| β Ο : β β β, StrictMono Ο β§ β Ο β Icc (0:β) 1, | |
| Tendsto (fun j => t (Ο j)) atTop (π Ο) β§ β v : β β Phase n, | |
| TendstoLocallyUniformly (fun j => u (Ο j)) v atTop β§ | |
| AffineLineCurve (lineHomotopy J Ο) p q v := by | |
| obtain β¨Ο,hΟ,Ο,hΟ,hΟtβ© := isCompact_Icc.tendsto_subseq ht | |
| obtain β¨Ο,hΟ,v,hvc,hΟv,hvp,hvq,a,ha,hasβ© := homotopy_C0_compactness | |
| n hn J hJs hJ hc hs p q hpq (t β Ο) (fun j => ht (Ο j)) | |
| (fun j => u (Ο j)) (fun j => hu (Ο j)) | |
| refine β¨Ο β Ο,hΟ.comp hΟ,Ο,hΟ,hΟt.comp hΟ.tendsto_atTop,v,hΟv,?_β© | |
| exact homotopy_C0_smooth_limit n hn J hJs hJ hc hs p q hpq | |
| (t β Ο β Ο) (fun j => ht (Ο (Ο j))) Ο (hΟt.comp hΟ.tendsto_atTop) | |
| (fun j => u (Ο (Ο j))) (fun j => hu (Ο (Ο j))) v hΟv | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |