Download data/lean/OAI/Geometry/BallPacking/Necessity/FramedCompactness.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 29.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/FramedCompactness.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/FramedCompactness.lean
-
curl -L -o FramedCompactness.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/FramedCompactness.lean
29.6 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.GradientLimits | |
| namespace OAI | |
| noncomputable section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| open scoped Manifold | |
| open MeasureTheory | |
| 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 MeasureTheory | |
| open scoped Topology | |
| open Finset | |
| open scoped ContDiff Classical | |
| open scoped BoundedContinuousFunction | |
| open Topology | |
| open scoped NNReal | |
| namespace HigherDimensionalBallPacking.Rigidity.FramedCR | |
| open HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] | |
| [FiniteDimensional β E] [CompleteSpace E] | |
| def HasFrame (J : E βL[β] E) : Prop := | |
| β S : E βL[β] E, β v, S (J v)=Complex.I β’ S v | |
| def centeredFrame (S : E βL[β] E) (p : E) | |
| (u : β β E) : β β E := fun z => S (u z-p) | |
| def frozenCoefficient (S : E βL[β] E) (J : (E βL[β] E)) | |
| (B : β β (E βL[β] E)) : β β (E βL[β] E) := fun z => | |
| S.toContinuousLinearMap.comp ((B z-J).comp S.symm.toContinuousLinearMap) | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| theorem centeredFrame_smooth [FiniteDimensional β E] [CompleteSpace E] | |
| (S : E βL[β] E) (p : E) | |
| {u : β β E} (hu : ContDiff β β u) : ContDiff β β (centeredFrame S p u) := | |
| S.contDiff.comp (hu.sub contDiff_const) | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| theorem centeredFrame_fderiv [FiniteDimensional β E] [CompleteSpace E] | |
| (S : E βL[β] E) (p : E) | |
| {u : β β E} (hu : Differentiable β u) (z : β) : | |
| fderiv β (centeredFrame S p u) z=S.toContinuousLinearMap.comp (fderiv β u z) := by | |
| exact (S.hasFDerivAt.comp z ((hu z).hasFDerivAt.sub_const p)).fderiv | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| theorem frozenCoefficient_smooth [FiniteDimensional β E] [CompleteSpace E] | |
| (S : E βL[β] E) (J : (E βL[β] E)) | |
| {B : β β (E βL[β] E)} (hB : ContDiff β β B) : ContDiff β β (frozenCoefficient S J B) := | |
| contDiff_const.clm_comp ((hB.sub contDiff_const).clm_comp contDiff_const) | |
| theorem frozen_CR_equation (S : E βL[β] E) (J : (E βL[β] E)) | |
| (hS : β v, S (J v)=Complex.I β’ S v) (p : E) | |
| {u : β β E} (hu : Differentiable β u) (B : β β (E βL[β] E)) {z : β} | |
| (hCR : fderiv β u z Complex.I=B z (fderiv β u z 1)) : | |
| fderiv β (centeredFrame S p u) z Complex.I- | |
| Complex.I β’ fderiv β (centeredFrame S p u) z 1= | |
| frozenCoefficient S J B z (fderiv β (centeredFrame S p u) z 1) := by | |
| rw [centeredFrame_fderiv S p hu z] | |
| change S (fderiv β u z Complex.I)-Complex.I β’ S (fderiv β u z 1)= | |
| S ((B z-J) (S.symm (S (fderiv β u z 1)))) | |
| simp only [S.symm_apply_apply,sub_apply,map_sub,hCR,hS] | |
| def frameConjugation (S : E βL[β] E) : (E βL[β] E) βL[β] (E βL[β] E) := | |
| (ContinuousLinearMap.compL β (E) (E) (E) S.toContinuousLinearMap).comp | |
| ((ContinuousLinearMap.compL β (E) (E) (E)).flip S.symm.toContinuousLinearMap) | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| @[simp] theorem frameConjugation_apply [FiniteDimensional β E] [CompleteSpace E] | |
| (S : E βL[β] E) (B : (E βL[β] E)) : | |
| frameConjugation S B=S.toContinuousLinearMap.comp (B.comp S.symm.toContinuousLinearMap) := rfl | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| theorem frozenCoefficient_fderiv [FiniteDimensional β E] [CompleteSpace E] | |
| (S : E βL[β] E) (J : (E βL[β] E)) | |
| {B : β β (E βL[β] E)} (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 | |
| (u : β β β β E) (hu : β j, ContDiff β β (u j)) | |
| (B : β β β β (E βL[β] E)) (hB : β j, ContDiff β β (B j)) | |
| (p : E) (J : (E βL[β] E)) (hJ : HasFrame 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β© := hJ | |
| let U : β β β β E := fun j => centeredFrame S p (u j) | |
| let A : β β β β (E βL[β] E) := 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:E)) atTop (Metric.closedBall (0:β) 3) := by | |
| have hc : ContinuousAt (fun x : E => 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:(E βL[β] E))) atTop (Metric.closedBall (0:β) 3) := by | |
| have hc : ContinuousAt (fun x : (E βL[β] E) => 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 _ | |
| theorem field_CR_no_gradient_loss (H : β Γ E β E βL[β] E) | |
| (hH : β y : β Γ E, y.1 β Icc (0:β) 1 β ContDiffAt β β H y) | |
| (hHF : β y : β Γ E, y.1 β Icc (0:β) 1 β HasFrame (H y)) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) {s : β} | |
| (hts : Tendsto t atTop (π s)) | |
| (u : β β β β E) (hu : β j, ContDiff β β (u j)) (p : E) | |
| {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=H (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 B : β β β β (E βL[β] E) := 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 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)) | |
| (hHF (s,p) hs) hL (mul_nonneg hK.le hL) huD hBD hCR hu0 hB0 | |
| omit [FiniteDimensional β E] [CompleteSpace E] in | |
| theorem rescaleMap_CR_I [FiniteDimensional β E] [CompleteSpace E] | |
| {J : E β E βL[β] E} {u : β β E} | |
| (hu : Differentiable β u) | |
| (hCR : β z, fderiv β u z Complex.I=J (u z) (fderiv β u z 1)) | |
| (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,rescaleMap] using | |
| congrArg (fun v : E => r β’ v) (hCR (x+r β’ z)) | |
| theorem field_C0_gradient_bound (H : β Γ E β E βL[β] E) | |
| (hH : β y : β Γ E, y.1 β Icc (0:β) 1 β ContDiffAt β β H y) | |
| (hHF : β y : β Γ E, y.1 β Icc (0:β) 1 β HasFrame (H y)) | |
| (t : β β β) (ht : β j, t j β Icc (0:β) 1) {s : β} | |
| (hts : Tendsto t atTop (π s)) | |
| (u : β β β β E) (hu : β j, ContDiff β β (u j)) | |
| (hCR : β j z, fderiv β (u j) z Complex.I=H (t j,u j z) (fderiv β (u j) z 1)) | |
| (v : β β E) (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 : β β β β E := 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= | |
| H (t (b j),U j z) (fderiv β (U j) z 1) := by | |
| intro j z | |
| exact rescaleMap_CR_I (J := fun x => H (t (b j),x)) ((hu (b j)).differentiable (by simp)) (hCR (b j)) _ _ _ | |
| have hzero := field_CR_no_gradient_loss H hH hHF (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.FramedCR | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| open HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| section | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| theorem holder_gradient_limit_C1 (f : β β β β E) (hf : β j, ContDiff β β (f j)) | |
| (v : β β E) (hv : TendstoLocallyUniformly f v atTop) | |
| {M C Ξ± : β} (hM : 0 β€ M) (hC : 0 β€ C) (hΞ± : 0 < Ξ±) | |
| (hval : β j z, z β Metric.closedBall (0:β) 1 β βf j zβ β€ M) | |
| (hD : β j x y, βfderiv β (f j) x-fderiv β (f j) yβ β€ C*βx-yβ^Ξ±) : | |
| ContDiff β 1 v β§ β Ο : β β β, StrictMono Ο β§ | |
| TendstoLocallyUniformly (fun j => fderiv β (f (Ο j))) (fderiv β v) atTop := by | |
| classical | |
| let D : β β β β (β βL[β] E) := fun j => fderiv β (f j) | |
| have hD0 (j : β) : βD j 0β β€ 2*M+C := by | |
| have hh := derivative_bound_of_holder_and_values (f j) ((hf j).differentiable (by simp)) | |
| hM hC (by norm_num : (0:β)<1) hΞ±.le (hval j) | |
| (fun z _ => by simpa using hD j z 0) | |
| simpa only [div_one,Real.one_rpow,mul_one] using hh | |
| have hpoint (j : β) (z : β) : βD j zβ β€ 2*M+C+C*βzβ^Ξ± := by | |
| have hh := norm_sub_le (D j z-D j 0) (-D j 0) | |
| simp only [sub_neg_eq_add,sub_add_cancel,norm_neg] at hh | |
| have h := hD j z 0 | |
| simp only [sub_zero] at h | |
| exact hh.trans (by linarith [hD0 j]) | |
| have heq : UniformEquicontinuous D := by | |
| apply Metric.uniformEquicontinuous_iff.mpr | |
| intro Ξ΅ hΞ΅ | |
| have hg : Tendsto (fun r : β => C*r^Ξ±) (π 0) (π 0) := by | |
| simpa [Real.zero_rpow hΞ±.ne'] using | |
| (Real.continuousAt_rpow_const 0 Ξ± (Or.inr hΞ±.le)).tendsto.const_mul C | |
| have hh := hg.eventually (gt_mem_nhds hΞ΅) | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄bβ© := Metric.mem_nhds_iff.mp hh | |
| refine β¨Ξ΄,hΞ΄,?_β© | |
| intro z w hzw j | |
| rw [dist_eq_norm] | |
| apply (hD j z w).trans_lt | |
| apply hΞ΄b | |
| simpa [Metric.mem_ball,dist_eq_norm] using hzw | |
| let F : β β C(β,(β βL[β] E)) := fun j => β¨D j,(hf j).continuous_fderiv (by simp)β© | |
| have heqr : Equicontinuous (fun f : Set.range F => (f.val : β β (β βL[β] E))) := 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 : β β (β βL[β] E))) = D β Ο := by | |
| funext f z | |
| exact congrArg (fun g : C(β,(β βL[β] E)) => g z) (hp f).symm | |
| rw [he] | |
| exact heq.equicontinuous.comp Ο | |
| let : T2Space (UniformOnFun β (β βL[β] E) {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(β,(β βL[β] E)) => (f : β β (β βL[β] E))) | |
| (π := {K | IsCompact K}) (fun K hK => hK) | |
| ContinuousMap.isUniformEmbedding_toUniformOnFunIsCompact.isClosedEmbedding | |
| Β· intro K hK | |
| exact heqr.equicontinuousOn K | |
| Β· intro K hK z hz | |
| refine β¨Metric.closedBall 0 (2*M+C+C*βzβ^Ξ±),isCompact_closedBall _ _,?_β© | |
| rintro f β¨j,rflβ© | |
| rw [Metric.mem_closedBall,dist_zero_right] | |
| convert hpoint j z using 1 | |
| obtain β¨w,hw,Ο,hΟ,hΟwβ© := hcomp.tendsto_subseq (x := F) | |
| (fun j => subset_closure (mem_range_self j)) | |
| have hloc : TendstoLocallyUniformly (fun j => D (Ο j)) w atTop := | |
| ContinuousMap.tendsto_iff_tendstoLocallyUniformly.mp hΟw | |
| have hvl := locally_uniform_reindex hv hΟ.tendsto_atTop | |
| have hvD (x : β) : HasFDerivAt v (w x) x := | |
| hasFDerivAt_of_tendstoLocallyUniformlyOn isOpen_univ | |
| hloc.tendstoLocallyUniformlyOn (fun j z _ => ((hf (Ο j)).differentiable (by simp) z).hasFDerivAt) | |
| (fun z _ => hvl.tendstoLocallyUniformlyOn.tendsto_at (mem_univ z)) (mem_univ x) | |
| refine β¨contDiff_one_iff_hasFDerivAt.mpr β¨w,w.continuous,hvDβ©,Ο,hΟ,?_β© | |
| convert hloc using 1 | |
| funext z | |
| exact (hvD z).fderiv | |
| end | |
| section | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance packageC1Norm (Ξ± : β) : NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance packageC1Space (Ξ± : β) : NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance packageCompactNorm (F : Type) [NormedAddCommGroup F] [NormedSpace β F] (R : β) : | |
| NormedAddCommGroup (CompactHolderSpace F R) := inferInstance | |
| local instance packageCompactSpace (F : Type) [NormedAddCommGroup F] [NormedSpace β F] (R : β) : | |
| NormedSpace β (CompactHolderSpace F R) := inferInstance | |
| private theorem exists_principal_threshold (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_local_modulus (L K : β) (hL : 0 β€ L) (hK : 0 β€ K) : | |
| β (Ο : β β β) (Ξ΄ C : β), ContDiff β β Ο β§ HasCompactSupport Ο β§ | |
| Ο =αΆ [π 0] (fun _ => (1:β)) β§ (β z, |Ο z| β€ 1) β§ | |
| tsupport Ο β Metric.closedBall (0:β) 3 β§ 0 < Ξ΄ β§ 0 β€ C β§ | |
| β (u : β β E) (A : β β E βL[β] E), | |
| ContDiff β β u β ContDiff β β A β | |
| (β z β Metric.closedBall (0:β) 3, βu zβ β€ 1) β | |
| (β z β Metric.closedBall (0:β) 3, βfderiv β u zβ β€ L) β | |
| (β z β Metric.closedBall (0:β) 3, βA zβ β€ Ξ΄) β | |
| (β z β Metric.closedBall (0:β) 3, βfderiv β A zβ β€ K) β | |
| (β z β Metric.closedBall (0:β) 3, | |
| fderiv β u z Complex.I-Complex.I β’ fderiv β u z 1=A z (fderiv β u z 1)) β | |
| β x y, βfderiv β (fun z => Ο z β’ u z) x-fderiv β (fun z => Ο z β’ u z) yβ β€ | |
| C*βx-yβ^((1:β)/3) := 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_principal_threshold B (K+D) | |
| refine β¨Ο,Ξ΄,localSchauderBound E 3 D L (K+D),hΟ,hΟc,hΟ1, | |
| fun z => (hΟΞΈ z).1,hΟ3,hΞ΄,?_,?_β© | |
| Β· dsimp [localSchauderBound] | |
| positivity | |
| intro u A hu hA huv huD hAv hAD hCR | |
| let AA : β β E βL[β] E := fun z => ΞΈ z β’ A z | |
| have hAA : ContDiff β β AA := hΞΈ.smul hA | |
| have hAAc : HasCompactSupport AA := hΞΈc.smul_right | |
| have hAAs : tsupport AA β Metric.closedBall (0:β) 3 := | |
| (tsupport_smul_subset_left ΞΈ A).trans hΞΈ3 | |
| have hb := cutoff_smul_bounds hΞΈ hA 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) hAv hAD | |
| 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 hu | |
| hD hL (add_nonneg hK hD) hΞ΄.le hΞ΄1 (fun z => (hd z).1) | |
| (fun z => (hd z).2.1) (fun z hz => huv z (hΟ3 hz)) (fun z hz => huD z (hΟ3 hz)) | |
| hAAv hAAD | |
| Β· intro z hz | |
| rw [show AA z=A z by simp only [AA,hΞΈ1 z hz,one_smul]] | |
| exact hCR z (hΟ3 hz) | |
| Β· dsimp [B] at hsmall | |
| nlinarith only [hsmall] | |
| end | |
| section | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] | |
| [FiniteDimensional β E] [CompleteSpace E] | |
| theorem smallCR_C1_closure_threshold (L K : β) (hL : 0 β€ L) (hK : 0 β€ K) : | |
| β Ξ΄ : β, 0 < Ξ΄ β§ β (u : β β β β E) (A : β β β β E βL[β] E) | |
| (v : β β E), (β j, ContDiff β β (u j)) β (β j, ContDiff β β (A j)) β | |
| TendstoLocallyUniformly u v atTop β | |
| (βαΆ j in atTop, β z β Metric.closedBall (0:β) 3, | |
| βu j zβ β€ 1 β§ βfderiv β (u j) zβ β€ L β§ βA j zβ β€ Ξ΄ β§ | |
| βfderiv β (A j) zβ β€ K β§ | |
| fderiv β (u j) z Complex.I-Complex.I β’ fderiv β (u j) z 1= | |
| A j z (fderiv β (u j) z 1)) β | |
| ContDiffAt β 1 v 0 β§ β Ο : β β β, StrictMono Ο β§ | |
| Tendsto (fun j => fderiv β (u (Ο j)) 0) atTop (π (fderiv β v 0)) := by | |
| obtain β¨Ο,Ξ΄,C,hΟ,hΟc,hΟ1,hΟb,hΟ3,hΞ΄,hC,hmodβ© := smallCR_local_modulus (E := E) L K hL hK | |
| refine β¨Ξ΄,hΞ΄,?_β© | |
| intro u A v hu hA hv hb | |
| obtain β¨N,hNβ© := eventually_atTop.mp hb | |
| let f : β β β β E := fun j z => Ο z β’ u (j+N) z | |
| let w : β β E := fun z => Ο z β’ v z | |
| have hvc : Continuous v := hv.continuous (Eventually.of_forall (fun j => (hu j).continuous)).frequently | |
| have hΟlim : TendstoLocallyUniformly (fun _ : β => Ο) Ο atTop := by | |
| exact ContinuousMap.tendsto_iff_tendstoLocallyUniformly.mp | |
| (tendsto_const_nhds (x := (β¨Ο,hΟ.continuousβ© : C(β,β)))) | |
| have hflim : TendstoLocallyUniformly f w atTop := by | |
| exact hΟlim.smulβ (locally_uniform_reindex hv (tendsto_add_atTop_nat N)) hΟ.continuous hvc | |
| have hfb (j : β) (z : β) (hz : z β Metric.closedBall (0:β) 1) : βf j zβ β€ 1 := by | |
| have hu1 := (hN (j+N) (Nat.le_add_left N j) z | |
| ((Metric.closedBall_subset_closedBall (by norm_num : (1:β) β€ 3)) hz)).1 | |
| calc βf j zβ = |Ο z| *βu (j+N) zβ := by simp only [f,norm_smul,Real.norm_eq_abs] | |
| _ β€ 1*1 := mul_le_mul (hΟb z) hu1 (norm_nonneg _) (by norm_num) | |
| _ = 1 := one_mul 1 | |
| have hfmod (j : β) := hmod (u (j+N)) (A (j+N)) (hu _) (hA _) | |
| (fun z hz => (hN _ (Nat.le_add_left N j) z hz).1) | |
| (fun z hz => (hN _ (Nat.le_add_left N j) z hz).2.1) | |
| (fun z hz => (hN _ (Nat.le_add_left N j) z hz).2.2.1) | |
| (fun z hz => (hN _ (Nat.le_add_left N j) z hz).2.2.2.1) | |
| (fun z hz => (hN _ (Nat.le_add_left N j) z hz).2.2.2.2) | |
| obtain β¨hw,Ο,hΟ,hΟDβ© := holder_gradient_limit_C1 f (fun j => hΟ.smul (hu (j+N))) w hflim | |
| (by norm_num : (0:β) β€ 1) hC (by norm_num : (0:β) < 1/3) hfb hfmod | |
| have he (g : β β E) : (fun z => Ο z β’ g z) =αΆ [π 0] g := by | |
| filter_upwards [hΟ1] with z hz | |
| simp only [hz,one_smul] | |
| refine β¨hw.contDiffAt.congr_of_eventuallyEq (he v).symm,fun j => Ο j+N, | |
| fun i j hij => Nat.add_lt_add_right (hΟ hij) N,?_β© | |
| have hd := hΟD.tendstoLocallyUniformlyOn.tendsto_at (mem_univ (0:β)) | |
| convert hd using 1 | |
| Β· funext j | |
| exact (he (u (Ο j+N))).fderiv_eq.symm | |
| Β· exact congrArg nhds (he v).fderiv_eq.symm | |
| end | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedAddCommGroup F] | |
| theorem locally_uniform_small_ball {u : β β β β E} {v : β β E} | |
| (hv : TendstoLocallyUniformly u v atTop) {c : β} (hvc : ContinuousAt v c) | |
| {t : β β β} {s : β} (ht : Tendsto t atTop (π s)) | |
| {G : β Γ E β F} (hG : ContinuousAt G (s,v c)) (hG0 : G (s,v c)=0) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) : | |
| β r : β, 0 < r β§ r β€ 1 β§ βαΆ j in atTop, | |
| β z β Metric.closedBall c r, βG (t j,u j z)β β€ Ξ΅ := by | |
| obtain β¨Ξ΄,hΞ΄,hΞ΄Gβ© := Metric.continuousAt_iff.mp hG Ξ΅ hΞ΅ | |
| obtain β¨a,ha,havβ© := Metric.continuousAt_iff.mp hvc (Ξ΄/2) (by linarith) | |
| obtain β¨U,hU,hUfβ© := hv _ (Metric.dist_mem_uniformity (by linarith : (0:β)<Ξ΄/2)) c | |
| obtain β¨b,hb,hbUβ© := Metric.mem_nhds_iff.mp hU | |
| let r := min 1 (min a b/2) | |
| have hr : 0 < r := lt_min (by norm_num) (half_pos (lt_min ha hb)) | |
| refine β¨r,hr,min_le_left _ _,?_β© | |
| filter_upwards [hUf,Metric.tendsto_nhds.mp ht Ξ΄ hΞ΄] with j hj hjt | |
| intro z hz | |
| have hza : dist z c < a := by | |
| have h := (show dist z c β€ r from hz).trans (min_le_right 1 (min a b/2)) | |
| linarith [min_le_left a b,lt_min ha hb] | |
| have hzb : dist z c < b := by | |
| have h := (show dist z c β€ r from hz).trans (min_le_right 1 (min a b/2)) | |
| linarith [min_le_right a b,lt_min ha hb] | |
| have h1 : dist (v z) (u j z)<Ξ΄/2 := hj z (hbU hzb) | |
| have h2 : dist (v z) (v c)<Ξ΄/2 := hav hza | |
| have hu : dist (u j z) (v c)<Ξ΄ := by | |
| have hh := dist_triangle (u j z) (v z) (v c) | |
| rw [dist_comm (u j z) (v z)] at hh | |
| linarith | |
| have hh := hΞ΄G (show dist (t j,u j z) (s,v c)<Ξ΄ by rw [Prod.dist_eq]; exact max_lt hjt hu) | |
| simpa only [hG0,dist_zero_right] using hh.le | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |