Download data/lean/OAI/Geometry/BallPacking/Necessity/GradientLimits.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 36.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/GradientLimits.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/GradientLimits.lean
-
curl -L -o GradientLimits.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/GradientLimits.lean
36.4 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.FreezeJ | |
| import OAI.Geometry.BallPacking.Necessity.SchauderBounds | |
| 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 ContDiff Topology | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| theorem exists_nested_complex_cutoffs : | |
| β (Ο ΞΈ : β β β) (D : β), 0 β€ D β§ | |
| ContDiff β β Ο β§ HasCompactSupport Ο β§ | |
| ContDiff β β ΞΈ β§ HasCompactSupport ΞΈ β§ | |
| tsupport Ο β Metric.closedBall (0:β) 2 β§ | |
| tsupport ΞΈ β Metric.closedBall (0:β) 3 β§ | |
| Ο =αΆ [π 0] (fun _ => (1:β)) β§ | |
| (β z β tsupport Ο, ΞΈ z=1) β§ | |
| (β z, |Ο z| β€ 1 β§ |ΞΈ z| β€ 1) β§ | |
| (β z, βfderiv β Ο zβ β€ D β§ βfderiv β (fderiv β Ο) zβ β€ D β§ | |
| βfderiv β ΞΈ zβ β€ D) := by | |
| let Ο : ContDiffBump (0:β) := β¨1,2,by norm_num,by norm_numβ© | |
| let ΞΈ : ContDiffBump (0:β) := β¨2,3,by norm_num,by norm_numβ© | |
| have hΟ : ContDiff β β (Ο : β β β) := Ο.contDiff | |
| have hΞΈ : ContDiff β β (ΞΈ : β β β) := ΞΈ.contDiff | |
| have hΟD : ContDiff β β (fderiv β (Ο : β β β)) := hΟ.fderiv_right (by simp) | |
| obtain β¨Dβ,hDβ,hBββ© := ((Ο.hasCompactSupport.fderiv β).isCompact_range | |
| (hΟ.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le | |
| have hbD2 : Bornology.IsBounded (range (fderiv β (fderiv β (Ο : β β β)))) := | |
| (((Ο.hasCompactSupport.fderiv β).fderiv β).isCompact_range | |
| (hΟD.continuous_fderiv (by simp))).isBounded | |
| obtain β¨Dβ,hDβ,hBββ© := hbD2.exists_pos_norm_le | |
| obtain β¨Dβ,hDβ,hBββ© := ((ΞΈ.hasCompactSupport.fderiv β).isCompact_range | |
| (hΞΈ.continuous_fderiv (by simp))).isBounded.exists_pos_norm_le | |
| refine β¨Ο,ΞΈ,Dβ+Dβ+Dβ,by positivity,hΟ,Ο.hasCompactSupport,hΞΈ,ΞΈ.hasCompactSupport,?_,?_,?_,?_,?_,?_β© | |
| Β· rw [Ο.tsupport_eq] | |
| Β· rw [ΞΈ.tsupport_eq] | |
| Β· exact Ο.eventuallyEq_one | |
| Β· intro z hz | |
| rw [Ο.tsupport_eq] at hz | |
| exact ΞΈ.one_of_mem_closedBall hz | |
| Β· intro z | |
| constructor | |
| Β· rw [abs_of_nonneg Ο.nonneg] | |
| exact Ο.le_one | |
| Β· rw [abs_of_nonneg ΞΈ.nonneg] | |
| exact ΞΈ.le_one | |
| Β· intro z | |
| have h1 := hBβ _ (mem_range_self z) | |
| have h2 := hBβ _ (mem_range_self z) | |
| have h3 := hBβ _ (mem_range_self z) | |
| exact β¨by linarith,by linarith,by linarithβ© | |
| open scoped Topology ContDiff | |
| open Set Filter Function | |
| section | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| theorem derivative_bound_of_holder_and_values (f : E β F) | |
| (hf : Differentiable β f) {M C r Ξ± : β} (hM : 0 β€ M) (hC : 0 β€ C) | |
| (hr : 0 < r) (hΞ± : 0 β€ Ξ±) | |
| (hv : β z β Metric.closedBall (0:E) r, βf zβ β€ M) | |
| (hD : β z β Metric.closedBall (0:E) r, | |
| βfderiv β f z-fderiv β f 0β β€ C*βzβ^Ξ±) : | |
| βfderiv β f 0β β€ 2*M/r+C*r^Ξ± := by | |
| apply ContinuousLinearMap.opNorm_le_of_unit_norm (by positivity) | |
| intro v hvn | |
| have hrv : r β’ v β Metric.closedBall (0:E) r := by | |
| simp [Metric.mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_pos hr,hvn] | |
| have h0 : (0:E) β Metric.closedBall (0:E) r := Metric.mem_closedBall_self hr.le | |
| have herr := (convex_closedBall (0:E) r).norm_image_sub_le_of_norm_fderiv_le' | |
| (fun z _ => hf z) (Ο := fderiv β f 0) (C := C*r^Ξ±) | |
| (fun z hz => (hD z hz).trans (mul_le_mul_of_nonneg_left | |
| (Real.rpow_le_rpow (norm_nonneg _) (by simpa using hz) hΞ±) hC)) h0 hrv | |
| simp only [sub_zero,norm_smul,Real.norm_eq_abs,abs_of_pos hr,hvn,mul_one] at herr | |
| have hval : βf (r β’ v)-f 0β β€ 2*M := | |
| (norm_sub_le _ _).trans (by linarith [hv (r β’ v) hrv,hv 0 h0]) | |
| have hsum := norm_sub_le (f (r β’ v)-f 0) | |
| (f (r β’ v)-f 0-(fderiv β f 0) (r β’ v)) | |
| rw [sub_sub_cancel] at hsum | |
| rw [map_smul,norm_smul,Real.norm_eq_abs,abs_of_pos hr] at hsum | |
| rw [map_smul] at herr | |
| have hbound : r*β(fderiv β f 0) vβ β€ 2*M+(C*r^Ξ±)*r := by linarith | |
| have hh : β(fderiv β f 0) vβ β€ (2*M+(C*r^Ξ±)*r)/r := | |
| (le_div_iffβ hr).mpr (by nlinarith) | |
| convert hh using 1 | |
| field_simp | |
| theorem norm_fderiv_tendsto_zero_of_holder {f : β β E β F} | |
| (hf : β j, Differentiable β (f j)) {C Ξ± : β} (hC : 0 β€ C) (hΞ± : 0 < Ξ±) | |
| (hD : βαΆ j in atTop, β x y, βfderiv β (f j) x-fderiv β (f j) yβ β€ C*βx-yβ^Ξ±) | |
| (hv : TendstoUniformlyOn f (fun _ => (0:F)) atTop (Metric.closedBall (0:E) 1)) : | |
| Tendsto (fun j => βfderiv β (f j) 0β) atTop (π 0) := by | |
| apply tendsto_order.2 | |
| constructor | |
| Β· intro a ha | |
| exact Eventually.of_forall (fun j => ha.trans_le (norm_nonneg _)) | |
| intro Ξ΅ hΞ΅ | |
| have hpow : Tendsto (fun r : β => C*r^Ξ±) (π[>] 0) (π 0) := by | |
| simpa [Real.zero_rpow (ne_of_gt hΞ±)] using | |
| ((tendsto_const_nhds : Tendsto (fun _ : β => C) (π[>] 0) (π C)).mul | |
| ((Real.continuousAt_rpow_const 0 Ξ± (Or.inr hΞ±.le)).tendsto.mono_left nhdsWithin_le_nhds)) | |
| have hs := hpow.eventually (gt_mem_nhds (show 0 < Ξ΅/2 by linarith)) | |
| have hs' : βαΆ r : β in π[>] 0, r < 1 := | |
| (eventually_lt_nhds (show (0:β) < 1 by norm_num)).filter_mono nhdsWithin_le_nhds | |
| have hpos : βαΆ r : β in π[>] 0, 0 < r := self_mem_nhdsWithin | |
| obtain β¨r,hr,hr1,hsmallβ© := (hpos.and (hs'.and hs)).exists | |
| have hΞ΄ : 0 < Ξ΅*r/8 := by positivity | |
| have hev := (Metric.tendstoUniformlyOn_iff.mp hv) (Ξ΅*r/8) hΞ΄ | |
| filter_upwards [hev,hD] with j hj hjD | |
| have hb := derivative_bound_of_holder_and_values (f j) (hf j) (M := Ξ΅*r/8) | |
| (C := C) hΞ΄.le hC hr hΞ±.le | |
| (fun z hz => le_of_lt (by | |
| have hh := hj z (Metric.closedBall_subset_closedBall hr1.le hz) | |
| simpa [dist_eq_norm] using hh)) | |
| (fun z _ => by simpa using hjD z 0) | |
| have hid : 2*(Ξ΅*r/8)/r=Ξ΅/4 := by field_simp; ring | |
| rw [hid] at hb | |
| linarith | |
| end | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| section | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance gradientLimitsC1NormedAddCommGroup (Ξ± : β) : NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance gradientLimitsC1NormedSpace (Ξ± : β) : NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance gradientLimitsCompactNormedAddCommGroup (F : Type) [NormedAddCommGroup F] [NormedSpace β F] (R : β) : | |
| NormedAddCommGroup (CompactHolderSpace F R) := inferInstance | |
| local instance gradientLimitsCompactNormedSpace (F : Type) [NormedAddCommGroup F] [NormedSpace β F] (R : β) : | |
| NormedSpace β (CompactHolderSpace F R) := inferInstance | |
| private theorem exists_small_principal_const (B K : β) : | |
| β Ξ΄ : β, 0 < Ξ΄ β§ Ξ΄ β€ 1 β§ | |
| B*max Ξ΄ ((2*Ξ΄)^((2:β)/3)*K^((1:β)/3)) β€ 1/2 := by | |
| let g : β β β := fun r => B*max r ((2*r)^((2:β)/3)*K^((1:β)/3)) | |
| have hg : Continuous g := by | |
| exact continuous_const.mul (continuous_id.max | |
| (((Real.continuous_rpow_const (by norm_num : (0:β) β€ 2/3)).comp | |
| (continuous_const.mul continuous_id)).mul continuous_const)) | |
| have hg0 : g 0=0 := by simp [g,Real.zero_rpow (show (2:β)/3 β 0 by norm_num)] | |
| have hev : βαΆ r : β in π[>] 0, g r < 1/2 := by | |
| have ht : Tendsto g (π[>] 0) (π (g 0)) := | |
| hg.continuousAt.tendsto.mono_left nhdsWithin_le_nhds | |
| exact ht.eventually (gt_mem_nhds (show g 0 < (1:β)/2 by rw [hg0]; norm_num)) | |
| have hr1 : βαΆ r : β in π[>] 0, r < 1 := | |
| (eventually_lt_nhds (show (0:β) < 1 by norm_num)).filter_mono nhdsWithin_le_nhds | |
| have hr0 : βαΆ r : β in π[>] 0, 0 < r := self_mem_nhdsWithin | |
| obtain β¨r,h0,h1,hgβ© := (hr0.and (hr1.and hev)).exists | |
| exact β¨r,h0,h1.le,hg.leβ© | |
| theorem smallCR_sequence_derivative_zero | |
| (u : β β β β E) (hu : β j, ContDiff β β (u j)) | |
| (A : β β β β E βL[β] E) (hA : β j, ContDiff β β (A j)) | |
| {L K : β} (hL : 0 β€ L) (hK : 0 β€ K) | |
| (huD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βfderiv β (u j) zβ β€ L) | |
| (hAD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βfderiv β (A j) zβ β€ K) | |
| (hCR : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| fderiv β (u j) z Complex.I-Complex.I β’ fderiv β (u j) z 1= | |
| A j z (fderiv β (u j) z 1)) | |
| (hu0 : TendstoUniformlyOn u (fun _ => (0:E)) atTop (Metric.closedBall (0:β) 3)) | |
| (hA0 : TendstoUniformlyOn A (fun _ => (0:E βL[β] E)) atTop (Metric.closedBall (0:β) 3)) : | |
| Tendsto (fun j => βfderiv β (u j) 0β) atTop (π 0) := by | |
| obtain β¨Ο,ΞΈ,D,hD,hΟ,hΟc,hΞΈ,hΞΈc,hΟ2,hΞΈ3,hΟ1,hΞΈ1,hΟΞΈ,hdβ© := exists_nested_complex_cutoffs | |
| have hΟ3 : tsupport Ο β Metric.closedBall (0:β) 3 := | |
| hΟ2.trans (Metric.closedBall_subset_closedBall (by norm_num)) | |
| let B := 2*βcompactCRInverse (E := E) 3β*βc1HolderDx (E := E)β | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄1,hsmallβ© := exists_small_principal_const B (K+D) | |
| have hu1 : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βu j zβ β€ 1 := by | |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu0 1 (by norm_num)] with j hj | |
| intro z hz | |
| exact le_of_lt (by simpa [dist_eq_norm] using hj z hz) | |
| have hAΞ΄ : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βA j zβ β€ Ξ΄ := by | |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp hA0 Ξ΄ hΞ΄] with j hj | |
| intro z hz | |
| exact le_of_lt (by simpa [dist_eq_norm] using hj z hz) | |
| let v : β β β β E := fun j z => Ο z β’ u j z | |
| have hv : β j, ContDiff β β (v j) := fun j => hΟ.smul (hu j) | |
| have hv0 : TendstoUniformlyOn v (fun _ => (0:E)) atTop (Metric.closedBall (0:β) 1) := by | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro Ξ΅ hΞ΅ | |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu0 Ξ΅ hΞ΅] with j hj | |
| intro z hz | |
| simp only [dist_zero_left,v,norm_smul,Real.norm_eq_abs] | |
| exact (mul_le_mul_of_nonneg_right (hΟΞΈ z).1 (norm_nonneg _)).trans_lt (by | |
| simpa only [one_mul,dist_zero_left] using hj z | |
| (Metric.closedBall_subset_closedBall (by norm_num : (1:β) β€ 3) hz)) | |
| have hvD : βαΆ j in atTop, β x y, | |
| βfderiv β (v j) x-fderiv β (v j) yβ β€ | |
| localSchauderBound E 3 D L (K+D)*βx-yβ^((1:β)/3) := by | |
| filter_upwards [huD,hAD,hCR,hu1,hAΞ΄] with j hjD hjAD hjCR hj1 hjAΞ΄ | |
| let AA : β β E βL[β] E := fun z => ΞΈ z β’ A j z | |
| have hAA : ContDiff β β AA := hΞΈ.smul (hA j) | |
| have hAAc : HasCompactSupport AA := hΞΈc.smul_right | |
| have hAAs : tsupport AA β Metric.closedBall (0:β) 3 := | |
| (tsupport_smul_subset_left ΞΈ (A j)).trans hΞΈ3 | |
| have hb := cutoff_smul_bounds hΞΈ (hA j) hΞΈ3 (C := 1) (D := D) (M := Ξ΄) (L := K) | |
| (by norm_num) hD hΞ΄.le hK (fun z => (hΟΞΈ z).2) (fun z => (hd z).2.2) hjAΞ΄ hjAD | |
| have hAAv : β z, βAA zβ β€ Ξ΄ := by simpa only [one_mul] using hb.1 | |
| have hAAD : β z, βfderiv β AA zβ β€ K+D := by | |
| intro z | |
| exact (hb.2 z).trans (by nlinarith) | |
| apply cutoff_smallCR_schauder 3 Ο hΟ hΟc hΟ3 AA hAA hAAc hAAs (u j) (hu j) | |
| hD hL (add_nonneg hK hD) hΞ΄.le hΞ΄1 (fun z => (hd z).1) | |
| (fun z => (hd z).2.1) (fun z hz => hj1 z (hΟ3 hz)) (fun z hz => hjD z (hΟ3 hz)) | |
| hAAv hAAD | |
| Β· intro z hz | |
| rw [show AA z=A j z by simp only [AA,hΞΈ1 z hz,one_smul]] | |
| exact hjCR z (hΟ3 hz) | |
| Β· dsimp [B] at hsmall | |
| nlinarith only [hsmall] | |
| have hC : 0 β€ localSchauderBound E 3 D L (K+D) := by | |
| dsimp [localSchauderBound] | |
| positivity | |
| have hlim := norm_fderiv_tendsto_zero_of_holder (fun j => (hv j).differentiable (by simp)) | |
| hC (by norm_num : (0:β) < 1/3) hvD hv0 | |
| convert hlim using 1 | |
| funext j | |
| congr 1 | |
| apply Filter.EventuallyEq.fderiv_eq | |
| filter_upwards [hΟ1] with z hz | |
| simp only [v,hz,one_smul] | |
| end | |
| open scoped Topology | |
| open Set Filter Function | |
| section | |
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| [NormedAddCommGroup G] [NormedSpace β G] | |
| omit [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] in | |
| theorem locally_uniform_comp_uniform_constant | |
| [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] | |
| {f : β β E β F} {v : E β F} | |
| (hv : TendstoLocallyUniformly f v atTop) {x : E} (hvc : ContinuousAt v x) | |
| {g : β β G β E} {K : Set G} | |
| (hg : TendstoUniformlyOn g (fun _ => x) atTop K) : | |
| TendstoUniformlyOn (fun j z => f j (g j z)) (fun _ => v x) atTop K := by | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro Ξ΅ hΞ΅ | |
| have he := show {p : F Γ F | dist p.1 p.2 < Ξ΅/2} β uniformity F from | |
| Metric.dist_mem_uniformity (by linarith) | |
| obtain β¨U,hU,hUfβ© := hv _ he x | |
| obtain β¨V,hV,hVcβ© := Metric.continuousAt_iff.mp hvc (Ξ΅/2) (by linarith) | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄Uβ© := Metric.mem_nhds_iff.mp hU | |
| have hmin : 0 < min Ξ΄ V := lt_min hΞ΄ hV | |
| filter_upwards [hUf,Metric.tendstoUniformlyOn_iff.mp hg (min Ξ΄ V) hmin] with j hj hjg | |
| intro z hz | |
| have hgdist : dist (g j z) x < min Ξ΄ V := by simpa [dist_comm] using hjg z hz | |
| have hmem : g j z β U := hΞ΄U (hgdist.trans_le (min_le_left _ _)) | |
| have h1 := hj (g j z) hmem | |
| have h2 := hVc (lt_of_lt_of_le hgdist (min_le_right _ _)) | |
| have ht := dist_triangle (v x) (v (g j z)) (f j (g j z)) | |
| rw [dist_comm (v x) (v (g j z))] at ht | |
| linarith | |
| omit [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] in | |
| theorem continuousAt_comp_uniform_constant | |
| [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] | |
| {g : E β F} {x : E} | |
| (hg : ContinuousAt g x) {u : β β G β E} {K : Set G} | |
| (hu : TendstoUniformlyOn u (fun _ => x) atTop K) : | |
| TendstoUniformlyOn (fun j z => g (u j z)) (fun _ => g x) atTop K := by | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨Ξ΄,hΞ΄,hbβ© := Metric.continuousAt_iff.mp hg Ξ΅ hΞ΅ | |
| filter_upwards [Metric.tendstoUniformlyOn_iff.mp hu Ξ΄ hΞ΄] with j hj | |
| intro z hz | |
| rw [dist_comm] | |
| exact hb (by simpa [dist_comm] using hj z hz) | |
| omit [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] in | |
| theorem uniform_constant_prod | |
| [NormedSpace β E] [NormedSpace β F] [NormedAddCommGroup G] [NormedSpace β G] | |
| {x : β β E} {p : E} (hx : Tendsto x atTop (π p)) | |
| {u : β β G β F} {q : F} {K : Set G} | |
| (hu : TendstoUniformlyOn u (fun _ => q) atTop K) : | |
| TendstoUniformlyOn (fun j z => (x j,u j z)) (fun _ => (p,q)) atTop K := by | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro Ξ΅ hΞ΅ | |
| filter_upwards [Metric.tendsto_nhds.mp hx Ξ΅ hΞ΅,Metric.tendstoUniformlyOn_iff.mp hu Ξ΅ hΞ΅] with j hj hju | |
| intro z hz | |
| rw [Prod.dist_eq] | |
| exact max_lt (by simpa [dist_comm] using hj) (hju z hz) | |
| theorem affine_rescale_uniform_constant {x : β β E} {c : E} | |
| (hx : Tendsto x atTop (π c)) {r : β β β} (hr : Tendsto r atTop (π 0)) | |
| {K : Set E} (hK : Bornology.IsBounded K) : | |
| TendstoUniformlyOn (fun j z => x j+r j β’ z) (fun _ => c) atTop K := by | |
| obtain β¨M,hM,hMbβ© := hK.exists_pos_norm_le | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro Ξ΅ hΞ΅ | |
| have hsmall : βαΆ j in atTop, dist (x j) c+|r j| * M < Ξ΅ := by | |
| have ht : Tendsto (fun j => dist (x j) c+|r j| * M) atTop (π 0) := by | |
| simpa using (hx.dist (tendsto_const_nhds (x := c))).add (hr.abs.mul_const M) | |
| exact ht.eventually (gt_mem_nhds hΞ΅) | |
| filter_upwards [hsmall] with j hj | |
| intro z hz | |
| rw [dist_comm,dist_eq_norm] | |
| have he : x j+r j β’ z-c=(x j-c)+r j β’ z := by abel | |
| rw [he] | |
| apply (norm_add_le _ _).trans_lt | |
| rw [norm_smul,Real.norm_eq_abs] | |
| apply lt_of_le_of_lt _ hj | |
| rw [dist_eq_norm] | |
| exact add_le_add le_rfl (mul_le_mul_of_nonneg_left (hMb z hz) (abs_nonneg _)) | |
| theorem rescaled_maps_uniform_constant {f : β β E β F} {v : E β F} | |
| (hv : TendstoLocallyUniformly f v atTop) {x : β β E} {c : E} | |
| (hvc : ContinuousAt v c) (hx : Tendsto x atTop (π c)) | |
| {r : β β β} (hr : Tendsto r atTop (π 0)) {K : Set E} (hK : Bornology.IsBounded K) : | |
| TendstoUniformlyOn (fun j z => f j (x j+r j β’ z)) (fun _ => v c) atTop K := | |
| locally_uniform_comp_uniform_constant hv hvc (affine_rescale_uniform_constant hx hr hK) | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| section | |
| open HigherDimensionalBallPacking.Rigidity | |
| def frameConjugation {n : β} (S : Phase n βL[β] Phase n) : End n βL[β] End n := | |
| (ContinuousLinearMap.compL β (Phase n) (Phase n) (Phase n) S.toContinuousLinearMap).comp | |
| ((ContinuousLinearMap.compL β (Phase n) (Phase n) (Phase n)).flip S.symm.toContinuousLinearMap) | |
| @[simp] theorem frameConjugation_apply {n : β} (S : Phase n βL[β] Phase n) (B : End n) : | |
| frameConjugation S B=S.toContinuousLinearMap.comp (B.comp S.symm.toContinuousLinearMap) := rfl | |
| theorem frozenCoefficient_fderiv {n : β} (S : Phase n βL[β] Phase n) (J : End n) | |
| {B : β β End n} (hB : Differentiable β B) (z : β) : | |
| fderiv β (frozenCoefficient S J B) z=(frameConjugation S).comp (fderiv β B z) := | |
| ((frameConjugation S).hasFDerivAt.comp z ((hB z).hasFDerivAt.sub_const J)).fderiv | |
| theorem frozen_CR_no_gradient_loss {n : β} | |
| (u : β β β β Phase n) (hu : β j, ContDiff β β (u j)) | |
| (B : β β β β End n) (hB : β j, ContDiff β β (B j)) | |
| (p : Phase n) (J : End n) (hJ : Compatible J) | |
| {L K : β} (hL : 0 β€ L) (hK : 0 β€ K) | |
| (huD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βfderiv β (u j) zβ β€ L) | |
| (hBD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βfderiv β (B j) zβ β€ K) | |
| (hCR : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| fderiv β (u j) z Complex.I=B j z (fderiv β (u j) z 1)) | |
| (hu0 : TendstoUniformlyOn u (fun _ => p) atTop (Metric.closedBall (0:β) 3)) | |
| (hB0 : TendstoUniformlyOn B (fun _ => J) atTop (Metric.closedBall (0:β) 3)) : | |
| Tendsto (fun j => βfderiv β (u j) 0β) atTop (π 0) := by | |
| obtain β¨S,hSβ© := compatible_standard_frame hJ | |
| let U : β β β β Phase n := fun j => centeredFrame S p (u j) | |
| let A : β β β β End n := fun j => frozenCoefficient S J (B j) | |
| have hU : β j, ContDiff β β (U j) := fun j => centeredFrame_smooth S p (hu j) | |
| have hA : β j, ContDiff β β (A j) := fun j => frozenCoefficient_smooth S J (hB j) | |
| have hUD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| βfderiv β (U j) zβ β€ βS.toContinuousLinearMapβ*L := by | |
| filter_upwards [huD] with j hj | |
| intro z hz | |
| rw [show fderiv β (U j) z=S.toContinuousLinearMap.comp (fderiv β (u j) z) from | |
| centeredFrame_fderiv S p ((hu j).differentiable (by simp)) z] | |
| exact (S.toContinuousLinearMap.opNorm_comp_le _).trans | |
| (mul_le_mul_of_nonneg_left (hj z hz) (norm_nonneg _)) | |
| have hAD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| βfderiv β (A j) zβ β€ βframeConjugation Sβ*K := by | |
| filter_upwards [hBD] with j hj | |
| intro z hz | |
| rw [show fderiv β (A j) z=(frameConjugation S).comp (fderiv β (B j) z) from | |
| frozenCoefficient_fderiv S J ((hB j).differentiable (by simp)) z] | |
| exact ((frameConjugation S).opNorm_comp_le _).trans | |
| (mul_le_mul_of_nonneg_left (hj z hz) (norm_nonneg _)) | |
| have hACR : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| fderiv β (U j) z Complex.I-Complex.I β’ fderiv β (U j) z 1= | |
| A j z (fderiv β (U j) z 1) := by | |
| filter_upwards [hCR] with j hj | |
| intro z hz | |
| exact frozen_CR_equation S J hS p ((hu j).differentiable (by simp)) (B j) (hj z hz) | |
| have hU0 : TendstoUniformlyOn U (fun _ => (0:Phase n)) atTop (Metric.closedBall (0:β) 3) := by | |
| have hc : ContinuousAt (fun x : Phase n => S (x-p)) p := | |
| S.continuous.continuousAt.comp (continuousAt_id.sub continuousAt_const) | |
| convert continuousAt_comp_uniform_constant hc hu0 using 1 | |
| all_goals try simp only [U,sub_self,map_zero] | |
| all_goals rfl | |
| have hA0 : TendstoUniformlyOn A (fun _ => (0:End n)) atTop (Metric.closedBall (0:β) 3) := by | |
| have hc : ContinuousAt (fun x : End n => frameConjugation S (x-J)) J := | |
| (frameConjugation S).continuous.continuousAt.comp (continuousAt_id.sub continuousAt_const) | |
| convert continuousAt_comp_uniform_constant hc hB0 using 1 | |
| all_goals try simp only [A,frameConjugation_apply,sub_self,map_zero] | |
| all_goals rfl | |
| have hlim := smallCR_sequence_derivative_zero U hU A hA | |
| (mul_nonneg (norm_nonneg S.toContinuousLinearMap) hL) | |
| (mul_nonneg (norm_nonneg (frameConjugation S)) hK) hUD hAD hACR hU0 hA0 | |
| apply squeeze_zero (fun j => norm_nonneg _) | |
| (fun j => show βfderiv β (u j) 0β β€ βS.symm.toContinuousLinearMapβ*βfderiv β (U j) 0β from ?_) | |
| (by simpa using hlim.const_mul βS.symm.toContinuousLinearMapβ) | |
| have he : fderiv β (u j) 0=S.symm.toContinuousLinearMap.comp (fderiv β (U j) 0) := by | |
| rw [show fderiv β (U j) 0=S.toContinuousLinearMap.comp (fderiv β (u j) 0) from | |
| centeredFrame_fderiv S p ((hu j).differentiable (by simp)) 0] | |
| apply ContinuousLinearMap.ext | |
| intro z | |
| change (fderiv β (u j) 0) z=S.symm (S ((fderiv β (u j) 0) z)) | |
| simp | |
| rw [he] | |
| exact S.symm.toContinuousLinearMap.opNorm_comp_le _ | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| section | |
| open HigherDimensionalBallPacking.Rigidity | |
| theorem lineHomotopy_contDiffAt {n : β} {J : Phase n β End n} | |
| (hJs : ContDiff β β J) (hJ : β x, Compatible (J x)) | |
| {y : β Γ Phase n} (hy : y.1 β Icc (0:β) 1) : | |
| ContDiffAt β β (fun y : β Γ Phase n => lineHomotopy J y.1 y.2) y := | |
| contDiffAt_interpolateJ (hJs.contDiffAt.comp y contDiffAt_snd) | |
| contDiffAt_fst (hJ y.2) hy | |
| theorem homotopy_CR_no_gradient_loss {n : β} {J : Phase n β End n} | |
| (hJs : ContDiff β β J) (hJ : β x, Compatible (J x)) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) {s : β} | |
| (hts : Tendsto t atTop (π s)) | |
| (u : β β β β Phase n) (hu : β j, ContDiff β β (u j)) (p : Phase n) | |
| {L : β} (hL : 0 β€ L) | |
| (huD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, βfderiv β (u j) zβ β€ L) | |
| (hCR : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| fderiv β (u j) z Complex.I=lineHomotopy J (t j) (u j z) (fderiv β (u j) z 1)) | |
| (hu0 : TendstoUniformlyOn u (fun _ => p) atTop (Metric.closedBall (0:β) 3)) : | |
| Tendsto (fun j => βfderiv β (u j) 0β) atTop (π 0) := by | |
| let H : β Γ Phase n β End n := fun y => lineHomotopy J y.1 y.2 | |
| let B : β β β β End n := fun j z => H (t j,u j z) | |
| have hs : s β Icc (0:β) 1 := isClosed_Icc.mem_of_tendsto hts (Eventually.of_forall ht) | |
| have hH (y : β Γ Phase n) (hy : y.1 β Icc (0:β) 1) : ContDiffAt β β H y := | |
| lineHomotopy_contDiffAt hJs hJ hy | |
| have hB (j : β) : ContDiff β β (B j) := by | |
| rw [contDiff_iff_contDiffAt] | |
| intro z | |
| exact ContDiffAt.comp (g := H) (f := fun z => (t j,u j z)) z | |
| (hH (t j,u j z) (ht j)) (contDiffAt_const.prodMk (hu j).contDiffAt) | |
| have hBounded : Bornology.IsBounded | |
| ((fderiv β H) '' (Icc (0:β) 1 ΓΛ’ Metric.closedBall p 1)) := | |
| ((isCompact_Icc.prod (isCompact_closedBall p 1)).image_of_continuousOn | |
| (fun y hy => ((hH y hy.1).continuousAt_fderiv (by simp)).continuousWithinAt)).isBounded | |
| obtain β¨K,hK,hKbβ© := hBounded.exists_pos_norm_le | |
| have hB0 : TendstoUniformlyOn B (fun _ => H (s,p)) atTop (Metric.closedBall (0:β) 3) := by | |
| convert continuousAt_comp_uniform_constant (hH (s,p) hs).continuousAt | |
| (uniform_constant_prod hts hu0) using 1 | |
| have hBD : βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| βfderiv β (B j) zβ β€ K*L := by | |
| filter_upwards [huD,Metric.tendstoUniformlyOn_iff.mp hu0 1 (by norm_num)] with j hj hju | |
| intro z hz | |
| have hmem : (t j,u j z) β Icc (0:β) 1 ΓΛ’ Metric.closedBall p 1 := | |
| β¨ht j,by simpa [Metric.mem_closedBall,dist_comm] using (hju z hz).leβ© | |
| have hd : HasFDerivAt (fun z => (t j,u j z)) | |
| ((0 : β βL[β] β).prod (fderiv β (u j) z)) z := | |
| (hasFDerivAt_const (t j) z).prodMk ((hu j).differentiable (by simp) z).hasFDerivAt | |
| have he : fderiv β (B j) z=(fderiv β H (t j,u j z)).comp | |
| ((0 : β βL[β] β).prod (fderiv β (u j) z)) := | |
| (HasFDerivAt.comp (g := H) (f := fun z => (t j,u j z)) z | |
| ((hH (t j,u j z) (ht j)).differentiableAt (by simp)).hasFDerivAt hd).fderiv | |
| rw [he] | |
| apply ((fderiv β H (t j,u j z)).opNorm_comp_le _).trans | |
| have hnorm : β(0 : β βL[β] β).prod (fderiv β (u j) z)β=βfderiv β (u j) zβ := by | |
| rw [ContinuousLinearMap.opNorm_prod,Prod.norm_def,norm_zero,max_eq_right (norm_nonneg _)] | |
| rw [hnorm] | |
| exact mul_le_mul (hKb _ β¨(t j,u j z),hmem,rflβ©) (hj z hz) (norm_nonneg _) hK.le | |
| exact frozen_CR_no_gradient_loss u hu B hB p (H (s,p)) | |
| (lineHomotopy_compatible hJ hs p) hL (mul_nonneg hK.le hL) huD hBD hCR hu0 hB0 | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| section | |
| variable {F : Type*} [NormedAddCommGroup F] [NormedSpace β F] | |
| def rescaleMap (u : β β F) (x : β) (r : β) : β β F := fun z => u (x+r β’ z) | |
| theorem rescaleMap_smooth {u : β β F} (hu : ContDiff β β u) (x : β) (r : β) : | |
| ContDiff β β (rescaleMap u x r) := by | |
| exact ContDiff.comp (g := u) (f := fun z : β => x+r β’ z) hu | |
| (contDiff_const.add (contDiff_id.const_smul r)) | |
| theorem rescaleMap_fderiv {u : β β F} (hu : Differentiable β u) (x : β) (r : β) (z : β) : | |
| fderiv β (rescaleMap u x r) z=r β’ fderiv β u (x+r β’ z) := by | |
| have hd : HasFDerivAt (fun z : β => x+r β’ z) (r β’ ContinuousLinearMap.id β β) z := | |
| by | |
| have hh := (hasFDerivAt_const (π := β) x z).add ((hasFDerivAt_id (π := β) z).const_smul r) | |
| simp only [zero_add] at hh | |
| convert hh using 1 | |
| rfl | |
| have he := (HasFDerivAt.comp (g := u) (f := fun z : β => x+r β’ z) z | |
| (hu (x+r β’ z)).hasFDerivAt hd).fderiv | |
| simp only [Function.comp_def,ContinuousLinearMap.comp_smul, | |
| ContinuousLinearMap.comp_id] at he | |
| convert he using 1 | |
| rfl | |
| theorem rescaleMap_norm_fderiv {u : β β F} (hu : Differentiable β u) | |
| (x : β) (r : β) (z : β) : | |
| βfderiv β (rescaleMap u x r) zβ=|r| * βfderiv β u (x+r β’ z)β := by | |
| rw [rescaleMap_fderiv hu,norm_smul,Real.norm_eq_abs] | |
| theorem weighted_rescale_bounds {u : β β F} (hu : Differentiable β u) | |
| {x c : β} {R : β} (hg : 0 < βfderiv β u xβ) | |
| (hm : 6 β€ (R-dist x c)*βfderiv β u xβ) | |
| (hb : β y β Metric.closedBall x ((R-dist x c)/2), | |
| βfderiv β u yβ β€ 2*βfderiv β u xβ) : | |
| βfderiv β (rescaleMap u x βfderiv β u xββ»ΒΉ) 0β=1 β§ | |
| β z β Metric.closedBall (0:β) 3, | |
| βfderiv β (rescaleMap u x βfderiv β u xββ»ΒΉ) zβ β€ 2 := by | |
| have hr : 0 β€ βfderiv β u xββ»ΒΉ := inv_nonneg.mpr hg.le | |
| constructor | |
| Β· rw [rescaleMap_norm_fderiv hu,abs_of_nonneg hr,smul_zero,add_zero,inv_mul_cancelβ hg.ne'] | |
| Β· intro z hz | |
| have hhalf : βfderiv β u xββ»ΒΉ*3 β€ (R-dist x c)/2 := by | |
| have hh := mul_le_mul_of_nonneg_right hm hr | |
| rw [mul_assoc,mul_inv_cancelβ hg.ne',mul_one] at hh | |
| linarith | |
| have hmem : x+βfderiv β u xββ»ΒΉ β’ z β Metric.closedBall x ((R-dist x c)/2) := by | |
| rw [Metric.mem_closedBall,dist_eq_norm,add_sub_cancel_left,norm_smul,Real.norm_eq_abs, | |
| abs_of_nonneg hr] | |
| exact (mul_le_mul_of_nonneg_left (by simpa using hz : βzβ β€ 3) hr).trans hhalf | |
| rw [rescaleMap_norm_fderiv hu,abs_of_nonneg hr] | |
| calc | |
| _ β€ βfderiv β u xββ»ΒΉ*(2*βfderiv β u xβ) := mul_le_mul_of_nonneg_left (hb _ hmem) hr | |
| _ = 2 := by rw [mul_left_comm,inv_mul_cancelβ hg.ne',mul_one] | |
| theorem rescaleMap_CR {n : β} {J : Phase n β End n} {u : β β Phase n} | |
| (hu : Differentiable β u) (hCR : β z, PseudoHolomorphicAt J u z) | |
| (x : β) (r : β) (z : β) : | |
| fderiv β (rescaleMap u x r) z Complex.I= | |
| J (rescaleMap u x r z) (fderiv β (rescaleMap u x r) z 1) := by | |
| rw [rescaleMap_fderiv hu] | |
| simpa only [smul_apply,map_smul,mul_one,rescaleMap] using | |
| congrArg (fun v : Phase n => r β’ v) ((hCR (x+r β’ z)).2 1) | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| section | |
| variable {F : Type*} [NormedAddCommGroup F] [NormedSpace β F] | |
| theorem weighted_gradient_maximum (f : β β F) (hf : ContDiff β β f) | |
| (c : β) {R : β} (hR : 0 < R) (hgrad : 0 < βfderiv β f cβ) : | |
| β x β Metric.ball c R, | |
| R*βfderiv β f cβ β€ (R-dist x c)*βfderiv β f xβ β§ | |
| βfderiv β f cβ β€ βfderiv β f xβ β§ | |
| β y β Metric.closedBall x ((R-dist x c)/2), | |
| βfderiv β f yβ β€ 2*βfderiv β f xβ := by | |
| let g : β β β := fun z => (R-dist z c)*βfderiv β f zβ | |
| have hg : Continuous g := | |
| (continuous_const.sub (continuous_id.dist continuous_const)).mul | |
| ((hf.continuous_fderiv (by simp)).norm) | |
| obtain β¨x,hx,hxmβ© := (isCompact_closedBall c R).exists_isMaxOn | |
| (Metric.nonempty_closedBall.mpr hR.le) hg.continuousOn | |
| have hcm : c β Metric.closedBall c R := Metric.mem_closedBall_self hR.le | |
| have hcx : R*βfderiv β f cβ β€ (R-dist x c)*βfderiv β f xβ := by | |
| simpa only [Set.mem_ofPred_eq,g,dist_self,sub_zero] using hxm hcm | |
| have hxp : 0 < R-dist x c := by | |
| have hm : 0 < (R-dist x c)*βfderiv β f xβ := (mul_pos hR hgrad).trans_le hcx | |
| exact pos_of_mul_pos_left hm (norm_nonneg _) | |
| have hxmem : x β Metric.ball c R := by | |
| rw [Metric.mem_ball] | |
| linarith | |
| have hgx : βfderiv β f cβ β€ βfderiv β f xβ := by | |
| apply le_of_mul_le_mul_left (a := R) | |
| Β· calc | |
| R*βfderiv β f cβ β€ (R-dist x c)*βfderiv β f xβ := hcx | |
| _ β€ R*βfderiv β f xβ := mul_le_mul_of_nonneg_right (by linarith [dist_nonneg (x := x) (y := c)]) (norm_nonneg _) | |
| Β· exact hR | |
| refine β¨x,hxmem,hcx,hgx,?_β© | |
| intro y hy | |
| have hyx : dist y x β€ (R-dist x c)/2 := Metric.mem_closedBall.mp hy | |
| have hyc : dist y c β€ (R+dist x c)/2 := by | |
| have hh := dist_triangle y x c | |
| linarith | |
| have hymem : y β Metric.closedBall c R := by | |
| rw [Metric.mem_closedBall] | |
| linarith | |
| have hxy := hxm hymem | |
| change (R-dist y c)*βfderiv β f yβ β€ (R-dist x c)*βfderiv β f xβ at hxy | |
| have hb : ((R-dist x c)/2)*βfderiv β f yβ β€ | |
| (R-dist y c)*βfderiv β f yβ := | |
| mul_le_mul_of_nonneg_right (by linarith) (norm_nonneg _) | |
| have hh := hb.trans hxy | |
| nlinarith | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| open HigherDimensionalBallPacking.Rigidity | |
| theorem locally_uniform_reindex {E F : Type*} [TopologicalSpace E] [UniformSpace F] | |
| {u : β β E β F} {v : E β F} (hv : TendstoLocallyUniformly u v atTop) | |
| {a : β β β} (ha : Tendsto a atTop atTop) : | |
| TendstoLocallyUniformly (fun j => u (a j)) v atTop := by | |
| intro V hV x | |
| obtain β¨U,hU,hUVβ© := hv V hV x | |
| exact β¨U,hU,ha.eventually hUVβ© | |
| theorem homotopy_C0_gradient_bound {n : β} {J : Phase n β End n} | |
| (hJs : ContDiff β β J) (hJ : β x, Compatible (J x)) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) {s : β} | |
| (hts : Tendsto t atTop (π s)) | |
| (u : β β β β Phase n) (hu : β j, ContDiff β β (u j)) | |
| (hCR : β j z, PseudoHolomorphicAt (lineHomotopy J (t j)) (u j) z) | |
| (v : β β Phase n) (hv : TendstoLocallyUniformly u v atTop) | |
| (c : β) {R : β} (_hR : 0 β€ R) : | |
| β L β₯ 0, βαΆ j in atTop, β z β Metric.closedBall c R, βfderiv β (u j) zβ β€ L := by | |
| by_contra hn | |
| have hbad (j : β) : β i β₯ j, β z β Metric.closedBall c R, | |
| (j:β)+1 < βfderiv β (u i) zβ := by | |
| have hnot : Β¬ βαΆ i in atTop, β z β Metric.closedBall c R, | |
| βfderiv β (u i) zβ β€ (j:β)+1 := by | |
| intro hh | |
| exact hn β¨(j:β)+1,by positivity,hhβ© | |
| rw [Filter.eventually_atTop] at hnot | |
| push Not at hnot | |
| obtain β¨i,hi,z,hz,hbigβ© := hnot j | |
| exact β¨i,hi,z,hz,hbigβ© | |
| choose a ha z hz hbig using hbad | |
| have hat : Tendsto a atTop atTop := tendsto_atTop_mono ha tendsto_id | |
| have hpos (j : β) : 0 < βfderiv β (u (a j)) (z j)β := lt_trans (by positivity) (hbig j) | |
| choose x hx hweight hlarger hlocal using | |
| (fun j => weighted_gradient_maximum (u (a j)) (hu (a j)) (z j) (by norm_num : (0:β)<1) (hpos j)) | |
| have hxmem (j : β) : x j β Metric.closedBall c (R+1) := by | |
| have h1 : dist (x j) (z j) < 1 := hx j | |
| have h2 : dist (z j) c β€ R := hz j | |
| rw [Metric.mem_closedBall] | |
| linarith [dist_triangle (x j) (z j) c] | |
| obtain β¨d,hd,Ο,hΟ,hΟxβ© := (isCompact_closedBall c (R+1)).tendsto_subseq hxmem | |
| let b : β β β := fun j => a (Ο j) | |
| have hbt : Tendsto b atTop atTop := hat.comp hΟ.tendsto_atTop | |
| let g : β β β := fun j => βfderiv β (u (b j)) (x (Ο j))β | |
| have hgp (j : β) : 0 < g j := (hpos (Ο j)).trans_le (hlarger (Ο j)) | |
| have hgb (j : β) : (Ο j:β)+1 < g j := (hbig (Ο j)).trans_le (hlarger (Ο j)) | |
| have hgt : Tendsto g atTop atTop := by | |
| apply tendsto_atTop_mono (fun j => (le_add_of_nonneg_right (by norm_num : (0:β) β€ 1)).trans (hgb j).le) | |
| exact tendsto_natCast_atTop_atTop.comp hΟ.tendsto_atTop | |
| let r : β β β := fun j => (g j)β»ΒΉ | |
| have hrt : Tendsto r atTop (π 0) := tendsto_inv_atTop_zero.comp hgt | |
| let U : β β β β Phase n := fun j => rescaleMap (u (b j)) (x (Ο j)) (r j) | |
| have hUs (j : β) : ContDiff β β (U j) := rescaleMap_smooth (hu (b j)) _ _ | |
| have hlim : TendstoUniformlyOn U (fun _ => v d) atTop (Metric.closedBall (0:β) 3) := by | |
| have hv' := locally_uniform_reindex hv hbt | |
| have hvc : Continuous v := hv.continuous (Eventually.of_forall (fun j => (hu j).continuous)).frequently | |
| convert rescaled_maps_uniform_constant hv' hvc.continuousAt hΟx hrt | |
| (Metric.isBounded_closedBall (x := (0:β)) (r := 3)) using 1 | |
| rfl | |
| have hUb : βαΆ j in atTop, βfderiv β (U j) 0β=1 β§ | |
| β z β Metric.closedBall (0:β) 3, βfderiv β (U j) zβ β€ 2 := by | |
| filter_upwards [eventually_ge_atTop (6:β)] with j hj | |
| apply weighted_rescale_bounds ((hu (b j)).differentiable (by simp)) (hgp j) | |
| Β· have hΟj : j β€ Ο j := hΟ.id_le j | |
| have h6 : (6:β) β€ Ο j := by exact_mod_cast le_trans hj hΟj | |
| have hw := hweight (Ο j) | |
| dsimp [g,b] at hgb | |
| nlinarith [hbig (Ο j)] | |
| Β· exact hlocal (Ο j) | |
| have hUCR : β j z, fderiv β (U j) z Complex.I= | |
| lineHomotopy J (t (b j)) (U j z) (fderiv β (U j) z 1) := by | |
| intro j z | |
| exact rescaleMap_CR ((hu (b j)).differentiable (by simp)) (hCR (b j)) _ _ _ | |
| have hzero := homotopy_CR_no_gradient_loss hJs hJ (fun j => t (b j)) | |
| (fun j => ht (b j)) (hts.comp hbt) U hUs (v d) (by norm_num : (0:β) β€ 2) | |
| (hUb.mono (fun j hj => hj.2)) (Eventually.of_forall (fun j z _ => hUCR j z)) hlim | |
| have hone : Tendsto (fun j => βfderiv β (U j) 0β) atTop (π 1) := | |
| tendsto_const_nhds.congr' (hUb.mono (fun j hj => hj.1.symm)) | |
| have he : (0:β)=1 := tendsto_nhds_unique hzero hone | |
| norm_num at he | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |