| 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 |
|
|
