| import Mathlib |
| import OAI.Geometry.BallPacking.Compactness.JetCauchy |
| |
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {n : ℕ} |
| local instance fcrInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance fcrInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
|
|
| def frozenTargetCoefficient (J : Phase n → End n) (x v : Phase n) : End n := |
| let P := compatibleFrame (J x) |
| (P.comp (J (x+P.inverse v)-J x)).comp P.inverse |
|
|
| @[simp] lemma frozenTargetCoefficient_zero (J : Phase n → End n) (x : Phase n) : |
| frozenTargetCoefficient J x 0=0 := by |
| simp only [frozenTargetCoefficient,map_zero,add_zero,sub_self, |
| ContinuousLinearMap.comp_zero,ContinuousLinearMap.zero_comp] |
|
|
| lemma frozenTargetCoefficient_continuous {J : Phase n → End n} (hJ : Continuous J) (x : Phase n) : |
| Continuous (frozenTargetCoefficient J x) := by |
| exact (continuous_const.clm_comp ((hJ.comp (continuous_const.add (compatibleFrame (J x)).inverse.continuous)).sub continuous_const)).clm_comp continuous_const |
|
|
| lemma frozenTargetCoefficient_difference (J : Phase n → End n) (x v w : Phase n) : |
| frozenTargetCoefficient J x v-frozenTargetCoefficient J x w= |
| ((compatibleFrame (J x)).comp (J (x+(compatibleFrame (J x)).inverse v)- |
| J (x+(compatibleFrame (J x)).inverse w))).comp (compatibleFrame (J x)).inverse := by |
| apply ContinuousLinearMap.ext |
| intro a |
| simp only [frozenTargetCoefficient,ContinuousLinearMap.comp_apply,sub_apply,map_sub] |
| abel |
|
|
| lemma frozenTargetCoefficient_lipschitz {J : Phase n → End n} {x : Phase n} {L G : ℝ} |
| (hL : 0≤L) (hG : 0≤G) |
| (hJ : ∀ v w,‖J v-J w‖≤L*‖v-w‖) |
| (hP : ‖compatibleFrame (J x)‖≤G) (hPi : ‖(compatibleFrame (J x)).inverse‖≤G) : |
| ∀ v w,‖frozenTargetCoefficient J x v-frozenTargetCoefficient J x w‖≤(G^3*L)*‖v-w‖ := by |
| intro v w |
| let P := compatibleFrame (J x) |
| have hp : ∀ z,‖P.inverse z‖≤G*‖z‖ := fun z => |
| (P.inverse.le_opNorm z).trans (mul_le_mul_of_nonneg_right hPi (norm_nonneg _)) |
| have hj : ‖J (x+P.inverse v)-J (x+P.inverse w)‖≤L*(G*‖v-w‖) := by |
| have hh := hJ (x+P.inverse v) (x+P.inverse w) |
| rw [add_sub_add_left_eq_sub,←map_sub] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (hp _) hL) |
| rw [frozenTargetCoefficient_difference] |
| have h1 : ‖P.comp (J (x+P.inverse v)-J (x+P.inverse w))‖≤G*(L*(G*‖v-w‖)) := |
| (P.opNorm_comp_le _).trans (mul_le_mul hP hj (norm_nonneg _) hG) |
| have hh := (P.comp (J (x+P.inverse v)-J (x+P.inverse w))).opNorm_comp_le P.inverse |
| exact hh.trans ((mul_le_mul h1 hPi (norm_nonneg _) (by positivity)).trans_eq (by ring)) |
|
|
| def frozenCurve (J : Phase n → End n) (x : Phase n) (u : ℂ → Phase n) (z : ℂ) : Phase n := |
| compatibleFrame (J x) (u z-x) |
|
|
| lemma frozenCurve_smooth {J : Phase n → End n} (x : Phase n) {u : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) : ContDiff ℝ ∞ (frozenCurve J x u) := |
| (compatibleFrame (J x)).contDiff.comp (hu.sub contDiff_const) |
|
|
| lemma frozenCurve_fderiv {J : Phase n → End n} (x : Phase n) {u : ℂ → Phase n} |
| {z : ℂ} (hu : DifferentiableAt ℝ u z) : |
| fderiv ℝ (frozenCurve J x u) z=(compatibleFrame (J x)).comp (fderiv ℝ u z) := by |
| exact ((compatibleFrame (J x)).hasFDerivAt.comp z (hu.hasFDerivAt.sub_const x)).fderiv |
|
|
| lemma frozenCurve_CR {J : Phase n → End n} {x : Phase n} (hx : Compatible (J x)) |
| {u : ℂ → Phase n} {z : ℂ} (hu : DifferentiableAt ℝ u z) |
| (hcr : fderiv ℝ u z Complex.I=J (u z) (fderiv ℝ u z 1)) : |
| fderiv ℝ (frozenCurve J x u) z Complex.I-Complex.I • fderiv ℝ (frozenCurve J x u) z 1= |
| frozenTargetCoefficient J x (frozenCurve J x u z) (fderiv ℝ (frozenCurve J x u) z 1) := by |
| rw [frozenCurve_fderiv x hu] |
| simp only [frozenTargetCoefficient,frozenCurve,ContinuousLinearMap.comp_apply] |
| rw [compatibleFrame_inverse_left hx,compatibleFrame_inverse_left hx] |
| rw [add_sub_cancel,hcr,sub_apply,map_sub] |
| have hh := compatibleFrame_intertwine hx (fderiv ℝ u z 1) |
| change compatibleFrame (J x) (J (u z) (fderiv ℝ u z 1))- |
| standardJ n (compatibleFrame (J x) (fderiv ℝ u z 1))=_ |
| rw [←hh] |
|
|
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
|
|
| namespace HigherDimensionalBallPacking.Rigidity |
| open scoped ContDiff Topology |
| open Set Filter |
| open HolderCompletion |
| open scoped BoundedContinuousFunction |
| section |
| variable {n : ℕ} |
| local instance hcbInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance hcbInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance hcbInst3 : NormedAddCommGroup (Phase n →L[ℝ] End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance hcbInst4 : NormedSpace ℝ (Phase n →L[ℝ] End n) := ContinuousLinearMap.toNormedSpace |
|
|
| lemma lineHomotopy_joint_contDiffAt {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) {v : ℝ × Phase n} |
| (ht : v.1∈Icc (0:ℝ) 1) : |
| ContDiffAt ℝ ∞ (fun v : ℝ × Phase n => lineHomotopy J v.1 v.2) v := |
| contDiffAt_interpolateJ (hJs.contDiffAt.comp v contDiffAt_snd) contDiffAt_fst (hJ _) ht |
|
|
| lemma lineHomotopy_slice_contDiff {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) : |
| ContDiff ℝ ∞ (lineHomotopy J t) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro x |
| exact contDiffAt_interpolateJ hJs.contDiffAt contDiffAt_const (hJ x) ht |
|
|
| lemma lineHomotopy_partial_deriv {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : Phase n) : |
| fderiv ℝ (lineHomotopy J t) x= |
| (fderiv ℝ (fun v : ℝ × Phase n => lineHomotopy J v.1 v.2) (t,x)).comp |
| (ContinuousLinearMap.inr ℝ ℝ (Phase n)) := by |
| have hj := (lineHomotopy_joint_contDiffAt hJs hJ (v := (t,x)) ht).differentiableAt (by simp) |
| have hg := (hasFDerivAt_const (𝕜 := ℝ) (x := x) t).prodMk (hasFDerivAt_id (𝕜 := ℝ) x) |
| exact (hj.hasFDerivAt.comp x hg).fderiv |
|
|
| lemma lineHomotopy_eventually_standard {J : Phase n → End n} {t : ℝ} (ht : t∈Icc (0:ℝ) 1) |
| {x : Phase n} (hx : x∉tsupport (fun x => J x-standardJ n)) : |
| lineHomotopy J t =ᶠ[𝓝 x] fun _ => standardJ n := by |
| have he := notMem_tsupport_iff_eventuallyEq.mp hx |
| filter_upwards [he] with y hy |
| have hy' : J y=standardJ n := sub_eq_zero.mp hy |
| change interpolateJ (J y) t=standardJ n |
| rw [hy'] |
| exact interpolateJ_standard ht |
|
|
| lemma compatibleFrame_contDiffAt {D : Type*} [NormedAddCommGroup D] [NormedSpace ℝ D] |
| {A : D → End n} {x : D} (hA : ContDiffAt ℝ ∞ A x) : |
| ContDiffAt ℝ ∞ (fun z => compatibleFrame (A z)) x := by |
| simpa only [compatibleFrame,cayleyP,one_smul,relativeOperator] using |
| ((contDiffAt_const.clm_comp hA).neg.add (contDiffAt_const (c := ContinuousLinearMap.id ℝ (Phase n)))) |
|
|
| theorem exact_homotopy_target_bounds {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) : |
| ∃ L G : ℝ,0≤L ∧ 1≤G ∧ |
| (∀ t∈Icc (0:ℝ) 1,∀ x y,‖lineHomotopy J t x-lineHomotopy J t y‖≤L*‖x-y‖) ∧ |
| (∀ t∈Icc (0:ℝ) 1,∀ x,‖compatibleFrame (lineHomotopy J t x)‖≤G) ∧ |
| (∀ t∈Icc (0:ℝ) 1,∀ x,‖(compatibleFrame (lineHomotopy J t x)).inverse‖≤G) := by |
| let K := (Icc (0:ℝ) 1) ×ˢ tsupport (fun x => J x-standardJ n) |
| have hK : IsCompact K := isCompact_Icc.prod hJc |
| let A : ℝ × Phase n → End n := fun v => lineHomotopy J v.1 v.2 |
| let D : ℝ × Phase n → Phase n →L[ℝ] End n := fun v => |
| (fderiv ℝ A v).comp (ContinuousLinearMap.inr ℝ ℝ (Phase n)) |
| have hDc : ContinuousOn D K := by |
| intro v hv |
| exact (((lineHomotopy_joint_contDiffAt hJs hJ hv.1).continuousAt_fderiv (by simp)).clm_comp continuousAt_const).continuousWithinAt |
| have hPc : ContinuousOn (fun v => compatibleFrame (A v)) K := by |
| intro v hv |
| exact (compatibleFrame_contDiffAt (lineHomotopy_joint_contDiffAt hJs hJ hv.1)).continuousAt.continuousWithinAt |
| have hPic : ContinuousOn (fun v => (compatibleFrame (A v)).inverse) K := by |
| intro v hv |
| have hp := compatibleFrame_contDiffAt (lineHomotopy_joint_contDiffAt hJs hJ hv.1) |
| exact ((compatibleFrame_invertible (lineHomotopy_compatible hJ hv.1 v.2)).contDiffAt_map_inverse.comp v hp).continuousAt.continuousWithinAt |
| obtain ⟨B,hB⟩ := hK.exists_bound_of_continuousOn hDc |
| obtain ⟨P,hP⟩ := hK.exists_bound_of_continuousOn hPc |
| obtain ⟨Q,hQ⟩ := hK.exists_bound_of_continuousOn hPic |
| let L := max B 0 |
| let G := |P|+|Q|+‖compatibleFrame (standardJ n)‖+‖(compatibleFrame (standardJ n)).inverse‖+1 |
| have hL : 0≤L := le_max_right B 0 |
| have hG : 1≤G := by dsimp [G] |
| have hLd : ∀ t∈Icc (0:ℝ) 1,∀ x,‖fderiv ℝ (lineHomotopy J t) x‖≤L := by |
| intro t ht x |
| by_cases hx : x∈tsupport (fun x => J x-standardJ n) |
| · rw [lineHomotopy_partial_deriv hJs hJ ht x] |
| exact (hB (t,x) ⟨ht,hx⟩).trans (le_max_left B 0) |
| · rw [(lineHomotopy_eventually_standard ht hx).fderiv_eq] |
| simpa only [fderiv_fun_const,Pi.zero_apply,norm_zero] using hL |
| refine ⟨L,G,hL,hG,?_,?_,?_⟩ |
| · intro t ht x y |
| exact norm_sub_le_of_deriv_bound ((lineHomotopy_slice_contDiff hJs hJ ht).differentiable (by simp)) (hLd t ht) x y |
| · intro t ht x |
| by_cases hx : x∈tsupport (fun x => J x-standardJ n) |
| · have hh := (hP (t,x) ⟨ht,hx⟩).trans (le_abs_self P) |
| exact hh.trans (by dsimp [G] |
| · rw [(lineHomotopy_eventually_standard ht hx).eq_of_nhds] |
| dsimp [G] |
| linarith [abs_nonneg P,abs_nonneg Q,norm_nonneg (compatibleFrame (standardJ n)),norm_nonneg ((compatibleFrame (standardJ n)).inverse)] |
| · intro t ht x |
| by_cases hx : x∈tsupport (fun x => J x-standardJ n) |
| · have hh := (hQ (t,x) ⟨ht,hx⟩).trans (le_abs_self Q) |
| exact hh.trans (by dsimp [G] |
| · rw [(lineHomotopy_eventually_standard ht hx).eq_of_nhds] |
| dsimp [G] |
| linarith [abs_nonneg P,abs_nonneg Q,norm_nonneg (compatibleFrame (standardJ n)),norm_nonneg ((compatibleFrame (standardJ n)).inverse)] |
|
|
| end |
| section |
|
|
| variable {n : ℕ} |
| local instance fhcInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance fhcInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
|
|
| lemma frozenHomotopy_joint_contDiffAt {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| {v : (ℝ × Phase n) × Phase n} (ht : v.1.1∈Icc (0:ℝ) 1) : |
| ContDiffAt ℝ ∞ (fun w : (ℝ × Phase n) × Phase n => |
| frozenTargetCoefficient (lineHomotopy J w.1.1) w.1.2 w.2) v := by |
| have htfun : ContDiffAt ℝ ∞ (fun w : (ℝ × Phase n) × Phase n => w.1.1) v := |
| contDiffAt_fst.comp v contDiffAt_fst |
| have hxfun : ContDiffAt ℝ ∞ (fun w : (ℝ × Phase n) × Phase n => w.1.2) v := |
| contDiffAt_snd.comp v contDiffAt_fst |
| let A : (ℝ × Phase n) × Phase n → End n := fun w => lineHomotopy J w.1.1 w.1.2 |
| have hA : ContDiffAt ℝ ∞ A v := |
| contDiffAt_interpolateJ (hJs.contDiffAt.comp v hxfun) htfun (hJ _) ht |
| let P : (ℝ × Phase n) × Phase n → End n := fun w => compatibleFrame (A w) |
| have hP : ContDiffAt ℝ ∞ P v := compatibleFrame_contDiffAt hA |
| have hi : ContDiffAt ℝ ∞ (fun T : End n => T.inverse) (P v) := |
| (compatibleFrame_invertible (lineHomotopy_compatible hJ ht v.1.2)).contDiffAt_map_inverse |
| have hPi : ContDiffAt ℝ ∞ (fun w => (P w).inverse) v := hi.comp v hP |
| have harg : ContDiffAt ℝ ∞ (fun w => w.1.2+(P w).inverse w.2) v := |
| hxfun.add (hPi.clm_apply contDiffAt_snd) |
| have hB : ContDiffAt ℝ ∞ (fun w => lineHomotopy J w.1.1 (w.1.2+(P w).inverse w.2)) v := |
| contDiffAt_interpolateJ (hJs.contDiffAt.comp v harg) htfun (hJ _) ht |
| exact (hP.clm_comp (hB.sub hA)).clm_comp hPi |
|
|
| lemma frozenHomotopy_tendstoUniformlyOn {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) {s : ℝ} (hs : Tendsto t atTop (𝓝 s)) |
| {x : ℕ → Phase n} {y : Phase n} (hx : Tendsto x atTop (𝓝 y)) |
| {K : Set (Phase n)} (hK : IsCompact K) : |
| TendstoUniformlyOn (fun i => frozenTargetCoefficient (lineHomotopy J (t i)) (x i)) |
| (frozenTargetCoefficient (lineHomotopy J s) y) atTop K := by |
| have hsI : s∈Icc (0:ℝ) 1 := isClosed_Icc.mem_of_tendsto hs (Eventually.of_forall ht) |
| let U : Set (ℝ × Phase n) := (Icc (0:ℝ) 1) ×ˢ insert y (range x) |
| have hU : IsCompact U := isCompact_Icc.prod hx.isCompact_insert_range |
| have hc : ContinuousOn (fun w : (ℝ × Phase n) × Phase n => |
| frozenTargetCoefficient (lineHomotopy J w.1.1) w.1.2 w.2) (U ×ˢ K) := by |
| intro w hw |
| exact (frozenHomotopy_joint_contDiffAt hJs hJ hw.1.1).continuousAt.continuousWithinAt |
| have huc := (hU.prod hK).uniformContinuousOn_of_continuous hc |
| have hlim := UniformContinuousOn.tendstoUniformlyOn |
| (F := fun a : ℝ × Phase n => frozenTargetCoefficient (lineHomotopy J a.1) a.2) huc (show (s,y)∈U from ⟨hsI,mem_insert _ _⟩) |
| have hp : Tendsto (fun i => (t i,x i)) atTop (𝓝[U] (s,y)) := |
| tendsto_nhdsWithin_iff.mpr ⟨hs.prodMk_nhds hx,Eventually.of_forall (fun i => ⟨ht i,mem_insert_of_mem _ ⟨i,rfl⟩⟩)⟩ |
| intro W hW |
| exact hp (hlim W hW) |
|
|
| lemma exact_frame_tendsto {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) {s : ℝ} (hs : Tendsto t atTop (𝓝 s)) |
| {x : ℕ → Phase n} {y : Phase n} (hx : Tendsto x atTop (𝓝 y)) : |
| Tendsto (fun i => compatibleFrame (lineHomotopy J (t i) (x i))) atTop |
| (𝓝 (compatibleFrame (lineHomotopy J s y))) ∧ |
| Tendsto (fun i => (compatibleFrame (lineHomotopy J (t i) (x i))).inverse) atTop |
| (𝓝 (compatibleFrame (lineHomotopy J s y)).inverse) := by |
| have hsI : s∈Icc (0:ℝ) 1 := isClosed_Icc.mem_of_tendsto hs (Eventually.of_forall ht) |
| have hP := compatibleFrame_contDiffAt (lineHomotopy_joint_contDiffAt hJs hJ (v := (s,y)) hsI) |
| have hp := hP.continuousAt.tendsto.comp (hs.prodMk_nhds hx) |
| refine ⟨hp,?_⟩ |
| have hi : ContDiffAt ℝ ∞ (fun T : End n => T.inverse) (compatibleFrame (lineHomotopy J s y)) := |
| (compatibleFrame_invertible (lineHomotopy_compatible hJ hsI y)).contDiffAt_map_inverse |
| exact hi.continuousAt.tendsto.comp hp |
|
|
| end |
|
|
| lemma weighted_gradient_selection {X : Type*} [MetricSpace X] [ProperSpace X] |
| {f : X → ℝ} (hf : Continuous f) (hn : ∀ x,0≤f x) |
| (x : X) {R : ℝ} (hR : 0<R) (hx : 0<f x) : |
| ∃ y : X,∃ r : ℝ,0<r ∧ dist y x+r≤R ∧ 0<f y ∧ |
| R*f x≤2*r*f y ∧ ∀ z,dist z y≤r → f z≤2*f y := by |
| let g : X → ℝ := fun y => (R-dist y x)*f y |
| have hg : Continuous g := (continuous_const.sub (continuous_id.dist continuous_const)).mul hf |
| obtain ⟨y,hy,hmax⟩ := (isCompact_closedBall x R).exists_isMaxOn |
| ⟨x,Metric.mem_closedBall_self hR.le⟩ hg.continuousOn |
| have hm : R*f x≤(R-dist y x)*f y := by |
| have hh := hmax (Metric.mem_closedBall_self hR.le) |
| change (R-dist x x)*f x≤(R-dist y x)*f y at hh |
| simpa only [dist_self,sub_zero] using hh |
| have hdy : dist y x<R := by |
| by_contra! h |
| have hnz : (R-dist y x)*f y≤0 := mul_nonpos_of_nonpos_of_nonneg (by linarith) (hn y) |
| have hp := mul_pos hR hx |
| linarith |
| have hfy : 0<f y := by |
| by_contra! h |
| have hh : f y=0 := le_antisymm h (hn y) |
| rw [hh,mul_zero] at hm |
| exact (not_le_of_gt (mul_pos hR hx)) hm |
| let r : ℝ := (R-dist y x)/2 |
| have hr : 0<r := by dsimp [r] |
| have hrr : dist y x+r≤R := by dsimp [r] |
| refine ⟨y,r,hr,hrr,hfy,by dsimp [r] |
| intro z hz |
| have hzx : dist z x≤R := (dist_triangle z y x).trans (by linarith) |
| have hzg := hmax (show z∈Metric.closedBall x R from hzx) |
| change (R-dist z x)*f z≤(R-dist y x)*f y at hzg |
| have hcoef : r≤R-dist z x := by |
| have hh := dist_triangle z y x |
| dsimp [r] at * |
| linarith |
| have hh := mul_le_mul_of_nonneg_right hcoef (hn z) |
| have he : R-dist y x=2*r := by dsimp [r] |
| rw [he] at hzg |
| have hmul : r*f z≤r*(2*f y) := (hh.trans hzg).trans_eq (by ring) |
| exact (mul_le_mul_iff_right₀ hr).mp hmul |
|
|
| variable {n : ℕ} |
| local instance ecgInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance ecgInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
|
|
| def rescaledCurve (u : ℂ → Phase n) (y : ℂ) (r : ℝ) (z : ℂ) : Phase n := u (y+r • z) |
|
|
| lemma rescaledCurve_smooth {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (y : ℂ) (r : ℝ) : |
| ContDiff ℝ ∞ (rescaledCurve u y r) := hu.comp (contDiff_const.add (contDiff_id.const_smul r)) |
|
|
| lemma rescaledCurve_fderiv {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) (y : ℂ) (r : ℝ) (z : ℂ) : |
| fderiv ℝ (rescaledCurve u y r) z=r • fderiv ℝ u (y+r • z) := by |
| have hh := (hu.differentiable (by simp) (y+r • z)).hasFDerivAt.comp z |
| (((ContinuousLinearMap.id ℝ ℂ).hasFDerivAt.const_smul r).const_add y) |
| have he : (fderiv ℝ u (y+r • z)).comp (r • ContinuousLinearMap.id ℝ ℂ)= |
| r • fderiv ℝ u (y+r • z) := by ext h |
| rw [he] at hh |
| exact hh.fderiv |
|
|
| lemma rescaledCurve_CR {J : Phase n → End n} {u : ℂ → Phase n} |
| (hu : ContDiff ℝ ∞ u) (hcr : ∀ z,PseudoHolomorphicAt J u z) (y : ℂ) (r : ℝ) (z : ℂ) : |
| fderiv ℝ (rescaledCurve u y r) z Complex.I= |
| J (rescaledCurve u y r z) (fderiv ℝ (rescaledCurve u y r) z 1) := by |
| rw [rescaledCurve_fderiv hu y r z] |
| simp only [smul_apply,map_smul] |
| have hh := (hcr (y+r • z)).2 1 |
| simp only [mul_one] at hh |
| exact congrArg (fun v => r • v) hh |
|
|
| lemma rescaledCurve_source_dist (y z : ℂ) {r : ℝ} (hr : 0≤r) : dist (y+r • z) y=r*‖z‖ := by |
| rw [dist_eq_norm,add_sub_cancel_left,norm_smul,Real.norm_eq_abs,abs_of_nonneg hr] |
|
|
| theorem equicontinuous_CR_derivative_bound {ι : Type*} (J : ι → Phase n → End n) |
| (u : ι → ℂ → Phase n) (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| (hJc : ∀ i,Continuous (J i)) (hJ : ∀ i x,Compatible (J i x)) |
| (hcr : ∀ i z,PseudoHolomorphicAt (J i) (u i) z) |
| {L G : ℝ} (hL : 0≤L) (hG : 1≤G) |
| (hJL : ∀ i x y,‖J i x-J i y‖≤L*‖x-y‖) |
| (hP : ∀ i x,‖compatibleFrame (J i x)‖≤G) |
| (hPi : ∀ i x,‖(compatibleFrame (J i x)).inverse‖≤G) |
| (hm : ∀ ε : ℝ,0<ε →∃ δ : ℝ,0<δ ∧ ∀ i x y,dist x y<δ →dist (u i x) (u i y)<ε) : |
| ∃ M : ℝ,0<M ∧ ∀ i z,‖fderiv ℝ (u i) z‖≤M := by |
| have hG0 : 0<G := lt_of_lt_of_le zero_lt_one hG |
| obtain ⟨e,he,hell⟩ := local_nonlinear_gradient_small (E := Phase n) |
| (by positivity : 0≤G^3*L) (by positivity : 0≤G*2) (div_pos zero_lt_one hG0) |
| obtain ⟨d,hd,hmod⟩ := hm (e/G) (div_pos he hG0) |
| let M := max 4 (4/d)+1 |
| have hM : 0<M := by dsimp [M] |
| refine ⟨M,hM,?_⟩ |
| intro i x |
| by_contra! hgt |
| let f : ℂ → ℝ := fun z => ‖fderiv ℝ (u i) z‖ |
| have hfx : 0<f x := hM.trans hgt |
| have hfc : Continuous f := ((hu i).continuous_fderiv (by simp)).norm |
| obtain ⟨y,s,hs,hsy,hfy,hweight,hsel⟩ := weighted_gradient_selection hfc (fun _ => norm_nonneg _) x zero_lt_one hfx |
| have hs1 : s≤1 := by linarith [dist_nonneg (x := y) (y := x)] |
| have hfx4 : 4<f x := by have hh := le_max_left (4:ℝ) (4/d) |
| have hfxd : 4/d<f x := by have hh := le_max_right (4:ℝ) (4/d) |
| have hfxfy : f x≤2*f y := by |
| have hh := mul_le_mul_of_nonneg_right hs1 hfy.le |
| nlinarith only [hweight,hh] |
| have hradius : 2/f y<s := by |
| apply (div_lt_iff₀ hfy).mpr |
| nlinarith only [hweight,hfx4] |
| have hor : 2/f y<d := by |
| have hh := (div_lt_iff₀ hd).mp hfxd |
| apply (div_lt_iff₀ hfy).mpr |
| nlinarith [mul_le_mul_of_nonneg_right hfxfy hd.le] |
| let r : ℝ := (f y)⁻¹ |
| have hr : 0<r := inv_pos.mpr hfy |
| let v := rescaledCurve (u i) y r |
| have hv : ContDiff ℝ ∞ v := rescaledCurve_smooth (hu i) y r |
| have hv0 : v 0=u i y := by simp only [v,rescaledCurve,smul_zero,add_zero] |
| have hdist : ∀ z,‖z‖≤2 →dist (y+r • z) y≤2/f y := by |
| intro z hz |
| rw [rescaledCurve_source_dist y z hr.le] |
| have hh := mul_le_mul_of_nonneg_left hz hr.le |
| simpa only [r,mul_comm,div_eq_mul_inv] using hh |
| have hvd : ∀ z,‖z‖≤2 →‖fderiv ℝ v z‖≤2 := by |
| intro z hz |
| rw [rescaledCurve_fderiv (hu i),norm_smul,Real.norm_eq_abs,abs_of_nonneg hr.le] |
| have hh := hsel (y+r • z) ((hdist z hz).trans hradius.le) |
| have hm := mul_le_mul_of_nonneg_left hh hr.le |
| have hid : r*(2*f y)=2 := by dsimp [r] |
| exact hm.trans_eq hid |
| have hvd0 : ‖fderiv ℝ v 0‖=1 := by |
| rw [rescaledCurve_fderiv (hu i),smul_zero,add_zero,norm_smul,Real.norm_eq_abs,abs_of_nonneg hr.le] |
| change (f y)⁻¹*f y=1 |
| exact inv_mul_cancel₀ hfy.ne' |
| let a := u i y |
| let w := frozenCurve (J i) a v |
| have hw : ContDiff ℝ ∞ w := frozenCurve_smooth a hv |
| have hw0 : w 0=0 := by simp only [w,frozenCurve,hv0,a,sub_self,map_zero] |
| have hwb : ∀ z,‖z‖≤2 →‖w z‖≤e := by |
| intro z hz |
| have ho := hmod i (y+r • z) y ((hdist z hz).trans_lt hor) |
| rw [dist_eq_norm] at ho |
| have ht : G*‖v z-a‖<e := by |
| have hh := (lt_div_iff₀ hG0).mp ho |
| simpa only [v,rescaledCurve,a,mul_comm] using hh |
| exact ((compatibleFrame (J i a)).le_opNorm _).trans |
| ((mul_le_mul_of_nonneg_right (hP i a) (norm_nonneg _)).trans ht.le) |
| have hwD : ∀ z,‖z‖≤2 →‖fderiv ℝ w z‖≤G*2 := by |
| intro z hz |
| rw [frozenCurve_fderiv a (hv.differentiable (by simp) z)] |
| exact ((compatibleFrame (J i a)).opNorm_comp_le _).trans |
| (mul_le_mul (hP i a) (hvd z hz) (norm_nonneg _) hG0.le) |
| have hwcr : ∀ z,‖z‖<2 → fderiv ℝ w z Complex.I-Complex.I • fderiv ℝ w z 1= |
| frozenTargetCoefficient (J i) a (w z) (fderiv ℝ w z 1) := by |
| intro z _ |
| exact frozenCurve_CR (hJ i a) (hv.differentiable (by simp) z) |
| (rescaledCurve_CR (hu i) (hcr i) y r z) |
| have hh := hell (frozenTargetCoefficient (J i) a) (frozenTargetCoefficient_continuous (hJc i) a) |
| (frozenTargetCoefficient_zero _ _) (frozenTargetCoefficient_lipschitz hL hG0.le (hJL i) (hP i a) (hPi i a)) |
| w hw hw0 hwb hwD hwcr |
| have heD : ((compatibleFrame (J i a)).inverse).comp (fderiv ℝ w 0)=fderiv ℝ v 0 := by |
| rw [frozenCurve_fderiv a (hv.differentiable (by simp) 0)] |
| apply ContinuousLinearMap.ext |
| intro z |
| exact compatibleFrame_inverse_left (hJ i a) _ |
| have hnorm := ((compatibleFrame (J i a)).inverse).opNorm_comp_le (fderiv ℝ w 0) |
| rw [heD,hvd0] at hnorm |
| have hc : 1≤G*‖fderiv ℝ w 0‖ := hnorm.trans |
| (mul_le_mul_of_nonneg_right (hPi i a) (norm_nonneg _)) |
| have hlt := (lt_div_iff₀ hG0).mp hh |
| nlinarith |
| |
| end HigherDimensionalBallPacking.Rigidity |
| |
| namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| open scoped Topology ContDiff |
| open Set Filter |
| variable {X E F : Type*} [MetricSpace X] [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| |
| omit [MetricSpace X] [NormedSpace ℝ E] in |
| lemma uniform_values_cauchy_on {u : ℕ → X → E} {v : X → E} {K : Set X} |
| (hu : TendstoUniformlyOn u v atTop K) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x∈K,‖u i x-u j x‖≤ε := by |
| have hh := (tendstoUniformlyOn_iff_restrict.mp hu) |
| have hc := uniform_cauchy_of_tendstoUniformly hh |
| intro ε hε |
| obtain ⟨N,hN⟩ := hc ε hε |
| exact ⟨N,fun i hi j hj x hx => hN i hi j hj ⟨x,hx⟩⟩ |
| |
| omit [MetricSpace X] in |
| lemma uniform_clm_cauchy_on {P : ℕ → E →L[ℝ] F} {u : ℕ → X → E} {K : Set X} |
| {G M : ℝ} (hG : 0≤G) (hM : 0≤M) |
| (hP : ∀ i,‖P i‖≤G) (hu : ∀ i,∀ x∈K,‖u i x‖≤M) |
| (hPc : CauchySeq P) |
| (huc : ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x∈K,‖u i x-u j x‖≤ε) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x∈K,‖P i (u i x)-P j (u j x)‖≤ε := by |
| intro ε hε |
| have hh : 0<G+M+1 := by linarith |
| let d := ε/(G+M+1) |
| have hd : 0<d := div_pos hε hh |
| obtain ⟨N,hN⟩ := huc d hd |
| obtain ⟨Q,hQ⟩ := Metric.cauchySeq_iff.mp hPc d hd |
| refine ⟨max N Q,fun i hi j hj x hx => ?_⟩ |
| have h1 := hN i ((le_max_left _ _).trans hi) j ((le_max_left _ _).trans hj) x hx |
| have h2 := hQ i ((le_max_right _ _).trans hi) j ((le_max_right _ _).trans hj) |
| rw [dist_eq_norm] at h2 |
| have hbound := clm_pair_difference (P i) (P j) (u i x) (u j x) |
| have hA := mul_le_mul (hP i) h1 (norm_nonneg _) hG |
| have hB := mul_le_mul h2.le (hu j x hx) (norm_nonneg _) hd.le |
| have he : G*d+d*M≤ε := by |
| have hid : (G+M+1)*d=ε := mul_div_cancel₀ ε (ne_of_gt hh) |
| nlinarith |
| exact hbound.trans ((add_le_add hA hB).trans he) |
| |
| variable {n : ℕ} |
| lemma centered_rescaled_cauchy {u : ℕ → ℂ → Phase n} {v : ℂ → Phase n} |
| (hu : ∀ K : Set ℂ,IsCompact K →TendstoUniformlyOn u v atTop K) (c : ℂ) (r : ℝ) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖z‖≤2 → |
| ‖(rescaledCurve (u i) c r z-u i c)-(rescaledCurve (u j) c r z-u j c)‖≤ε := by |
| let K := (fun z : ℂ => c+r • z) '' Metric.closedBall (0:ℂ) 2 |
| have hK : IsCompact K := (isCompact_closedBall (0:ℂ) 2).image (continuous_const.add (continuous_id.const_smul r)) |
| have hval := uniform_values_cauchy_on (hu K hK) |
| intro ε hε |
| obtain ⟨N,hN⟩ := hval (ε/2) (half_pos hε) |
| refine ⟨N,fun i hi j hj z hz => ?_⟩ |
| have hzK : c+r • z∈K := ⟨z,by simpa only [Metric.mem_closedBall,dist_zero_right] using hz,rfl⟩ |
| have hcK : c∈K := ⟨0,by simp,by simp⟩ |
| have h1 := hN i hi j hj (c+r • z) hzK |
| have h2 := hN i hi j hj c hcK |
| have he : (rescaledCurve (u i) c r z-u i c)-(rescaledCurve (u j) c r z-u j c)= |
| (u i (c+r • z)-u j (c+r • z))-(u i c-u j c) := by dsimp [rescaledCurve]; abel |
| rw [he] |
| exact (norm_sub_le _ _).trans (by linarith) |
| |
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| end |
| |
| end OAI |
| |
