| import Mathlib |
| import OAI.Geometry.BallPacking.Annuli.AnnularCurvaturePrimitive |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PackingSufficiencySupport.Hamiltonian |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold MeasureTheory |
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| theorem annularCylinderScalar_differential_cover {V : Set P} {I : Set ℝ} |
| (hV : IsOpen V) (hI : IsOpen I) {F : P × Plane → ℝ} |
| (hF : ContDiffOn ℝ ∞ F (V ×ˢ (I ×ˢ univ))) |
| (hper : ∀ p∈V,∀ s∈I,Periodic (fun t => F (p,(s,t))) 1) |
| {p : P} (hp : p∈V) {q : Plane} (hq : q.1∈I) (v : Plane) : |
| manifoldScalarDifferential (E := CylinderModel) (annularCylinderScalar F p) (cylinderCover q) |
| (mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q v)= |
| fderiv ℝ (fun z => F (p,z)) q v := by |
| have hs := annularCylinderScalar_smoothAt hV hI hF hper hp (z := cylinderCover q) hq |
| have hd := mfderiv_comp q (hs.mdifferentiableAt (by simp)) |
| (cylinderCover_smooth.mdifferentiableAt (by simp)) |
| rw [mfderiv_eq_fderiv] at hd |
| have he : (annularCylinderScalar F p ∘ cylinderCover) =ᶠ[𝓝 q] (fun z => F (p,z)) := by |
| filter_upwards [(hI.prod isOpen_univ).mem_nhds (show q∈I ×ˢ univ from ⟨hq,mem_univ _⟩)] with z hz |
| exact annularScalarDescent_turn (hper p hp z.1 hz.1) z.2 |
| rw [he.fderiv_eq] at hd |
| exact congrArg (fun L : Plane →L[ℝ] ℝ => L v) hd.symm |
|
|
| variable [FiniteDimensional ℝ P] |
|
|
| theorem normalized_annular_scalar_intrinsic {V : Set P} {I : Set ℝ} |
| (hV : IsOpen V) (hI : IsOpen I) (hc : Convex ℝ I) |
| {a : ℝ} (ha : a∈I) {A B : P × Plane → ℝ} {β : ℝ → ℝ} |
| (hA : ContDiffOn ℝ ∞ A (V ×ˢ (I ×ˢ univ))) |
| (hB : ContDiffOn ℝ ∞ B (V ×ˢ (I ×ˢ univ))) |
| (hβ : ContDiff ℝ ∞ β) (hpβ : Periodic β 1) |
| (hβint : (∫ t in (0:ℝ)..1,β t)=1) |
| (hpA : ∀ p∈V,∀ s∈I,Periodic (fun t => A (p,(s,t))) 1) |
| (hpB : ∀ p∈V,∀ s∈I,Periodic (fun t => B (p,(s,t))) 1) |
| (hclosed : ∀ p∈V,∀ s∈I,∀ t, |
| fderiv ℝ (fun z => A (p,z)) (s,t) (0,1)= |
| fderiv ℝ (fun z => B (p,z)) (s,t) (1,0)) : |
| ContMDiffOn ((𝓘(ℝ,P × ℝ)).prod 𝓘(ℝ,CircleModel)) 𝓘(ℝ,ℝ) ∞ |
| (annularScalarDescent (normalizedAnnularPrimitive a A B β)) ((V ×ˢ I) ×ˢ univ) ∧ |
| (∀ p∈V,∀ z : HandleCylinder,z.1∈I → ∀ v : CylinderModel, |
| manifoldScalarDifferential (E := CylinderModel) (annularCylinderScalar (normalizedAnnularPrimitive a A B β) p) z v= |
| annularCylinderScalar A p z*v.1+ |
| (annularCylinderScalar B p z-annularMean a B p*circlePeriodicDescent β z.2)* |
| circleAngular z.2 v.2) := by |
| obtain ⟨hF,hFp,hFd⟩ := annular_normalization hV hI hc ha hA hB hβ hpβ hβint hpA hpB hclosed |
| refine ⟨annularScalarDescent_smoothOn hV hI hF hFp,?_⟩ |
| intro p hp z hz v |
| let q : Plane := (z.1,shortCircleArgument z.2) |
| have hq : cylinderCover q=z := by |
| apply Prod.ext |
| · rfl |
| · exact circleTurn_shortCircleArgument z.2 |
| let u : Plane := (v.1,circleAngular (circleTurn q.2) v.2) |
| have hd := annularCylinderScalar_differential_cover hV hI hF hFp hp (q := q) hz u |
| have hL : mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q u=v := |
| cylinderCover_derivative_right_inverse q v |
| have hval : manifoldScalarDifferential (E := CylinderModel) |
| (annularCylinderScalar (normalizedAnnularPrimitive a A B β) p) (cylinderCover q) v= |
| A (p,q)*u.1+(B (p,q)-annularMean a B p*β q.2)*u.2 := by |
| calc |
| _ = manifoldScalarDifferential (E := CylinderModel) |
| (annularCylinderScalar (normalizedAnnularPrimitive a A B β) p) (cylinderCover q) |
| (mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q u) := congrArg _ hL.symm |
| _ = _ := hd.trans (hFd p hp q hz u) |
| have hAv : annularCylinderScalar A p (cylinderCover q)=A (p,q) := |
| annularScalarDescent_turn (hpA p hp q.1 hz) q.2 |
| have hBv : annularCylinderScalar B p (cylinderCover q)=B (p,q) := |
| annularScalarDescent_turn (hpB p hp q.1 hz) q.2 |
| have hβv := circlePeriodicDescent_turn hpβ q.2 |
| rw [← hq,hAv,hBv] |
| change _=A (p,q)*v.1+(B (p,q)-annularMean a B p*circlePeriodicDescent β (circleTurn q.2))* |
| circleAngular (circleTurn q.2) v.2 |
| rw [hβv] |
| exact hval |
|
|
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold MeasureTheory |
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| theorem closed_cylinder_cover_equation {I : Set ℝ} (hI : IsOpen I) |
| {α : ManifoldOneForm CylinderModel HandleCylinder} {A B : Plane → ℝ} |
| (hA : ContDiffOn ℝ ∞ A (I ×ˢ univ)) |
| (hB : ContDiffOn ℝ ∞ B (I ×ˢ univ)) |
| (hα : ∀ q : Plane,q.1∈I → ContDiffAt ℝ ∞ |
| (chartOneForm α (cylinderCover q)) |
| (extChartAt 𝓘(ℝ,CylinderModel) (cylinderCover q) (cylinderCover q))) |
| (hclosed : ∀ z : HandleCylinder,z.1∈I → manifoldExteriorOneForm α z=0) |
| (hrep : ∀ q : Plane,q.1∈I → |
| euclideanPullbackOneForm (fun _ => α) cylinderCover (0,q)=planarCovector (A q) (B q)) |
| {q : Plane} (hq : q.1∈I) : |
| fderiv ℝ A q (0,1)=fderiv ℝ B q (1,0) := by |
| have hn := (hI.prod isOpen_univ).mem_nhds (show q∈I ×ˢ univ from ⟨hq,mem_univ _⟩) |
| have he : (fun y => euclideanPullbackOneForm (fun _ => α) cylinderCover (0,y)) |
| =ᶠ[𝓝 q] (fun y => planarCovector (A y) (B y)) := by |
| filter_upwards [hn] with y hy |
| exact hrep y hy.1 |
| have hd := euclidean_manifold_pullback_exterior_at |
| (g := cylinderCover) cylinderCover_smooth.contMDiffAt (hα q hq) |
| rw [hclosed (cylinderCover q) hq] at hd |
| have hz : euclideanExteriorOneForm (fun y => planarCovector (A y) (B y)) q=0 := by |
| have hder : fderiv ℝ (fun y => euclideanPullbackOneForm (fun _ => α) cylinderCover (0,y)) q= |
| fderiv ℝ (fun y => planarCovector (A y) (B y)) q := he.fderiv_eq |
| unfold euclideanExteriorOneForm at hd ⊢ |
| rw [hder] at hd |
| exact hd |
| rw [planarCovector_exterior_at (hA.contDiffAt hn) (hB.contDiffAt hn)] at hz |
| have hv := congrArg (fun Ω : Plane →L[ℝ] Plane →L[ℝ] ℝ => Ω (1,0) (0,1)) hz |
| simp only [smul_apply,smul_eq_mul,planarArea_apply,mul_one,mul_zero, |
| sub_zero,zero_apply] at hv |
| linarith |
|
|
| variable [FiniteDimensional ℝ P] |
|
|
| theorem closed_cylinder_normalized_potential {V : Set P} {I : Set ℝ} |
| (hV : IsOpen V) (hI : IsOpen I) (hc : Convex ℝ I) {a : ℝ} (ha : a∈I) |
| {α : P → ManifoldOneForm CylinderModel HandleCylinder} |
| {A B : P × Plane → ℝ} {β : ℝ → ℝ} |
| (hA : ContDiffOn ℝ ∞ A (V ×ˢ (I ×ˢ univ))) |
| (hB : ContDiffOn ℝ ∞ B (V ×ˢ (I ×ˢ univ))) |
| (hβ : ContDiff ℝ ∞ β) (hpβ : Periodic β 1) |
| (hβint : (∫ t in (0:ℝ)..1,β t)=1) |
| (hpA : ∀ p∈V,∀ s∈I,Periodic (fun t => A (p,(s,t))) 1) |
| (hpB : ∀ p∈V,∀ s∈I,Periodic (fun t => B (p,(s,t))) 1) |
| (hα : ∀ p∈V,∀ q : Plane,q.1∈I → ContDiffAt ℝ ∞ |
| (chartOneForm (α p) (cylinderCover q)) |
| (extChartAt 𝓘(ℝ,CylinderModel) (cylinderCover q) (cylinderCover q))) |
| (hclosed : ∀ p∈V,∀ z : HandleCylinder,z.1∈I → manifoldExteriorOneForm (α p) z=0) |
| (hrep : ∀ p∈V,∀ q : Plane,q.1∈I → |
| euclideanPullbackOneForm (fun _ => α p) cylinderCover (0,q)= |
| planarCovector (A (p,q)) (B (p,q))) : |
| ContMDiffOn ((𝓘(ℝ,P × ℝ)).prod 𝓘(ℝ,CircleModel)) 𝓘(ℝ,ℝ) ∞ |
| (annularScalarDescent (normalizedAnnularPrimitive a A B β)) ((V ×ˢ I) ×ˢ univ) ∧ |
| (∀ p∈V,∀ z : HandleCylinder,z.1∈I → ∀ v : CylinderModel, |
| manifoldScalarDifferential (E := CylinderModel) |
| (annularCylinderScalar (normalizedAnnularPrimitive a A B β) p) z v= |
| α p z v-annularMean a B p*circlePeriodicDescent β z.2*circleAngular z.2 v.2) := by |
| have hc' : ∀ p∈V,∀ s∈I,∀ t, |
| fderiv ℝ (fun z => A (p,z)) (s,t) (0,1)= |
| fderiv ℝ (fun z => B (p,z)) (s,t) (1,0) := by |
| intro p hp s hs t |
| exact closed_cylinder_cover_equation hI |
| (hA.comp (contDiff_const.prodMk contDiff_id).contDiffOn (fun _ hz => ⟨hp,hz⟩)) |
| (hB.comp (contDiff_const.prodMk contDiff_id).contDiffOn (fun _ hz => ⟨hp,hz⟩)) |
| (hα p hp) (hclosed p hp) (hrep p hp) hs |
| obtain ⟨hs,hd⟩ := normalized_annular_scalar_intrinsic hV hI hc ha hA hB |
| hβ hpβ hβint hpA hpB hc' |
| refine ⟨hs,?_⟩ |
| intro p hp z hz v |
| rw [hd p hp z hz v] |
| let q : Plane := (z.1,shortCircleArgument z.2) |
| have hq : cylinderCover q=z := by |
| apply Prod.ext |
| · rfl |
| · exact circleTurn_shortCircleArgument z.2 |
| let u : Plane := (v.1,circleAngular (circleTurn q.2) v.2) |
| have hL : mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q u=v := |
| cylinderCover_derivative_right_inverse q v |
| have hr := congrArg (fun L : Plane →L[ℝ] ℝ => L u) (hrep p hp q hz) |
| change α p (cylinderCover q) |
| (mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q u)=_ |
| at hr |
| rw [hL] at hr |
| have hAv : annularCylinderScalar A p (cylinderCover q)=A (p,q) := |
| annularScalarDescent_turn (hpA p hp q.1 hz) q.2 |
| have hBv : annularCylinderScalar B p (cylinderCover q)=B (p,q) := |
| annularScalarDescent_turn (hpB p hp q.1 hz) q.2 |
| rw [← hq,hAv,hBv,hr] |
| simp only [planarCovector_apply,u,cylinderCover] |
| ring |
|
|
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold MeasureTheory |
|
|
| theorem circleTurn_period_one : Periodic circleTurn 1 := by |
| intro t |
| exact (circleTurn_eq_iff (t+1) t).2 ⟨1,by simp⟩ |
|
|
| theorem cylinderCover_period_one (q : Plane) : |
| cylinderCover (q+(0,1))=cylinderCover q := by |
| apply Prod.ext |
| · simp [cylinderCover] |
| · exact circleTurn_period_one q.2 |
|
|
| theorem cylinderCover_derivative_period_one (q : Plane) : |
| mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover (q+(0,1))= |
| mfderiv 𝓘(ℝ,Plane) 𝓘(ℝ,CylinderModel) cylinderCover q := by |
| have hT : HasFDerivAt (fun z : Plane => z+(0,1)) (ContinuousLinearMap.id ℝ Plane) q := |
| (hasFDerivAt_id q).add_const (0,1) |
| have hd := ((cylinderCover_smooth.mdifferentiableAt (by simp) |
| (x := q+(0,1))).hasMFDerivAt.comp q |
| (hasMFDerivAt_iff_hasFDerivAt.mpr hT)).mfderiv |
| have he : cylinderCover ∘ (fun z : Plane => z+(0,1))=cylinderCover := |
| funext cylinderCover_period_one |
| rw [he] at hd |
| apply ContinuousLinearMap.ext |
| intro v |
| have hv := congrArg (fun D : Plane →L[ℝ] CylinderModel => D v) hd |
| exact hv.symm |
|
|
| variable {P : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| def cylinderFormA (α : P → ManifoldOneForm CylinderModel HandleCylinder) (q : P × Plane) : ℝ := |
| parameterEuclideanPullbackOneForm α cylinderCover q (1,0) |
|
|
| def cylinderFormB (α : P → ManifoldOneForm CylinderModel HandleCylinder) (q : P × Plane) : ℝ := |
| parameterEuclideanPullbackOneForm α cylinderCover q (0,1) |
|
|
| omit [NormedAddCommGroup P] [NormedSpace ℝ P] in |
| theorem cylinderForm_rep (α : P → ManifoldOneForm CylinderModel HandleCylinder) |
| (p : P) (q : Plane) : |
| euclideanPullbackOneForm (fun _ => α p) cylinderCover (0,q)= |
| planarCovector (cylinderFormA α (p,q)) (cylinderFormB α (p,q)) := by |
| let L := parameterEuclideanPullbackOneForm α cylinderCover (p,q) |
| change L=planarCovector (L (1,0)) (L (0,1)) |
| apply ContinuousLinearMap.ext |
| intro v |
| have hv : v=v.1 • (1,0)+v.2 • (0,1) := by ext <;> simp |
| rw [show L v=L (v.1 • (1,0)+v.2 • (0,1)) from congrArg L hv] |
| simp only [map_add,map_smul,smul_eq_mul,planarCovector_apply] |
| ring |
|
|
| theorem cylinderForm_coefficients_smooth {V : Set P} {I : Set ℝ} |
| {α : P → ManifoldOneForm CylinderModel HandleCylinder} |
| (hα : ∀ p∈V,∀ z : HandleCylinder,z.1∈I → ContDiffAt ℝ ∞ |
| (fun q : P × CylinderModel => chartOneForm (α q.1) z q.2) |
| (p,extChartAt 𝓘(ℝ,CylinderModel) z z)) : |
| ContDiffOn ℝ ∞ (cylinderFormA α) (V ×ˢ (I ×ˢ univ)) ∧ |
| ContDiffOn ℝ ∞ (cylinderFormB α) (V ×ˢ (I ×ˢ univ)) := by |
| have hs : ∀ q∈V ×ˢ (I ×ˢ (univ : Set ℝ)), |
| ContDiffAt ℝ ∞ (parameterEuclideanPullbackOneForm α cylinderCover) q := by |
| intro q hq |
| exact parameterEuclideanPullbackOneForm_contDiffAt |
| (hα q.1 hq.1 (cylinderCover q.2) hq.2.1) cylinderCover_smooth.contMDiffAt |
| exact ⟨fun q hq => ((hs q hq).clm_apply contDiffAt_const).contDiffWithinAt, |
| fun q hq => ((hs q hq).clm_apply contDiffAt_const).contDiffWithinAt⟩ |
|
|
| omit [NormedAddCommGroup P] [NormedSpace ℝ P] in |
| theorem cylinderForm_coefficients_periodic |
| (α : P → ManifoldOneForm CylinderModel HandleCylinder) (p : P) (s : ℝ) : |
| Periodic (fun t => cylinderFormA α (p,(s,t))) 1 ∧ |
| Periodic (fun t => cylinderFormB α (p,(s,t))) 1 := by |
| have he (t : ℝ) : parameterEuclideanPullbackOneForm α cylinderCover (p,(s,t+1))= |
| parameterEuclideanPullbackOneForm α cylinderCover (p,(s,t)) := by |
| have hq : (s,t+1)=(s,t)+(0,1) := by ext <;> simp |
| unfold parameterEuclideanPullbackOneForm |
| rw [hq,cylinderCover_period_one,cylinderCover_derivative_period_one] |
| exact ⟨fun t => congrArg (fun L : Plane →L[ℝ] ℝ => L (1,0)) (he t), |
| fun t => congrArg (fun L : Plane →L[ℝ] ℝ => L (0,1)) (he t)⟩ |
|
|
| def cylinderFormPeriod (a : ℝ) (α : P → ManifoldOneForm CylinderModel HandleCylinder) (p : P) : ℝ := |
| annularMean a (cylinderFormB α) p |
|
|
| variable [FiniteDimensional ℝ P] |
| theorem cylinderFormPeriod_smooth {V : Set P} {I : Set ℝ} (hV : IsOpen V) |
| {a : ℝ} (ha : a∈I) {α : P → ManifoldOneForm CylinderModel HandleCylinder} |
| (hα : ∀ p∈V,∀ z : HandleCylinder,z.1∈I → ContDiffAt ℝ ∞ |
| (fun q : P × CylinderModel => chartOneForm (α q.1) z q.2) |
| (p,extChartAt 𝓘(ℝ,CylinderModel) z z)) : |
| ContDiffOn ℝ ∞ (cylinderFormPeriod a α) V := |
| annularMean_smooth hV ha (cylinderForm_coefficients_smooth hα).2 |
|
|
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold MeasureTheory |
|
|
| section Naturality |
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] |
| {M N Q : Type*} [TopologicalSpace M] [ChartedSpace E M] [IsManifold 𝓘(ℝ,E) ∞ M] |
| [TopologicalSpace N] [ChartedSpace F N] [IsManifold 𝓘(ℝ,F) ∞ N] |
| [TopologicalSpace Q] [ChartedSpace G Q] |
|
|
| omit [IsManifold 𝓘(ℝ,E) ∞ M] [IsManifold 𝓘(ℝ,F) ∞ N] in |
|
|
| theorem handlePushforwardOneForm_comp_apply |
| (e : PartialDiffeomorph 𝓘(ℝ,E) 𝓘(ℝ,F) M N ∞) |
| (α : ManifoldOneForm E M) {g : Q → M} {x : Q} |
| (hx : g x∈e.source) (hg : MDifferentiableAt 𝓘(ℝ,G) 𝓘(ℝ,E) g x) (v : G) : |
| handlePushforwardOneForm e α (e (g x)) |
| (mfderiv 𝓘(ℝ,G) 𝓘(ℝ,F) (e ∘ g) x v) = |
| α (g x) (mfderiv 𝓘(ℝ,G) 𝓘(ℝ,E) g x v) := by |
| have hd := mfderiv_comp x (e.mdifferentiableAt (by simp) hx) hg |
| have he := handlePushforwardOneForm_pullback e α hx |
| have hev := congrArg (fun L : E →L[ℝ] ℝ => L (mfderiv 𝓘(ℝ,G) 𝓘(ℝ,E) g x v)) he |
| rw [hd] |
| exact hev |
| end Naturality |
|
|
| variable {F N : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] |
| [TopologicalSpace N] [ChartedSpace F N] [IsManifold 𝓘(ℝ,F) ∞ N] [T2Space N] |
|
|
| def globalHandleForm |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,F) HandleTorus N ∞) |
| (f : Circle → ℝ) : ManifoldOneForm F N := |
| handlePushforwardOneForm e (torusHandleForm f) |
|
|
| theorem globalHandleForm_properties |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,F) HandleTorus N ∞) |
| {f : Circle → ℝ} (hf : ContMDiff 𝓘(ℝ,CircleModel) 𝓘(ℝ,ℝ) ∞ f) |
| (hs : tsupport (torusHandleForm f) ⊆ e.source) : |
| SmoothOneFormFamily (fun _ : ℝ => globalHandleForm e f) ∧ |
| HasCompactSupport (globalHandleForm e f) ∧ |
| tsupport (globalHandleForm e f) ⊆ e '' tsupport (torusHandleForm f) ∧ |
| ∀ y, manifoldExteriorOneForm (globalHandleForm e f) y=0 := by |
| have hK : IsCompact (tsupport (torusHandleForm f)) := isClosed_closure.isCompact |
| have hz : ∀ x, x∉tsupport (torusHandleForm f) → torusHandleForm f x=0 := |
| fun _ hx => image_eq_zero_of_notMem_tsupport hx |
| exact ⟨handlePushforwardOneForm_smooth e hK hs (torusHandleForm_smooth hf) hz, |
| handlePushforwardOneForm_compact e hK hs hz, |
| handlePushforwardOneForm_tsupport e hK hs hz, |
| handlePushforwardOneForm_closed e hK hs (torusHandleForm_smooth hf) hz |
| (torusHandleForm_closed hf)⟩ |
|
|
| omit [IsManifold 𝓘(ℝ,F) ∞ N] [T2Space N] in |
|
|
| theorem globalHandleForm_annular |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,F) HandleTorus N ∞) |
| (f : Circle → ℝ) {z : HandleCylinder} (hz : torusAnnulusMap z∈e.source) |
| (v : CylinderModel) : |
| globalHandleForm e f (e (torusAnnulusMap z)) |
| (mfderiv 𝓘(ℝ,CylinderModel) 𝓘(ℝ,F) (e ∘ torusAnnulusMap) z v) = |
| weightedCircleAngular f z.2 v.2 := by |
| rw [globalHandleForm,handlePushforwardOneForm_comp_apply e _ hz |
| (torusAnnulusMap_smooth.mdifferentiableAt (by simp))] |
| exact torusAnnulus_pullback f z v |
|
|
| omit [IsManifold 𝓘(ℝ,F) ∞ N] [T2Space N] in |
|
|
| theorem globalHandleForm_period |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,F) HandleTorus N ∞) |
| {f : Circle → ℝ} (hf : (∫ t in (0:ℝ)..1,f (circleTurn t))=1) |
| {z : Circle} (hz : ∀ t,transverseTorusCircle z t∈e.source) : |
| (∫ t in (0:ℝ)..1, globalHandleForm e f (e (transverseTorusCircle z t)) |
| (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,F) (e ∘ transverseTorusCircle z) t 1))=1 := by |
| have he : ∀ t : ℝ, globalHandleForm e f (e (transverseTorusCircle z t)) |
| (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,F) (e ∘ transverseTorusCircle z) t 1) = f (circleTurn t) := by |
| intro t |
| rw [globalHandleForm] |
| exact (handlePushforwardOneForm_comp_apply e (torusHandleForm f) (hz t) |
| ((transverseTorusCircle_smooth z).mdifferentiableAt (by simp)) 1).trans |
| ((torusHandleForm_transverse f z t 1).trans (mul_one _)) |
| refine Eq.trans ?_ hf |
| apply intervalIntegral.integral_congr |
| intro t _ |
| exact he t |
|
|
| theorem exists_global_handle_form {a : ℝ} (ha : a<1/2) : |
| ∃ (f : Circle → ℝ) (U : Set HandleTorus), |
| ContMDiff 𝓘(ℝ,CircleModel) 𝓘(ℝ,ℝ) ∞ f ∧ (∀ z,0≤f z) ∧ |
| IsOpen U ∧ handlePuncture∈U ∧ Disjoint U (compactHandleBand a) ∧ |
| ∀ e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,F) HandleTorus N ∞, |
| Uᶜ⊆e.source → |
| SmoothOneFormFamily (fun _ : ℝ => globalHandleForm e f) ∧ |
| HasCompactSupport (globalHandleForm e f) ∧ |
| tsupport (globalHandleForm e f) ⊆ e.target ∧ |
| (∀ y,manifoldExteriorOneForm (globalHandleForm e f) y=0) ∧ |
| (∀ s∈Icc (-a) a, (∫ t in (0:ℝ)..1, |
| globalHandleForm e f (e (transverseTorusCircle (circleTurn s) t)) |
| (mfderiv 𝓘(ℝ,ℝ) 𝓘(ℝ,F) (e ∘ transverseTorusCircle (circleTurn s)) t 1))=1) := by |
| obtain ⟨f,U,hf,hpos,_,hU,hp,hband,hsupp,hJ⟩ := exists_torus_handle_away_from_puncture ha |
| refine ⟨f,U,hf,hpos,hU,hp,hband,?_⟩ |
| intro e he |
| have hs : tsupport (torusHandleForm f) ⊆ e.source := by |
| intro x hx |
| apply he |
| exact fun hxU => Set.disjoint_left.mp hsupp hxU hx |
| obtain ⟨hsm,hcomp,hsp,hd⟩ := globalHandleForm_properties e hf hs |
| refine ⟨hsm,hcomp,?_,hd,?_⟩ |
| · intro y hy |
| obtain ⟨x,hx,rfl⟩ := hsp hy |
| exact e.map_source (hs hx) |
| · intro s hs |
| have hper : (∫ t in (0:ℝ)..1,f (circleTurn t))=1 := by |
| refine Eq.trans ?_ (hJ (circleTurn s)) |
| apply intervalIntegral.integral_congr |
| intro t _ |
| exact ((torusHandleForm_transverse f (circleTurn s) t 1).trans (mul_one _)).symm |
| apply globalHandleForm_period e hper |
| intro t |
| apply he |
| intro hx |
| exact Set.disjoint_left.mp hband hx ⟨(s,circleTurn t),⟨hs,mem_univ _⟩,rfl⟩ |
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold |
|
|
| section Restriction |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| {M N : Type*} [TopologicalSpace M] [ChartedSpace E M] |
| [TopologicalSpace N] [ChartedSpace F N] |
|
|
| def restrictHandleDiffeomorph |
| (e : PartialDiffeomorph 𝓘(ℝ,E) 𝓘(ℝ,F) M N ∞) |
| (U : Set M) (hU : IsOpen U) : PartialDiffeomorph 𝓘(ℝ,E) 𝓘(ℝ,F) M N ∞ where |
| __ := e.toOpenPartialHomeomorph.restrOpen U hU |
| contMDiffOn_toFun := e.contMDiffOn.mono inter_subset_left |
| contMDiffOn_invFun := e.symm.contMDiffOn.mono inter_subset_left |
| end Restriction |
|
|
| variable {E M : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [TopologicalSpace M] [ChartedSpace E M] |
|
|
| def handleAnnularChart |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| (a : ℝ) : PartialDiffeomorph 𝓘(ℝ,CylinderModel) 𝓘(ℝ,E) HandleCylinder M ∞ := |
| restrictHandleDiffeomorph (torusAnnulus.trans e) (Ioo (-a) a ×ˢ univ) |
| (isOpen_Ioo.prod isOpen_univ) |
|
|
| @[simp] theorem handleAnnularChart_apply |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| (a : ℝ) (z : HandleCylinder) : handleAnnularChart e a z=e (torusAnnulusMap z) := rfl |
|
|
| theorem handleAnnularChart_source |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| {a : ℝ} (ha : a<1/2) (he : compactHandleBand a⊆e.source) : |
| (handleAnnularChart e a).source=Ioo (-a) a ×ˢ univ := by |
| apply inter_eq_right.mpr |
| intro z hz |
| refine ⟨?_,he ?_⟩ |
| · change z.1∈Ioo (-(1/2)) (1/2) ∧ z.2∈(univ : Set Circle) |
| exact ⟨⟨by linarith [hz.1.1],by linarith [hz.1.2]⟩,mem_univ _⟩ |
| · exact ⟨z,⟨⟨hz.1.1.le,hz.1.2.le⟩,mem_univ _⟩,rfl⟩ |
|
|
| theorem handleAnnularChart_pullback |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| (a : ℝ) (f : Circle → ℝ) {z : HandleCylinder} |
| (hz : z∈(handleAnnularChart e a).source) (v : CylinderModel) : |
| globalHandleForm e f (handleAnnularChart e a z) |
| (mfderiv 𝓘(ℝ,CylinderModel) 𝓘(ℝ,E) (handleAnnularChart e a) z v)= |
| f z.2*circleAngular z.2 v.2 := by |
| exact globalHandleForm_annular e f hz.1.2 v |
|
|
| theorem handleAnnularChart_compact [T2Space M] |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| {a b : ℝ} (hab : b<a) (he : compactHandleBand a⊆e.source) : |
| IsCompact (e '' compactHandleBand b) := by |
| apply (compactHandleBand_isCompact b).image_of_continuousOn |
| apply e.contMDiffOn.continuousOn.mono |
| intro x hx |
| apply he |
| obtain ⟨z,hz,rfl⟩ := hx |
| exact ⟨z,⟨⟨by linarith [hz.1.1],by linarith [hz.1.2]⟩,mem_univ _⟩,rfl⟩ |
|
|
| theorem handleAnnularChart_compact_subset |
| (e : PartialDiffeomorph 𝓘(ℝ,TorusModel) 𝓘(ℝ,E) HandleTorus M ∞) |
| {a b : ℝ} (ha : a<1/2) (hab : b<a) (he : compactHandleBand a⊆e.source) : |
| e '' compactHandleBand b⊆(handleAnnularChart e a).target := by |
| rintro x ⟨y,⟨z,hz,rfl⟩,rfl⟩ |
| apply (handleAnnularChart e a).map_source |
| rw [handleAnnularChart_source e ha he] |
| exact ⟨⟨by linarith [hz.1.1],by linarith [hz.1.2]⟩,mem_univ _⟩ |
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold |
|
|
| theorem circleTurn_sub (s t : ℝ) : circleTurn (s-t)=circleTurn s/circleTurn t := by |
| simp only [circleTurn,mul_sub,Circle.exp_sub] |
|
|
| def positiveCircleArgument (z : Circle) : ℝ := |
| shortCircleArgument (z/circleTurn (1/2))+1/2 |
|
|
| theorem positiveCircleArgument_turn {s : ℝ} (hs : s∈Ioo (0:ℝ) 1) : |
| positiveCircleArgument (circleTurn s)=s := by |
| unfold positiveCircleArgument |
| rw [← circleTurn_sub,shortCircleArgument_turn (show s-1/2∈Ioo (-(1/2):ℝ) (1/2) by |
| constructor <;> linarith [hs.1,hs.2])] |
| ring |
|
|
| theorem circleTurn_positiveCircleArgument (z : Circle) : |
| circleTurn (positiveCircleArgument z)=z := by |
| rw [positiveCircleArgument,circleTurn_add,circleTurn_shortCircleArgument,div_mul_cancel] |
|
|
| theorem positiveCircleArgument_smooth {s : ℝ} (hs : s∈Ioo (0:ℝ) 1) : |
| ContMDiffAt 𝓘(ℝ,CircleModel) 𝓘(ℝ,ℝ) ∞ positiveCircleArgument (circleTurn s) := by |
| have hi : ContMDiffAt 𝓘(ℝ,CircleModel) 𝓘(ℝ,CircleModel) ∞ |
| (fun z : Circle => z/circleTurn (1/2)) (circleTurn s) := |
| contMDiffAt_id.div contMDiffAt_const |
| have hslit : ((circleTurn s/circleTurn (1/2) : Circle) : ℂ)∈Complex.slitPlane := by |
| rw [← circleTurn_sub] |
| apply circleTurn_short_slit |
| constructor <;> linarith [hs.1,hs.2] |
| exact ((shortCircleArgument_smooth_at hslit).comp (circleTurn s) hi).add contMDiffAt_const |
|
|
| def positiveCircleCoordinate : PartialDiffeomorph 𝓘(ℝ,ℝ) 𝓘(ℝ,CircleModel) ℝ Circle ∞ where |
| toFun := circleTurn |
| invFun := positiveCircleArgument |
| source := Ioo (0:ℝ) 1 |
| target := circleTurn '' Ioo (0:ℝ) 1 |
| map_source' s hs := ⟨s,hs,rfl⟩ |
| map_target' := by |
| rintro z ⟨s,hs,rfl⟩ |
| rwa [positiveCircleArgument_turn hs] |
| left_inv' := fun _ hs => positiveCircleArgument_turn hs |
| right_inv' := fun _ _ => circleTurn_positiveCircleArgument _ |
| open_source := isOpen_Ioo |
| open_target := circleTurn_isOpenMap _ isOpen_Ioo |
| contMDiffOn_toFun := circleTurn_smooth.contMDiffOn |
| contMDiffOn_invFun := by |
| rintro z ⟨s,hs,rfl⟩ |
| exact (positiveCircleArgument_smooth hs).contMDiffWithinAt |
|
|
| theorem shortCircleArgument_bounds (z : Circle) : |
| -(1/2:ℝ)<shortCircleArgument z ∧ shortCircleArgument z≤1/2 := by |
| have hp : 0<2*Real.pi := by positivity |
| constructor |
| · apply (lt_div_iff₀ hp).mpr |
| nlinarith [Complex.neg_pi_lt_arg (z : ℂ)] |
| · apply (div_le_iff₀ hp).mpr |
| nlinarith [Complex.arg_le_pi (z : ℂ)] |
|
|
| theorem positiveCircleCoordinate_target : positiveCircleCoordinate.target=({1}ᶜ : Set Circle) := by |
| ext z |
| constructor |
| · rintro ⟨s,hs,rfl⟩ hz |
| have he : circleTurn s=circleTurn 0 := by simpa only [mem_singleton_iff,circleTurn,mul_zero,Circle.exp_zero] using hz |
| obtain ⟨m,hm⟩ := (circleTurn_eq_iff s 0).mp he |
| have hlo : (0:ℤ) < m := by exact_mod_cast (show (0:ℝ) < m by linarith [hs.1]) |
| have hhi : m < (1:ℤ) := by exact_mod_cast (show (m:ℝ)<1 by linarith [hs.2]) |
| omega |
| · intro hz |
| have hb := shortCircleArgument_bounds z |
| have hne : shortCircleArgument z≠0 := by |
| intro he |
| apply hz |
| have hc := circleTurn_shortCircleArgument z |
| rw [he] at hc |
| simpa only [mem_singleton_iff,circleTurn,mul_zero,Circle.exp_zero] using hc.symm |
| by_cases hpos : 0<shortCircleArgument z |
| · exact ⟨shortCircleArgument z,⟨hpos,by linarith [hb.2]⟩,circleTurn_shortCircleArgument z⟩ |
| · refine ⟨shortCircleArgument z+1,⟨by linarith [hb.1],by |
| have hn : shortCircleArgument z<0 := lt_of_le_of_ne (le_of_not_gt hpos) hne |
| linarith⟩,?_⟩ |
| rw [circleTurn_period_one,circleTurn_shortCircleArgument] |
|
|
| def torusRectangleInverse (z : HandleTorus) : Plane := |
| (shortCircleArgument z.1,positiveCircleArgument z.2) |
|
|
| theorem torusRectangleInverse_smooth {z : HandleTorus} |
| (hz : z∈circleBandCoordinate.target ×ˢ positiveCircleCoordinate.target) : |
| ContMDiffAt 𝓘(ℝ,TorusModel) 𝓘(ℝ,Plane) ∞ torusRectangleInverse z := by |
| have hf := circleBandCoordinate.contMDiffOn_invFun.contMDiffAt |
| (circleBandCoordinate.open_target.mem_nhds hz.1) |
| have hg := positiveCircleCoordinate.contMDiffOn_invFun.contMDiffAt |
| (positiveCircleCoordinate.open_target.mem_nhds hz.2) |
| have hp : ContMDiffAt 𝓘(ℝ,TorusModel) 𝓘(ℝ,CircleModel) ∞ |
| (Prod.fst : HandleTorus → Circle) z := torus_fst_smooth.contMDiffAt |
| have hq : ContMDiffAt 𝓘(ℝ,TorusModel) 𝓘(ℝ,CircleModel) ∞ |
| (Prod.snd : HandleTorus → Circle) z := torus_snd_smooth.contMDiffAt |
| exact (contMDiffAt_prod_module_iff _).2 ⟨hf.comp z hp,hg.comp z hq⟩ |
|
|
| def torusRectangle : PartialDiffeomorph 𝓘(ℝ,Plane) 𝓘(ℝ,TorusModel) Plane HandleTorus ∞ where |
| toFun := torusTurns |
| invFun := torusRectangleInverse |
| source := circleBandCoordinate.source ×ˢ positiveCircleCoordinate.source |
| target := circleBandCoordinate.target ×ˢ positiveCircleCoordinate.target |
| map_source' _z hz := ⟨circleBandCoordinate.map_source hz.1,positiveCircleCoordinate.map_source hz.2⟩ |
| map_target' _z hz := ⟨circleBandCoordinate.map_target hz.1,positiveCircleCoordinate.map_target hz.2⟩ |
| left_inv' _z hz := Prod.ext (circleBandCoordinate.left_inv hz.1) (positiveCircleCoordinate.left_inv hz.2) |
| right_inv' _z hz := Prod.ext (circleBandCoordinate.right_inv hz.1) (positiveCircleCoordinate.right_inv hz.2) |
| open_source := circleBandCoordinate.open_source.prod positiveCircleCoordinate.open_source |
| open_target := circleBandCoordinate.open_target.prod positiveCircleCoordinate.open_target |
| contMDiffOn_toFun := torusTurns_smooth.contMDiffOn |
| contMDiffOn_invFun := fun _ hz => (torusRectangleInverse_smooth hz).contMDiffWithinAt |
|
|
|
|
| end |
|
|
| section |
|
|
| open scoped ContDiff Manifold Topology |
| open Set Function Manifold MeasureTheory |
|
|
| def positiveCircleClock (b : ℝ) (z : Circle) : ℝ := |
| circleClockDensity b (z/circleTurn (1/2)) |
|
|
| theorem positiveCircleClock_smooth {b : ℝ} (hb : 0<b) (hsmall : b<1/2) : |
| ContMDiff 𝓘(ℝ,CircleModel) 𝓘(ℝ,ℝ) ∞ (positiveCircleClock b) := |
| (circleClockDensity_smooth hb hsmall).comp (contMDiff_id.div contMDiff_const) |
|
|
| theorem positiveCircleClock_nonneg {b : ℝ} (hb : 0<b) (z : Circle) : |
| 0≤positiveCircleClock b z := circleClockDensity_nonneg hb _ |
|
|
| theorem positiveCircleClock_turn {b s : ℝ} (hs : s∈Ioo (0:ℝ) 1) : |
| positiveCircleClock b (circleTurn s)=deriv (intervalClock (-b) b) (s-1/2) := by |
| unfold positiveCircleClock |
| rw [←circleTurn_sub,circleClockDensity_turn (show s-1/2∈Ioo (-(1/2):ℝ) (1/2) by |
| constructor <;> linarith [hs.1,hs.2])] |
|
|
| theorem positiveCircleClock_tsupport {b : ℝ} (hb : 0<b) : |
| tsupport (positiveCircleClock b)⊆circleTurn '' Icc (1/2-b) (1/2+b) := by |
| apply closure_minimal _ (isCompact_Icc.image circleTurn_smooth.continuous).isClosed |
| intro z hz |
| obtain ⟨s,hs,he⟩ := circleClockDensity_support hb hz |
| refine ⟨s+1/2,⟨by linarith [hs.1],by linarith [hs.2]⟩,?_⟩ |
| rw [circleTurn_add,he,div_mul_cancel] |
|
|
| theorem positiveCircleClock_cut {b : ℝ} (hb : 0<b) (hsmall : b<1/2) : |
| tsupport (positiveCircleClock b)⊆({1}ᶜ : Set Circle) := by |
| intro z hz |
| rw [←positiveCircleCoordinate_target] |
| obtain ⟨s,hs,rfl⟩ := positiveCircleClock_tsupport hb hz |
| exact ⟨s,⟨by linarith [hs.1],by linarith [hs.2]⟩,rfl⟩ |
|
|
| theorem positiveCircleClock_pos {b s : ℝ} (hb : 0<b) (hsmall : b<1/2) |
| (hs : s∈Ioo (1/2-b) (1/2+b)) : 0<positiveCircleClock b (circleTurn s) := by |
| rw [positiveCircleClock_turn (show s∈Ioo (0:ℝ) 1 by constructor <;> linarith [hs.1,hs.2])] |
| exact intervalClock_deriv_pos (by linarith) ⟨by linarith [hs.1],by linarith [hs.2]⟩ |
|
|
| theorem positiveCircleClock_integral {b : ℝ} (hb : 0<b) (hsmall : b<1/2) : |
| (∫ s in (0:ℝ)..1,positiveCircleClock b (circleTurn s))=1 := by |
| let T : ℝ → ℝ := fun s => intervalClock (-b) b (s-1/2) |
| have hd (s : ℝ) : HasDerivAt T (deriv (intervalClock (-b) b) (s-1/2)) s := by |
| have hh := (((intervalClock_smooth (-b) b).differentiable (by simp) (s-1/2)).hasDerivAt.comp s |
| ((hasDerivAt_id s).sub_const (1/2))) |
| convert hh using 1 <;> first | rfl | ring |
| rw [intervalIntegral.integral_congr_Ioo_of_le (by norm_num : (0:ℝ)≤1) |
| (fun s hs => positiveCircleClock_turn hs)] |
| rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (fun s _ => hd s) |
| (((intervalClock_deriv_smooth (-b) b).continuous.comp (continuous_id.sub continuous_const)).intervalIntegrable _ _)] |
| dsimp [T] |
| rw [intervalClock_one (by linarith : -b<b) (by linarith), |
| intervalClock_zero (by linarith : -b<b) (by linarith)] |
| norm_num |
|
|
|
|
| end |
|
|
| section |
| open scoped ContDiff Topology |
| open Set Function |
|
|
| theorem positiveCircleClock_inverse {b : ℝ} (hb : 0<b) (hsmall : b<1/2) : |
| ∃ g : ℝ → ℝ,ContDiffOn ℝ ∞ g (Ioo (0:ℝ) 1) ∧ |
| (∀ T∈Ioo (0:ℝ) 1,g T∈Ioo (1/2-b) (1/2+b)) ∧ |
| (∀ t∈Ioo (1/2-b) (1/2+b),g (intervalClock (-b) b (t-1/2))=t) ∧ |
| (∀ T∈Ioo (0:ℝ) 1,intervalClock (-b) b (g T-1/2)=T) ∧ |
| (∀ T∈Ioo (0:ℝ) 1,0<deriv g T ∧ |
| positiveCircleClock b (circleTurn (g T))*deriv g T=1) := by |
| have hab : -b<b := by linarith |
| obtain ⟨g,hg,hl,hr⟩ := intervalClock_smooth_inverse hab |
| let G : ℝ → ℝ := fun T => g T+1/2 |
| have hGs : ContDiffOn ℝ ∞ G (Ioo (0:ℝ) 1) := hg.add contDiffOn_const |
| have hmem (T : ℝ) (hT : T∈Ioo (0:ℝ) 1) : G T∈Ioo (1/2-b) (1/2+b) := by |
| have hh := (hr T hT).1 |
| dsimp [G] |
| constructor <;> linarith [hh.1,hh.2] |
| refine ⟨G,hGs,hmem,?_,?_,?_⟩ |
| · intro t ht |
| dsimp [G] |
| rw [hl _ (show t-1/2∈Ioo (-b) b from ⟨by linarith [ht.1],by linarith [ht.2]⟩)] |
| ring |
| · intro T hT |
| simpa only [G,add_sub_cancel_right] using (hr T hT).2 |
| · intro T hT |
| have hpos := intervalClock_deriv_pos hab (hr T hT).1 |
| have he : ∀ᶠ S in 𝓝 T,intervalClock (-b) b (g S)=S := by |
| filter_upwards [isOpen_Ioo.mem_nhds hT] with S hS |
| exact (hr S hS).2 |
| have hd := HasDerivAt.of_local_left_inverse |
| (hg.contDiffAt (isOpen_Ioo.mem_nhds hT)).continuousAt |
| ((intervalClock_smooth (-b) b).differentiable (by simp) (g T)).hasDerivAt |
| (ne_of_gt hpos) he |
| have hGd : HasDerivAt G (deriv (intervalClock (-b) b) (g T))⁻¹ T := hd.add_const (1/2) |
| rw [hGd.deriv] |
| refine ⟨inv_pos.mpr hpos,?_⟩ |
| rw [positiveCircleClock_turn (show G T∈Ioo (0:ℝ) 1 by |
| have hm := hmem T hT |
| constructor <;> linarith [hm.1,hm.2])] |
| simp only [G,add_sub_cancel_right,mul_inv_cancel₀ (ne_of_gt hpos)] |
|
|
|
|
| end |
|
|
|
|
| open scoped ContDiff Topology |
| open Set Function |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| def angularReparam (g : ℝ → ℝ) (p : Plane × E) : Plane × E := |
| ((p.1.1,g p.1.2),p.2) |
|
|
| theorem angularReparam_fderiv {g : ℝ → ℝ} {p : Plane × E} |
| (hg : DifferentiableAt ℝ g p.1.2) (v : Plane × E) : |
| fderiv ℝ (angularReparam g) p v=((v.1.1,deriv g p.1.2*v.1.2),v.2) := by |
| have hd := (((hasFDerivAt_fst (𝕜 := ℝ) (p := p.1)).comp p (hasFDerivAt_fst (𝕜 := ℝ) (p := p))).prodMk |
| (hg.hasDerivAt.comp_hasFDerivAt p ((hasFDerivAt_snd (𝕜 := ℝ) (p := p.1)).comp p |
| (hasFDerivAt_fst (𝕜 := ℝ) (p := p))))).prodMk (hasFDerivAt_snd (𝕜 := ℝ) (p := p)) |
| change HasFDerivAt (angularReparam g) _ p at hd |
| rw [hd.fderiv] |
| rfl |
|
|
| theorem baseCoefficient_fderiv_at {a : Plane → ℝ} {p : Plane × E} |
| (ha : DifferentiableAt ℝ a p.1) (v : Plane × E) : |
| fderiv ℝ (baseCoefficient a) p v=fderiv ℝ a p.1 v.1 := by |
| exact congrArg (fun L : (Plane × E) →L[ℝ] ℝ => L v) |
| ((ha.hasFDerivAt.comp p (hasFDerivAt_fst (𝕜 := ℝ) (p := p))).fderiv) |
|
|
| theorem firstBaseCoefficient_fderiv_at {a : ℝ × E → ℝ} {p : Plane × E} |
| (ha : DifferentiableAt ℝ a (p.1.1,p.2)) (v : Plane × E) : |
| fderiv ℝ (firstBaseCoefficient a) p v=fderiv ℝ a (p.1.1,p.2) (v.1.1,v.2) := by |
| exact congrArg (fun L : (Plane × E) →L[ℝ] ℝ => L v) |
| ((ha.hasFDerivAt.comp p (((hasFDerivAt_fst (𝕜 := ℝ) (p := p.1)).comp p |
| (hasFDerivAt_fst (𝕜 := ℝ) (p := p))).prodMk (hasFDerivAt_snd (𝕜 := ℝ) (p := p)))).fderiv) |
|
|
| theorem weightedSecondCoefficient_fderiv_at {b w : Plane → ℝ} {G : ℝ × E → ℝ} |
| {p : Plane × E} (hb : DifferentiableAt ℝ b p.1) (hw : DifferentiableAt ℝ w p.1) |
| (hG : DifferentiableAt ℝ G (p.1.1,p.2)) (v : Plane × E) : |
| fderiv ℝ (weightedSecondCoefficient b w G) p v = |
| fderiv ℝ b p.1 v.1+fderiv ℝ w p.1 v.1*G (p.1.1,p.2)+ |
| w p.1*fderiv ℝ G (p.1.1,p.2) (v.1.1,v.2) := by |
| have hbD : DifferentiableAt ℝ (baseCoefficient b) p := hb.comp p differentiableAt_fst |
| have hwD : DifferentiableAt ℝ (baseCoefficient w) p := hw.comp p differentiableAt_fst |
| have hcoord : DifferentiableAt ℝ (fun q : Plane × E => (q.1.1,q.2)) p := by fun_prop |
| have hgD : DifferentiableAt ℝ (firstBaseCoefficient G) p := hG.comp p hcoord |
| change fderiv ℝ (baseCoefficient b+baseCoefficient w*firstBaseCoefficient G) p v = _ |
| rw [fderiv_add hbD (hwD.mul hgD),fderiv_mul hwD hgD] |
| simp only [add_apply,smul_apply,smul_eq_mul,baseCoefficient_fderiv_at hb, |
| baseCoefficient_fderiv_at hw,firstBaseCoefficient_fderiv_at hG,baseCoefficient,firstBaseCoefficient] |
| ring |
|
|
| def normalizedAreaDensity (A B : Plane → ℝ) (g : ℝ → ℝ) (q : Plane) : ℝ := |
| (fderiv ℝ B (q.1,g q.2) (1,0)-fderiv ℝ A (q.1,g q.2) (0,1))*deriv g q.2 |
|
|
| theorem plane_covector_decomp (L : Plane →L[ℝ] ℝ) (v : Plane) : |
| L v=v.1*L (1,0)+v.2*L (0,1) := by |
| have he : v=v.1 • (1,0)+v.2 • (0,1) := by ext <;> simp |
| conv_lhs => rw [he] |
| simp only [map_add,map_smul,smul_eq_mul] |
|
|
| theorem angularReparam_weighted_pullback (Ω : E →L[ℝ] E →L[ℝ] ℝ) |
| {A B : Plane → ℝ} {w g : ℝ → ℝ} {G : ℝ × E → ℝ} {p : Plane × E} |
| (hA : DifferentiableAt ℝ A (p.1.1,g p.1.2)) |
| (hB : DifferentiableAt ℝ B (p.1.1,g p.1.2)) |
| (hw : DifferentiableAt ℝ w (g p.1.2)) (hg : DifferentiableAt ℝ g p.1.2) |
| (hG : DifferentiableAt ℝ G (p.1.1,p.2)) (hnorm : w (g p.1.2)*deriv g p.1.2=1) |
| (v z : Plane × E) : |
| horizontalCoupling Ω (baseCoefficient A) (weightedSecondCoefficient B (fun q => w q.2) G) |
| (angularReparam g p) (fderiv ℝ (angularReparam g) p v) (fderiv ℝ (angularReparam g) p z) = |
| Ω v.2 z.2+normalizedAreaDensity A B g p.1*(v.1.1*z.1.2-v.1.2*z.1.1)+ |
| fderiv ℝ G (p.1.1,p.2) (v.1.1,v.2)*z.1.2- |
| v.1.2*fderiv ℝ G (p.1.1,p.2) (z.1.1,z.2) := by |
| have hwp : DifferentiableAt ℝ (fun q : Plane => w q.2) (p.1.1,g p.1.2) := hw.comp (p.1.1,g p.1.2) differentiableAt_snd |
| have hAp : DifferentiableAt ℝ (baseCoefficient A) (angularReparam g p) := hA.comp (angularReparam g p) differentiableAt_fst |
| have hcoord : DifferentiableAt ℝ (fun q : Plane × E => (q.1.1,q.2)) (angularReparam g p) := by fun_prop |
| have hBw : DifferentiableAt ℝ (baseCoefficient B) (angularReparam g p) := |
| hB.comp (angularReparam g p) differentiableAt_fst |
| have hww : DifferentiableAt ℝ (baseCoefficient (fun q => w q.2)) (angularReparam g p) := by |
| exact (hw.hasDerivAt.comp_hasFDerivAt (angularReparam g p) |
| ((hasFDerivAt_snd (𝕜 := ℝ) (p := (p.1.1,g p.1.2))).comp (angularReparam g p) |
| (hasFDerivAt_fst (𝕜 := ℝ) (p := angularReparam g p)))).differentiableAt |
| have hGw : DifferentiableAt ℝ (firstBaseCoefficient G) (angularReparam g p) := |
| hG.comp (angularReparam g p) hcoord |
| have hBp : DifferentiableAt ℝ (weightedSecondCoefficient B (fun q => w q.2) G) (angularReparam g p) := |
| hBw.add (hww.mul hGw) |
| have hwd (u : Plane) : fderiv ℝ (fun q : Plane => w q.2) (p.1.1,g p.1.2) u=deriv w (g p.1.2)*u.2 := by |
| have hd : HasFDerivAt (fun q : Plane => w q.2) |
| (deriv w (g p.1.2) • ContinuousLinearMap.snd ℝ ℝ ℝ) (p.1.1,g p.1.2) := |
| hw.hasDerivAt.comp_hasFDerivAt (p.1.1,g p.1.2) (hasFDerivAt_snd (𝕜 := ℝ) (p := (p.1.1,g p.1.2))) |
| exact congrArg (fun L : Plane →L[ℝ] ℝ => L u) hd.fderiv |
| rw [angularReparam_fderiv hg,angularReparam_fderiv hg] |
| simp only [horizontalCoupling,add_apply,ContinuousLinearMap.bilinearComp_apply, |
| euclideanExteriorOneForm,sub_apply,ContinuousLinearMap.flip_apply, |
| horizontalOneForm_fderiv hAp hBp] |
| change Ω v.2 z.2 + _ = _ |
| rw [baseCoefficient_fderiv_at (p := angularReparam g p) hA, |
| baseCoefficient_fderiv_at (p := angularReparam g p) hA, |
| weightedSecondCoefficient_fderiv_at (p := angularReparam g p) hB hwp hG, |
| weightedSecondCoefficient_fderiv_at (p := angularReparam g p) hB hwp hG] |
| simp only [angularReparam,hwd,normalizedAreaDensity] |
| rw [plane_covector_decomp (fderiv ℝ A (p.1.1,g p.1.2)) (v.1.1,deriv g p.1.2*v.1.2), |
| plane_covector_decomp (fderiv ℝ A (p.1.1,g p.1.2)) (z.1.1,deriv g p.1.2*z.1.2), |
| plane_covector_decomp (fderiv ℝ B (p.1.1,g p.1.2)) (v.1.1,deriv g p.1.2*v.1.2), |
| plane_covector_decomp (fderiv ℝ B (p.1.1,g p.1.2)) (z.1.1,deriv g p.1.2*z.1.2)] |
| linear_combination (fderiv ℝ G (p.1.1,p.2) (v.1.1,v.2)*z.1.2- |
| v.1.2*fderiv ℝ G (p.1.1,p.2) (z.1.1,z.2))*hnorm |
|
|
|
|
|
|
| end PackingSufficiencySupport.Hamiltonian |
| end |
|
|
| end OAI |
|
|
