Download data/lean/OAI/Geometry/BallPacking/Necessity/OrbitRegularity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 28.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/OrbitRegularity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Necessity/OrbitRegularity.lean
-
curl -L -o OrbitRegularity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Necessity/OrbitRegularity.lean
28.7 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Necessity.FrozenResponse | |
| 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 Function | |
| open scoped Topology ContDiff | |
| open scoped ContDiff Topology Convolution | |
| open Set Filter Function MeasureTheory _root_.ContinuousLinearMap _root_.OAI.ContinuousLinearMap | |
| open Set Filter Function MeasureTheory | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance htransHolderGroup (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace β V Ξ±) := inferInstance | |
| local instance htransHolderSpace (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedSpace β (HolderSpace β V Ξ±) := inferInstance | |
| local instance htransC1Group (V : Type) [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] (Ξ± : β) : | |
| NormedAddCommGroup (C1HolderSpace V Ξ±) := inferInstance | |
| local instance htransC1Space (V : Type) [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] (Ξ± : β) : | |
| NormedSpace β (C1HolderSpace V Ξ±) := inferInstance | |
| def diagonalShift (h : β) : C(OffDiagonal β,OffDiagonal β) := | |
| β¨fun p => β¨(p.val.1+h,p.val.2+h),fun he => p.property (add_right_cancel he)β©, | |
| Continuous.subtype_mk (((continuous_fst.comp continuous_subtype_val).add continuous_const).prodMk | |
| ((continuous_snd.comp continuous_subtype_val).add continuous_const)) _β© | |
| def holderShift (Ξ± : β) (h : β) : HolderSpace β E Ξ± βL[β] HolderSpace β E Ξ± := | |
| ((((BoundedContinuousFunction.compContinuousCLM E β β¨fun z => z+h,continuous_id.add continuous_constβ©).comp | |
| (holderValue Ξ±)).prod | |
| ((BoundedContinuousFunction.compContinuousCLM E β (diagonalShift h)).comp | |
| (holderDifference Ξ±))).codRestrict (holderGraph β E Ξ±) (by | |
| intro f p | |
| change holderValue Ξ± f (p.val.1+h)-holderValue Ξ± f (p.val.2+h)= | |
| (dist p.val.1 p.val.2)^Ξ± β’ holderDifference Ξ± f (diagonalShift h p) | |
| have hh := f.property (diagonalShift h p) | |
| change holderValue Ξ± f (p.val.1+h)-holderValue Ξ± f (p.val.2+h)= | |
| (dist (p.val.1+h) (p.val.2+h))^Ξ± β’ holderDifference Ξ± f (diagonalShift h p) at hh | |
| simpa only [dist_add_right] using hh)) | |
| omit [CompleteSpace E] in | |
| @[simp] theorem holderShift_value (Ξ± : β) (h : β) (f : HolderSpace β E Ξ±) (z : β) : | |
| holderValue Ξ± (holderShift Ξ± h f) z=holderValue Ξ± f (z+h) := rfl | |
| omit [CompleteSpace E] in | |
| theorem holderShift_norm (Ξ± : β) (h : β) (f : HolderSpace β E Ξ±) : | |
| βholderShift Ξ± h fββ€βfβ := by | |
| change max β(holderValue Ξ± f).compContinuous _β β(holderDifference Ξ± f).compContinuous _ββ€ max βf.val.1β βf.val.2β | |
| exact max_le_max (BoundedContinuousFunction.norm_compContinuous_le _ _) (BoundedContinuousFunction.norm_compContinuous_le _ _) | |
| def c1HolderShift (Ξ± : β) (h : β) : C1HolderSpace E Ξ± βL[β] C1HolderSpace E Ξ± := | |
| (((holderShift Ξ± h).comp (c1HolderValue Ξ±)).prod | |
| ((holderShift Ξ± h).comp (c1HolderDeriv Ξ±))).codRestrict (c1HolderGraph Ξ±) (by | |
| intro f | |
| apply c1HolderGraph_mem_of_hasFDerivAt | |
| intro z | |
| exact (c1Holder_hasFDerivAt Ξ± f (z+h)).comp z ((hasFDerivAt_id z).add_const h)) | |
| @[simp] theorem c1HolderShift_value (Ξ± : β) (h : β) (f : C1HolderSpace E Ξ±) (z : β) : | |
| holderValue Ξ± (c1HolderValue Ξ± (c1HolderShift Ξ± h f)) z= | |
| holderValue Ξ± (c1HolderValue Ξ± f) (z+h) := rfl | |
| @[simp] theorem c1HolderShift_Deriv (Ξ± : β) (h : β) (f : C1HolderSpace E Ξ±) : | |
| c1HolderDeriv Ξ± (c1HolderShift Ξ± h f)=holderShift Ξ± h (c1HolderDeriv Ξ± f) := rfl | |
| theorem c1HolderShift_norm (Ξ± : β) (h : β) (f : C1HolderSpace E Ξ±) : | |
| βc1HolderShift Ξ± h fββ€βfβ := | |
| max_le_max (holderShift_norm Ξ± h _) (holderShift_norm Ξ± h _) | |
| theorem c1_shift_value_holder_bound (Ξ± : β) (hΞ± : 0<Ξ±) (f : C1HolderSpace E Ξ±) (h k : β) : | |
| βholderShift Ξ± h (c1HolderValue Ξ± f)-holderShift Ξ± k (c1HolderValue Ξ± f)ββ€ | |
| βc1HolderDeriv Ξ± fβ*βh-kβ := by | |
| let v := holderValue Ξ± (c1HolderValue Ξ± f) | |
| let d := holderValue Ξ± (c1HolderDeriv Ξ± f) | |
| have hd (z : β) : HasFDerivAt v (d z) z := c1Holder_hasFDerivAt Ξ± f z | |
| have hd0 (z : β) : βd zββ€βc1HolderDeriv Ξ± fβ := | |
| ((holderValue Ξ± (c1HolderDeriv Ξ± f)).norm_coe_le_norm z).trans (holderValue_norm Ξ± _) | |
| have he (x y : β) : βd x-d yββ€βc1HolderDeriv Ξ± fβ*(dist x y)^Ξ± := | |
| holderSpace_estimate Ξ± hΞ± _ x y | |
| apply (holder_norm_le_of_estimate Ξ± _ (by positivity) (by positivity) _ _).trans_eq (max_self _) | |
| Β· intro z | |
| change βv (z+h)-v (z+k)ββ€_ | |
| have hh := (convex_univ : Convex β (univ : Set β)).norm_image_sub_le_of_norm_hasFDerivWithin_le | |
| (fun x _ => (hd x).hasFDerivWithinAt) (fun x _ => hd0 x) (mem_univ (z+k)) (mem_univ (z+h)) | |
| simpa only [add_sub_add_left_eq_sub] using hh | |
| Β· intro x y | |
| let w : β β E := fun z => v (x+z)-v (y+z) | |
| have hw (z : β) : HasFDerivAt w (d (x+z)-d (y+z)) z := | |
| ((hd (x+z)).comp z ((hasFDerivAt_id z).const_add x)).sub | |
| ((hd (y+z)).comp z ((hasFDerivAt_id z).const_add y)) | |
| have hb (z : β) : βd (x+z)-d (y+z)ββ€βc1HolderDeriv Ξ± fβ*(dist x y)^Ξ± := by | |
| simpa only [dist_add_right] using he (x+z) (y+z) | |
| have hh := (convex_univ : Convex β (univ : Set β)).norm_image_sub_le_of_norm_hasFDerivWithin_le | |
| (fun z _ => (hw z).hasFDerivWithinAt) (fun z _ => hb z) (mem_univ k) (mem_univ h) | |
| change β(v (x+h)-v (x+k))-(v (y+h)-v (y+k))ββ€_ | |
| have heq : (v (x+h)-v (x+k))-(v (y+h)-v (y+k))=w h-w k := by dsimp [w]; abel | |
| rw [heq] | |
| convert hh using 1 | |
| ring | |
| theorem c1_shift_value_continuous (Ξ± : β) (hΞ± : 0<Ξ±) (f : C1HolderSpace E Ξ±) : | |
| Continuous (fun h : β => holderShift Ξ± h (c1HolderValue Ξ± f)) := by | |
| apply (LipschitzWith.of_dist_le_mul (K := β¨βc1HolderDeriv Ξ± fβ,norm_nonneg _β©) ?_).continuous | |
| intro h k | |
| simp only [dist_eq_norm] | |
| change βholderShift Ξ± h (c1HolderValue Ξ± f)-holderShift Ξ± k (c1HolderValue Ξ± f)ββ€ | |
| βc1HolderDeriv Ξ± fβ*βh-kβ | |
| exact c1_shift_value_holder_bound Ξ± hΞ± f h k | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E X : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| [NormedAddCommGroup X] [NormedSpace β X] | |
| local instance hdiffHolderGroup (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace β V Ξ±) := inferInstance | |
| local instance hdiffHolderSpace (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedSpace β (HolderSpace β V Ξ±) := inferInstance | |
| def holderTranspose (Ξ± : β) : HolderSpace β (X βL[β] E) Ξ± βL[β] (X βL[β] HolderSpace β E Ξ±) := | |
| (ContinuousLinearMap.compL β X (HolderSpace β X Ξ±) (HolderSpace β E Ξ±)).flip | |
| (holderConstantCLM Ξ±) |>.comp (holderOperatorCLM Ξ±) | |
| omit [CompleteSpace E] in | |
| @[simp] theorem holderTranspose_value (Ξ± : β) (D : HolderSpace β (X βL[β] E) Ξ±) (v : X) (z : β) : | |
| holderValue Ξ± (holderTranspose Ξ± D v) z=holderValue Ξ± D z v := rfl | |
| omit [CompleteSpace E] in | |
| theorem holder_hasFDerivAt (Ξ± : β) (hΞ± : 0<Ξ±) | |
| (F : X β HolderSpace β E Ξ±) (D : X β HolderSpace β (X βL[β] E) Ξ±) | |
| (hD : β y z, HasFDerivAt (fun x => holderValue Ξ± (F x) z) (holderValue Ξ± (D y) z) y) | |
| (x : X) (hc : ContinuousAt D x) : HasFDerivAt F (holderTranspose Ξ± (D x)) x := by | |
| rw [hasFDerivAt_iff_isLittleO,Asymptotics.isLittleO_iff] | |
| intro c hcpos | |
| obtain β¨Ξ΅,hΞ΅,hΞ΅cβ© := Metric.mem_nhds_iff.mp (hc (Metric.ball_mem_nhds (D x) hcpos)) | |
| filter_upwards [Metric.ball_mem_nhds x hΞ΅] with y hy | |
| have hb (w : X) (hw : wβMetric.ball x Ξ΅) : βD w-D xββ€c := by | |
| simpa only [dist_eq_norm] using (show dist (D w) (D x)<c from hΞ΅c hw).le | |
| apply (holder_norm_le_of_estimate Ξ± _ (by positivity) (by positivity) _ _).trans_eq (max_self _) | |
| Β· intro z | |
| change βholderValue Ξ± (F y) z-holderValue Ξ± (F x) z-holderValue Ξ± (D x) z (y-x)ββ€_ | |
| apply (convex_ball x Ξ΅).norm_image_sub_le_of_norm_hasFDerivWithin_le' | |
| (fun w _ => (hD w z).hasFDerivWithinAt) _ (Metric.mem_ball_self hΞ΅) hy | |
| intro w hw | |
| have hh := ((holderValue Ξ± (D w-D x)).norm_coe_le_norm z).trans (holderValue_norm Ξ± _) | |
| exact hh.trans (hb w hw) | |
| Β· intro z w | |
| have hh := (convex_ball x Ξ΅).norm_image_sub_le_of_norm_hasFDerivWithin_le' | |
| (fun t _ => ((hD t z).sub (hD t w)).hasFDerivWithinAt) | |
| (C := c*(dist z w)^Ξ±) (Ο := holderValue Ξ± (D x) z-holderValue Ξ± (D x) w) ?_ | |
| (Metric.mem_ball_self hΞ΅) hy | |
| Β· change β(holderValue Ξ± (F y) z-holderValue Ξ± (F x) z-holderValue Ξ± (D x) z (y-x))- | |
| (holderValue Ξ± (F y) w-holderValue Ξ± (F x) w-holderValue Ξ± (D x) w (y-x))ββ€_ | |
| convert hh using 1 | |
| Β· congr 1 | |
| simp only [sub_apply,Pi.sub_apply] | |
| abel | |
| Β· ring | |
| Β· intro t ht | |
| have he := holderSpace_estimate Ξ± hΞ± (D t-D x) z w | |
| have heq : (holderValue Ξ± (D t) z-holderValue Ξ± (D t) w)- | |
| (holderValue Ξ± (D x) z-holderValue Ξ± (D x) w)= | |
| holderValue Ξ± (D t-D x) z-holderValue Ξ± (D t-D x) w := by | |
| simp only [map_sub,BoundedContinuousFunction.sub_apply] | |
| abel | |
| rw [heq] | |
| exact he.trans (mul_le_mul_of_nonneg_right (hb t ht) (Real.rpow_nonneg (dist_nonneg) _)) | |
| theorem holder_shift_value_hasFDerivAt (Ξ± : β) (hΞ± : 0<Ξ±) (f : C1HolderSpace E Ξ±) (x : β) | |
| (hc : ContinuousAt (fun h : β => holderShift Ξ± h (c1HolderDeriv Ξ± f)) x) : | |
| HasFDerivAt (fun h : β => holderShift Ξ± h (c1HolderValue Ξ± f)) | |
| (holderTranspose Ξ± (holderShift Ξ± x (c1HolderDeriv Ξ± f))) x := by | |
| apply holder_hasFDerivAt Ξ± hΞ± _ _ _ x hc | |
| intro y z | |
| exact (c1Holder_hasFDerivAt Ξ± f (z+y)).comp y ((hasFDerivAt_id y).const_add z) | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] | |
| local instance orbitHolderGroup (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace β V Ξ±) := inferInstance | |
| local instance orbitHolderSpace (V : Type) [NormedAddCommGroup V] [NormedSpace β V] (Ξ± : β) : | |
| NormedSpace β (HolderSpace β V Ξ±) := inferInstance | |
| local instance orbitC1Group (V : Type) [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] (Ξ± : β) : | |
| NormedAddCommGroup (C1HolderSpace V Ξ±) := inferInstance | |
| local instance orbitC1Space (V : Type) [NormedAddCommGroup V] [NormedSpace β V] [CompleteSpace V] (Ξ± : β) : | |
| NormedSpace β (C1HolderSpace V Ξ±) := inferInstance | |
| theorem orbit_response_comp (Ξ± : β) (k : β) (f : C1HolderSpace E Ξ±) (x : β) | |
| (Ξ¦ : β Γ HolderSpace β E Ξ± β C1HolderSpace E Ξ±) | |
| (hΞ¦ : ContDiffAt β β Ξ¦ (x,holderShift Ξ± x (c1HolderValue Ξ± f))) | |
| (heq : (fun h => c1HolderShift Ξ± h f)=αΆ [π x] fun h => Ξ¦ (h,holderShift Ξ± h (c1HolderValue Ξ± f))) | |
| (hG : ContDiffAt β (k:ββΟ) (fun h => holderShift Ξ± h (c1HolderValue Ξ± f)) x) : | |
| ContDiffAt β (k:ββΟ) (fun h => c1HolderShift Ξ± h f) x := by | |
| have hk : (k:ββΟ) β€ β := by exact_mod_cast (le_top : (k:ββ) β€ β€) | |
| exact ((hΦ.of_le hk).comp x (contDiffAt_id.prodMk hG)).congr_of_eventuallyEq heq | |
| theorem orbit_gain (Ξ± : β) (f : C1HolderSpace E Ξ±) (k : β) (x : β) | |
| (hF : ContDiffAt β (k:ββΟ) (fun h => c1HolderShift Ξ± h f) x) | |
| (hDG : βαΆ h in π x, HasFDerivAt (fun h => holderShift Ξ± h (c1HolderValue Ξ± f)) | |
| (holderTranspose Ξ± (holderShift Ξ± h (c1HolderDeriv Ξ± f))) h) : | |
| ContDiffAt β (k+1) (fun h => holderShift Ξ± h (c1HolderValue Ξ± f)) x := by | |
| apply contDiffAt_succ_iff_hasFDerivAt.mpr | |
| refine β¨fun h => holderTranspose Ξ± (holderShift Ξ± h (c1HolderDeriv Ξ± f)),?_,?_β© | |
| Β· exact β¨{h | HasFDerivAt (fun h => holderShift Ξ± h (c1HolderValue Ξ± f)) | |
| (holderTranspose Ξ± (holderShift Ξ± h (c1HolderDeriv Ξ± f))) h},hDG,fun _ h => hβ© | |
| Β· have hdL : ContDiff β (k:ββΟ) (c1HolderDeriv (E := E) Ξ±) := ContinuousLinearMap.contDiff _ | |
| have htL : ContDiff β (k:ββΟ) (holderTranspose (X := β) (E := E) Ξ±) := ContinuousLinearMap.contDiff _ | |
| exact htL.contDiffAt.comp x (hdL.contDiffAt.comp x hF) | |
| theorem c1_orbit_contDiff (Ξ± : β) (hΞ± : 0<Ξ±) (f : C1HolderSpace E Ξ±) | |
| (U : Set β) (hU : IsOpen U) | |
| (Ξ¦ : β Γ HolderSpace β E Ξ± β C1HolderSpace E Ξ±) | |
| (hΞ¦ : β hβU, ContDiffAt β β Ξ¦ (h,holderShift Ξ± h (c1HolderValue Ξ± f))) | |
| (heq : β hβU, c1HolderShift Ξ± h f=Ξ¦ (h,holderShift Ξ± h (c1HolderValue Ξ± f))) : | |
| β hβU, ContDiffAt β β (fun h => c1HolderShift Ξ± h f) h := by | |
| let F := fun h : β => c1HolderShift Ξ± h f | |
| let G := fun h : β => holderShift Ξ± h (c1HolderValue Ξ± f) | |
| have he (h : β) (hh : hβU) : F=αΆ [π h] fun x => Ξ¦ (x,G x) := by | |
| filter_upwards [hU.mem_nhds hh] with x hx | |
| exact heq x hx | |
| have hG0 : ContDiff β 0 G := contDiff_zero.mpr (c1_shift_value_continuous Ξ± hΞ± f) | |
| have hF0 : β hβU, ContDiffAt β 0 F h := by | |
| intro h hh | |
| exact orbit_response_comp α 0 f h Φ (hΦ h hh) (he h hh) hG0.contDiffAt | |
| have hDG : β hβU, HasFDerivAt G (holderTranspose Ξ± (holderShift Ξ± h (c1HolderDeriv Ξ± f))) h := by | |
| intro h hh | |
| apply holder_shift_value_hasFDerivAt Ξ± hΞ± f h | |
| exact (c1HolderDeriv (E := E) Ξ±).continuous.continuousAt.comp (hF0 h hh).continuousAt | |
| have hn : β k : β, β hβU, ContDiffAt β k F h := by | |
| intro k | |
| induction k with | |
| | zero => exact hF0 | |
| | succ k ih => | |
| intro h hh | |
| have hkG := orbit_gain Ξ± f k h (ih h hh) (by | |
| filter_upwards [hU.mem_nhds hh] with x hx | |
| exact hDG x hx) | |
| exact orbit_response_comp α (k+1) f h Φ (hΦ h hh) (he h hh) hkG | |
| intro h hh | |
| exact contDiffAt_infty.mpr (fun k => hn k h hh) | |
| theorem c1_orbit_smooth_function (Ξ± : β) (f : C1HolderSpace E Ξ±) | |
| (hf : ContDiffAt β β (fun h : β => c1HolderShift Ξ± h f) 0) : | |
| ContDiff β β (holderValue Ξ± (c1HolderValue Ξ± f)) := by | |
| apply contDiff_iff_contDiffAt.mpr | |
| intro z | |
| have he : ContDiffAt β β (fun h : β => holderValue Ξ± (c1HolderValue Ξ± f) (z+h)) 0 := | |
| (c1HolderEval (E := E) Ξ± z).contDiff.contDiffAt.comp 0 hf | |
| have hz : ContDiffAt β β (fun h : β => h-z) z := contDiffAt_id.sub contDiffAt_const | |
| have he' : ContDiffAt β β (fun h : β => holderValue Ξ± (c1HolderValue Ξ± f) (z+h)) (z-z) := by simpa only [sub_self] using he | |
| have hh := he'.comp (f := fun h : β => h-z) z hz | |
| convert hh using 1 | |
| funext x | |
| congr 1 | |
| dsimp only [Function.comp_def] | |
| abel | |
| theorem c1_orbit_regular (Ξ± : β) (hΞ± : 0<Ξ±) (f : C1HolderSpace E Ξ±) | |
| (U : Set β) (hU : IsOpen U) (h0 : (0:β)βU) | |
| (Ξ¦ : β Γ HolderSpace β E Ξ± β C1HolderSpace E Ξ±) | |
| (hΞ¦ : β hβU, ContDiffAt β β Ξ¦ (h,holderShift Ξ± h (c1HolderValue Ξ± f))) | |
| (heq : β hβU, c1HolderShift Ξ± h f=Ξ¦ (h,holderShift Ξ± h (c1HolderValue Ξ± f))) : | |
| ContDiff β β (holderValue Ξ± (c1HolderValue Ξ± f)) := | |
| c1_orbit_smooth_function α f (c1_orbit_contDiff α hα f U hU Φ hΦ heq 0 h0) | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| open HigherDimensionalBallPacking.Rigidity | |
| local instance orbitHGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace β E Ξ±) := inferInstance | |
| local instance orbitHSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (Ξ± : β) : | |
| NormedSpace β (HolderSpace β E Ξ±) := inferInstance | |
| local instance orbitCGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] (Ξ± : β) : | |
| NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance orbitCSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] (Ξ± : β) : | |
| NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance orbitCompactGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (R : β) : | |
| NormedAddCommGroup (CompactHolderSpace E R) := inferInstance | |
| local instance orbitCompactSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (R : β) : | |
| NormedSpace β (CompactHolderSpace E R) := inferInstance | |
| def affineSlope {n : β} (a : Phase n) : β βL[β] Phase n := | |
| ((ContinuousLinearMap.lsmul β β : β βL[β] Phase n βL[β] Phase n).flip) a | |
| @[simp] theorem affineSlope_apply {n : β} (a : Phase n) (z : β) : affineSlope a z=z β’ a := rfl | |
| def orbitCoefficient {n : β} (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (p : β Γ HolderSpace β (Phase n) ((1:β)/3)) : HolderSpace β (End n) ((1:β)/3) := | |
| holderAffineFamily ((1:β)/3) (by norm_num) (by norm_num) f hf hc ((c+p.1 β’ a,affineSlope a),p.2) | |
| theorem orbitCoefficient_contDiff {n : β} (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (ha : aβ 0) : ContDiff β β (orbitCoefficient f hf hc c a) := by | |
| apply contDiff_iff_contDiffAt.mpr | |
| intro p | |
| have hA (z : β) : βaβ*βzββ€βaffineSlope a zβ := by | |
| rw [affineSlope_apply,norm_smul,mul_comm] | |
| have hh := holderAffineFamily_contDiffAt ((1:β)/3) (by norm_num) (by norm_num) f hf hc | |
| ((c+p.1 β’ a,affineSlope a),p.2) βaβ (norm_pos_iff.mpr ha) hA | |
| have hp : ContDiff β β (fun p : β Γ HolderSpace β (Phase n) ((1:β)/3) => | |
| ((c+p.1 β’ a,affineSlope a),p.2)) := | |
| ((contDiff_const.add (contDiff_fst.smul contDiff_const)).prodMk contDiff_const).prodMk contDiff_snd | |
| exact hh.comp p hp.contDiffAt | |
| theorem orbitCoefficient_value {n : β} (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (v : C1HolderSpace (Phase n) ((1:β)/3)) (h z : β) : | |
| holderValue ((1:β)/3) (orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v))) z= | |
| f (c1HolderAffineCurve ((1:β)/3) c (affineSlope a) v (z+h)) := by | |
| change f (c+h β’ a+z β’ a+holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) v) (z+h))=_ | |
| congr 1 | |
| unfold c1HolderAffineCurve | |
| rw [affineSlope_apply,add_smul] | |
| abel | |
| theorem orbitCoefficient_C1 {n : β} (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (v : C1HolderSpace (Phase n) ((1:β)/3)) (h : β) : | |
| β H : C1HolderSpace (End n) ((1:β)/3), c1HolderValue ((1:β)/3) H= | |
| orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v)) := | |
| β¨c1HolderAffineCompose ((1:β)/3) (by norm_num) (by norm_num) f hf hc | |
| (c+h β’ a) (affineSlope a) (c1HolderShift ((1:β)/3) h v),rflβ© | |
| theorem affineCoefficient_exterior {n : β} (f : Phase n β End n) (hc : HasCompactSupport f) | |
| (c a : Phase n) (ha : aβ 0) (v : C1HolderSpace (Phase n) ((1:β)/3)) : | |
| β R : β, 0<R β§ β z : β, R<βzβ β f (c1HolderAffineCurve ((1:β)/3) c (affineSlope a) v z)=0 := by | |
| have hc' : HasCompactSupport (fun x => f x-(0:End n)) := by simpa only [sub_zero] using hc | |
| obtain β¨R,hR,hhβ© := affineC1_uniform_exterior f 0 hc' ((c,affineSlope a),v) βaβ (norm_pos_iff.mpr ha) (by | |
| intro z | |
| rw [affineSlope_apply,norm_smul,mul_comm]) | |
| refine β¨R,hR,?_β© | |
| exact hh ((c,affineSlope a),v) (by simp only [sub_self,norm_zero]; exact lt_min zero_lt_one (half_pos (norm_pos_iff.mpr ha))) | |
| theorem orbitCoefficient_support {n : β} (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (ha : aβ 0) (v : C1HolderSpace (Phase n) ((1:β)/3)) : | |
| β b : ContDiffBump (0:β), β h : β, βhβ<1 β β z : β, b.rIn<βzβ β | |
| holderValue ((1:β)/3) (orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v))) z=0 := by | |
| obtain β¨R,hR,hsβ© := affineCoefficient_exterior f hc c a ha v | |
| let b : ContDiffBump (0:β) := β¨R+1,R+2,by linarith,by linarithβ© | |
| refine β¨b,?_β© | |
| intro h hh z hz | |
| rw [orbitCoefficient_value] | |
| apply hs | |
| have hn : βzββ€βz+hβ+βhβ := by | |
| simpa only [add_sub_cancel_right] using norm_sub_le (z+h) h | |
| change R+1<βzβ at hz | |
| linarith | |
| theorem c1_shift_decay {n : β} (v : C1HolderSpace (Phase n) ((1:β)/3)) | |
| (hl : Tendsto (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) v)) (cocompact β) (π 0)) (h : β) : | |
| Tendsto (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) (c1HolderShift ((1:β)/3) h v))) (cocompact β) (π 0) := by | |
| exact hl.comp ((Homeomorph.addRight h).isClosedEmbedding.tendsto_cocompact) | |
| theorem c1_shift_curl {n : β} (v : C1HolderSpace (Phase n) ((1:β)/3)) (h z : β) : | |
| holderValue ((1:β)/3) (c1StandardCurl (c1HolderShift ((1:β)/3) h v)) z= | |
| holderValue ((1:β)/3) (c1StandardCurl v) (z+h) := rfl | |
| end HigherDimensionalBallPacking.Rigidity | |
| open scoped ContDiff Topology BoundedContinuousFunction | |
| open Set Filter Function | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| open HigherDimensionalBallPacking.Rigidity | |
| local instance regularHGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (Ξ± : β) : | |
| NormedAddCommGroup (HolderSpace β E Ξ±) := inferInstance | |
| local instance regularHSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (Ξ± : β) : | |
| NormedSpace β (HolderSpace β E Ξ±) := inferInstance | |
| local instance regularCGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] (Ξ± : β) : | |
| NormedAddCommGroup (C1HolderSpace E Ξ±) := inferInstance | |
| local instance regularCSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] [CompleteSpace E] (Ξ± : β) : | |
| NormedSpace β (C1HolderSpace E Ξ±) := inferInstance | |
| local instance regularCompactGroup (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (R : β) : | |
| NormedAddCommGroup (CompactHolderSpace E R) := inferInstance | |
| local instance regularCompactSpace (E : Type) [NormedAddCommGroup E] [NormedSpace β E] (R : β) : | |
| NormedSpace β (CompactHolderSpace E R) := inferInstance | |
| local instance AffineC1RegularityLocal1 (n : β) : NormedAddCommGroup (HolderSpace β (Phase n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal2 (n : β) : NormedSpace β (HolderSpace β (Phase n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal3 (n : β) : NormedAddCommGroup (HolderSpace β (End n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal4 (n : β) : NormedSpace β (HolderSpace β (End n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal5 (n : β) : NormedAddCommGroup (C1HolderSpace (Phase n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal6 (n : β) : NormedSpace β (C1HolderSpace (Phase n) ((1:β)/3)) := inferInstance | |
| local instance AffineC1RegularityLocal7 (n : β) (R : β) : NormedAddCommGroup (CompactHolderSpace (Phase n) R) := inferInstance | |
| local instance AffineC1RegularityLocal8 (n : β) (R : β) : NormedSpace β (CompactHolderSpace (Phase n) R) := inferInstance | |
| def orbitResponse {n : β} (b : ContDiffBump (0:β)) | |
| (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) (c a : Phase n) | |
| (p : β Γ HolderSpace β (Phase n) ((1:β)/3)) : C1HolderSpace (Phase n) ((1:β)/3) := | |
| compactCRInverse b.rOut (frozenResponse b (orbitCoefficient f hf hc c a p,a)) | |
| theorem orbitResponseDensity_contDiffAt {n : β} (b : ContDiffBump (0:β)) | |
| (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) (c a : Phase n) (ha : aβ 0) | |
| (p : β Γ HolderSpace β (Phase n) ((1:β)/3)) | |
| (hi : (cutoffFrozen b (orbitCoefficient f hf hc c a p)).IsInvertible) : | |
| ContDiffAt β β (fun p : β Γ HolderSpace β (Phase n) ((1:β)/3) => | |
| frozenResponse b (orbitCoefficient f hf hc c a p,a)) p := by | |
| exact frozenResponse_comp_contDiffAt b _ a p | |
| (orbitCoefficient_contDiff f hf hc c a ha).contDiffAt hi | |
| theorem orbitResponse_contDiffAt {n : β} (b : ContDiffBump (0:β)) | |
| (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) (c a : Phase n) (ha : aβ 0) | |
| (p : β Γ HolderSpace β (Phase n) ((1:β)/3)) | |
| (hi : (cutoffFrozen b (orbitCoefficient f hf hc c a p)).IsInvertible) : | |
| ContDiffAt β β (orbitResponse b f hf hc c a) p := by | |
| unfold orbitResponse | |
| have hC : ContDiff β β (compactCRInverse (E := Phase n) b.rOut) := ContinuousLinearMap.contDiff _ | |
| exact hC.contDiffAt.comp p (orbitResponseDensity_contDiffAt b f hf hc c a ha p hi) | |
| theorem orbitResponse_identity {n : β} (b : ContDiffBump (0:β)) | |
| (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (c a : Phase n) (v : C1HolderSpace (Phase n) ((1:β)/3)) (h : β) | |
| (hs : β z, b.rIn<βzβ β holderValue ((1:β)/3) | |
| (orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v))) z=0) | |
| (hi : (cutoffFrozen b (orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v)))).IsInvertible) | |
| (hcurl : β z, holderValue ((1:β)/3) (c1StandardCurl v) z= | |
| f (c1HolderAffineCurve ((1:β)/3) c (affineSlope a) v z) | |
| (a+holderValue ((1:β)/3) (c1HolderDeriv ((1:β)/3) v) z 1)) | |
| (hlim : Tendsto (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) v)) (cocompact β) (π 0)) : | |
| c1HolderShift ((1:β)/3) h v= | |
| orbitResponse b f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v)) := by | |
| apply c1_frozen_response (n := n) b _ a _ hs hi _ (c1_shift_decay v hlim h) | |
| intro z | |
| rw [c1_shift_curl v h z,orbitCoefficient_value f hf hc c a v h z,hcurl (z+h)] | |
| rfl | |
| theorem affine_c1_regular {n : β} | |
| (f : Phase n β End n) (hf : ContDiff β β f) (hc : HasCompactSupport f) | |
| (hK : β x, Compatible (standardJ n+f x)) | |
| (c a : Phase n) (ha : aβ 0) (v : C1HolderSpace (Phase n) ((1:β)/3)) | |
| (hcurl : β z, holderValue ((1:β)/3) (c1StandardCurl v) z= | |
| f (c1HolderAffineCurve ((1:β)/3) c (affineSlope a) v z) | |
| (a+holderValue ((1:β)/3) (c1HolderDeriv ((1:β)/3) v) z 1)) | |
| (hlim : Tendsto (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) v)) (cocompact β) (π 0)) : | |
| ContDiff β β (holderValue ((1:β)/3) (c1HolderValue ((1:β)/3) v)) := by | |
| obtain β¨b,hbβ© := orbitCoefficient_support f hf hc c a ha v | |
| have hi (h : β) (hh : βhβ<1) : | |
| (cutoffFrozen b (orbitCoefficient f hf hc c a (h,holderShift ((1:β)/3) h (c1HolderValue ((1:β)/3) v)))).IsInvertible := by | |
| obtain β¨H,hHβ© := orbitCoefficient_C1 f hf hc c a v h | |
| rw [βhH] | |
| apply cutoffFrozen_invertible b H | |
| Β· simpa only [hH] using hb h hh | |
| Β· intro z | |
| rw [hH,orbitCoefficient_value] | |
| exact hK _ | |
| apply c1_orbit_regular ((1:β)/3) (by norm_num) v (Metric.ball 0 1) Metric.isOpen_ball | |
| (Metric.mem_ball_self (by norm_num)) (orbitResponse b f hf hc c a) | |
| Β· intro h hh | |
| exact orbitResponse_contDiffAt b f hf hc c a ha _ (hi h (by simpa using hh)) | |
| Β· intro h hh | |
| have hh' : βhβ<1 := by simpa using hh | |
| exact orbitResponse_identity b f hf hc c a v h (hb h hh') (hi h hh') hcurl hlim | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |