| import Mathlib |
| import OAI.Geometry.BallPacking.Holder.MarkedJets |
|
|
| 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 markedFrameInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance markedFrameInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance markedFrameInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance markedFrameInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance markedFrameInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance markedFrameInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| omit [CompleteSpace E] in |
| lemma coefficientDeriv_zero_outside {K : Set ℂ} (hK : IsClosed K) |
| (M : COne ℂ (E →L[ℝ] E)) (c : ℝ) |
| (hM : ∀ z ∉ K, cValue M z = c • ContinuousLinearMap.id ℝ E) |
| {z : ℂ} (hz : z ∉ K) : cDeriv M z = 0 := by |
| have he : (cValue M : ℂ → E →L[ℝ] E) =ᶠ[𝓝 z] fun _ => c • ContinuousLinearMap.id ℝ E := by |
| filter_upwards [hK.isOpen_compl.mem_nhds hz] with w hw |
| exact hM w hw |
| rw [← c_fderiv,he.fderiv_eq] |
| exact (hasFDerivAt_const (𝕜 := ℝ) (c • ContinuousLinearMap.id ℝ E) z).fderiv |
|
|
| omit [CompleteSpace E] in |
| lemma coefficientAction_mem_marked {K : Set ℂ} (hK : IsClosed K) |
| (M : COne ℂ (E →L[ℝ] E)) (c : ℝ) |
| (hM : ∀ z ∉ K, cValue M z = c • ContinuousLinearMap.id ℝ E) |
| {u : COne ℂ E} (hu : u ∈ markedModel K) : coefficientAction M u ∈ markedModel K := by |
| refine ⟨?_,?_⟩ |
| · change cValue M 0 (cValue u 0) = 0 |
| have hu0 : cValue u 0 = 0 := hu.1 |
| rw [hu0,map_zero] |
| · change standardJetCR (coefficientAction M u) ∈ supportedHolder K |
| apply (mem_supportedHolder _ K).mpr |
| intro z hz |
| have hzD := coefficientDeriv_zero_outside hK M c hM hz |
| have hzC := hM z hz |
| have huZ := (mem_supportedHolder (standardJetCR u) K).mp hu.2 z hz |
| rw [standardJetCR_value] at huZ |
| rw [standardJetCR_value,coefficientAction_deriv] |
| simp only [add_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearMap.flip_apply,hzD,zero_apply,add_zero,hzC, |
| smul_apply,ContinuousLinearMap.id_apply] |
| rw [smul_comm Complex.I c,←smul_sub] |
| exact (congrArg (fun v : E => c • v) huZ).trans (smul_zero c) |
|
|
| variable {K : Set ℂ} |
| local instance markedFrameInst7 : NormedAddCommGroup (markedModel (E := E) K) := inferInstance |
| local instance markedFrameInst8 : NormedSpace ℝ (markedModel (E := E) K) := inferInstance |
| local instance markedFrameInst9 : NormedAddCommGroup (supportedHolder (E := E) K) := inferInstance |
| local instance markedFrameInst10 : NormedSpace ℝ (supportedHolder (E := E) K) := inferInstance |
|
|
| def markedCoefficientAction (hK : IsClosed K) (M : COne ℂ (E →L[ℝ] E)) (c : ℝ) |
| (hM : ∀ z ∉ K, cValue M z = c • ContinuousLinearMap.id ℝ E) : |
| markedModel (E := E) K →L[ℝ] markedModel (E := E) K := |
| (coefficientAction M).restrict (fun _u hu => coefficientAction_mem_marked hK M c hM hu) |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma markedCoefficientAction_value (hK : IsClosed K) (M : COne ℂ (E →L[ℝ] E)) (c : ℝ) |
| (hM : ∀ z ∉ K, cValue M z = c • ContinuousLinearMap.id ℝ E) |
| (u : markedModel (E := E) K) (z : ℂ) : |
| cValue (markedCoefficientAction hK M c hM u).val z = cValue M z (cValue u.val z) := rfl |
|
|
| def holderCoefficientAction (M : HMap ℂ (E →L[ℝ] E)) : HMap ℂ E →L[ℝ] HMap ℂ E := |
| bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip M |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma holderCoefficientAction_value (M : HMap ℂ (E →L[ℝ] E)) (g : HMap ℂ E) (z : ℂ) : |
| valueCLM _ (holderCoefficientAction M g) z = valueCLM _ M z (valueCLM _ g z) := rfl |
|
|
| def supportedCoefficientAction (M : HMap ℂ (E →L[ℝ] E)) : |
| supportedHolder (E := E) K →L[ℝ] supportedHolder (E := E) K := |
| (holderCoefficientAction M).restrict (fun g hg => by |
| apply (mem_supportedHolder _ K).mpr |
| intro z hz |
| rw [holderCoefficientAction_value,(mem_supportedHolder g K).mp hg z hz,map_zero]) |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma supportedCoefficientAction_value (M : HMap ℂ (E →L[ℝ] E)) |
| (g : supportedHolder (E := E) K) (z : ℂ) : |
| valueCLM _ (supportedCoefficientAction M g).val z = valueCLM _ M z (valueCLM _ g.val z) := rfl |
|
|
| def markedCoefficientEquiv (hK : IsClosed K) (M N : COne ℂ (E →L[ℝ] E)) (c d : ℝ) |
| (hM : ∀ z ∉ K, cValue M z = c • ContinuousLinearMap.id ℝ E) |
| (hN : ∀ z ∉ K, cValue N z = d • ContinuousLinearMap.id ℝ E) |
| (hNM : ∀ z v, cValue N z (cValue M z v) = v) |
| (hMN : ∀ z v, cValue M z (cValue N z v) = v) : |
| markedModel (E := E) K ≃L[ℝ] markedModel (E := E) K := |
| ContinuousLinearEquiv.equivOfInverse (markedCoefficientAction hK M c hM) |
| (markedCoefficientAction hK N d hN) |
| (by |
| intro u; apply Subtype.ext; apply cValue_ext; intro z |
| simpa only [markedCoefficientAction_value] using hNM z (cValue u.val z)) |
| (by |
| intro u; apply Subtype.ext; apply cValue_ext; intro z |
| simpa only [markedCoefficientAction_value] using hMN z (cValue u.val z)) |
|
|
| def supportedCoefficientEquiv (M N : HMap ℂ (E →L[ℝ] E)) |
| (hNM : ∀ z v, valueCLM _ N z (valueCLM _ M z v) = v) |
| (hMN : ∀ z v, valueCLM _ M z (valueCLM _ N z v) = v) : |
| supportedHolder (E := E) K ≃L[ℝ] supportedHolder (E := E) K := |
| ContinuousLinearEquiv.equivOfInverse (supportedCoefficientAction M) (supportedCoefficientAction N) |
| (by intro g; apply Subtype.ext; apply value_ext; intro z; exact hNM z _) |
| (by intro g; apply Subtype.ext; apply value_ext; intro z; exact hMN z _) |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance affineCutInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance affineCutInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance affineCutInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance affineCutInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
| local instance affineCutInst5 : NormedAddCommGroup (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance affineCutInst6 : NormedSpace ℝ (ℂ →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
|
|
| def complexSlopeCLM : E →L[ℝ] (ℂ →L[ℝ] E) := |
| (ContinuousLinearMap.lsmul ℝ ℂ (E := E)).flip |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma complexSlopeCLM_apply (a : E) : complexSlopeCLM a = complexSlope a := rfl |
|
|
| variable (b : ContDiffBump (0:ℂ)) |
|
|
| lemma cutoffCoordinate_smooth : ContDiff ℝ ∞ (fun z : ℂ => b z • z) := |
| b.contDiff.smul contDiff_id |
| lemma cutoffCoordinate_compact : HasCompactSupport (fun z : ℂ => b z • z) := |
| b.hasCompactSupport.smul_right |
|
|
| def cutoffCoordinate : COne ℂ ℂ := |
| ofBoundedCThree (boundedCThree_of_compactSupport (cutoffCoordinate_smooth b) (cutoffCoordinate_compact b)) |
|
|
| @[simp] lemma cutoffCoordinate_value (z : ℂ) : cValue (cutoffCoordinate b) z = b z • z := rfl |
|
|
| def cutoffSlope : E →L[ℝ] COne ℂ E := |
| ((mapJetBilinear (D := ℂ) (E := ℂ) (F := E)).flip (cutoffCoordinate b)).comp complexSlopeCLM |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma cutoffSlope_value (a : E) (z : ℂ) : |
| cValue (cutoffSlope b a) z = b z • (z • a) := by |
| change (b z • z) • a = _ |
| exact smul_assoc (b z) z a |
|
|
| def truncateShift : COne ℂ E →L[ℝ] COne ℂ E := |
| ContinuousLinearMap.id ℝ _ - (cutoffSlope b).comp (jetEval 1) |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma truncateShift_value (h : COne ℂ E) (z : ℂ) : |
| cValue (truncateShift b h) z = cValue h z-b z • (z • cValue h 1) := by |
| change cValue h z-cValue (cutoffSlope b (cValue h 1)) z = _ |
| rw [cutoffSlope_value] |
|
|
| omit [CompleteSpace E] in |
| lemma markedSlope_add (p q : E) (u h : COne ℂ E) : |
| markedSlope p q (u+h) = markedSlope p q u-cValue h 1 := by |
| simp only [markedSlope,cValue_add] |
| abel |
|
|
| def truncatedCurve (p q : E) (u h : COne ℂ E) (z : ℂ) : E := |
| affineCurve p (complexSlope (markedSlope p q u)) (u+truncateShift b h) z |
|
|
| omit [CompleteSpace E] in |
| lemma truncatedCurve_value (p q : E) (u h : COne ℂ E) (z : ℂ) : |
| truncatedCurve b p q u h z = p+z • markedSlope p q u+cValue u z+cValue h z- |
| b z • (z • cValue h 1) := by |
| simp only [truncatedCurve,affineCurve,affine,complexSlope_apply,cValue_add,truncateShift_value] |
| abel |
|
|
| omit [CompleteSpace E] in |
| lemma truncatedCurve_eq_marked (p q : E) (u h : COne ℂ E) {z : ℂ} |
| (hz : z ∈ Metric.closedBall 0 b.rIn) : |
| truncatedCurve b p q u h z = markedCurve p q (u+h) z := by |
| rw [truncatedCurve_value,b.one_of_mem_closedBall hz,one_smul,markedCurve,markedSlope_add] |
| simp only [cValue_add,smul_sub] |
| abel |
|
|
| omit [CompleteSpace E] in |
| lemma cValue_norm_le (u : COne ℂ E) (z : ℂ) : ‖cValue u z‖ ≤ ‖u‖ := |
| (norm_value_le (jetValueCLM _ u) z).trans (jetValue_norm_le u) |
|
|
| omit [CompleteSpace E] in |
| lemma truncatedCurve_norm_lower (p q : E) (u h : COne ℂ E) (z : ℂ) : |
| ‖z‖*(‖markedSlope p q u‖-‖h‖)-‖p‖-‖u‖-‖h‖ ≤ ‖truncatedCurve b p q u h z‖ := by |
| have hb : ‖b z • (z • cValue h 1)‖ ≤ ‖z‖*‖h‖ := by |
| rw [norm_smul,norm_smul,Real.norm_eq_abs,abs_of_nonneg (b.nonneg)] |
| calc |
| b z*(‖z‖*‖cValue h 1‖) ≤ 1*(‖z‖*‖cValue h 1‖) := |
| mul_le_mul_of_nonneg_right (b.le_one) (by positivity) |
| _ ≤ ‖z‖*‖h‖ := by rw [one_mul]; exact mul_le_mul_of_nonneg_left (cValue_norm_le h 1) (norm_nonneg z) |
| have he : z • markedSlope p q u = truncatedCurve b p q u h z -p-cValue u z-cValue h z+ |
| b z • (z • cValue h 1) := by rw [truncatedCurve_value]; abel |
| have hn := calc |
| ‖z • markedSlope p q u‖ = ‖truncatedCurve b p q u h z -p-cValue u z-cValue h z+ |
| b z • (z • cValue h 1)‖ := congrArg norm he |
| _ ≤ ‖truncatedCurve b p q u h z‖+‖p‖+‖u‖+‖h‖+‖z‖*‖h‖ := by |
| apply (norm_add_le _ _).trans |
| apply add_le_add _ hb |
| apply (norm_sub_le _ _).trans |
| apply add_le_add _ (cValue_norm_le h z) |
| apply (norm_sub_le _ _).trans |
| apply add_le_add _ (cValue_norm_le u z) |
| exact norm_sub_le _ _ |
| rw [norm_smul] at hn |
| nlinarith |
|
|
| omit [CompleteSpace E] in |
| lemma markedCurve_norm_lower (p q : E) (u h : COne ℂ E) (z : ℂ) : |
| ‖z‖*(‖markedSlope p q u‖-‖h‖)-‖p‖-‖u‖-‖h‖ ≤ ‖markedCurve p q (u+h) z‖ := by |
| have he : z • markedSlope p q u = markedCurve p q (u+h) z-p-cValue u z-cValue h z+ |
| z • cValue h 1 := by |
| simp only [markedCurve,markedSlope_add,cValue_add,smul_sub] |
| abel |
| have hn := calc |
| ‖z • markedSlope p q u‖ = ‖markedCurve p q (u+h) z-p-cValue u z-cValue h z+z • cValue h 1‖ := congrArg norm he |
| _ ≤ ‖markedCurve p q (u+h) z‖+‖p‖+‖u‖+‖h‖+‖z‖*‖h‖ := by |
| apply (norm_add_le _ _).trans |
| apply add_le_add _ (by rw [norm_smul]; exact mul_le_mul_of_nonneg_left (cValue_norm_le h 1) (norm_nonneg z)) |
| apply (norm_sub_le _ _).trans |
| apply add_le_add _ (cValue_norm_le h z) |
| apply (norm_sub_le _ _).trans |
| apply add_le_add _ (cValue_norm_le u z) |
| exact norm_sub_le _ _ |
| rw [norm_smul] at hn |
| nlinarith |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| local instance sourceCutInst1 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance sourceCutInst2 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| def constHolderCLM : E →L[ℝ] HMap ℂ E := |
| LinearMap.mkContinuous |
| { toFun := const _ |
| map_add' := fun u v => by apply value_ext; intro z; rfl |
| map_smul' := fun c v => by apply value_ext; intro z; rfl } |
| 1 (by intro v; change ‖const _ v‖ ≤ 1*‖v‖; rw [one_mul]; exact const_norm_le v) |
|
|
| @[simp] lemma constHolderCLM_value (v : E) (z : ℂ) : valueCLM _ (constHolderCLM v) z = v := rfl |
|
|
| variable (b : ContDiffBump (0:ℂ)) |
|
|
| def bumpHolder : HMap ℂ ℝ := |
| jetValueCLM _ (ofBoundedCThree (boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport)) |
|
|
| @[simp] lemma bumpHolder_value (z : ℂ) : valueCLM _ (bumpHolder b) z = b z := rfl |
|
|
| def sourceCutoff : HMap ℂ E →L[ℝ] HMap ℂ E := |
| bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.lsmul ℝ ℝ (E := E)) (bumpHolder b) |
|
|
| @[simp] lemma sourceCutoff_value (g : HMap ℂ E) (z : ℂ) : |
| valueCLM _ (sourceCutoff b g) z = b z • valueCLM _ g z := rfl |
|
|
| local instance sourceCutInst3 : NormedAddCommGroup (supportedHolder (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance sourceCutInst4 : NormedSpace ℝ (supportedHolder (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
|
|
| def supportedSourceCutoff : HMap ℂ E →L[ℝ] supportedHolder (E := E) (Metric.closedBall (0:ℂ) b.rOut) := |
| (sourceCutoff b).codRestrict _ (fun g => by |
| apply (mem_supportedHolder _ _).mpr |
| intro z hz |
| rw [sourceCutoff_value,b.zero_of_le_dist (by |
| simp only [Metric.mem_closedBall] at hz |
| exact (lt_of_not_ge hz).le),zero_smul]) |
|
|
| @[simp] lemma supportedSourceCutoff_value (g : HMap ℂ E) (z : ℂ) : |
| valueCLM _ (supportedSourceCutoff b g).val z = b z • valueCLM _ g z := rfl |
|
|
|
|
| end |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| variable {X E : Type*} [MetricSpace X] [NormedAddCommGroup E] [NormedSpace ℝ E] |
| local instance holderCompInst1 : NormedAddCommGroup (HMap X E) := inferInstance |
| local instance holderCompInst2 : NormedSpace ℝ (HMap X E) := inferInstance |
|
|
| omit [NormedSpace ℝ E] in |
| lemma third_interpolation {f : X → E} {M L A s : ℝ} |
| (_hM : 0 ≤ M) (hL : 0 ≤ L) (hA : 0 ≤ A) (hs : 0 < s) |
| (hb : ∀ x, ‖f x‖ ≤ M) (hl : ∀ x y, ‖f x-f y‖ ≤ L*dist x y) |
| (hsmall : L*s^((2:ℝ)/3) ≤ A) (hlarge : 2*M ≤ A*s^((1:ℝ)/3)) : |
| ∀ x y, ‖f x-f y‖ ≤ A*dist x y^((1:ℝ)/3) := by |
| intro x y |
| by_cases hxy : x = y |
| · subst y; simp |
| have hd : 0 < dist x y := dist_pos.mpr hxy |
| by_cases hds : dist x y ≤ s |
| · have hp : dist x y = dist x y^((2:ℝ)/3)*dist x y^((1:ℝ)/3) := by |
| rw [← Real.rpow_add hd]; norm_num |
| calc |
| _ ≤ L*dist x y := hl x y |
| _ = (L*dist x y^((2:ℝ)/3))*dist x y^((1:ℝ)/3) := (congrArg (fun t : ℝ => L*t) hp).trans (mul_assoc _ _ _).symm |
| _ ≤ (L*s^((2:ℝ)/3))*dist x y^((1:ℝ)/3) := |
| mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left |
| (Real.rpow_le_rpow hd.le hds (by norm_num)) hL) (by positivity) |
| _ ≤ A*dist x y^((1:ℝ)/3) := mul_le_mul_of_nonneg_right hsmall (by positivity) |
| · calc |
| _ ≤ 2*M := (norm_sub_le _ _).trans (by linarith [hb x,hb y]) |
| _ ≤ A*s^((1:ℝ)/3) := hlarge |
| _ ≤ A*dist x y^((1:ℝ)/3) := mul_le_mul_of_nonneg_left |
| (Real.rpow_le_rpow hs.le (le_of_not_ge hds) (by norm_num)) hA |
|
|
| lemma exists_small_third_scale {A : ℝ} (hA : 0 < A) (L : ℝ) : |
| ∃ s > 0, L*s^((2:ℝ)/3) < A := by |
| have ht : Tendsto (fun s : ℝ => L*s^((2:ℝ)/3)) (𝓝[>] 0) (𝓝 0) := by |
| have h := (Real.continuousAt_rpow_const (0:ℝ) ((2:ℝ)/3) (Or.inr (by norm_num))).const_mul L |
| simpa using h.tendsto.mono_left nhdsWithin_le_nhds |
| have he : ∀ᶠ s : ℝ in 𝓝[>] 0, L*s^((2:ℝ)/3) < A := ht.eventually (gt_mem_nhds hA) |
| have hh : ∀ᶠ s : ℝ in 𝓝[>] 0, 0 < s ∧ L*s^((2:ℝ)/3) < A := by |
| filter_upwards [self_mem_nhdsWithin,he] with s hs h |
| exact ⟨hs,h⟩ |
| exact hh.exists |
|
|
| lemma holder_small_of_small_value {L ε : ℝ} (hL : 0 ≤ L) (hε : 0 < ε) : |
| ∃ δ > 0, ∀ u : HMap X E, |
| (∀ x, ‖valueCLM _ u x‖ ≤ δ) → |
| (∀ x y, ‖valueCLM _ u x-valueCLM _ u y‖ ≤ L*dist x y) → ‖u‖ < ε := by |
| obtain ⟨s,hs,hscale⟩ := exists_small_third_scale (half_pos hε) L |
| let δ : ℝ := min (ε/2) (ε/4*s^((1:ℝ)/3)) |
| have hδ : 0 < δ := lt_min (half_pos hε) (by positivity) |
| refine ⟨δ,hδ,fun u hb hl => ?_⟩ |
| have hlarge : 2*δ ≤ ε/2*s^((1:ℝ)/3) := by |
| have hh : δ ≤ ε/4*s^((1:ℝ)/3) := min_le_right _ _ |
| linarith |
| have hh := third_interpolation hδ.le hL (half_pos hε).le hs hb hl hscale.le hlarge |
| have hn : ‖u‖ ≤ ε/2 := (norm_le_of_bounds u hδ.le (half_pos hε).le hb hh).trans |
| (max_le (min_le_left _ _) le_rfl) |
| exact hn.trans_lt (half_lt_self hε) |
|
|
| def lipHolderSet (K : Set X) (M L : ℝ) : Set (HMap X E) := |
| {u | (∀ x, ‖valueCLM _ u x‖ ≤ M) ∧ |
| (∀ x y, ‖valueCLM _ u x-valueCLM _ u y‖ ≤ L*dist x y) ∧ |
| (∀ x ∉ K, valueCLM _ u x = 0)} |
|
|
| def restrictedValue (K : Set X) : HMap X E →L[ℝ] (K →ᵇ E) := |
| (BoundedContinuousFunction.compContinuousCLM E ℝ ⟨Subtype.val,continuous_subtype_val⟩).comp (valueCLM _) |
|
|
| @[simp] lemma restrictedValue_apply (K : Set X) (u : HMap X E) (x : K) : |
| restrictedValue K u x = valueCLM _ u x.val := rfl |
|
|
| lemma restrictedValue_uniformInducing (K : Set X) (M : ℝ) {L : ℝ} (hL : 0 ≤ L) : |
| IsUniformInducing (fun u : lipHolderSet (E := E) K M L => restrictedValue K u.val) := by |
| apply Metric.isUniformInducing_iff.mpr |
| refine ⟨(restrictedValue (E := E) K).uniformContinuous.comp uniformContinuous_subtype_val,?_⟩ |
| intro ε hε |
| obtain ⟨δ,hδ,hd⟩ := holder_small_of_small_value (X := X) (E := E) (by linarith : 0 ≤ 2*L) hε |
| refine ⟨δ,hδ,fun {u v} huv => ?_⟩ |
| change dist u.val v.val < ε |
| rw [dist_eq_norm] |
| apply hd (u.val-v.val) |
| · intro x |
| change ‖valueCLM _ u.val x-valueCLM _ v.val x‖ ≤ δ |
| by_cases hx : x ∈ K |
| · have h := BoundedContinuousFunction.dist_coe_le_dist (f := restrictedValue K u.val) |
| (g := restrictedValue K v.val) (⟨x,hx⟩ : K) |
| have hh : ‖valueCLM _ u.val x-valueCLM _ v.val x‖ ≤ |
| dist (restrictedValue K u.val) (restrictedValue K v.val) := by |
| simpa only [restrictedValue_apply,dist_eq_norm] using h |
| exact hh.trans huv.le |
| · rw [u.property.2.2 x hx,v.property.2.2 x hx,sub_self,norm_zero] |
| exact hδ.le |
| · intro x y |
| change ‖(valueCLM _ u.val x-valueCLM _ v.val x)- |
| (valueCLM _ u.val y-valueCLM _ v.val y)‖ ≤ 2*L*dist x y |
| have he : (valueCLM _ u.val x-valueCLM _ v.val x)- |
| (valueCLM _ u.val y-valueCLM _ v.val y) = |
| (valueCLM _ u.val x-valueCLM _ u.val y)- |
| (valueCLM _ v.val x-valueCLM _ v.val y) := by abel |
| rw [he] |
| exact (norm_sub_le _ _).trans (by linarith [u.property.2.1 x y,v.property.2.1 x y]) |
|
|
| lemma lipHolderSet_totallyBounded [ProperSpace E] {K : Set X} (hK : IsCompact K) |
| (M : ℝ) {L : ℝ} (hL : 0 ≤ L) : TotallyBounded (lipHolderSet (E := E) K M L) := by |
| let : CompactSpace K := isCompact_iff_compactSpace.mp hK |
| let A : Set (K →ᵇ E) := restrictedValue K '' lipHolderSet (E := E) K M L |
| have heq : Equicontinuous ((↑) : A → K → E) := by |
| apply UniformEquicontinuous.equicontinuous |
| rw [Metric.uniformEquicontinuous_iff] |
| intro ε hε |
| refine ⟨ε/(L+1),div_pos hε (by linarith),?_⟩ |
| intro x y hxy f |
| obtain ⟨u,hu,huf⟩ := f.property |
| change restrictedValue K u = f.val at huf |
| rw [← huf,restrictedValue_apply,restrictedValue_apply,dist_eq_norm] |
| have hdist : dist x.val y.val < ε/(L+1) := hxy |
| have hb := hu.2.1 x.val y.val |
| have hmul := (lt_div_iff₀ (by linarith : 0 < L+1)).mp hdist |
| nlinarith [show 0 ≤ dist x.val y.val from dist_nonneg] |
| have hc : IsCompact (closure A) := BoundedContinuousFunction.arzela_ascoli |
| (Metric.closedBall (0:E) M) (isCompact_closedBall _ _) A (by |
| intro f x hf |
| obtain ⟨u,hu,rfl⟩ := hf |
| simpa only [Metric.mem_closedBall,dist_zero_right,restrictedValue_apply] using hu.1 x.val) heq |
| let F : lipHolderSet (E := E) K M L → (K →ᵇ E) := fun u => restrictedValue K u.val |
| have ht : TotallyBounded (F '' Set.univ) := hc.totallyBounded.subset (by |
| rintro _ ⟨u,_,rfl⟩ |
| exact subset_closure ⟨u.val,u.property,rfl⟩) |
| have hu : TotallyBounded (Set.univ : Set (lipHolderSet (E := E) K M L)) := |
| (totallyBounded_image_iff (restrictedValue_uniformInducing K M hL)).mp ht |
| have hh := hu.image uniformContinuous_subtype_val |
| simpa only [Set.image_univ,Subtype.range_coe_subtype,Set.ofPred_mem_eq] using hh |
|
|
| variable (b : ContDiffBump (0:ℂ)) |
| local instance holderLocInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance holderLocInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
|
|
| def localizedJetValue : COne ℂ E →L[ℝ] HMap ℂ E := |
| (sourceCutoff b).comp (jetValueCLM _) |
|
|
| @[simp] lemma localizedJetValue_apply (u : COne ℂ E) (z : ℂ) : |
| valueCLM _ (localizedJetValue b u) z = b z • cValue u z := rfl |
|
|
| lemma localizedJetValue_bounds (u : COne ℂ E) (hu : ‖u‖ ≤ 1) : |
| localizedJetValue b u ∈ lipHolderSet (Metric.closedBall (0:ℂ) b.rOut) 1 |
| (1+(boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport).bound) := by |
| let hb := boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport |
| have hbu : ∀ z : ℂ, ‖b z‖ ≤ 1 := fun z => by |
| rw [Real.norm_of_nonneg b.nonneg]; exact b.le_one |
| have huv : ∀ z : ℂ, ‖cValue u z‖ ≤ 1 := fun z => (c_value_bound u z).trans hu |
| have hul : ∀ x y : ℂ, ‖cValue u x-cValue u y‖ ≤ dist x y := by |
| intro x y |
| have hd : ∀ z, ‖fderiv ℝ (cValue u) z‖ ≤ (1:ℝ) := fun z => by |
| rw [c_fderiv]; exact (c_deriv_bound u z).trans hu |
| simpa only [one_mul,dist_eq_norm] using norm_sub_le_of_deriv_bound (c_differentiable u) hd x y |
| have hbl : ∀ x y : ℂ, ‖b x-b y‖ ≤ hb.bound*dist x y := by |
| intro x y |
| simpa only [dist_eq_norm] using norm_sub_le_of_deriv_bound |
| (b.contDiff.differentiable (by simp : (∞ : WithTop ℕ∞) ≠ 0)) hb.norm_fderiv_le x y |
| refine ⟨?_,?_,?_⟩ |
| · intro z |
| rw [localizedJetValue_apply,norm_smul] |
| calc |
| _ ≤ (1:ℝ)*1 := mul_le_mul (hbu z) (huv z) (norm_nonneg _) zero_le_one |
| _ = 1 := one_mul _ |
| · intro x y |
| change ‖b x • cValue u x-b y • cValue u y‖ ≤ (1+hb.bound)*dist x y |
| have he : b x • cValue u x-b y • cValue u y = |
| b x • (cValue u x-cValue u y)+(b x-b y) • cValue u y := by module |
| rw [he] |
| calc |
| _ ≤ ‖b x • (cValue u x-cValue u y)‖+‖(b x-b y) • cValue u y‖ := norm_add_le _ _ |
| _ = ‖b x‖*‖cValue u x-cValue u y‖+‖b x-b y‖*‖cValue u y‖ := by rw [norm_smul,norm_smul] |
| _ ≤ 1*dist x y+(hb.bound*dist x y)*1 := add_le_add |
| (mul_le_mul (hbu x) (hul x y) (norm_nonneg _) zero_le_one) |
| (mul_le_mul (hbl x y) (huv y) (norm_nonneg _) (by positivity [hb.bound_nonneg])) |
| _ = _ := by ring |
| · intro z hz |
| rw [localizedJetValue_apply,b.zero_of_le_dist (by |
| simp only [Metric.mem_closedBall] at hz |
| exact (lt_of_not_ge hz).le),zero_smul] |
|
|
| lemma localizedJetValue_isCompact [ProperSpace E] : IsCompactOperator (localizedJetValue (E := E) b) := by |
| let hb := boundedCThree_of_compactSupport b.contDiff b.hasCompactSupport |
| have ht := lipHolderSet_totallyBounded (E := E) (isCompact_closedBall (0:ℂ) b.rOut) 1 |
| (show 0 ≤ 1+hb.bound by linarith [hb.bound_nonneg]) |
| have hT : TotallyBounded (localizedJetValue (E := E) b '' Metric.closedBall 0 1) := ht.subset (by |
| rintro _ ⟨u,hu,rfl⟩ |
| exact localizedJetValue_bounds b u (by simpa only [Metric.mem_closedBall,dist_zero_right] using hu)) |
| apply (isCompactOperator_iff_exists_mem_nhds_isCompact_closure_image |
| (localizedJetValue (E := E) b)).mpr |
| exact ⟨Metric.closedBall 0 1,Metric.closedBall_mem_nhds _ (by norm_num), |
| hT.closure.isCompact_of_isClosed isClosed_closure⟩ |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| end |
|
|
| end OAI |
|
|
