Download data/lean/OAI/Geometry/BallPacking/Necessity/HolderCompactness.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/HolderCompactness.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/HolderCompactness.lean
-
curl -L -o HolderCompactness.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/HolderCompactness.lean
25.6 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.HolderCompletion | |
| namespace OAI | |
| noncomputable section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| open Set Function MeasureTheory | |
| open Set Function | |
| 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 Set Filter MeasureTheory | |
| open scoped Topology | |
| open Set Filter Finset | |
| open scoped ContDiff Topology Classical | |
| open Set Filter | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open Set Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| universe u v | |
| variable {K : Type u} {E F : Type v} [TopologicalSpace K] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| def sectionApply (M : K βα΅ (E βL[β] F)) (v : K βα΅ E) : K βα΅ F := | |
| BoundedContinuousFunction.ofNormedAddCommGroup | |
| (fun z => M z (v z)) (M.continuous.clm_apply v.continuous) | |
| (βMβ*βvβ) (fun z => (M z).le_opNorm (v z) |>.trans | |
| (mul_le_mul (M.norm_coe_le_norm z) (v.norm_coe_le_norm z) | |
| (norm_nonneg (v z)) (norm_nonneg M))) | |
| theorem sectionApply_norm (M : K βα΅ (E βL[β] F)) (v : K βα΅ E) : | |
| βsectionApply M vβ β€ βMβ*βvβ := by | |
| apply (BoundedContinuousFunction.norm_le (mul_nonneg (norm_nonneg M) (norm_nonneg v))).mpr | |
| intro z | |
| exact (M z).le_opNorm (v z) |>.trans | |
| (mul_le_mul (M.norm_coe_le_norm z) (v.norm_coe_le_norm z) | |
| (norm_nonneg (v z)) (norm_nonneg M)) | |
| def sectionCLM (M : K βα΅ (E βL[β] F)) : (K βα΅ E) βL[β] (K βα΅ F) := | |
| LinearMap.mkContinuous | |
| { toFun := sectionApply M | |
| map_add' := fun v w => by ext z; exact (M z).map_add _ _ | |
| map_smul' := fun c v => by ext z; exact (M z).map_smul c (v z) } | |
| βMβ (sectionApply_norm M) | |
| @[simp] theorem sectionCLM_apply (M : K βα΅ (E βL[β] F)) (v : K βα΅ E) (z : K) : | |
| sectionCLM M v z = M z (v z) := rfl | |
| def sectionOperatorCLM : (K βα΅ (E βL[β] F)) βL[β] ((K βα΅ E) βL[β] (K βα΅ F)) := | |
| LinearMap.mkContinuous | |
| { toFun := sectionCLM | |
| map_add' := fun M N => by ext v z; rfl | |
| map_smul' := fun c M => by ext v z; rfl } | |
| 1 (fun M => by | |
| change βsectionCLM Mβ β€ 1*βMβ | |
| rw [one_mul] | |
| exact ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg M) (sectionApply_norm M)) | |
| @[simp] theorem sectionOperatorCLM_apply (M : K βα΅ (E βL[β] F)) : | |
| sectionOperatorCLM M = sectionCLM M := rfl | |
| def superposeBCF (f : E βα΅ F) (base : C(K,E)) (v : K βα΅ E) : K βα΅ F := | |
| f.compContinuous β¨fun z => base z + v z, base.continuous.add v.continuousβ© | |
| omit [NormedSpace β E] [NormedSpace β F] in | |
| @[simp] theorem superposeBCF_apply (f : E βα΅ F) (base : C(K,E)) (v : K βα΅ E) (z : K) : | |
| superposeBCF f base v z = f (base z + v z) := rfl | |
| omit [NormedSpace β E] [NormedSpace β F] in | |
| theorem superposeBCF_uniformContinuous (f : E βα΅ F) | |
| (hf : UniformContinuous (f : E β F)) (base : C(K,E)) : | |
| UniformContinuous (superposeBCF f base) := by | |
| apply Metric.uniformContinuous_iff.mpr | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨Ξ΄,hΞ΄,hfΞ΄β© := Metric.uniformContinuous_iff.mp hf (Ξ΅/2) (by positivity) | |
| refine β¨Ξ΄,hΞ΄,fun v w hvw => ?_β© | |
| rw [dist_eq_norm] | |
| apply lt_of_le_of_lt _ (half_lt_self hΞ΅) | |
| apply (BoundedContinuousFunction.norm_le (by positivity : 0β€Ξ΅/2)).mpr | |
| intro z | |
| change βf (base z+v z)-f (base z+w z)ββ€Ξ΅/2 | |
| have hh : dist (base z+v z) (base z+w z)<Ξ΄ := by | |
| rw [dist_add_left, dist_eq_norm] | |
| exact ((v-w).norm_coe_le_norm z).trans_lt (by simpa only [dist_eq_norm] using hvw) | |
| simpa only [dist_eq_norm] using (hfΞ΄ hh).le | |
| theorem superposeBCF_hasFDerivAt (f : E βα΅ F) (g : E βα΅ (E βL[β] F)) | |
| (hfg : β x, HasFDerivAt (f : E β F) (g x) x) | |
| (hg : UniformContinuous (g : E β E βL[β] F)) (base : C(K,E)) (v : K βα΅ E) : | |
| HasFDerivAt (superposeBCF f base) (sectionCLM (superposeBCF g base v)) v := by | |
| rw [hasFDerivAt_iff_isLittleO_nhds_zero,Asymptotics.isLittleO_iff] | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨Ξ΄,hΞ΄,hgΞ΄β© := Metric.uniformContinuous_iff.mp hg Ξ΅ hΞ΅ | |
| filter_upwards [Metric.ball_mem_nhds (0 : K βα΅ E) hΞ΄] with h hh | |
| have hhn : βhβ<Ξ΄ := by simpa only [Metric.mem_ball,dist_zero_right] using hh | |
| apply (BoundedContinuousFunction.norm_le (mul_nonneg hΞ΅.le (norm_nonneg h))).mpr | |
| intro z | |
| change βf (base z+(v z+h z))-f (base z+v z)-g (base z+v z) (h z)ββ€Ξ΅*βhβ | |
| have hbound : β x β Metric.ball (base z+v z) Ξ΄, βg x-g (base z+v z)ββ€Ξ΅ := by | |
| intro x hx | |
| simpa only [dist_eq_norm] using (hgΞ΄ hx).le | |
| have hy : base z+(v z+h z)βMetric.ball (base z+v z) Ξ΄ := by | |
| simpa only [Metric.mem_ball,dist_eq_norm, | |
| show base z+(v z+h z)-(base z+v z)=h z by abel] using | |
| (h.norm_coe_le_norm z).trans_lt hhn | |
| have hb := (convex_ball (base z+v z) Ξ΄).norm_image_sub_le_of_norm_hasFDerivWithin_le' | |
| (fun x _ => (hfg x).hasFDerivWithinAt) hbound | |
| (Metric.mem_ball_self hΞ΄) hy | |
| have hc : βf (base z+(v z+h z))-f (base z+v z)-g (base z+v z) (h z)ββ€Ξ΅*βh zβ := by | |
| simpa only [show base z+(v z+h z)-(base z+v z)=h z by abel] using hb | |
| exact hc.trans (mul_le_mul_of_nonneg_left (h.norm_coe_le_norm z) hΞ΅.le) | |
| def compactCoefficient (f : E β F) (hf : Continuous f) (hc : HasCompactSupport f) : E βα΅ F := | |
| ({ toFun := f, continuous_toFun := hf, hasCompactSupport' := hc } : | |
| CompactlySupportedContinuousMap E F).toBoundedContinuousFunction | |
| omit [NormedSpace β E] [NormedSpace β F] in | |
| @[simp] theorem compactCoefficient_apply (f : E β F) (hf : Continuous f) | |
| (hc : HasCompactSupport f) (x : E) : compactCoefficient f hf hc x = f x := rfl | |
| theorem compactSuperpose_contDiff_nat (m : β) {f : E β F} | |
| (hf : ContDiff β m f) (hc : HasCompactSupport f) (base : C(K,E)) : | |
| ContDiff β m (superposeBCF (compactCoefficient f hf.continuous hc) base) := by | |
| induction m generalizing F with | |
| | zero => | |
| exact contDiff_zero.mpr | |
| (superposeBCF_uniformContinuous _ | |
| (hf.continuous.uniformContinuous_of_tendsto_cocompact hc.is_zero_at_infty) base).continuous | |
| | succ m ih => | |
| have hdf : ContDiff β m (fderiv β f) := hf.fderiv_right (by simp) | |
| let g : E βα΅ (E βL[β] F) := | |
| compactCoefficient (fderiv β f) hdf.continuous (hc.fderiv β) | |
| apply contDiff_succ_iff_hasFDerivAt.mpr | |
| refine β¨fun v => sectionOperatorCLM (superposeBCF g base v),?_,?_β© | |
| Β· have hi : ContDiff β m (superposeBCF g base) := ih hdf (hc.fderiv β) | |
| exact sectionOperatorCLM.contDiff.comp hi | |
| Β· intro v | |
| apply superposeBCF_hasFDerivAt | |
| Β· intro x | |
| exact (hf.differentiable (by simp) x).hasFDerivAt | |
| Β· exact hdf.continuous.uniformContinuous_of_tendsto_cocompact (hc.fderiv β).is_zero_at_infty | |
| theorem compactSuperpose_contDiff {f : E β F} | |
| (hf : ContDiff β β f) (hc : HasCompactSupport f) (base : C(K,E)) : | |
| ContDiff β β (superposeBCF (compactCoefficient f hf.continuous hc) base) := by | |
| apply contDiff_infty.mpr | |
| intro m | |
| exact compactSuperpose_contDiff_nat m (contDiff_infty.mp hf m) hc base | |
| def adaptedJSection (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) (v : K βα΅ E) : K βα΅ (E βL[β] E) := | |
| BoundedContinuousFunction.const K Jβ + | |
| superposeBCF (compactCoefficient (fun x => J x-Jβ) | |
| (hJ.continuous.sub continuous_const) hc) base v | |
| @[simp] theorem adaptedJSection_apply (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) (v : K βα΅ E) (z : K) : | |
| adaptedJSection J Jβ hJ hc base v z = J (base z+v z) := by | |
| change Jβ + (J (base z+v z)-Jβ) = _ | |
| abel | |
| theorem adaptedJSection_contDiff (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) : ContDiff β β (adaptedJSection J Jβ hJ hc base) := by | |
| exact contDiff_const.add (compactSuperpose_contDiff (hJ.sub contDiff_const) hc base) | |
| local instance : NormedAddCommGroup (K βα΅ (β βL[β] E)) := inferInstance | |
| local instance : NormedSpace β (K βα΅ (β βL[β] E)) := inferInstance | |
| def jetSectionEval (w : β) : (K βα΅ (β βL[β] E)) βL[β] (K βα΅ E) := | |
| ((ContinuousLinearMap.apply β E) w).compLeftContinuousBounded K | |
| @[simp] theorem jetSectionEval_apply (w : β) (A : K βα΅ (β βL[β] E)) (z : K) : | |
| jetSectionEval w A z = A z w := rfl | |
| def bcfCRJet (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) (p : (K βα΅ E) Γ (K βα΅ (β βL[β] E))) : K βα΅ E := | |
| jetSectionEval Complex.I p.2 - | |
| sectionCLM (adaptedJSection J Jβ hJ hc base p.1) (jetSectionEval 1 p.2) | |
| @[simp] theorem bcfCRJet_apply (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) (p : (K βα΅ E) Γ (K βα΅ (β βL[β] E))) (z : K) : | |
| bcfCRJet J Jβ hJ hc base p z = p.2 z Complex.I - J (base z+p.1 z) (p.2 z 1) := by | |
| change p.2 z Complex.I - adaptedJSection J Jβ hJ hc base p.1 z (p.2 z 1) = _ | |
| rw [adaptedJSection_apply] | |
| theorem bcfCRJet_contDiff (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) : ContDiff β β (bcfCRJet J Jβ hJ hc base) := by | |
| have hop : ContDiff β β (fun v : K βα΅ E => | |
| sectionCLM (adaptedJSection J Jβ hJ hc base v)) := by | |
| exact (sectionOperatorCLM (K := K) (E := E) (F := E)).contDiff.comp | |
| (adaptedJSection_contDiff J Jβ hJ hc base) | |
| exact ((jetSectionEval (K := K) (E := E) Complex.I).contDiff.comp contDiff_snd).sub | |
| ((hop.comp contDiff_fst).clm_apply | |
| ((jetSectionEval (K := K) (E := E) 1).contDiff.comp contDiff_snd)) | |
| theorem bcfCRJet_fderiv (J : E β E βL[β] E) (Jβ : E βL[β] E) | |
| (hJ : ContDiff β β J) (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (base : C(K,E)) (p h : (K βα΅ E) Γ (K βα΅ (β βL[β] E))) (z : K) : | |
| fderiv β (bcfCRJet J Jβ hJ hc base) p h z = | |
| h.2 z Complex.I - (fderiv β J (base z+p.1 z) (h.1 z)) (p.2 z 1) - | |
| J (base z+p.1 z) (h.2 z 1) := by | |
| let P := (K βα΅ E) Γ (K βα΅ (β βL[β] E)) | |
| have hf : HasFDerivAt (fun q : P => base z+q.1 z) | |
| ((BoundedContinuousFunction.evalCLM β z).comp (ContinuousLinearMap.fst β _ _)) p := by | |
| convert (hasFDerivAt_const (base z) p).add | |
| ((BoundedContinuousFunction.evalCLM β (Ξ² := E) z).hasFDerivAt.comp p | |
| (hasFDerivAt_fst (π := β) (p := p))) using 1 | |
| all_goals first | rfl | simp only [zero_add] | |
| have hs : HasFDerivAt (fun q : P => q.2 z) | |
| ((BoundedContinuousFunction.evalCLM β z).comp (ContinuousLinearMap.snd β _ _)) p := | |
| (BoundedContinuousFunction.evalCLM β (Ξ² := β βL[β] E) z).hasFDerivAt.comp p | |
| (hasFDerivAt_snd (π := β) (p := p)) | |
| have hdJ := ((hJ.differentiable (by simp)) (base z+p.1 z)).hasFDerivAt.comp p hf | |
| have hdI := hs.clm_apply (hasFDerivAt_const Complex.I p) | |
| have hd1 := hs.clm_apply (hasFDerivAt_const (1:β) p) | |
| have hd := hdI.sub (hdJ.clm_apply hd1) | |
| have hb := (BoundedContinuousFunction.evalCLM β z).hasFDerivAt.comp p | |
| (((bcfCRJet_contDiff J Jβ hJ hc base).differentiable (by simp)) p).hasFDerivAt | |
| have he : (fun q : P => bcfCRJet J Jβ hJ hc base q z) = | |
| (fun q : P => q.2 z Complex.I - J (base z+q.1 z) (q.2 z 1)) := by | |
| funext q | |
| exact bcfCRJet_apply J Jβ hJ hc base q z | |
| change HasFDerivAt (fun q : P => bcfCRJet J Jβ hJ hc base q z) _ p at hb | |
| rw [he] at hb | |
| have hder := congrArg (fun L : P βL[β] E => L h) (hb.unique hd) | |
| simp only [ContinuousLinearMap.comp_apply,BoundedContinuousFunction.evalCLM_apply, | |
| sub_apply,add_apply,ContinuousLinearMap.flip_apply,zero_apply,map_zero,zero_add, | |
| Function.comp_def, | |
| sub_add_eq_sub_sub_swap] at hder | |
| convert hder using 1 | |
| rfl | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open Set Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| universe u v | |
| variable {K : Type u} [MetricSpace K] | |
| variable {E F : Type v} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| local instance (G : Type v) [NormedAddCommGroup G] [NormedSpace β G] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace K G Ξ±) := inferInstance | |
| local instance (G : Type v) [NormedAddCommGroup G] [NormedSpace β G] (Ξ± : β) : | |
| NormedSpace β (HolderSpace K G Ξ±) := inferInstance | |
| def pairLeft (G : Type v) [NormedAddCommGroup G] [NormedSpace β G] : | |
| (K βα΅ G) βL[β] (OffDiagonal K βα΅ G) := | |
| BoundedContinuousFunction.compContinuousCLM G β | |
| β¨fun z => z.val.1, continuous_fst.comp continuous_subtype_valβ© | |
| def pairRight (G : Type v) [NormedAddCommGroup G] [NormedSpace β G] : | |
| (K βα΅ G) βL[β] (OffDiagonal K βα΅ G) := | |
| BoundedContinuousFunction.compContinuousCLM G β | |
| β¨fun z => z.val.2, continuous_snd.comp continuous_subtype_valβ© | |
| @[simp] theorem pairLeft_apply (v : K βα΅ E) (z : OffDiagonal K) : pairLeft E v z = v z.val.1 := rfl | |
| @[simp] theorem pairRight_apply (v : K βα΅ E) (z : OffDiagonal K) : pairRight E v z = v z.val.2 := rfl | |
| theorem pairLeft_norm (v : K βα΅ E) : βpairLeft E vβ β€ βvβ := | |
| BoundedContinuousFunction.norm_compContinuous_le _ _ | |
| theorem pairRight_norm (v : K βα΅ E) : βpairRight E vβ β€ βvβ := | |
| BoundedContinuousFunction.norm_compContinuous_le _ _ | |
| theorem holderValue_norm (Ξ± : β) (v : HolderSpace K E Ξ±) : βholderValue Ξ± vβ β€ βvβ := | |
| le_max_left _ _ | |
| theorem holderDifference_norm (Ξ± : β) (v : HolderSpace K E Ξ±) : βholderDifference Ξ± vβ β€ βvβ := | |
| le_max_right _ _ | |
| def holderApply (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) (v : HolderSpace K E Ξ±) : | |
| HolderSpace K F Ξ± := | |
| β¨(sectionCLM (holderValue Ξ± M) (holderValue Ξ± v), | |
| sectionCLM (holderDifference Ξ± M) (pairLeft E (holderValue Ξ± v)) + | |
| sectionCLM (pairRight (E βL[β] F) (holderValue Ξ± M)) (holderDifference Ξ± v)), by | |
| intro z | |
| change M.val.1 z.val.1 (v.val.1 z.val.1)-M.val.1 z.val.2 (v.val.1 z.val.2) = | |
| (dist z.val.1 z.val.2)^Ξ± β’ | |
| (M.val.2 z (v.val.1 z.val.1)+M.val.1 z.val.2 (v.val.2 z)) | |
| calc | |
| _ = (M.val.1 z.val.1-M.val.1 z.val.2) (v.val.1 z.val.1) + | |
| M.val.1 z.val.2 (v.val.1 z.val.1-v.val.1 z.val.2) := by | |
| simp only [sub_apply,map_sub] | |
| abel | |
| _ = _ := by | |
| rw [M.property z,v.property z] | |
| simp only [smul_apply,map_smul,smul_add]β© | |
| @[simp] theorem holderApply_value (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) | |
| (v : HolderSpace K E Ξ±) (x : K) : | |
| holderValue Ξ± (holderApply Ξ± M v) x = holderValue Ξ± M x (holderValue Ξ± v x) := rfl | |
| theorem holderApply_norm (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) (v : HolderSpace K E Ξ±) : | |
| βholderApply Ξ± M vβ β€ 2*βMβ*βvβ := by | |
| apply max_le | |
| Β· exact (sectionApply_norm _ _).trans ((mul_le_mul (holderValue_norm Ξ± M) (holderValue_norm Ξ± v) | |
| (norm_nonneg _) (norm_nonneg _)).trans (by nlinarith [norm_nonneg M,norm_nonneg v])) | |
| Β· refine (norm_add_le _ _).trans ?_ | |
| have h1 := (sectionApply_norm (holderDifference Ξ± M) (pairLeft E (holderValue Ξ± v))).trans | |
| (mul_le_mul (holderDifference_norm Ξ± M) ((pairLeft_norm _).trans (holderValue_norm Ξ± v)) | |
| (norm_nonneg _) (norm_nonneg _)) | |
| have h2 := (sectionApply_norm (pairRight (E βL[β] F) (holderValue Ξ± M)) (holderDifference Ξ± v)).trans | |
| (mul_le_mul ((pairRight_norm _).trans (holderValue_norm Ξ± M)) (holderDifference_norm Ξ± v) | |
| (norm_nonneg _) (norm_nonneg _)) | |
| exact (add_le_add h1 h2).trans_eq (by ring) | |
| def holderCLM (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) : | |
| HolderSpace K E Ξ± βL[β] HolderSpace K F Ξ± := | |
| LinearMap.mkContinuous | |
| { toFun := holderApply Ξ± M | |
| map_add' := by | |
| intro v w | |
| apply holderValue_injective Ξ± | |
| ext x | |
| exact (M.val.1 x).map_add _ _ | |
| map_smul' := by | |
| intro c v | |
| apply holderValue_injective Ξ± | |
| ext x | |
| exact (M.val.1 x).map_smul c (v.val.1 x) } | |
| (2*βMβ) (holderApply_norm Ξ± M) | |
| @[simp] theorem holderCLM_apply (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) | |
| (v : HolderSpace K E Ξ±) (x : K) : | |
| holderValue Ξ± (holderCLM Ξ± M v) x = holderValue Ξ± M x (holderValue Ξ± v x) := rfl | |
| def holderOperatorLinear (Ξ± : β) : | |
| HolderSpace K (E βL[β] F) Ξ± ββ[β] (HolderSpace K E Ξ± βL[β] HolderSpace K F Ξ±) where | |
| toFun M := holderCLM Ξ± M | |
| map_add' := by | |
| intro M N | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| apply holderValue_injective Ξ± | |
| apply BoundedContinuousFunction.ext | |
| intro x | |
| rfl | |
| map_smul' := by | |
| intro c M | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| apply holderValue_injective Ξ± | |
| apply BoundedContinuousFunction.ext | |
| intro x | |
| rfl | |
| theorem holderCLM_norm_bound (Ξ± : β) (M : HolderSpace K (E βL[β] F) Ξ±) : | |
| βholderCLM Ξ± Mβ β€ 2*βMβ := | |
| ContinuousLinearMap.opNorm_le_bound _ (by positivity) (holderApply_norm Ξ± M) | |
| def holderOperatorCLM (Ξ± : β) : | |
| HolderSpace K (E βL[β] F) Ξ± βL[β] (HolderSpace K E Ξ± βL[β] HolderSpace K F Ξ±) := | |
| LinearMap.mkContinuous (holderOperatorLinear (K := K) (E := E) (F := F) Ξ±) 2 | |
| (holderCLM_norm_bound Ξ±) | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open Set Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {K E : Type*} [MetricSpace K] [NormedAddCommGroup E] [NormedSpace β E] | |
| lemma holder_norm_le_of_estimate (Ξ± : β) (u : HolderSpace K E Ξ±) {A H : β} | |
| (hA : 0 β€ A) (hH : 0 β€ H) (h0 : β x, βholderValue Ξ± u xβ β€ A) | |
| (h1 : β x y, βholderValue Ξ± u x-holderValue Ξ± u yβ β€ H*(dist x y)^Ξ±) : | |
| βuβ β€ max A H := by | |
| change max βu.val.1β βu.val.2β β€ _ | |
| apply max_le_max | |
| Β· exact (BoundedContinuousFunction.norm_le hA).mpr h0 | |
| Β· apply (BoundedContinuousFunction.norm_le hH).mpr | |
| intro z | |
| have hh := h1 z.val.1 z.val.2 | |
| rw [holderSpace_relation Ξ± u _ _ z.property,norm_smul,Real.norm_eq_abs, | |
| abs_of_nonneg (Real.rpow_nonneg dist_nonneg _)] at hh | |
| exact le_of_mul_le_mul_left (hh.trans_eq (mul_comm _ _)) | |
| (Real.rpow_pos_of_pos (dist_pos.mpr z.property) Ξ±) | |
| lemma holder_third_interpolation (u : HolderSpace K E ((1:β)/3)) {A L : β} | |
| (hA : 0 β€ A) (hL : 0 β€ L) (h0 : β x, βholderValue ((1:β)/3) u xβ β€ A) | |
| (h1 : β x y, βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ β€ L*dist x y) : | |
| βuβ β€ max A ((2*A)^((2:β)/3)*L^((1:β)/3)) := by | |
| apply holder_norm_le_of_estimate _ _ hA (by positivity) h0 | |
| intro x y | |
| have hb : βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ β€ 2*A := | |
| (norm_sub_le _ _).trans (by linarith [h0 x,h0 y]) | |
| calc | |
| βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ = | |
| βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ^((2:β)/3)* | |
| βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ^((1:β)/3) := by | |
| rw [βReal.rpow_add_of_nonneg (norm_nonneg _) (by norm_num) (by norm_num)] | |
| norm_num | |
| _ β€ (2*A)^((2:β)/3)*(L*dist x y)^((1:β)/3) := by | |
| gcongr | |
| exact h1 x y | |
| _ = ((2*A)^((2:β)/3)*L^((1:β)/3))*(dist x y)^((1:β)/3) := by | |
| rw [Real.mul_rpow hL dist_nonneg,mul_assoc] | |
| lemma holder_third_small_sup (L Ξ΅ : β) (hL : 0 β€ L) (hΞ΅ : 0 < Ξ΅) : | |
| β Ξ΄ > 0, β u : HolderSpace K E ((1:β)/3), | |
| (β x, βholderValue ((1:β)/3) u xβ β€ Ξ΄) β | |
| (β x y, βholderValue ((1:β)/3) u x-holderValue ((1:β)/3) u yβ β€ L*dist x y) β | |
| βuβ < Ξ΅ := by | |
| let Ο : β β β := fun t => max t ((2*t)^((2:β)/3)*L^((1:β)/3)) | |
| have hc : Continuous Ο := continuous_id.max | |
| (((Real.continuous_rpow_const (by norm_num : (0:β)β€2/3)).comp | |
| (continuous_const.mul continuous_id)).mul continuous_const) | |
| have hΟ : Ο 0=0 := by simp [Ο,Real.zero_rpow (by norm_num : (2:β)/3β 0)] | |
| obtain β¨Ξ΄,hΞ΄,hdβ© := Metric.continuousAt_iff.mp hc.continuousAt Ξ΅ hΞ΅ | |
| refine β¨Ξ΄/2,half_pos hΞ΄,?_β© | |
| intro u h0 h1 | |
| have hh : Ο (Ξ΄/2) < Ξ΅ := by | |
| have ht := hd (show dist (Ξ΄/2) 0 < Ξ΄ by simpa [Real.dist_eq,abs_of_pos (half_pos hΞ΄),abs_of_pos hΞ΄] using half_lt_self hΞ΄) | |
| rw [hΟ,dist_zero_right] at ht | |
| exact (le_abs_self _).trans_lt ht | |
| exact (holder_third_interpolation u (half_pos hΞ΄).le hL h0 h1).trans_lt hh | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped BoundedContinuousFunction ContDiff Topology | |
| open Set Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| local instance : NormedAddCommGroup (HolderSpace β E ((1:β)/3)) := inferInstance | |
| local instance : NormedSpace β (HolderSpace β E ((1:β)/3)) := inferInstance | |
| def holderLipschitzSet (R M : β) (L : NNReal) : Set (HolderSpace β E ((1:β)/3)) := | |
| {u | (β x : β, R < βxβ β holderValue ((1:β)/3) u x=0) β§ | |
| βholderValue ((1:β)/3) uβ β€ M β§ LipschitzWith L (holderValue ((1:β)/3) u)} | |
| def holderDiskRestrict (R : β) : | |
| HolderSpace β E ((1:β)/3) βL[β] (Metric.closedBall (0:β) R βα΅ E) := | |
| (BoundedContinuousFunction.compContinuousCLM E β β¨Subtype.val,continuous_subtype_valβ©).comp | |
| (holderValue ((1:β)/3)) | |
| @[simp] lemma holderDiskRestrict_apply (R : β) (u : HolderSpace β E ((1:β)/3)) | |
| (x : Metric.closedBall (0:β) R) : holderDiskRestrict R u x=holderValue ((1:β)/3) u x := rfl | |
| lemma holderDiskRestrict_uniformInducing (R M : β) (L : NNReal) : | |
| IsUniformInducing (fun u : holderLipschitzSet (E := E) R M L => holderDiskRestrict R u.val) := by | |
| rw [Metric.isUniformInducing_iff] | |
| refine β¨(holderDiskRestrict (E := E) R).uniformContinuous.comp uniformContinuous_subtype_val,?_β© | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨Ξ΄,hΞ΄,hdβ© := holder_third_small_sup (K := β) (E := E) (2*L) Ξ΅ (by positivity) hΞ΅ | |
| refine β¨Ξ΄,hΞ΄,?_β© | |
| intro u v huv | |
| rw [Subtype.dist_eq,dist_eq_norm] | |
| apply hd (u.val-v.val) | |
| Β· intro x | |
| simp only [map_sub,BoundedContinuousFunction.sub_apply] | |
| by_cases hx : βxββ€R | |
| Β· let z : Metric.closedBall (0:β) R := β¨x,by simpa using hxβ© | |
| have hh := BoundedContinuousFunction.dist_coe_le_dist | |
| (f := holderDiskRestrict R u.val) (g := holderDiskRestrict R v.val) z | |
| have hh' : βholderValue ((1:β)/3) u.val x - holderValue ((1:β)/3) v.val xβ β€ | |
| dist (holderDiskRestrict R u.val) (holderDiskRestrict R v.val) := by | |
| simpa only [dist_eq_norm,holderDiskRestrict_apply] using hh | |
| exact hh'.trans huv.le | |
| Β· rw [u.property.1 x (lt_of_not_ge hx),v.property.1 x (lt_of_not_ge hx),sub_self,norm_zero] | |
| exact hΞ΄.le | |
| Β· intro x y | |
| have hh := (u.property.2.2.sub v.property.2.2).dist_le_mul x y | |
| simpa only [map_sub,BoundedContinuousFunction.sub_apply,Pi.sub_apply,dist_eq_norm, | |
| NNReal.coe_add,two_mul] using hh | |
| lemma holderLipschitzSet_totallyBounded [ProperSpace E] (R M : β) (L : NNReal) : | |
| TotallyBounded (holderLipschitzSet (E := E) R M L) := by | |
| let A := holderLipschitzSet (E := E) R M L | |
| let K := Metric.closedBall (0:β) R | |
| let : CompactSpace K := isCompact_iff_compactSpace.mp (isCompact_closedBall (0:β) R) | |
| let f : A β K βα΅ E := fun u => holderDiskRestrict R u.val | |
| have he : Equicontinuous ((β) : Set.range f β K β E) := by | |
| apply UniformEquicontinuous.equicontinuous | |
| apply LipschitzWith.uniformEquicontinuous _ L | |
| intro g | |
| obtain β¨u,huβ© := g.property | |
| rw [βhu] | |
| change LipschitzWith L (fun x : K => holderValue ((1:β)/3) u.val x.val) | |
| simpa only [mul_one,Function.comp_def] using u.property.2.2.comp (LipschitzWith.subtype_val K) | |
| have hc : IsCompact (closure (Set.range f)) := BoundedContinuousFunction.arzela_ascoli | |
| (Metric.closedBall (0:E) M) (isCompact_closedBall _ _) (Set.range f) | |
| (by | |
| intro g x hg | |
| obtain β¨u,rflβ© := hg | |
| rw [Metric.mem_closedBall,dist_zero_right] | |
| exact ((holderValue ((1:β)/3) u.val).norm_coe_le_norm x.val).trans u.property.2.1) he | |
| have ht : TotallyBounded (univ : Set A) := | |
| (totallyBounded_image_iff (holderDiskRestrict_uniformInducing R M L)).mp | |
| (by simpa only [image_univ] using hc.totallyBounded.subset subset_closure) | |
| have hti := ht.image uniformContinuous_subtype_val | |
| simpa only [image_univ,Subtype.range_coe] using hti | |
| lemma holderLipschitzSet_isCompact_closure [ProperSpace E] [CompleteSpace E] | |
| (R M : β) (L : NNReal) : IsCompact (closure (holderLipschitzSet (E := E) R M L)) := | |
| (holderLipschitzSet_totallyBounded R M L).closure.isCompact_of_isClosed isClosed_closure | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |