| import Mathlib |
| import OAI.Geometry.BallPacking.Compactness.GradientBounds |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion |
|
|
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance ljcInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance ljcInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance ljcInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance ljcInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance ljcInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance ljcInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
| local instance ljcInst7 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance |
| local instance ljcInst8 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance |
|
|
| lemma cauchy_coefficient_action {A : ℕ → HMap ℂ (E →L[ℝ] E)} {v : ℕ → HMap ℂ E} |
| (hA : CauchySeq A) (hv : CauchySeq v) : |
| CauchySeq (fun i => holderCoefficientAction (A i) (v i)) := by |
| obtain ⟨a,ha⟩ := cauchySeq_tendsto_of_complete hA |
| obtain ⟨w,hw⟩ := cauchySeq_tendsto_of_complete hv |
| have hAc : Continuous (fun x : HMap ℂ (E →L[ℝ] E) => holderCoefficientAction x) := |
| (bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip).continuous |
| have hc : Continuous (fun p : HMap ℂ (E →L[ℝ] E) × HMap ℂ E => |
| holderCoefficientAction p.1 p.2) := (hAc.comp continuous_fst).clm_apply continuous_snd |
| exact ((hc.tendsto (a,w)).comp (ha.prodMk_nhds hw)).cauchySeq |
|
|
| lemma cutoff_forcing_holder_cauchy (C D : HMap ℂ (E →L[ℝ] E)) |
| {A : ℕ → HMap ℂ (E →L[ℝ] E)} {v : ℕ → HMap ℂ E} |
| (hA : CauchySeq A) (hv : CauchySeq v) : |
| CauchySeq (fun i => holderCoefficientAction C (v i)- |
| holderCoefficientAction (A i) (holderCoefficientAction D (v i))) := by |
| have hC := cauchy_coefficient_action (E := E) (cauchySeq_const (x := C)) hv |
| have hD := cauchy_coefficient_action (E := E) (cauchySeq_const (x := D)) hv |
| obtain ⟨c,hc⟩ := cauchySeq_tendsto_of_complete hC |
| obtain ⟨d,hd⟩ := cauchySeq_tendsto_of_complete (cauchy_coefficient_action hA hD) |
| exact (hc.sub hd).cauchySeq |
|
|
| theorem cutoff_jet_cauchy (b : ContDiffBump (0:ℂ)) {L : ℝ} (hL : 0≤L) : |
| ∃ δ : ℝ,0<δ ∧ ∀ (u : ℕ → ℂ → E) (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| (A : ℕ → ℂ → E →L[ℝ] E), |
| (∀ i,Continuous (A i)) →(∀ i,u i 0=0) → |
| (∀ i z,‖A i z‖≤δ) → |
| (∀ i x y,‖A i x-A i y‖≤L*dist x y) → |
| (∃ M H : ℝ,0≤M ∧ 0≤H ∧ (∀ i z,‖u i z‖≤M) ∧ |
| ∀ i x y,‖u i x-u i y‖≤H*dist x y) → |
| (∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖u i z-u j z‖≤ε) → |
| (∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖A i z-A j z‖≤ε) → |
| (∀ i z,b z≠0 →fderiv ℝ (u i) z Complex.I-Complex.I • fderiv ℝ (u i) z 1= |
| A i z (fderiv ℝ (u i) z 1)) → |
| CauchySeq (fun i => cutoffCurveJet b (hu i)) := by |
| obtain ⟨ε,hε,hcauchy⟩ := small_coefficient_cauchy (E := E) (isCompact_closedBall (0:ℂ) b.rOut) |
| obtain ⟨δ,hδ,hsmall⟩ := holder_small_of_small_value (X := ℂ) (E := E →L[ℝ] E) hL hε |
| refine ⟨δ,hδ,?_⟩ |
| intro u hu A hAc h0 hAb hAl hUb hUc hAcc hcr |
| obtain ⟨M,H,hM,hH,hUb,hUl⟩ := hUb |
| obtain ⟨B,hB,hD,hDL,hC,hCL⟩ := cutoff_transport_bounds (E := E) b |
| let V : ℕ → HMap ℂ E := fun i => ofBoundedLipschitz (u i) (hu i).continuous M H hM hH (hUb i) (hUl i) |
| let T : ℕ → HMap ℂ (E →L[ℝ] E) := fun i => ofBoundedLipschitz (A i) (hAc i) δ L hδ.le hL (hAb i) (hAl i) |
| let C : HMap ℂ (E →L[ℝ] E) := ofBoundedLipschitz (cutoffCommute b) |
| (cutoffCommute_smooth b).continuous B B hB.le hB.le hC hCL |
| let D : HMap ℂ (E →L[ℝ] E) := ofBoundedLipschitz (cutoffTransport b 1) |
| (cutoffTransport_smooth b 1).continuous B B hB.le hB.le hD hDL |
| let f : ℕ → HMap ℂ E := fun i => holderCoefficientAction C (V i)- |
| holderCoefficientAction (T i) (holderCoefficientAction D (V i)) |
| have hVc : CauchySeq V := holder_cauchy_of_uniform_values hH hUl hUc |
| have hTc : CauchySeq T := holder_cauchy_of_uniform_values hL hAl hAcc |
| have hfc : CauchySeq f := cutoff_forcing_holder_cauchy C D hTc hVc |
| apply hcauchy (fun i => cutoffCurveJet b (hu i)) T f |
| (fun i => cutoffCurveJet_zero b (hu i) (h0 i)) (fun i => cutoffCurveJet_supported b (hu i)) |
| (fun i => (hsmall (T i) (hAb i) (hAl i)).le) ?_ hTc hfc |
| intro i |
| apply cutoffCurveJet_CR b (hu i) (hcr i) (T i) (fun _ _ => rfl) (f i) |
| intro z |
| rfl |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance lsoInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance lsoInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance lsoInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance lsoInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance lsoInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance lsoInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
| local instance lsoInst7 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance |
| local instance lsoInst8 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance |
|
|
| lemma common_small_value_scale {L K d : ℝ} (hL : 0≤L) (hK : 0≤K) (hd : 0<d) : |
| ∃ δ : ℝ,0<δ ∧ δ≤1 ∧ L*δ≤d ∧ K*δ≤d := by |
| have hp : 0<L+K+1 := by linarith |
| let δ := min 1 (d/(L+K+1)) |
| have hδ : 0<δ := lt_min zero_lt_one (div_pos hd hp) |
| have hm : (L+K+1)*δ≤d := by |
| have h := (le_div_iff₀ hp).mp (min_le_right 1 (d/(L+K+1))) |
| simpa only [mul_comm] using h |
| refine ⟨δ,hδ,min_le_left _ _,?_,?_⟩ <;> nlinarith |
|
|
| omit [CompleteSpace E] in |
| lemma cutoffCurveJet_deriv_zero (b : ContDiffBump (0:ℂ)) {u : ℂ → E} |
| (hu : ContDiff ℝ ∞ u) (h0 : u 0=0) : |
| cDeriv (cutoffCurveJet b hu) 0=fderiv ℝ u 0 := by |
| ext h |
| rw [cutoffCurveJet_deriv,h0,smul_zero,zero_add, |
| b.one_of_mem_closedBall (Metric.mem_closedBall_self b.rIn_pos.le),one_smul] |
|
|
| theorem bounded_cutoff_gradient_small (b : ContDiffBump (0:ℂ)) |
| {L H η : ℝ} (hL : 0≤L) (hH : 0≤H) (hη : 0<η) : |
| ∃ δ : ℝ,0<δ ∧ ∀ (F : E → E →L[ℝ] E),Continuous F → F 0=0 → |
| (∀ x y,‖F x-F y‖≤L*‖x-y‖) → ∀ u : ℂ → E,ContDiff ℝ ∞ u → u 0=0 → |
| (∀ z,‖u z‖≤δ) → (∀ x y,‖u x-u y‖≤H*dist x y) → |
| (∀ z,b z≠0 → fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1= |
| F (u z) (fderiv ℝ u z 1)) → ‖fderiv ℝ u 0‖<η := by |
| obtain ⟨B,hB,hD,hDL,hC,hCL⟩ := cutoff_transport_bounds (E := E) b |
| let M : ℝ := B*(H+1)+L*(B*(H+1))+L*H*B |
| have hM : 0≤M := by dsimp [M]; positivity |
| obtain ⟨d,hd,hsmall⟩ := small_value_elliptic_estimate (E := E) |
| (isCompact_closedBall (0:ℂ) b.rOut) (mul_nonneg hL hH) hM hη |
| obtain ⟨δ,hδ,hδ1,hδA,hδf⟩ := common_small_value_scale hL |
| (by positivity : 0≤(1+L)*B) hd |
| refine ⟨δ,hδ,?_⟩ |
| intro F hF hF0 hFL u hu h0 hub hul hcr |
| let A : ℂ → E →L[ℝ] E := fun z => F (u z) |
| have hAc : Continuous A := hF.comp hu.continuous |
| have hAb : ∀ z,‖A z‖≤L*δ := by |
| intro z |
| have hh := hFL (u z) 0 |
| rw [hF0,sub_zero,sub_zero] at hh |
| exact hh.trans (mul_le_mul_of_nonneg_left (hub z) hL) |
| have hAl : ∀ x y,‖A x-A y‖≤(L*H)*dist x y := by |
| intro x y |
| exact (hFL (u x) (u y)).trans ((mul_le_mul_of_nonneg_left (hul x y) hL).trans_eq (by ring)) |
| let ac : HMap ℂ (E →L[ℝ] E) := ofBoundedLipschitz A hAc (L*δ) (L*H) |
| (mul_nonneg hL hδ.le) (mul_nonneg hL hH) hAb hAl |
| have hbds := cutoff_forcing_bounds hδ.le hδ1 hH hL hB.le hub hul hAb hAl hC hCL hD hDL |
| let g : ℂ → E := fun z => cutoffCommute b z (u z)-A z (cutoffTransport b 1 z (u z)) |
| have hgc : Continuous g := ((cutoffCommute_smooth b).continuous.clm_apply hu.continuous).sub |
| (hAc.clm_apply ((cutoffTransport_smooth b 1).continuous.clm_apply hu.continuous)) |
| let f : HMap ℂ E := ofBoundedLipschitz g hgc (((1+L)*B)*δ) M |
| (by positivity) hM hbds.1 hbds.2 |
| have hAe : ∀ z,valueCLM _ ac z=A z := fun _ => rfl |
| have hfe : ∀ z,valueCLM _ f z=g z := fun _ => rfl |
| have heq : standardJetCR (cutoffCurveJet b hu)= |
| holderCoefficientAction ac (jetDirectional 1 (cutoffCurveJet b hu))+f := by |
| apply cutoffCurveJet_CR b hu hcr ac (fun z _ => hAe z) f |
| intro z |
| rw [hfe,hAe] |
| exact rfl |
| have hh := hsmall (cutoffCurveJet b hu) (cutoffCurveJet_zero b hu h0) |
| (cutoffCurveJet_supported b hu) ac f (fun z => (hAb z).trans hδA) hAl |
| (fun z => (hbds.1 z).trans hδf) hbds.2 heq |
| have hder : ‖fderiv ℝ u 0‖≤‖cutoffCurveJet b hu‖ := by |
| rw [←cutoffCurveJet_deriv_zero b hu h0] |
| exact c_deriv_bound _ _ |
| exact hder.trans_lt hh |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance legInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance legInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
|
|
| omit [CompleteSpace E] in |
| lemma smooth_cutoff_local_bounds (b : ContDiffBump (0:ℂ)) {u : ℂ → E} |
| (hu : ContDiff ℝ ∞ u) {R δ H : ℝ} (hR : b.rOut≤R) (hδ : 0≤δ) (hδ1 : δ≤1) (hH : 0≤H) |
| (hb : ∀ z,‖z‖≤R → ‖u z‖≤δ) (hd : ∀ z,‖z‖≤R → ‖fderiv ℝ u z‖≤H) : |
| ∃ K : ℝ,0≤K ∧ K=(boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport).bound ∧ |
| (∀ z,‖b z • u z‖≤δ) ∧ |
| (∀ z,‖fderiv ℝ (fun z => b z • u z) z‖≤H+K) := by |
| let hs := boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport |
| let K := hs.bound |
| have hK : 0≤K := hs.bound_nonneg |
| have hbn (z : ℂ) : ‖b z‖≤1 := by |
| rw [Real.norm_eq_abs,abs_of_nonneg b.nonneg] |
| exact b.le_one |
| have hder (z : ℂ) : fderiv ℝ (fun z => b z • u z) z= |
| b z • fderiv ℝ u z+(fderiv ℝ b z).smulRight (u z) := |
| fderiv_fun_smul (b.contDiff.differentiable (by simp : (∞ : WithTop ℕ∞)≠0) z) |
| (hu.differentiable (by simp : (∞ : WithTop ℕ∞)≠0) z) |
| have hzouts (z : ℂ) (hz : ¬‖z‖≤R) : b z=0 ∧ fderiv ℝ b z=0 := by |
| have hn : z∉tsupport b := by |
| rw [b.tsupport_eq,Metric.mem_closedBall,dist_zero_right] |
| exact fun hh => hz (hh.trans hR) |
| exact ⟨image_eq_zero_of_notMem_tsupport hn,fderiv_of_notMem_tsupport ℝ hn⟩ |
| refine ⟨K,hK,rfl,?_,?_⟩ |
| · intro z |
| by_cases hz : ‖z‖≤R |
| · rw [norm_smul] |
| exact (mul_le_mul (hbn z) (hb z hz) (norm_nonneg _) zero_le_one).trans_eq (one_mul _) |
| · rw [(hzouts z hz).1,zero_smul,norm_zero]; exact hδ |
| · intro z |
| by_cases hz : ‖z‖≤R |
| · rw [hder] |
| have h1 : ‖b z • fderiv ℝ u z‖≤H := by |
| rw [norm_smul] |
| exact (mul_le_mul (hbn z) (hd z hz) (norm_nonneg _) zero_le_one).trans_eq (one_mul _) |
| have h2 : ‖(fderiv ℝ b z).smulRight (u z)‖≤K := by |
| rw [ContinuousLinearMap.norm_smulRight_apply] |
| have h := mul_le_mul (hs.norm_fderiv_le z) (hb z hz) (norm_nonneg _) hK |
| exact h.trans (by nlinarith) |
| exact (norm_add_le _ _).trans (add_le_add h1 h2) |
| · rw [hder,(hzouts z hz).1,(hzouts z hz).2] |
| simp only [zero_smul,ContinuousLinearMap.zero_smulRight,add_zero,norm_zero] |
| positivity |
|
|
| theorem local_nonlinear_gradient_small {L H η : ℝ} (hL : 0≤L) (hH : 0≤H) (hη : 0<η) : |
| ∃ δ : ℝ,0<δ ∧ ∀ (F : E → E →L[ℝ] E),Continuous F → F 0=0 → |
| (∀ x y,‖F x-F y‖≤L*‖x-y‖) → ∀ u : ℂ → E,ContDiff ℝ ∞ u → u 0=0 → |
| (∀ z,‖z‖≤2 → ‖u z‖≤δ) → (∀ z,‖z‖≤2 → ‖fderiv ℝ u z‖≤H) → |
| (∀ z,‖z‖<2 → fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1= |
| F (u z) (fderiv ℝ u z 1)) → ‖fderiv ℝ u 0‖<η := by |
| let b : ContDiffBump (0:ℂ) := ⟨1/4,1/2,by norm_num,by norm_num⟩ |
| let c : ContDiffBump (0:ℂ) := ⟨1,3/2,by norm_num,by norm_num⟩ |
| let hc := boundedCThree_of_compactSupport c.contDiff c.hasCompactSupport |
| have hH' : 0≤H+hc.bound := add_nonneg hH hc.bound_nonneg |
| obtain ⟨d,hd,hsmall⟩ := bounded_cutoff_gradient_small (E := E) b hL hH' hη |
| let δ := min d 1 |
| have hδ : 0<δ := lt_min hd zero_lt_one |
| refine ⟨δ,hδ,?_⟩ |
| intro F hF hF0 hFL u hu h0 hb hdu hcr |
| let w : ℂ → E := fun z => c z • u z |
| have hw : ContDiff ℝ ∞ w := c.contDiff.smul hu |
| have hw0 : w 0=0 := by simp only [w,h0,smul_zero] |
| obtain ⟨K,hK,hKe,hwb,hwd⟩ := smooth_cutoff_local_bounds c hu (by change (3:ℝ)/2≤2; norm_num) |
| hδ.le (min_le_right _ _) hH hb hdu |
| have hwl : ∀ x y,‖w x-w y‖≤(H+hc.bound)*dist x y := by |
| intro x y |
| rw [dist_eq_norm] |
| apply norm_sub_le_of_deriv_bound (hw.differentiable (by simp)) |
| intro z |
| simpa only [hKe] using hwd z |
| have hwne (z : ℂ) (hz : ‖z‖<1) : w =ᶠ[𝓝 z] u := by |
| have he := c.eventuallyEq_one_of_mem_ball (show z∈Metric.ball (0:ℂ) c.rIn by |
| simpa only [Metric.mem_ball,dist_zero_right] using hz) |
| filter_upwards [he] with y hy |
| change c y • u y=u y |
| rw [hy]; exact one_smul ℝ (u y) |
| have hcrw : ∀ z,b z≠0 → fderiv ℝ w z Complex.I-Complex.I • fderiv ℝ w z 1= |
| F (w z) (fderiv ℝ w z 1) := by |
| intro z hz |
| have hz' : ‖z‖<(1:ℝ)/2 := by |
| have hs : z∈Function.support b := hz |
| rw [b.support_eq] at hs |
| simpa only [Metric.mem_ball,dist_zero_right] using hs |
| have he := hwne z (by linarith) |
| rw [he.fderiv_eq,he.eq_of_nhds] |
| exact hcr z (by linarith) |
| have hh := hsmall F hF hF0 hFL w hw hw0 (fun z => (hwb z).trans (min_le_left _ _)) hwl hcrw |
| rwa [(hwne 0 (by simp)).fderiv_eq] at hh |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance djcInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance djcInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance djcInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance djcInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
|
|
| lemma uniform_cauchy_comp_lipschitz {X Y Z : Type*} [NormedAddCommGroup Y] |
| [NormedAddCommGroup Z] {F : ℕ → Y → Z} {u : ℕ → X → Y} {L M : ℝ} |
| (hL : 0≤L) (hF : ∀ i x y,‖F i x-F i y‖≤L*‖x-y‖) |
| (hb : ∀ i x,‖u i x‖≤M) |
| (hu : ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x,‖u i x-u j x‖≤ε) |
| (hFc : ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ y,‖y‖≤M →‖F i y-F j y‖≤ε) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ x,‖F i (u i x)-F j (u j x)‖≤ε := by |
| intro ε hε |
| obtain ⟨N,hN⟩ := hu (ε/(2*(L+1))) (div_pos hε (by linarith)) |
| obtain ⟨M,hM⟩ := hFc (ε/2) (half_pos hε) |
| refine ⟨max N M,fun i hi j hj x => ?_⟩ |
| have h1 := hN i ((le_max_left _ _).trans hi) j ((le_max_left _ _).trans hj) x |
| have h2 := hM i ((le_max_right _ _).trans hi) j ((le_max_right _ _).trans hj) (u j x) (hb j x) |
| have hp : 0<L+1 := by linarith |
| have hscale : L*(ε/(2*(L+1)))≤ε/2 := by |
| apply (le_div_iff₀ (by norm_num : (0:ℝ)<2)).mpr |
| have he : (2*(L+1))*(ε/(2*(L+1)))=ε := mul_div_cancel₀ ε (by positivity) |
| have hd : 0≤ε/(2*(L+1)) := by positivity |
| nlinarith |
| have hbound : ‖F i (u i x)-F i (u j x)‖≤ε/2 := |
| (hF i _ _).trans ((mul_le_mul_of_nonneg_left h1 hL).trans hscale) |
| exact (norm_sub_le_norm_sub_add_norm_sub _ _ _).trans (by linarith) |
|
|
| omit [CompleteSpace E] in |
| lemma cutoff_uniform_cauchy (c : ContDiffBump (0:ℂ)) {R : ℝ} (hc : c.rOut≤R) |
| {u : ℕ → ℂ → E} |
| (hu : ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖z‖≤R →‖u i z-u j z‖≤ε) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖c z • u i z-c z • u j z‖≤ε := by |
| intro ε hε |
| obtain ⟨N,hN⟩ := hu ε hε |
| refine ⟨N,fun i hi j hj z => ?_⟩ |
| by_cases hz : ‖z‖≤R |
| · rw [←smul_sub,norm_smul,Real.norm_eq_abs,abs_of_nonneg c.nonneg] |
| exact (mul_le_mul c.le_one (hN i hi j hj z hz) (norm_nonneg _) zero_le_one).trans_eq (one_mul _) |
| · have hz' : z∉tsupport c := by |
| rw [c.tsupport_eq,Metric.mem_closedBall,dist_zero_right] |
| exact fun hh => hz (hh.trans hc) |
| simp only [image_eq_zero_of_notMem_tsupport hz',zero_smul,sub_self,norm_zero] |
| exact hε.le |
|
|
| def smallDiskBump : ContDiffBump (0:ℂ) := ⟨1/4,1/2,by norm_num,by norm_num⟩ |
| def largerDiskBump : ContDiffBump (0:ℂ) := ⟨1,3/2,by norm_num,by norm_num⟩ |
|
|
| omit [CompleteSpace E] in |
| lemma double_disk_cutoff {u : ℂ → E} (hu : ContDiff ℝ ∞ u) : |
| cutoffCurveJet smallDiskBump (largerDiskBump.contDiff.smul hu)=cutoffCurveJet smallDiskBump hu := by |
| apply cValue_ext |
| intro z |
| simp only [cutoffCurveJet_value] |
| by_cases hz : smallDiskBump z=0 |
| · rw [hz,zero_smul,zero_smul] |
| · have hr : ‖z‖<(1:ℝ)/2 := by |
| have hh : z∈Function.support smallDiskBump := hz |
| rw [smallDiskBump.support_eq,Metric.mem_ball,dist_zero_right] at hh |
| exact hh |
| have hc : largerDiskBump z=1 := largerDiskBump.one_of_mem_closedBall (by |
| rw [Metric.mem_closedBall,dist_zero_right] |
| change ‖z‖≤(1:ℝ) |
| linarith) |
| change smallDiskBump z • (largerDiskBump z • u z)=_ |
| rw [hc,one_smul] |
|
|
| theorem disk_nonlinear_jet_cauchy {L H : ℝ} (hL : 0≤L) (hH : 0≤H) : |
| ∃ δ : ℝ,0<δ ∧ ∀ (u : ℕ → ℂ → E) (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| (F : ℕ → E → E →L[ℝ] E), |
| (∀ i,Continuous (F i)) →(∀ i,F i 0=0) → |
| (∀ i x y,‖F i x-F i y‖≤L*‖x-y‖) →(∀ i,u i 0=0) → |
| (∀ i z,‖z‖≤2 →‖u i z‖≤δ) → |
| (∀ i z,‖z‖≤2 →‖fderiv ℝ (u i) z‖≤H) → |
| (∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ z,‖z‖≤2 →‖u i z-u j z‖≤ε) → |
| (∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N,∀ v,‖v‖≤δ →‖F i v-F j v‖≤ε) → |
| (∀ i z,‖z‖<2 →fderiv ℝ (u i) z Complex.I-Complex.I • fderiv ℝ (u i) z 1= |
| F i (u i z) (fderiv ℝ (u i) z 1)) → |
| CauchySeq (fun i => cutoffCurveJet smallDiskBump (hu i)) := by |
| let c := largerDiskBump |
| let B := (boundedCThree_of_compactSupport c.contDiff c.hasCompactSupport).bound |
| have hB : 0≤B := (boundedCThree_of_compactSupport c.contDiff c.hasCompactSupport).bound_nonneg |
| obtain ⟨d,hd,hcauchy⟩ := cutoff_jet_cauchy (E := E) smallDiskBump (mul_nonneg hL (add_nonneg hH hB)) |
| let δ := min 1 (d/(L+1)) |
| have hδ : 0<δ := lt_min zero_lt_one (div_pos hd (by linarith)) |
| have hδd : L*δ≤d := by |
| have hh := (le_div_iff₀ (by linarith : 0<L+1)).mp (min_le_right (1:ℝ) (d/(L+1))) |
| nlinarith |
| refine ⟨δ,hδ,?_⟩ |
| intro u hu F hFc hF0 hFL h0 hUb hUd hUc hFuc hcr |
| let w : ℕ → ℂ → E := fun i z => c z • u i z |
| have hw : ∀ i,ContDiff ℝ ∞ (w i) := fun i => c.contDiff.smul (hu i) |
| have hw0 : ∀ i,w i 0=0 := by intro i; simp only [w,h0 i,smul_zero] |
| have hwb : ∀ i z,‖w i z‖≤δ := by |
| intro i |
| exact (smooth_cutoff_local_bounds c (hu i) (by change (3:ℝ)/2≤2; norm_num) |
| hδ.le (min_le_left _ _) hH (hUb i) (hUd i)).choose_spec.2.2.1 |
| have hwd : ∀ i z,‖fderiv ℝ (w i) z‖≤H+B := by |
| intro i |
| obtain ⟨K,hK,hKe,_,hh⟩ := smooth_cutoff_local_bounds c (hu i) (by change (3:ℝ)/2≤2; norm_num) |
| hδ.le (min_le_left _ _) hH (hUb i) (hUd i) |
| simpa only [hKe] using hh |
| have hwl : ∀ i x y,‖w i x-w i y‖≤(H+B)*dist x y := by |
| intro i x y |
| rw [dist_eq_norm] |
| exact norm_sub_le_of_deriv_bound ((hw i).differentiable (by simp)) (hwd i) x y |
| have hwc := cutoff_uniform_cauchy (E := E) c (by change (3:ℝ)/2≤2; norm_num) hUc |
| let A : ℕ → ℂ → E →L[ℝ] E := fun i z => F i (w i z) |
| have hAb : ∀ i z,‖A i z‖≤d := by |
| intro i z |
| have hh := hFL i (w i z) 0 |
| rw [hF0 i,sub_zero,sub_zero] at hh |
| exact hh.trans ((mul_le_mul_of_nonneg_left (hwb i z) hL).trans hδd) |
| have hAl : ∀ i x y,‖A i x-A i y‖≤(L*(H+B))*dist x y := by |
| intro i x y |
| exact (hFL i _ _).trans ((mul_le_mul_of_nonneg_left (hwl i x y) hL).trans_eq (by ring)) |
| have hAc := uniform_cauchy_comp_lipschitz hL hFL hwb hwc hFuc |
| have heq (i : ℕ) (z : ℂ) (hz : ‖z‖<1) : w i =ᶠ[𝓝 z] u i := by |
| have he := c.eventuallyEq_one_of_mem_ball (show z∈Metric.ball (0:ℂ) c.rIn by |
| rw [Metric.mem_ball,dist_zero_right] |
| change ‖z‖<(1:ℝ) |
| exact hz) |
| filter_upwards [he] with y hy |
| change c y • u i y=u i y |
| rw [hy]; exact one_smul ℝ (u i y) |
| have hres : ∀ i z,smallDiskBump z≠0 → |
| fderiv ℝ (w i) z Complex.I-Complex.I • fderiv ℝ (w i) z 1=A i z (fderiv ℝ (w i) z 1) := by |
| intro i z hz |
| have hr : ‖z‖<(1:ℝ)/2 := by |
| have hh : z∈Function.support smallDiskBump := hz |
| rw [smallDiskBump.support_eq,Metric.mem_ball,dist_zero_right] at hh |
| exact hh |
| have he := heq i z (by linarith) |
| change _=F i (w i z) _ |
| rw [he.fderiv_eq,he.eq_of_nhds] |
| exact hcr i z (by linarith) |
| have hh := hcauchy w hw A (fun i => (hFc i).comp (hw i).continuous) hw0 hAb hAl |
| ⟨δ,H+B,hδ.le,add_nonneg hH hB,hwb,hwl⟩ hwc hAc hres |
| have he (i : ℕ) : cutoffCurveJet smallDiskBump (hw i)=cutoffCurveJet smallDiskBump (hu i) := by |
| change cutoffCurveJet smallDiskBump (largerDiskBump.contDiff.smul (hu i))=_ |
| exact double_disk_cutoff (hu i) |
| simpa only [he] using hh |
|
|
|
|
| end |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {n : ℕ} |
|
|
| def compatibleFrame (J : End n) : End n := cayleyP J 1 1 |
|
|
| @[simp] lemma compatibleFrame_apply (J : End n) (v : Phase n) : |
| compatibleFrame J v = -standardJ n (J v)+v := by |
| simp only [compatibleFrame,cayleyP_apply,one_smul,relativeOperator_apply] |
|
|
| lemma compatibleFrame_intertwine {J : End n} (hJ : Compatible J) (v : Phase n) : |
| compatibleFrame J (J v) = standardJ n (compatibleFrame J v) := by |
| simp only [compatibleFrame_apply,hJ.1,map_neg,map_add,standardJ_sq,neg_neg] |
| abel |
|
|
| lemma compatibleFrame_invertible {J : End n} (hJ : Compatible J) : |
| (compatibleFrame J).IsInvertible := cayleyP_invertible hJ zero_lt_one zero_le_one |
|
|
| lemma compatibleFrame_standard : |
| compatibleFrame (standardJ n) = (2:ℝ) • ContinuousLinearMap.id ℝ (Phase n) := by |
| ext v i |
| simp only [compatibleFrame_apply,standardJ_sq,neg_neg,Pi.add_apply, |
| smul_apply,ContinuousLinearMap.id_apply,Pi.smul_apply] |
| exact (two_smul ℝ (v i)).symm |
|
|
| lemma compatibleFrame_smooth {D : Type*} [NormedAddCommGroup D] [NormedSpace ℝ D] |
| {A : D → End n} (hA : ContDiff ℝ ∞ A) : ContDiff ℝ ∞ (fun z => compatibleFrame (A z)) := by |
| have hI : ContDiff ℝ ∞ (fun _ : D => standardJ n) := contDiff_const |
| simpa only [compatibleFrame,cayleyP,one_smul,relativeOperator] using |
| ((hI.clm_comp hA).neg.add (contDiff_const (c := ContinuousLinearMap.id ℝ (Phase n)))) |
|
|
| lemma compatibleFrame_inverse_smooth {D : Type*} [NormedAddCommGroup D] [NormedSpace ℝ D] |
| {A : D → End n} (hA : ContDiff ℝ ∞ A) (hc : ∀ z, Compatible (A z)) : |
| ContDiff ℝ ∞ (fun z => (compatibleFrame (A z)).inverse) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro z |
| exact (compatibleFrame_invertible (hc z)).contDiffAt_map_inverse.comp z |
| (compatibleFrame_smooth hA).contDiffAt |
|
|
| lemma compatibleFrame_inverse_left {J : End n} (hJ : Compatible J) (v : Phase n) : |
| (compatibleFrame J).inverse (compatibleFrame J v) = v := by |
| obtain ⟨e,he⟩ := compatibleFrame_invertible hJ |
| rw [←he] |
| simp only [ContinuousLinearMap.inverse_equiv,ContinuousLinearEquiv.coe_coe, |
| ContinuousLinearEquiv.symm_apply_apply] |
|
|
| lemma compatibleFrame_inverse_right {J : End n} (hJ : Compatible J) (v : Phase n) : |
| compatibleFrame J ((compatibleFrame J).inverse v) = v := by |
| obtain ⟨e,he⟩ := compatibleFrame_invertible hJ |
| rw [←he] |
| simp only [ContinuousLinearMap.inverse_equiv,ContinuousLinearEquiv.coe_coe, |
| ContinuousLinearEquiv.apply_symm_apply] |
|
|
| lemma compatibleFrame_inverse_standard : |
| (compatibleFrame (standardJ n)).inverse = (1/2:ℝ) • ContinuousLinearMap.id ℝ (Phase n) := by |
| apply ContinuousLinearMap.ext |
| intro v |
| obtain ⟨e,he⟩ := compatibleFrame_invertible (compatible_standardJ n) |
| apply (show Function.Injective (compatibleFrame (standardJ n)) by rw [←he]; exact e.injective) |
| rw [compatibleFrame_inverse_right (compatible_standardJ n)] |
| change v = compatibleFrame (standardJ n) ((1/2:ℝ) • v) |
| rw [compatibleFrame_standard] |
| simp only [smul_apply,ContinuousLinearMap.id_apply,smul_smul] |
| norm_num |
|
|
| variable {K : Set ℂ} (hK : IsCompact K) {A : ℂ → End n} |
| (hA : ContDiff ℝ ∞ A) (hc : ∀ z, Compatible (A z)) |
| (hstd : ∀ z ∉ K, A z = standardJ n) |
|
|
| include hK hstd in |
| lemma compatibleFrame_compactPerturbation : |
| HasCompactSupport (fun z => compatibleFrame (A z) - (2:ℝ) • ContinuousLinearMap.id ℝ (Phase n)) := by |
| apply HasCompactSupport.of_support_subset_isCompact hK |
| intro z hz |
| by_contra hzK |
| apply hz |
| change compatibleFrame (A z) - (2:ℝ) • ContinuousLinearMap.id ℝ (Phase n) = 0 |
| rw [hstd z hzK,compatibleFrame_standard,sub_self] |
|
|
| include hK hstd in |
| lemma compatibleFrame_inverse_compactPerturbation : |
| HasCompactSupport (fun z => (compatibleFrame (A z)).inverse - (1/2:ℝ) • ContinuousLinearMap.id ℝ (Phase n)) := by |
| apply HasCompactSupport.of_support_subset_isCompact hK |
| intro z hz |
| by_contra hzK |
| apply hz |
| change (compatibleFrame (A z)).inverse - (1/2:ℝ) • ContinuousLinearMap.id ℝ (Phase n) = 0 |
| rw [hstd z hzK,compatibleFrame_inverse_standard,sub_self] |
|
|
| def compatibleFrameJet : COne ℂ (End n) := |
| ofBoundedCThree (boundedCThree_of_compactPerturbation (compatibleFrame_smooth hA) _ |
| (compatibleFrame_compactPerturbation hK hstd)) |
|
|
| def compatibleInverseJet : COne ℂ (End n) := |
| ofBoundedCThree (boundedCThree_of_compactPerturbation (compatibleFrame_inverse_smooth hA hc) _ |
| (compatibleFrame_inverse_compactPerturbation hK hstd)) |
|
|
| @[simp] lemma compatibleFrameJet_value (z : ℂ) : |
| cValue (compatibleFrameJet hK hA hstd) z = compatibleFrame (A z) := rfl |
|
|
| @[simp] lemma compatibleInverseJet_value (z : ℂ) : |
| cValue (compatibleInverseJet hK hA hc hstd) z = (compatibleFrame (A z)).inverse := rfl |
|
|
| def compatibleMarkedEquiv : markedModel (E := Phase n) K ≃L[ℝ] markedModel (E := Phase n) K := |
| markedCoefficientEquiv hK.isClosed (compatibleFrameJet hK hA hstd) |
| (compatibleInverseJet hK hA hc hstd) 2 (1/2) |
| (by intro z hz; rw [compatibleFrameJet_value,hstd z hz,compatibleFrame_standard]) |
| (by intro z hz; rw [compatibleInverseJet_value,hstd z hz,compatibleFrame_inverse_standard]) |
| (by intro z v; exact compatibleFrame_inverse_left (hc z) v) |
| (by intro z v; exact compatibleFrame_inverse_right (hc z) v) |
|
|
| def compatibleResidualEquiv : supportedHolder (E := Phase n) K ≃L[ℝ] supportedHolder (E := Phase n) K := |
| supportedCoefficientEquiv (jetValueCLM _ (compatibleFrameJet hK hA hstd)) |
| (jetValueCLM _ (compatibleInverseJet hK hA hc hstd)) |
| (by intro z v; exact compatibleFrame_inverse_left (hc z) v) |
| (by intro z v; exact compatibleFrame_inverse_right (hc z) v) |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| end |
|
|
| end OAI |
|
|
