Download data/lean/OAI/Geometry/BallPacking/Necessity/LocalCharts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 27.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/LocalCharts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/LocalCharts.lean
-
curl -L -o LocalCharts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/LocalCharts.lean
27.1 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.MarkedProfiles | |
| 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 Set Function Filter Topology | |
| open scoped NNReal | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Function Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance localChartsInst1 (Ξ± : β) : NormedAddCommGroup (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst2 (Ξ± : β) : NormedSpace β (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst3 (Ξ± : β) : NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst4 (Ξ± : β) : NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst5 (R : β) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance | |
| local instance localChartsInst6 (R : β) : NormedSpace β (CompactHolderSpace E R) := inferInstance | |
| local instance localChartsInst7 (Ξ± : β) : NormedAddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst8 (Ξ± : β) : NormedSpace β ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst9 (Ξ± : β) : AddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := | |
| (inferInstance : NormedAddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±)).toAddCommGroup | |
| def affineC1Value (Ξ± : β) (z : β) : | |
| (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ± βL[β] E := | |
| (ContinuousLinearMap.fst β E (β βL[β] E)).comp (ContinuousLinearMap.fst β _ _) + | |
| ((ContinuousLinearMap.apply β E z).comp (ContinuousLinearMap.snd β E (β βL[β] E))).comp | |
| (ContinuousLinearMap.fst β _ _) + | |
| (c1HolderEval Ξ± z).comp (ContinuousLinearMap.snd β _ _) | |
| @[simp] theorem affineC1Value_apply (Ξ± : β) (z : β) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) : | |
| affineC1Value Ξ± z p = c1HolderAffineCurve Ξ± p.1.1 p.1.2 p.2 z := rfl | |
| def affineC1Deriv (Ξ± : β) (z : β) : | |
| (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ± βL[β] (β βL[β] E) := | |
| (ContinuousLinearMap.snd β E (β βL[β] E)).comp (ContinuousLinearMap.fst β _ _) + | |
| ((BoundedContinuousFunction.evalCLM β z).comp ((holderValue Ξ±).comp (c1HolderDeriv Ξ±))).comp | |
| (ContinuousLinearMap.snd β _ _) | |
| @[simp] theorem affineC1Deriv_apply (Ξ± : β) (z : β) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) : | |
| affineC1Deriv Ξ± z p = fderiv β (c1HolderAffineCurve Ξ± p.1.1 p.1.2 p.2) z := by | |
| rw [c1HolderAffineCurve_fderiv]; rfl | |
| theorem c1HolderCRFamily_fderiv (Ξ± : β) (hΞ±β : 0β€Ξ±) (hΞ±β : Ξ±β€1) | |
| (J : E β E βL[β] E) (Jβ : E βL[β] E) (hJ : ContDiff β β J) | |
| (hc : HasCompactSupport (fun x => J x-Jβ)) | |
| (p h : (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzββ€βp.1.2 zβ) (z : β) : | |
| holderValue Ξ± (fderiv β (c1HolderCRFamily Ξ± hΞ±β hΞ±β J Jβ hJ hc) p h) z = | |
| linearizedCR J (c1HolderAffineCurve Ξ± p.1.1 p.1.2 p.2) | |
| (c1HolderAffineCurve Ξ± h.1.1 h.1.2 h.2) z := by | |
| let : ContinuousSMul β ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := | |
| IsBoundedSMul.continuousSMul | |
| let ev := affineC1Value (E := E) Ξ± z | |
| let dev := affineC1Deriv (E := E) Ξ± z | |
| have hdJ := ((hJ.differentiable (by simp)) (ev p)).hasFDerivAt.comp p ev.hasFDerivAt | |
| have hdI := dev.hasFDerivAt.clm_apply (hasFDerivAt_const Complex.I p) | |
| have hd1 := dev.hasFDerivAt.clm_apply (hasFDerivAt_const (1:β) p) | |
| have hd := hdI.sub (hdJ.clm_apply hd1) | |
| let hev : HolderSpace β E Ξ± βL[β] E := | |
| (BoundedContinuousFunction.evalCLM β z).comp (holderValue Ξ±) | |
| have hout := hev.hasFDerivAt.comp p | |
| ((c1HolderCRFamily_contDiffAt Ξ± hΞ±β hΞ±β J Jβ hJ hc p m hm hA).differentiableAt | |
| (by simp)).hasFDerivAt | |
| have heq : (fun q => hev (c1HolderCRFamily Ξ± hΞ±β hΞ±β J Jβ hJ hc q)) = | |
| (fun q => dev q Complex.I-J (ev q) (dev q 1)) := by | |
| funext q | |
| simpa only [hev,ev,dev,ContinuousLinearMap.comp_apply, | |
| BoundedContinuousFunction.evalCLM_apply,c1HolderCRFamily,affineC1Value_apply,affineC1Deriv_apply] | |
| using c1HolderCR_apply Ξ± hΞ±β hΞ±β J Jβ hJ hc q.1.1 q.1.2 q.2 z | |
| change HasFDerivAt (fun q => hev (c1HolderCRFamily Ξ± hΞ±β hΞ±β J Jβ hJ hc q)) _ p at hout | |
| rw [heq] at hout | |
| have he := congrArg (fun L => L h) (hout.unique hd) | |
| simp only [hev,ev,dev,ContinuousLinearMap.comp_apply,BoundedContinuousFunction.evalCLM_apply, | |
| sub_apply,add_apply,ContinuousLinearMap.flip_apply,zero_apply,map_zero,zero_add, | |
| Function.comp_def,affineC1Value_apply,affineC1Deriv_apply] at he | |
| exact he.trans (by unfold linearizedCR; abel) | |
| def markedFramedCR (R : β) (Ainf : E βL[β] E) (P : β β E βL[β] E) | |
| (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (Jβ : E βL[β] E) (hJ : ContDiff β β J) | |
| (hJc : HasCompactSupport (fun x => J x-Jβ)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (g : CompactHolderSpace E R) : HolderSpace β E ((1:β)/3) := | |
| c1HolderCRFamily ((1:β)/3) (by norm_num) (by norm_num) J Jβ hJ hJc | |
| (p+markedFramedProfile R Ainf P hP hPc g) | |
| theorem markedFramedCR_contDiffAt_zero (R : β) (Ainf : E βL[β] E) (P : β β E βL[β] E) | |
| (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (Jβ : E βL[β] E) (hJ : ContDiff β β J) | |
| (hJc : HasCompactSupport (fun x => J x-Jβ)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzββ€βp.1.2 zβ) : | |
| ContDiffAt β β (markedFramedCR R Ainf P hP hPc J Jβ hJ hJc p) 0 := by | |
| have hs := c1HolderCRFamily_contDiffAt ((1:β)/3) (by norm_num) (by norm_num) | |
| J Jβ hJ hJc p m hm hA | |
| have ht : ContDiffAt β β (fun g => p+markedFramedProfile R Ainf P hP hPc g) | |
| (0:CompactHolderSpace E R) := | |
| (contDiff_const.add (markedFramedProfile R Ainf P hP hPc).contDiff).contDiffAt | |
| apply hs.comp_of_eq 0 ht | |
| Β· exact mapsTo_univ _ _ | |
| Β· rw [(markedFramedProfile R Ainf P hP hPc).map_zero,add_zero] | |
| lemma affineC1Curve_profile (R : β) (Ainf : E βL[β] E) (P : β β E βL[β] E) | |
| (hP : ContDiff β β P) (hPc : HasCompactSupport P) (g : CompactHolderSpace E R) : | |
| let h := markedFramedProfile R Ainf P hP hPc g | |
| c1HolderAffineCurve ((1:β)/3) h.1.1 h.1.2 h.2 = fun z => (Ainf+P z) (markedCRInverse R g z) := by | |
| funext z | |
| exact markedFramedProfile_value R Ainf P hP hPc g z | |
| theorem markedFramedCR_fderiv_zero (R : β) (Ainf : E βL[β] E) (P : β β E βL[β] E) | |
| (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (Jβ : E βL[β] E) (hJ : ContDiff β β J) | |
| (hJc : HasCompactSupport (fun x => J x-Jβ)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzββ€βp.1.2 zβ) | |
| (g : CompactHolderSpace E R) (z : β) : | |
| holderValue ((1:β)/3) (fderiv β (markedFramedCR R Ainf P hP hPc J Jβ hJ hJc p) 0 g) z = | |
| linearizedCR J (c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2) | |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z := by | |
| let F := markedFramedProfile R Ainf P hP hPc | |
| have hs := (c1HolderCRFamily_contDiffAt ((1:β)/3) (by norm_num) (by norm_num) | |
| J Jβ hJ hJc p m hm hA).differentiableAt (by simp) | |
| have ht : HasFDerivAt (fun v => p+F v) F (0:CompactHolderSpace E R) := F.hasFDerivAt.const_add p | |
| have hs' : HasFDerivAt (c1HolderCRFamily ((1:β)/3) (by norm_num) (by norm_num) J Jβ hJ hJc) | |
| (fderiv β (c1HolderCRFamily ((1:β)/3) (by norm_num) (by norm_num) J Jβ hJ hJc) p) (p+F 0) := by | |
| rw [F.map_zero,add_zero] | |
| exact hs.hasFDerivAt | |
| have hd := hs'.comp 0 ht | |
| change HasFDerivAt (markedFramedCR R Ainf P hP hPc J Jβ hJ hJc p) _ 0 at hd | |
| rw [hd.fderiv,ContinuousLinearMap.comp_apply] | |
| rw [c1HolderCRFamily_fderiv _ _ _ _ _ _ _ _ _ m hm hA] | |
| rw [affineC1Curve_profile] | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Function Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] [FiniteDimensional β E] | |
| local instance localChartsInst10 (Ξ± : β) : NormedAddCommGroup (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst11 (Ξ± : β) : NormedSpace β (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst12 (Ξ± : β) : NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst13 (Ξ± : β) : NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst14 (R : β) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance | |
| local instance localChartsInst15 (R : β) : NormedSpace β (CompactHolderSpace E R) := inferInstance | |
| local instance localChartsInst16 (Ξ± : β) : NormedAddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst17 (Ξ± : β) : NormedSpace β ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst18 (Ξ± : β) : AddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) := | |
| (inferInstance : NormedAddCommGroup ((E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±)).toAddCommGroup | |
| omit [FiniteDimensional β E] in | |
| theorem affineC1_uniform_exterior (J : E β E βL[β] E) (B : E βL[β] E) | |
| (hc : HasCompactSupport (fun x => J x-B)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzβ β€ βp.1.2 zβ) : | |
| β S : β, 0 < S β§ β q : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3), | |
| βq-pβ < min 1 (m/2) β β z : β, S < βzβ β | |
| J (c1HolderAffineCurve ((1:β)/3) q.1.1 q.1.2 q.2 z)=B := by | |
| obtain β¨T,hT,hJTβ© := compactCoefficient_zero_outside hc | |
| let U := βp.2β+1 | |
| let S := max 1 (2*(T+βp.1.1β+1+U)/m) | |
| have hS : 0 < S := lt_of_lt_of_le zero_lt_one (le_max_left _ _) | |
| refine β¨S,hS,?_β© | |
| intro q hq z hz | |
| have hqpβ : βq.1-p.1β < min 1 (m/2) := lt_of_le_of_lt (norm_fst_le (q-p)) hq | |
| have hd : βq.1.1-p.1.1β β€ 1 := | |
| ((norm_fst_le (q.1-p.1)).trans hqpβ.le).trans (min_le_left _ _) | |
| have hB : βq.1.2-p.1.2β β€ m/2 := | |
| ((norm_snd_le (q.1-p.1)).trans hqpβ.le).trans (min_le_right _ _) | |
| have hqβ : βq.2-p.2β β€ 1 := | |
| ((norm_snd_le (q-p)).trans hq.le).trans (min_le_left _ _) | |
| have hqU : βq.2β β€ U := by | |
| have hh : βq.2β β€ βq.2-p.2β+βp.2β := norm_le_norm_sub_add _ _ | |
| change βq.2β β€ βp.2β+1 | |
| linarith only [hh,hqβ] | |
| have hv := (c1HolderValue_bound ((1:β)/3) q.2 z).trans hqU | |
| have hzS : T+βp.1.1β+1+U β€ m/2*βzβ := by | |
| have hh := (le_max_right 1 (2*(T+βp.1.1β+1+U)/m)).trans hz.le | |
| have hh' := (div_le_iffβ hm).mp hh | |
| linarith | |
| have he := affineProfile_lower_bound p.1.1 (q.1.1-p.1.1) | |
| (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) q.2) z) | |
| p.1.2 (q.1.2-p.1.2) m U T 1 hm hA hd hB hv β¨zero_le_one,le_rflβ© z hzS | |
| have he' : T β€ βc1HolderAffineCurve ((1:β)/3) q.1.1 q.1.2 q.2 zβ := by | |
| convert he using 1 | |
| rw [one_smul,sub_apply] | |
| congr 1 | |
| unfold c1HolderAffineCurve | |
| abel | |
| exact sub_eq_zero.mp (hJT _ he') | |
| omit [FiniteDimensional β E] in | |
| lemma affineC1Curve_add (Ξ± : β) | |
| (p q : (E Γ (β βL[β] E)) Γ C1HolderSpace E Ξ±) : | |
| c1HolderAffineCurve Ξ± (p+q).1.1 (p+q).1.2 (p+q).2 = | |
| fun z => c1HolderAffineCurve Ξ± p.1.1 p.1.2 p.2 z+ | |
| c1HolderAffineCurve Ξ± q.1.1 q.1.2 q.2 z := by | |
| funext z | |
| exact (affineC1Value Ξ± z).map_add p q | |
| omit [FiniteDimensional β E] in | |
| lemma framed_variation_exterior_cr (R : β) (Ainf : E βL[β] E) | |
| (hAinf : β v, Ainf (Complex.I β’ v)=Complex.I β’ Ainf v) | |
| (P : β β E βL[β] E) (_hP : ContDiff β β P) | |
| (_hc : HasCompactSupport P) (hPR : β z : β, R < βzβ β P z=0) | |
| (g : CompactHolderSpace E R) (z : β) (hz : R < βzβ) : | |
| crOperator (fun _ => (ContinuousLinearMap.lsmul β β) Complex.I) | |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z=0 := by | |
| have hp : βαΆ w in π z, P w=0 := by | |
| filter_upwards [((isOpen_lt continuous_const continuous_norm).mem_nhds hz)] with w hw | |
| exact hPR w hw | |
| have he : (fun w => (Ainf+P w) (markedCRInverse R g w)) =αΆ [π z] | |
| fun w => Ainf (markedCRInverse R g w) := by | |
| filter_upwards [hp] with w hw | |
| rw [hw,add_zero] | |
| have hd := Ainf.hasFDerivAt.comp z (markedCRInverse_differentiable R g z).hasFDerivAt | |
| change HasFDerivAt (fun w => Ainf (markedCRInverse R g w)) _ z at hd | |
| unfold crOperator | |
| rw [he.fderiv_eq,hd.fderiv] | |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.lsmul_apply] | |
| rw [β hAinf,β map_sub,markedCRInverse_rightInverse] | |
| change Ainf (holderValue ((1:β)/3) g.val z)=0 | |
| rw [g.property z hz,map_zero] | |
| omit [FiniteDimensional β E] in | |
| theorem markedFramedCR_eventually_compact (Ainf : E βL[β] E) | |
| (hAinf : β v, Ainf (Complex.I β’ v)=Complex.I β’ Ainf v) | |
| (P : β β E βL[β] E) (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (hJ : ContDiff β β J) | |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul β β) Complex.I)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzβ β€ βp.1.2 zβ) | |
| (hsol : β z, crOperator J (c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2) z=0) : | |
| β S : β, 0 < S β§ β R : β, S β€ R β | |
| βαΆ g : CompactHolderSpace E R in π 0, | |
| markedFramedCR R Ainf P hP hPc J ((ContinuousLinearMap.lsmul β β) Complex.I) hJ hc p g | |
| β compactHolderSubmodule R := by | |
| let B : E βL[β] E := (ContinuousLinearMap.lsmul β β) Complex.I | |
| obtain β¨Sβ,hSβ,hJSβ© := affineC1_uniform_exterior J B hc p m hm hA | |
| obtain β¨Sβ,hSβ,hPSβ© := compactCoefficient_zero_outside hPc | |
| let S := max Sβ Sβ | |
| refine β¨S,lt_of_lt_of_le hSβ (le_max_left _ _),?_β© | |
| intro R hR | |
| let F := markedFramedProfile R Ainf P hP hPc | |
| have hsmall : βαΆ g : CompactHolderSpace E R in π 0, βF gβ < min 1 (m/2) := by | |
| have ht := (F.continuous.continuousAt (x := 0)).tendsto | |
| have hm' : (0:β) < min 1 (m/2) := lt_min zero_lt_one (by linarith) | |
| have hh : {q | βqβ < min 1 (m/2)} β π (F 0) := by | |
| rw [F.map_zero] | |
| simpa only [Metric.ball,dist_zero_right] using Metric.ball_mem_nhds (0 : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) hm' | |
| exact ht.eventually hh | |
| filter_upwards [hsmall] with g hg | |
| intro z hz | |
| let u := c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2 | |
| let v := fun w => (Ainf+P w) (markedCRInverse R g w) | |
| have hPR : β w : β, R < βwβ β P w=0 := fun w hw => | |
| hPS w (((le_max_right _ _).trans hR).trans hw.le) | |
| have hJq : J (u z+v z)=B := by | |
| have hh := hJS (p+F g) (by simpa only [add_sub_cancel_left] using hg) z | |
| (lt_of_le_of_lt ((le_max_left _ _).trans hR) hz) | |
| rw [affineC1Curve_add,affineC1Curve_profile] at hh | |
| exact hh | |
| have hJp : J (u z)=B := hJS p (by simpa only [sub_self,norm_zero] using lt_min zero_lt_one (show (0:β) < m/2 by linarith)) z | |
| (lt_of_le_of_lt ((le_max_left _ _).trans hR) hz) | |
| have hdu := (c1HolderAffineCurve_hasFDerivAt ((1:β)/3) p.1.1 p.1.2 p.2 z).differentiableAt | |
| have hdv : DifferentiableAt β v z := | |
| ((contDiff_const.add hP).differentiable (by simp) z).clm_apply | |
| (markedCRInverse_differentiable R g z) | |
| have hv := framed_variation_exterior_cr R Ainf hAinf P hP hPc hPR g z hz | |
| have hu := hsol z | |
| change crOperator J u z=0 at hu | |
| unfold crOperator at hu hv | |
| rw [hJp] at hu | |
| change holderValue ((1:β)/3) (c1HolderCRFamily _ _ _ _ _ _ _ (p+F g)) z=0 | |
| rw [c1HolderCRFamily,c1HolderCR_apply,affineC1Curve_add,affineC1Curve_profile] | |
| change fderiv β (fun w => u w+v w) z Complex.I- | |
| J (u z+v z) (fderiv β (fun w => u w+v w) z 1)=0 | |
| rw [fderiv_fun_add hdu hdv,hJq] | |
| simp only [add_apply,map_add] | |
| change fderiv β v z Complex.I-B (fderiv β v z 1)=0 at hv | |
| rw [sub_eq_zero] at hu hv β’ | |
| rw [hu,hv] | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| universe u | |
| variable {X Y Z : Type u} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| [NormedAddCommGroup Z] [NormedSpace β Z] | |
| lemma linearIsometry_fderiv_mem (e : Y ββα΅’[β] Z) (f : X β Y) (x v : X) : | |
| fderiv β (e β f) x v β e.toLinearMap.range := by | |
| let S := e.toLinearMap.range | |
| let : IsClosed (S : Set Z) := e.isometry.isClosedEmbedding.isClosed_range | |
| by_cases hd : DifferentiableAt β (e β f) x | |
| Β· have he : (fun y => S.mkQL (e (f y))) = fun _ : X => (0 : Z β§Έ S) := by | |
| funext y | |
| exact (Submodule.Quotient.mk_eq_zero S).mpr β¨f y,rflβ© | |
| have hh := S.mkQL.hasFDerivAt.comp x hd.hasFDerivAt | |
| change HasFDerivAt (fun y => S.mkQL (e (f y))) _ x at hh | |
| rw [he] at hh | |
| have hv := congrArg (fun L : X βL[β] (Z β§Έ S) => L v) | |
| (hh.unique (hasFDerivAt_const (0 : Z β§Έ S) x)) | |
| exact (Submodule.Quotient.mk_eq_zero S).mp hv | |
| Β· rw [fderiv_zero_of_not_differentiableAt hd] | |
| exact S.zero_mem | |
| def reflectedFDeriv (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) : X βL[β] Y := | |
| e.equivRange.symm.toContinuousLinearEquiv.toContinuousLinearMap.comp | |
| ((fderiv β (e β f) x).codRestrict e.toLinearMap.range | |
| (linearIsometry_fderiv_mem e f x)) | |
| lemma reflectedFDeriv_comp (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) : | |
| e.toContinuousLinearMap.comp (reflectedFDeriv e f x) = fderiv β (e β f) x := by | |
| ext v | |
| exact congrArg Subtype.val (e.equivRange.apply_symm_apply | |
| β¨fderiv β (e β f) x v,linearIsometry_fderiv_mem e f x vβ©) | |
| lemma hasFDerivAt_reflected (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) | |
| (hd : DifferentiableAt β (e β f) x) : | |
| HasFDerivAt f (reflectedFDeriv e f x) x := by | |
| have hh := hd.hasFDerivAt | |
| rw [β reflectedFDeriv_comp e f x] at hh | |
| rw [hasFDerivAt_iff_isLittleO_nhds_zero] at hh β’ | |
| rw [β Asymptotics.isLittleO_norm_left] at hh β’ | |
| simpa only [Function.comp_apply,ContinuousLinearMap.comp_apply, | |
| LinearIsometry.coe_toContinuousLinearMap,β map_sub,e.norm_map] using hh | |
| lemma fderiv_comp_linearIsometry (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) : | |
| e.toContinuousLinearMap.comp (fderiv β f x) = fderiv β (e β f) x := by | |
| by_cases hd : DifferentiableAt β (e β f) x | |
| Β· rw [(hasFDerivAt_reflected e f x hd).fderiv] | |
| exact reflectedFDeriv_comp e f x | |
| Β· have hdf : Β¬ DifferentiableAt β f x := by | |
| intro hf | |
| exact hd (e.toContinuousLinearMap.differentiableAt.comp x hf) | |
| rw [fderiv_zero_of_not_differentiableAt hd,fderiv_zero_of_not_differentiableAt hdf] | |
| simp | |
| theorem contDiffAt_reflect_isometry_nat (m : β) (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) | |
| (hf : ContDiffAt β m (e β f) x) : ContDiffAt β m f x := by | |
| induction m generalizing Y Z with | |
| | zero => | |
| obtain β¨U,hU,hcβ© := contDiffAt_zero.mp hf | |
| apply contDiffAt_zero.mpr | |
| refine β¨U,hU,?_β© | |
| intro y hy | |
| exact e.isEmbedding.isInducing.continuousWithinAt_iff.mpr (hc y hy) | |
| | succ m ih => | |
| apply contDiffAt_succ_iff_hasFDerivAt.mpr | |
| refine β¨fderiv β f,?_,?_β© | |
| Β· have hlocal := hf.eventually (by simp) | |
| refine β¨{y | ContDiffAt β ((m+1 : β) : ββΟ) (e β f) y},hlocal,?_β© | |
| intro y hy | |
| change ContDiffAt β ((m+1 : β) : ββΟ) (e β f) y at hy | |
| have hd := (hasFDerivAt_reflected e f y (hy.differentiableAt (by simp))) | |
| rw [hd.fderiv] | |
| exact hd | |
| Β· let ep : (X βL[β] Y) ββα΅’[β] (X βL[β] Z) := e.postcomp | |
| apply ih ep (fderiv β f) | |
| have he : ep β fderiv β f = fderiv β (e β f) := by | |
| funext y | |
| exact fderiv_comp_linearIsometry e f y | |
| rw [he] | |
| exact hf.fderiv_right (by simp) | |
| theorem contDiffAt_reflect_isometry (e : Y ββα΅’[β] Z) (f : X β Y) (x : X) | |
| (hf : ContDiffAt β β (e β f) x) : ContDiffAt β β f x := | |
| contDiffAt_infty.mpr (fun m => contDiffAt_reflect_isometry_nat m e f x | |
| (contDiffAt_infty.mp hf m)) | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| universe u | |
| variable {X Y : Type u} [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| def localCodRestrict (S : Submodule β Y) (f : X β Y) (x : X) : S := by | |
| classical | |
| exact if h : f x β S then β¨f x,hβ© else 0 | |
| omit [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace Y] in | |
| lemma localCodRestrict_eq (S : Submodule β Y) (f : X β Y) {x : X} (h : f x β S) : | |
| (localCodRestrict S f x : Y)=f x := by | |
| simp only [localCodRestrict,dite_eq_left h] | |
| omit [NormedSpace β X] [CompleteSpace Y] in | |
| lemma localCodRestrict_eventually (S : Submodule β Y) (f : X β Y) {x : X} | |
| (h : βαΆ y in π x, f y β S) : | |
| (fun y => (localCodRestrict S f y : Y)) =αΆ [π x] f := by | |
| filter_upwards [h] with y hy | |
| exact localCodRestrict_eq S f hy | |
| def submoduleInclusionIsometry (S : Submodule β Y) : S ββα΅’[β] Y where | |
| toLinearMap := S.subtype | |
| norm_map' := fun _ => rfl | |
| theorem localCodRestrict_contDiffAt (S : Submodule β Y) [IsClosed (S : Set Y)] | |
| (f : X β Y) {x : X} (h : βαΆ y in π x, f y β S) (hf : ContDiffAt β β f x) : | |
| ContDiffAt β β (localCodRestrict S f) x := by | |
| let : CompleteSpace S := IsClosed.completeSpace_coe | |
| apply contDiffAt_reflect_isometry (submoduleInclusionIsometry S) | |
| exact hf.congr_of_eventuallyEq (localCodRestrict_eventually S f h) | |
| theorem localCodRestrict_fderiv (S : Submodule β Y) [IsClosed (S : Set Y)] | |
| (f : X β Y) {x : X} (h : βαΆ y in π x, f y β S) (v : X) : | |
| (fderiv β (localCodRestrict S f) x v : Y)=fderiv β f x v := by | |
| let : CompleteSpace S := IsClosed.completeSpace_coe | |
| have hh := congrArg (fun L : X βL[β] Y => L v) | |
| (fderiv_comp_linearIsometry (submoduleInclusionIsometry S) (localCodRestrict S f) x) | |
| change (fderiv β (localCodRestrict S f) x v : Y)= | |
| fderiv β (fun y => (localCodRestrict S f y : Y)) x v at hh | |
| rw [(localCodRestrict_eventually S f h).fderiv_eq] at hh | |
| exact hh | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Function Filter | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| [FiniteDimensional β E] | |
| local instance localChartsInst19 (Ξ± : β) : NormedAddCommGroup (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst20 (Ξ± : β) : NormedSpace β (HolderSpace β E Ξ±) := inferInstance | |
| local instance localChartsInst21 (Ξ± : β) : NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst22 (Ξ± : β) : NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance localChartsInst23 (R : β) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance | |
| local instance localChartsInst24 (R : β) : NormedSpace β (CompactHolderSpace E R) := inferInstance | |
| def compactMarkedCR (R : β) (Ainf : E βL[β] E) (P : β β E βL[β] E) | |
| (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (hJ : ContDiff β β J) | |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul β β) Complex.I)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) : | |
| CompactHolderSpace E R β CompactHolderSpace E R := | |
| localCodRestrict (compactHolderSubmodule R) | |
| (markedFramedCR R Ainf P hP hPc J ((ContinuousLinearMap.lsmul β β) Complex.I) hJ hc p) | |
| omit [FiniteDimensional β E] in | |
| theorem compactMarkedCR_local_chart (Ainf : E βL[β] E) | |
| (hAinf : β v, Ainf (Complex.I β’ v)=Complex.I β’ Ainf v) | |
| (P : β β E βL[β] E) (hP : ContDiff β β P) (hPc : HasCompactSupport P) | |
| (J : E β E βL[β] E) (hJ : ContDiff β β J) | |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul β β) Complex.I)) | |
| (p : (E Γ (β βL[β] E)) Γ C1HolderSpace E ((1:β)/3)) | |
| (m : β) (hm : 0 < m) (hA : β z, m*βzβ β€ βp.1.2 zβ) | |
| (hsol : β z, crOperator J (c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2) z=0) : | |
| β S : β, 0 < S β§ β R : β, S β€ R β | |
| ContDiffAt β β (compactMarkedCR R Ainf P hP hPc J hJ hc p) 0 β§ | |
| (βαΆ g : CompactHolderSpace E R in π 0, β z, | |
| compactHolderValue R (compactMarkedCR R Ainf P hP hPc J hJ hc p g) z = | |
| crOperator J (fun w => c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2 w+ | |
| (Ainf+P w) (markedCRInverse R g w)) z) β§ | |
| β g z, compactHolderValue R (fderiv β (compactMarkedCR R Ainf P hP hPc J hJ hc p) 0 g) z = | |
| linearizedCR J (c1HolderAffineCurve ((1:β)/3) p.1.1 p.1.2 p.2) | |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z := by | |
| obtain β¨S,hS,hSRβ© := markedFramedCR_eventually_compact Ainf hAinf P hP hPc J hJ hc p m hm hA hsol | |
| refine β¨S,hS,?_β© | |
| intro R hR | |
| have he := hSR R hR | |
| refine β¨localCodRestrict_contDiffAt _ _ he | |
| (markedFramedCR_contDiffAt_zero R Ainf P hP hPc J _ hJ hc p m hm hA),?_,?_β© | |
| Β· filter_upwards [he] with g hg | |
| intro z | |
| change holderValue ((1:β)/3) (localCodRestrict _ _ g).val z=_ | |
| rw [localCodRestrict_eq _ _ hg] | |
| unfold markedFramedCR | |
| rw [c1HolderCRFamily,c1HolderCR_apply,affineC1Curve_add,affineC1Curve_profile] | |
| rfl | |
| Β· intro g z | |
| change holderValue ((1:β)/3) | |
| (fderiv β (localCodRestrict _ _) 0 g).val z=_ | |
| rw [localCodRestrict_fderiv _ _ he] | |
| exact markedFramedCR_fderiv_zero R Ainf P hP hPc J _ hJ hc p m hm hA g z | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |