Download data/lean/OAI/Geometry/BallPacking/Annuli/AnnularChartNormalization.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Annuli/AnnularChartNormalization.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Annuli/AnnularChartNormalization.lean
-
curl -L -o AnnularChartNormalization.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Annuli/AnnularChartNormalization.lean
26.5 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Annuli.QuadricNormalizedCycle | |
| namespace OAI | |
| noncomputable section | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold MeasureTheory | |
| section | |
| variable {P E : Type} [NormedAddCommGroup P] [NormedSpace β P] [FiniteDimensional β P] | |
| [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| {M : Type} [TopologicalSpace M] [ChartedSpace E M] [IsManifold π(β,E) β M] | |
| [T2Space M] [NormalSpace M] [SigmaCompactSpace M] | |
| theorem exists_normalized_primitive_on_annular_chart | |
| {V : Set P} {I : Set β} {K : Set M} | |
| (hV : IsOpen V) (hI : IsOpen I) (hc : Convex β I) {a : β} (ha : aβI) | |
| (e : PartialDiffeomorph π(β,CylinderModel) π(β,E) HandleCylinder M β) | |
| (he_source : e.source=I ΓΛ’ univ) (hK : IsCompact K) (hKA : Kβe.target) | |
| {Ξ N : P β ManifoldOneForm E M} {Ξ² : ManifoldOneForm E M} | |
| (hΞ : β c,ContDiffOn β β (fun q : P Γ E => chartOneForm (Ξ q.1) c q.2) | |
| (V ΓΛ’ (extChartAt π(β,E) c).target)) | |
| (hN : β pβV,β xβe.target,ContDiffAt β β | |
| (fun q : P Γ E => chartOneForm (N q.1) x q.2) (p,extChartAt π(β,E) x x)) | |
| (hcurv : β pβV,β xβe.target,manifoldExteriorOneForm (Ξ p) x=manifoldExteriorOneForm (N p) x) | |
| (hΞ² : β c,ContDiffOn β β (chartOneForm Ξ² c) (extChartAt π(β,E) c).target) | |
| (hΞ²closed : β x,manifoldExteriorOneForm Ξ² x=0) (hΞ²compact : HasCompactSupport Ξ²) | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (hfint : (β« t in (0:β)..1,f (circleTurn t))=1) | |
| (hΞ²coord : β zβe.source,β v : CylinderModel, | |
| Ξ² (e z) (mfderiv π(β,CylinderModel) π(β,E) e z v)=f z.2*circleAngular z.2 v.2) : | |
| β (Ξβ : P β ManifoldOneForm E M) (L W : Set M), | |
| IsCompact L β§ Lβe.target β§ IsOpen W β§ KβW β§ Wβe.target β§ | |
| (β c,ContDiffOn β β (fun q : P Γ E => chartOneForm (Ξβ q.1) c q.2) | |
| (V ΓΛ’ (extChartAt π(β,E) c).target)) β§ | |
| (β p,support (Ξβ p-Ξ p)βtsupport Ξ²βͺL) β§ | |
| (β p,HasCompactSupport (Ξβ p-Ξ p)) β§ | |
| (β pβV,β x,manifoldExteriorOneForm (Ξβ p) x=manifoldExteriorOneForm (Ξ p) x) β§ | |
| (β pβV,β xβW,Ξβ p x=N p x) := by | |
| let Ξ΄ : P β ManifoldOneForm E M := fun p => Ξ p-N p | |
| let Ξ± := parameterManifoldPullbackOneForm (E := E) (F := CylinderModel) Ξ΄ e | |
| have hΞat (p : P) (hp : pβV) (x : M) : ContDiffAt β β | |
| (fun q : P Γ E => chartOneForm (Ξ q.1) x q.2) (p,extChartAt π(β,E) x x) := | |
| (hΞ x).contDiffAt ((hV.prod (isOpen_extChartAt_target (I := π(β,E)) x)).mem_nhds | |
| β¨hp,(extChartAt π(β,E) x).map_source (mem_extChartAt_source x)β©) | |
| have hΞ΄ (p : P) (hp : pβV) (x : M) (hx : xβe.target) : ContDiffAt β β | |
| (fun q : P Γ E => chartOneForm (Ξ΄ q.1) x q.2) (p,extChartAt π(β,E) x x) := by | |
| apply ((hΞat p hp x).sub (hN p hp x hx)).congr_of_eventuallyEq | |
| exact Filter.Eventually.of_forall (fun q => chartOneForm_sub (Ξ q.1) (N q.1) x q.2) | |
| have hΞ΄closed (p : P) (hp : pβV) (x : M) (hx : xβe.target) : | |
| manifoldExteriorOneForm (Ξ΄ p) x=0 := by | |
| change manifoldExteriorOneForm (Ξ p-N p) x=0 | |
| rw [manifoldExteriorOneForm_sub_at (Ξ± := Ξ p) (Ξ² := N p) (x := x) | |
| ((hΞat p hp x).comp _ (contDiffAt_const.prodMk contDiffAt_id)) | |
| ((hN p hp x hx).comp _ (contDiffAt_const.prodMk contDiffAt_id)),hcurv p hp x hx] | |
| ext u v | |
| simp | |
| have hsrc (z : HandleCylinder) (hz : z.1βI) : zβe.source := by | |
| rw [he_source]; exact β¨hz,mem_univ _β© | |
| have hΞ± (p : P) (hp : pβV) (z : HandleCylinder) (hz : z.1βI) : ContDiffAt β β | |
| (fun q : P Γ CylinderModel => chartOneForm (Ξ± q.1) z q.2) | |
| (p,extChartAt π(β,CylinderModel) z z) := | |
| parameterManifoldPullbackOneForm_contDiffAt (Ξ± := Ξ΄) (g := e) | |
| (hΞ΄ p hp (e z) (e.map_source (hsrc z hz))) (e.contMDiffOn.contMDiffAt (e.open_source.mem_nhds (hsrc z hz))) | |
| have hclosed (p : P) (hp : pβV) (z : HandleCylinder) (hz : z.1βI) : | |
| manifoldExteriorOneForm (Ξ± p) z=0 := by | |
| change manifoldExteriorOneForm (manifoldPullbackOneForm (E := E) (F := CylinderModel) (fun _ => Ξ΄ p) e 0) z=0 | |
| rw [manifold_pullback_exterior_at (Ξ± := Ξ΄ p) (g := e) (b := z) | |
| ((hΞ΄ p hp (e z) (e.map_source (hsrc z hz))).comp _ (contDiffAt_const.prodMk contDiffAt_id)) | |
| (e.contMDiffOn.contMDiffAt (e.open_source.mem_nhds (hsrc z hz)))] | |
| dsimp only [manifoldPullbackTwoForm] | |
| rw [hΞ΄closed p hp (e z) (e.map_source (hsrc z hz))] | |
| rfl | |
| have hmem (x : M) (hx : xβe.target) : (e.symm x).1βI := by | |
| have hm := e.map_target hx | |
| rw [he_source] at hm | |
| exact hm.1 | |
| obtain β¨F,hF,hFdβ© := exists_intrinsic_annular_coordinate_potential hV hI e.open_target hc ha | |
| hΞ± hclosed hf hfint e.symm.contMDiffOn hmem | |
| have hFd' : β pβV,β xβe.target, | |
| manifoldScalarDifferential (E := E) (fun y => F (p,y)) x= | |
| Ξ p x-N p x-cylinderFormPeriod a Ξ± p β’ Ξ² x := by | |
| intro p hp x hx | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| rw [hFd p hp x hx v] | |
| have hd := parameterManifoldPullbackOneForm_inverse_apply e Ξ΄ p hx v | |
| change Ξ± p (e.symm x) (mfderiv π(β,E) π(β,CylinderModel) e.symm x v)=_ at hd | |
| rw [hd] | |
| have hbc := hΞ²coord (e.symm x) (e.map_target hx) | |
| (mfderiv π(β,E) π(β,CylinderModel) e.symm x v) | |
| have hb := parameterManifoldPullbackOneForm_inverse_apply e (fun _ : P => Ξ²) p hx v | |
| change Ξ² (e (e.symm x)) (mfderiv π(β,CylinderModel) π(β,E) e (e.symm x) | |
| (mfderiv π(β,E) π(β,CylinderModel) e.symm x v))=Ξ² x v at hb | |
| rw [hb] at hbc | |
| simp only [Ξ΄,Pi.sub_apply,sub_apply,smul_apply,smul_eq_mul] | |
| rw [hbc] | |
| ring | |
| exact exists_normalized_manifold_primitive_neighborhood hV hK e.open_target hKA | |
| hΞ hΞ² hΞ²closed hΞ²compact (cylinderFormPeriod_smooth hV ha hΞ±) hF hFd' | |
| end | |
| def cylinderClockPrimitive (S : β β β) (f : Circle β β) : | |
| ManifoldOneForm CylinderModel HandleCylinder := | |
| weightedCylinderAngular (fun z => S z.1*f z.2) | |
| theorem cylinderClockPrimitive_smoothAt {S : β β β} (hS : ContDiff β β S) | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (z : HandleCylinder) : | |
| ContDiffAt β β (chartOneForm (cylinderClockPrimitive S f) z) | |
| (extChartAt π(β,CylinderModel) z z) := by | |
| have hp : ContMDiff π(β,CylinderModel) π(β,β) β (Prod.fst : HandleCylinder β β) := by | |
| rw [show π(β,CylinderModel) = (π(β,β)).prod π(β,CircleModel) from modelWithCornersSelf_prod] | |
| exact contMDiff_fst | |
| exact weightedCylinderAngular_smoothAt | |
| (((hS.contMDiff.comp hp).mul (hf.comp cylinder_snd_smooth)).contMDiffAt) | |
| theorem cylinderClockPrimitive_exterior_cover {S : β β β} (hS : ContDiff β β S) | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) (q : Plane) : | |
| (manifoldExteriorOneForm (cylinderClockPrimitive S f) (cylinderCover q)).bilinearComp | |
| (mfderiv π(β,Plane) π(β,CylinderModel) cylinderCover q) | |
| (mfderiv π(β,Plane) π(β,CylinderModel) cylinderCover q)= | |
| (deriv S q.1*f (circleTurn q.2)) β’ planarArea := by | |
| have hn := euclidean_manifold_pullback_exterior_at cylinderCover_smooth.contMDiffAt | |
| (cylinderClockPrimitive_smoothAt hS hf (cylinderCover q)) | |
| have he : (fun y => euclideanPullbackOneForm (fun _ => cylinderClockPrimitive S f) cylinderCover (0,y))= | |
| (fun y => planarCovector 0 (S y.1*f (circleTurn y.2))) := by | |
| funext y | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| change (S y.1*f (circleTurn y.2))*cylinderAngular (cylinderCover y) | |
| (mfderiv π(β,Plane) π(β,CylinderModel) cylinderCover y v)=_ | |
| rw [cylinderAngular_cover] | |
| simp only [planarCovector_apply,zero_mul,zero_add] | |
| have hc : ContDiff β β (fun y : Plane => S y.1*f (circleTurn y.2)) := | |
| (hS.comp contDiff_fst).mul (((hf.comp circleTurn_smooth).contDiff).comp contDiff_snd) | |
| have hd : deriv (fun s => S s*f (circleTurn q.2)) q.1=deriv S q.1*f (circleTurn q.2) := | |
| ((hS.differentiable (by simp) q.1).hasDerivAt.mul_const _).deriv | |
| calc | |
| _ = euclideanExteriorOneForm | |
| (fun y => euclideanPullbackOneForm (fun _ => cylinderClockPrimitive S f) cylinderCover (0,y)) q := hn.symm | |
| _ = _ := by | |
| rw [he,planarCovector_exterior contDiff_const hc,hd,deriv_const,sub_zero] | |
| theorem cylinderClockPrimitive_exterior {S : β β β} (hS : ContDiff β β S) | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (z : HandleCylinder) : | |
| manifoldExteriorOneForm (cylinderClockPrimitive S f) z= | |
| (deriv S z.1*f z.2) β’ cylinderAreaForm z := by | |
| let q : Plane := (z.1,shortCircleArgument z.2) | |
| have hq : cylinderCover q=z := by | |
| apply Prod.ext | |
| Β· rfl | |
| Β· exact circleTurn_shortCircleArgument z.2 | |
| rw [β hq] | |
| let D : Plane βL[β] CylinderModel := mfderiv π(β,Plane) π(β,CylinderModel) cylinderCover q | |
| have he : (manifoldExteriorOneForm (cylinderClockPrimitive S f) (cylinderCover q)).bilinearComp D D= | |
| (deriv S q.1*f (circleTurn q.2)) β’ planarArea := | |
| cylinderClockPrimitive_exterior_cover hS hf q | |
| have hd (u : CylinderModel) : D (u.1,circleAngular (circleTurn q.2) u.2)=u := | |
| cylinderCover_derivative_right_inverse q u | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| apply ContinuousLinearMap.ext | |
| intro w | |
| have hv := congrArg (fun Ξ© : Plane βL[β] Plane βL[β] β => | |
| Ξ© (v.1,circleAngular (circleTurn q.2) v.2) (w.1,circleAngular (circleTurn q.2) w.2)) he | |
| simp only [ContinuousLinearMap.bilinearComp_apply,smul_apply,smul_eq_mul] at hv | |
| rw [hd v,hd w] at hv | |
| simpa only [planarArea_apply,cylinderAreaForm_apply,cylinderCover,smul_apply,smul_eq_mul] using hv | |
| variable {E M : Type} [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| [TopologicalSpace M] [ChartedSpace E M] [IsManifold π(β,E) β M] | |
| [T2Space M] [NormalSpace M] [SigmaCompactSpace M] | |
| theorem exists_compact_annular_dual_normalization | |
| (e : PartialDiffeomorph π(β,CylinderModel) π(β,E) HandleCylinder M β) | |
| {I : Set β} (hI : IsOpen I) (hc : Convex β I) (he : e.source=I ΓΛ’ univ) | |
| {a : β} (ha : aβI) {K : Set M} (hK : IsCompact K) (hKA : Kβe.target) | |
| {Ξ² : ManifoldOneForm E M} (hΞ² : SmoothOneFormFamily (fun _ : β => Ξ²)) | |
| (hclosed : β x,manifoldExteriorOneForm Ξ² x=0) (hcompact : HasCompactSupport Ξ²) | |
| (hperiod : cylinderFormPeriod a (parameterManifoldPullbackOneForm (fun _ : β => Ξ²) e) 0=1) | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (hfint : (β« t in (0:β)..1,f (circleTurn t))=1) : | |
| β (Ξ²' : ManifoldOneForm E M) (L W : Set M), | |
| IsCompact L β§ Lβe.target β§ IsOpen W β§ KβW β§ Wβe.target β§ | |
| SmoothOneFormFamily (fun _ : β => Ξ²') β§ HasCompactSupport Ξ²' β§ | |
| (β x,manifoldExteriorOneForm Ξ²' x=0) β§ | |
| support (Ξ²'-Ξ²)βL β§ | |
| β zβe.source,e zβW β β v : CylinderModel, | |
| Ξ²' (e z) (mfderiv π(β,CylinderModel) π(β,E) e z v)= | |
| f z.2*circleAngular z.2 v.2 := by | |
| let Ξ± := parameterManifoldPullbackOneForm (E := E) (F := CylinderModel) (fun _ : β => Ξ²) e | |
| have hΞ²at (p : β) (x : M) : ContDiffAt β β | |
| (fun q : β Γ E => chartOneForm Ξ² x q.2) (p,extChartAt π(β,E) x x) := | |
| (hΞ² x).contDiffAt ((isOpen_univ.prod (isOpen_extChartAt_target (I := π(β,E)) x)).mem_nhds | |
| β¨mem_univ _,(extChartAt π(β,E) x).map_source (mem_extChartAt_source x)β©) | |
| have hsrc (z : HandleCylinder) (hz : z.1βI) : zβe.source := by | |
| rw [he]; exact β¨hz,mem_univ _β© | |
| have hΞ± (p : β) (_hp : pβ(univ : Set β)) (z : HandleCylinder) (hz : z.1βI) : ContDiffAt β β | |
| (fun q : β Γ CylinderModel => chartOneForm (Ξ± q.1) z q.2) | |
| (p,extChartAt π(β,CylinderModel) z z) := | |
| parameterManifoldPullbackOneForm_contDiffAt (hΞ²at p (e z)) | |
| (e.contMDiffOn.contMDiffAt (e.open_source.mem_nhds (hsrc z hz))) | |
| have hΞ±closed (p : β) (_hp : pβ(univ : Set β)) (z : HandleCylinder) (hz : z.1βI) : | |
| manifoldExteriorOneForm (Ξ± p) z=0 := by | |
| change manifoldExteriorOneForm (manifoldPullbackOneForm (E := E) (F := CylinderModel) (fun _ => Ξ²) e 0) z=0 | |
| rw [manifold_pullback_exterior_at (Ξ± := Ξ²) (g := e) (b := z) | |
| ((hΞ²at p (e z)).comp _ (contDiffAt_const.prodMk contDiffAt_id)) | |
| (e.contMDiffOn.contMDiffAt (e.open_source.mem_nhds (hsrc z hz)))] | |
| dsimp only [manifoldPullbackTwoForm] | |
| rw [hclosed] | |
| rfl | |
| have hmem (x : M) (hx : xβe.target) : (e.symm x).1βI := by | |
| have hm := e.map_target hx | |
| rw [he] at hm | |
| exact hm.1 | |
| obtain β¨F,hF,hFdβ© := exists_intrinsic_annular_coordinate_potential isOpen_univ hI | |
| e.open_target hc ha hΞ± hΞ±closed hf hfint e.symm.contMDiffOn hmem | |
| let N : β β ManifoldOneForm E M := fun _ => manifoldPullbackOneForm | |
| (fun _ => cylinderClockPrimitive (fun _ => 1) f) e.symm 0 | |
| have hFd' : β pβ(univ : Set β),β xβe.target, | |
| manifoldScalarDifferential (E := E) (fun y => F (p,y)) x= | |
| Ξ² x-N p x-(0:β) β’ (0 : ManifoldOneForm E M) x := by | |
| intro p hp x hx | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| rw [hFd p hp x hx v] | |
| have hd := parameterManifoldPullbackOneForm_inverse_apply e (fun _ : β => Ξ²) p hx v | |
| change Ξ± p (e.symm x) (mfderiv π(β,E) π(β,CylinderModel) e.symm x v)=_ at hd | |
| rw [hd] | |
| have hp' : cylinderFormPeriod a Ξ± p=1 := hperiod | |
| rw [hp',one_mul] | |
| simp only [N, sub_apply, zero_smul, sub_zero, manifoldPullbackOneForm, | |
| cylinderClockPrimitive, weightedCylinderAngular, one_mul, manifoldMapDifferential] | |
| change Ξ² x v - _ = Ξ² x v - f (e.symm x).2 * | |
| cylinderAngular (e.symm x) (mfderiv π(β,E) π(β,CylinderModel) e.symm x v) | |
| erw [cylinderAngular_apply] | |
| have hz : β c,ContDiffOn β β (chartOneForm (0 : ManifoldOneForm E M) c) | |
| (extChartAt π(β,E) c).target := by | |
| intro c | |
| simpa only [show chartOneForm (0 : ManifoldOneForm E M) c=(fun _ => 0) from | |
| funext (chartOneForm_zero c)] using (contDiffOn_const : ContDiffOn β β | |
| (fun _ : E => (0 : E βL[β] β)) (extChartAt π(β,E) c).target) | |
| obtain β¨Ξ,L,W,hL,hLA,hW,hKW,hWA,hΞ,hsp,hcp,hd,hnβ© := | |
| exists_normalized_manifold_primitive_neighborhood (E := E) (M := M) | |
| (Ξ := fun _ : β => Ξ²) (N := N) (Ξ² := 0) (a := fun _ => 0) isOpen_univ hK e.open_target hKA | |
| hΞ² hz (fun x => manifoldExteriorOneForm_zero x) (HasCompactSupport.zero) | |
| (contDiffOn_const : ContDiffOn β β (fun _ : β => (0:β)) univ) hF hFd' | |
| refine β¨Ξ 0,L,W,hL,hLA,hW,hKW,hWA,?_,?_,?_,?_,?_β© | |
| Β· intro c | |
| exact (hΞ c).comp (contDiff_const.prodMk contDiff_snd).contDiffOn (fun q hq => β¨mem_univ _,hq.2β©) | |
| Β· have hp := (hcp 0).add hcompact | |
| simpa only [sub_add_cancel] using hp | |
| Β· intro x | |
| rw [hd 0 (mem_univ _) x,hclosed] | |
| Β· simpa only [tsupport_zero,empty_union] using hsp 0 | |
| Β· intro z hz' hw v | |
| rw [hn 0 (mem_univ _) (e z) hw] | |
| have hi := parameterManifoldPullbackOneForm_inverse_apply e.symm | |
| (fun _ : β => cylinderClockPrimitive (fun _ => 1) f) 0 hz' v | |
| change (N 0 (e z)) (mfderiv π(β,CylinderModel) π(β,E) e z v)=_ | |
| rw [show N 0 (e z) (mfderiv π(β,CylinderModel) π(β,E) e z v)= | |
| cylinderClockPrimitive (fun _ => 1) f z v from hi] | |
| simp only [cylinderClockPrimitive,weightedCylinderAngular,smul_apply,smul_eq_mul, | |
| one_mul,cylinderAngular_apply] | |
| end PackingSufficiencySupport.Hamiltonian | |
| namespace PackingSufficiencySupport.DiagonalQuadrics.Explicit | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold MeasureTheory | |
| open Hamiltonian | |
| variable (m : β) | |
| instance surfaceSigmaCompact : SigmaCompactSpace (Surface m) := by | |
| exact IsClosed.sigmaCompactSpace (locus_isClosed (parameters m)) | |
| def restrictedTransverseCylinder (a : β) : | |
| PartialDiffeomorph π(β,CylinderModel) π(β,RealModel) HandleCylinder (Surface m) β := | |
| restrictHandleDiffeomorph (transverseCylinder m) (Ioo (-a) a ΓΛ’ univ) | |
| (isOpen_Ioo.prod isOpen_univ) | |
| theorem restrictedTransverseCylinder_source {a : β} | |
| (ha : aβ€transverseCylinderWidth m) : | |
| (restrictedTransverseCylinder m a).source=Ioo (-a) a ΓΛ’ univ := by | |
| apply inter_eq_right.mpr | |
| intro z hz | |
| exact transverseCylinderWidth_subset m β¨β¨by linarith [hz.1.1],by linarith [hz.1.2]β©,hz.2β© | |
| theorem exists_actual_compact_normalized_dual_fixed | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (hfi : (β« t in (0:β)..1,f (circleTurn t))=1) : | |
| β (a : β) (e : PartialDiffeomorph π(β,CylinderModel) π(β,RealModel) | |
| HandleCylinder (Surface m) β) (Ξ² : ManifoldOneForm RealModel (Surface m)), | |
| a=transverseCylinderWidth m/2 β§ | |
| e=restrictedTransverseCylinder m (transverseCylinderWidth m/2) β§ | |
| 0<a β§ e.source=Ioo (-a) a ΓΛ’ univ β§ IsCompact (closure e.target) β§ | |
| SmoothOneFormFamily (fun _ : β => Ξ²) β§ HasCompactSupport Ξ² β§ | |
| (β x,manifoldExteriorOneForm Ξ² x=0) β§ | |
| β zβe.source,β v : CylinderModel, | |
| Ξ² (e z) (mfderiv π(β,CylinderModel) π(β,RealModel) e z v)= | |
| f z.2*circleAngular z.2 v.2 := by | |
| let a := transverseCylinderWidth m | |
| have ha : 0<a := transverseCylinderWidth_pos m | |
| let e := restrictedTransverseCylinder m a | |
| have he : e.source=Ioo (-a) a ΓΛ’ univ := restrictedTransverseCylinder_source m le_rfl | |
| let K := e '' (Icc (-a/2) (a/2) ΓΛ’ (univ : Set Circle)) | |
| have hsub : Icc (-a/2) (a/2) ΓΛ’ (univ : Set Circle)βe.source := by | |
| intro z hz | |
| rw [he] | |
| exact β¨β¨by linarith [hz.1.1],by linarith [hz.1.2]β©,hz.2β© | |
| have hK : IsCompact K := (isCompact_Icc.prod isCompact_univ).image_of_continuousOn | |
| (e.contMDiffOn.continuousOn.mono hsub) | |
| have hKA : Kβe.target := image_subset_iff.mpr (fun z hz => e.map_source (hsub hz)) | |
| have hp : cylinderFormPeriod 0 | |
| (parameterManifoldPullbackOneForm (fun _ : β => compactDualForm m) e) 0=1 := | |
| cylinderDualForm_period m 0 | |
| obtain β¨Ξ²,L,W,_,_,_,hKW,_,hΞ²,hcp,hcl,_,hnβ© := exists_compact_annular_dual_normalization | |
| e isOpen_Ioo (convex_Ioo (-a) a) he (show (0:β)βIoo (-a) a by constructor <;> linarith) | |
| hK hKA (compactDualForm_smooth m) (compactDualForm_closed m) (compactDualForm_compact m) hp hf hfi | |
| let d := restrictedTransverseCylinder m (a/2) | |
| have hd : d.source=Ioo (-(a/2)) (a/2) ΓΛ’ univ := | |
| restrictedTransverseCylinder_source m (by dsimp [a]; linarith [transverseCylinderWidth_pos m]) | |
| have hdK : d.targetβK := by | |
| intro x hx | |
| obtain β¨z,hz,hzxβ© := d.toPartialEquiv.surjOn hx | |
| rw [hd] at hz | |
| exact β¨z,β¨β¨by linarith [hz.1.1],hz.1.2.leβ©,hz.2β©,hzxβ© | |
| refine β¨a/2,d,Ξ²,rfl,rfl,half_pos ha,hd,hK.of_isClosed_subset isClosed_closure | |
| (closure_minimal hdK hK.isClosed),hΞ²,hcp,hcl,?_β© | |
| intro z hz v | |
| have hzK : zβIcc (-a/2) (a/2) ΓΛ’ (univ : Set Circle) := by | |
| rw [hd] at hz | |
| exact β¨β¨by linarith [hz.1.1],hz.1.2.leβ©,hz.2β© | |
| exact hn z (hsub hzK) (hKW β¨z,hzK,rflβ©) v | |
| theorem exists_actual_compact_normalized_dual | |
| {f : Circle β β} (hf : ContMDiff π(β,CircleModel) π(β,β) β f) | |
| (hfi : (β« t in (0:β)..1,f (circleTurn t))=1) : | |
| β (a : β) (e : PartialDiffeomorph π(β,CylinderModel) π(β,RealModel) | |
| HandleCylinder (Surface m) β) (Ξ² : ManifoldOneForm RealModel (Surface m)), | |
| 0<a β§ e.source=Ioo (-a) a ΓΛ’ univ β§ IsCompact (closure e.target) β§ | |
| SmoothOneFormFamily (fun _ : β => Ξ²) β§ HasCompactSupport Ξ² β§ | |
| (β x,manifoldExteriorOneForm Ξ² x=0) β§ | |
| β zβe.source,β v : CylinderModel, | |
| Ξ² (e z) (mfderiv π(β,CylinderModel) π(β,RealModel) e z v)= | |
| f z.2*circleAngular z.2 v.2 := by | |
| obtain β¨a,e,Ξ²,_,_,hβ© := exists_actual_compact_normalized_dual_fixed m hf hfi | |
| exact β¨a,e,Ξ²,hβ© | |
| end PackingSufficiencySupport.DiagonalQuadrics.Explicit | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold MeasureTheory | |
| variable {E M : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [TopologicalSpace M] [ChartedSpace E M] | |
| structure AnnularHandleData (E M : Type*) [NormedAddCommGroup E] [NormedSpace β E] | |
| [TopologicalSpace M] [ChartedSpace E M] where | |
| width : β | |
| width_pos : 0<width | |
| chart : PartialDiffeomorph π(β,CylinderModel) π(β,E) HandleCylinder M β | |
| source_eq : chart.source=Ioo (-width) width ΓΛ’ univ | |
| compact_target : IsCompact (closure chart.target) | |
| clock : Circle β β | |
| clock_smooth : ContMDiff π(β,CircleModel) π(β,β) β clock | |
| clock_nonneg : β z,0β€clock z | |
| clock_support : tsupport clockβ({1}αΆ : Set Circle) | |
| clock_integral : (β« t in (0:β)..1,clock (circleTurn t))=1 | |
| dual : ManifoldOneForm E M | |
| dual_smooth : SmoothOneFormFamily (fun _ : β => dual) | |
| dual_compact : HasCompactSupport dual | |
| dual_closed : β x,manifoldExteriorOneForm dual x=0 | |
| dual_pullback : β zβchart.source,β v : CylinderModel, | |
| dual (chart z) (mfderiv π(β,CylinderModel) π(β,E) chart z v)= | |
| clock z.2*circleAngular z.2 v.2 | |
| namespace AnnularHandleData | |
| def band (b : β) : Set HandleCylinder := Icc (-b) b ΓΛ’ univ | |
| def core (H : AnnularHandleData E M) (b : β) : Set HandleCylinder := | |
| Icc (-b) b ΓΛ’ tsupport H.clock | |
| theorem band_compact (b : β) : IsCompact (band b) := isCompact_Icc.prod isCompact_univ | |
| theorem core_compact (H : AnnularHandleData E M) (b : β) : IsCompact (H.core b) := | |
| isCompact_Icc.prod (isClosed_tsupport H.clock).isCompact | |
| theorem core_subset_band (H : AnnularHandleData E M) (b : β) : H.core bβband b := | |
| prod_mono_right (subset_univ _) | |
| theorem band_subset_source (H : AnnularHandleData E M) {b : β} (hb : b<H.width) : | |
| band bβH.chart.source := by | |
| rw [H.source_eq] | |
| intro z hz | |
| exact β¨β¨by linarith [hz.1.1],by linarith [hz.1.2]β©,hz.2β© | |
| theorem image_band_compact (H : AnnularHandleData E M) {b : β} (hb : b<H.width) : | |
| IsCompact (H.chart '' band b) := | |
| (band_compact b).image_of_continuousOn | |
| (H.chart.contMDiffOn.continuousOn.mono (H.band_subset_source hb)) | |
| theorem image_core_compact (H : AnnularHandleData E M) {b : β} (hb : b<H.width) : | |
| IsCompact (H.chart '' H.core b) := | |
| (H.core_compact b).image_of_continuousOn | |
| (H.chart.contMDiffOn.continuousOn.mono ((H.core_subset_band b).trans (H.band_subset_source hb))) | |
| end AnnularHandleData | |
| end PackingSufficiencySupport.Hamiltonian | |
| namespace PackingSufficiencySupport.DiagonalQuadrics.Explicit | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold MeasureTheory | |
| open Hamiltonian | |
| theorem exists_fixed_annularHandleData (m : β) : | |
| β H : AnnularHandleData RealModel (Surface m), | |
| H.width=transverseCylinderWidth m/2 β§ | |
| H.chart=restrictedTransverseCylinder m (transverseCylinderWidth m/2) β§ | |
| H.clock=positiveCircleClock (1/4) := by | |
| let f := positiveCircleClock (1/4) | |
| have hf : ContMDiff π(β,CircleModel) π(β,β) β f := positiveCircleClock_smooth (by norm_num) (by norm_num) | |
| have hfi : (β« t in (0:β)..1,f (circleTurn t))=1 := positiveCircleClock_integral (by norm_num) (by norm_num) | |
| obtain β¨a,e,Ξ²,hae,hee,ha,he,hec,hΞ²,hcp,hcl,hpbβ© := | |
| exists_actual_compact_normalized_dual_fixed m hf hfi | |
| exact β¨β¨a,ha,e,he,hec,f,hf,positiveCircleClock_nonneg (by norm_num), | |
| positiveCircleClock_cut (by norm_num) (by norm_num),hfi,Ξ²,hΞ²,hcp,hcl,hpbβ©,hae,hee,rflβ© | |
| theorem exists_annularHandleData (m : β) : Nonempty (AnnularHandleData RealModel (Surface m)) := | |
| β¨(exists_fixed_annularHandleData m).chooseβ© | |
| end PackingSufficiencySupport.DiagonalQuadrics.Explicit | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold | |
| def cylinderRadialForm (b : β) : ManifoldOneForm CylinderModel HandleCylinder := | |
| manifoldScalarDifferential (fun z : HandleCylinder => intervalClock (-b) b z.1) | |
| theorem cylinder_fst_smooth : | |
| ContMDiff π(β,CylinderModel) π(β,β) β (Prod.fst : HandleCylinder β β) := by | |
| rw [show π(β,CylinderModel) = (π(β,β)).prod π(β,CircleModel) from modelWithCornersSelf_prod] | |
| exact contMDiff_fst | |
| theorem cylinderRadialForm_smooth (b : β) (c : HandleCylinder) : | |
| ContDiffOn β β (chartOneForm (cylinderRadialForm b) c) | |
| (extChartAt π(β,CylinderModel) c).target := | |
| manifoldScalarDifferential_smooth ((intervalClock_smooth (-b) b).contMDiff.comp cylinder_fst_smooth) c | |
| theorem cylinderRadialForm_apply (b : β) (z : HandleCylinder) (v : CylinderModel) : | |
| cylinderRadialForm b z v=deriv (intervalClock (-b) b) z.1*v.1 := by | |
| unfold cylinderRadialForm manifoldScalarDifferential | |
| change mfderiv π(β,CylinderModel) π(β,β) (intervalClock (-b) b β Prod.fst) z v=_ | |
| rw [mfderiv_comp z ((intervalClock_smooth (-b) b).contMDiff.mdifferentiableAt (by simp)) | |
| (cylinder_fst_smooth.mdifferentiableAt (by simp)),mfderiv_eq_fderiv] | |
| have he : mfderiv π(β,CylinderModel) π(β,β) (Prod.fst : HandleCylinder β β) z= | |
| ContinuousLinearMap.fst β β CircleModel := by | |
| rw [show π(β,CylinderModel) = (π(β,β)).prod π(β,CircleModel) from modelWithCornersSelf_prod] | |
| exact mfderiv_fst | |
| rw [he] | |
| change fderiv β (intervalClock (-b) b) z.1 v.1=_ | |
| exact fderiv_eq_deriv_mul | |
| theorem cylinderRadialForm_zero {b : β} (hb : 0<b) {z : HandleCylinder} | |
| (hz : zβAnnularHandleData.band b) : cylinderRadialForm b z=0 := by | |
| have hn : z.1βIcc (-b) b := fun hk => hz β¨hk,mem_univ _β© | |
| have hd : deriv (intervalClock (-b) b) z.1=0 := by | |
| simp only [mem_Icc,not_and_or,not_le] at hn | |
| rcases hn with h|h | |
| Β· exact intervalClock_deriv_zero_left (by linarith) h | |
| Β· exact intervalClock_deriv_zero_right (by linarith) h | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| simp [cylinderRadialForm_apply,hd] | |
| theorem cylinderRadialForm_closed (b : β) (z : HandleCylinder) : | |
| manifoldExteriorOneForm (cylinderRadialForm b) z=0 := | |
| manifoldScalarDifferential_closed ((intervalClock_smooth (-b) b).contMDiff.comp cylinder_fst_smooth) z | |
| end PackingSufficiencySupport.Hamiltonian | |
| end | |
| end OAI | |