Download data/lean/OAI/Geometry/BallPacking/CircleAction/CircleRelativeOneForm.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/CircleAction/CircleRelativeOneForm.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/CircleAction/CircleRelativeOneForm.lean
-
curl -L -o CircleRelativeOneForm.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/CircleAction/CircleRelativeOneForm.lean
26.1 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.RelativeJets.EmbeddingAdaptedNeighborhood | |
| namespace OAI | |
| noncomputable section | |
| namespace PackingSufficiencySupport.Hamiltonian | |
| open scoped ContDiff Manifold Topology | |
| open Set Function Manifold MeasureTheory | |
| section | |
| variable {E F : Type} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {M N : Type*} [TopologicalSpace M] [ChartedSpace E M] [IsManifold π(β,E) β M] | |
| [TopologicalSpace N] [ChartedSpace F N] [IsManifold π(β,F) β N] | |
| namespace SmoothCircleAction | |
| variable (A : SmoothCircleAction E M) (B : SmoothCircleAction F N) | |
| omit [IsManifold π(β,E) β M] [IsManifold π(β,F) β N] in | |
| theorem differential_intertwine {e : N β M} | |
| (he : ContMDiff π(β,F) π(β,E) β e) | |
| (heq : β s b, e (B.slice s b) = A.slice s (e b)) (s : β) (b : N) : | |
| (A.differential s (e b)).comp (manifoldMapDifferential (E := E) (F := F) e b) = | |
| (manifoldMapDifferential (E := E) (F := F) e (B.slice s b)).comp (B.differential s b) := by | |
| have heq' : A.slice s β e = e β B.slice s := funext (fun b => (heq s b).symm) | |
| have hβ := (((A.slice_smooth s).mdifferentiable (by simp) (e b)).hasMFDerivAt.comp b | |
| (he.mdifferentiable (by simp) b).hasMFDerivAt).mfderiv | |
| have hβ := ((he.mdifferentiable (by simp) (B.slice s b)).hasMFDerivAt.comp b | |
| ((B.slice_smooth s).mdifferentiable (by simp) b).hasMFDerivAt).mfderiv | |
| rw [heq'] at hβ | |
| exact hβ.symm.trans hβ | |
| variable [FiniteDimensional β E] | |
| omit [IsManifold π(β,F) β N] [FiniteDimensional β E] in | |
| theorem averageOneForm_apply {Ξ± : β β ManifoldOneForm E M} | |
| (hΞ± : β c, ContDiffOn β β (fun q : β Γ E => chartOneForm (Ξ± q.1) c q.2) | |
| (univ ΓΛ’ (extChartAt π(β,E) c).target)) (t : β) (x : M) (v : E) : | |
| A.averageOneForm Ξ± t x v = β« s in (0:β)..1, | |
| parameterPullbackOneForm (E := E) (F := E) Ξ± A.toFun s t x v := by | |
| exact ContinuousLinearMap.intervalIntegral_apply (ΞΌ := volume) | |
| ((A.pullbackOneForm_continuous hΞ± t x).intervalIntegrable 0 1) v | |
| omit [IsManifold π(β,F) β N] [FiniteDimensional β E] in | |
| theorem averageOneForm_normal_annihilation | |
| {Ξ© : β β ManifoldTwoForm E M} {Ξ± : β β ManifoldOneForm E M} {e : N β M} | |
| (he : ContMDiff π(β,F) π(β,E) β e) | |
| (heq : β s b, e (B.slice s b) = A.slice s (e b)) | |
| (hΞ© : β s t x u v, Ξ© t (A.slice s x) (A.differential s x u) (A.differential s x v) = Ξ© t x u v) | |
| (hΞ± : β c, ContDiffOn β β (fun q : β Γ E => chartOneForm (Ξ± q.1) c q.2) | |
| (univ ΓΛ’ (extChartAt π(β,E) c).target)) {t : β} | |
| (hi : β b, (manifoldPullbackTwoForm (F := F) Ξ© e t b).IsInvertible) | |
| (ha : β b v, Ξ± t (e b) v = Ξ± t (e b) | |
| (manifoldMapDifferential (E := E) (F := F) e b | |
| (symplecticProjection (Ξ© t (e b)) (manifoldMapDifferential (E := E) (F := F) e b) v))) | |
| (b : N) (v : E) : | |
| A.averageOneForm Ξ± t (e b) v = A.averageOneForm Ξ± t (e b) | |
| (manifoldMapDifferential (E := E) (F := F) e b | |
| (symplecticProjection (Ξ© t (e b)) (manifoldMapDifferential (E := E) (F := F) e b) v)) := by | |
| rw [A.averageOneForm_apply hΞ±,A.averageOneForm_apply hΞ±] | |
| apply intervalIntegral.integral_congr | |
| intro s _ | |
| have hL : β u w, Ξ© t (e (B.slice s b)) (A.differential s (e b) u) | |
| (A.differential s (e b) w) = Ξ© t (e b) u w := by | |
| intro u w | |
| rw [heq] | |
| exact hΞ© s t (e b) u w | |
| have hI : β u, A.differential s (e b) (manifoldMapDifferential (E := E) (F := F) e b u) = | |
| manifoldMapDifferential (E := E) (F := F) e (B.slice s b) (B.differential s b u) := | |
| fun u => congrArg (fun L : F βL[β] E => L u) (A.differential_intertwine B he heq s b) | |
| have hh := normal_annihilation_pullback (hi b) (hi (B.slice s b)) | |
| (B.differential_invertible s b).surjective hL hI (ha (B.slice s b)) v | |
| rw [heq] at hh | |
| exact hh | |
| end SmoothCircleAction | |
| end | |
| section | |
| attribute [local instance 1001] NormedAddCommGroup.toAddCommGroup AddCommGroup.toAddCommMonoid | |
| variable {E F P : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| [NormedAddCommGroup P] [NormedSpace β P] | |
| theorem symplecticHorizontalLift_unique {Ξ© : E βL[β] E βL[β] β} {A : E βL[β] F} | |
| (h : (horizontalSystem Ξ© A).IsInvertible) | |
| (hV : β v, A v = 0 β (β w, A w = 0 β Ξ© v w = 0) β v = 0) | |
| (b : F) (v : E) (hv : A v = b) (ho : β w, A w = 0 β Ξ© v w = 0) : | |
| v = symplecticHorizontalLift Ξ© A b := by | |
| apply sub_eq_zero.mp | |
| apply hV | |
| Β· rw [map_sub,hv,symplecticHorizontalLift_projects h,sub_self] | |
| Β· intro w hw | |
| rw [map_sub,sub_apply,ho w hw,symplecticHorizontalLift_orthogonal h b hw,sub_self] | |
| theorem horizontalSystem_contDiffAt {Ξ© : P β E βL[β] E βL[β] β} | |
| {A : P β E βL[β] F} {p : P} (hΞ© : ContDiffAt β β Ξ© p) | |
| (hA : ContDiffAt β β A p) : | |
| ContDiffAt β β (fun q => horizontalSystem (Ξ© q) (A q)) p := by | |
| unfold horizontalSystem | |
| have hdual : ContDiffAt β β (fun q => (ContinuousLinearMap.compL β E F β).flip (A q)) p := | |
| (ContinuousLinearMap.contDiff _).contDiffAt.comp p hA | |
| have hp : ContDiff β β (fun L : | |
| ((E Γ (F βL[β] β)) βL[β] E βL[β] β) Γ ((E Γ (F βL[β] β)) βL[β] F) => | |
| L.1.prod L.2) := by | |
| exact LinearIsometryEquiv.contDiff (π := β) (n := β) | |
| (E := ((E Γ (F βL[β] β)) βL[β] E βL[β] β) Γ ((E Γ (F βL[β] β)) βL[β] F)) | |
| (F := (E Γ (F βL[β] β)) βL[β] ((E βL[β] β) Γ F)) | |
| (ContinuousLinearMap.prodβα΅’ β) | |
| exact hp.contDiffAt.comp p | |
| (((hΞ©.clm_comp (contDiffAt_const (c := ContinuousLinearMap.fst β E (F βL[β] β)))).sub | |
| (hdual.clm_comp (contDiffAt_const (c := ContinuousLinearMap.snd β E (F βL[β] β))))).prodMk | |
| (hA.clm_comp (contDiffAt_const (c := ContinuousLinearMap.fst β E (F βL[β] β))))) | |
| variable [CompleteSpace E] [CompleteSpace F] | |
| omit [CompleteSpace F] in | |
| theorem symplecticHorizontalLift_contDiffAt {Ξ© : P β E βL[β] E βL[β] β} | |
| {A : P β E βL[β] F} {p : P} (hΞ© : ContDiffAt β β Ξ© p) | |
| (hA : ContDiffAt β β A p) (hi : (horizontalSystem (Ξ© p) (A p)).IsInvertible) : | |
| ContDiffAt β β (fun q => symplecticHorizontalLift (Ξ© q) (A q)) p := by | |
| unfold symplecticHorizontalLift | |
| have hInv : ContDiffAt β β (fun L : | |
| (E Γ (F βL[β] β)) βL[β] ((E βL[β] β) Γ F) => L.inverse) | |
| (horizontalSystem (Ξ© p) (A p)) := hi.contDiffAt_map_inverse | |
| have hI : ContDiffAt β β (fun q => (horizontalSystem (Ξ© q) (A q)).inverse) p := | |
| by convert! hInv.comp p (horizontalSystem_contDiffAt hΞ© hA) using 1 | |
| have hR : ContDiffAt β β (fun q => (horizontalSystem (Ξ© q) (A q)).inverse.comp | |
| (ContinuousLinearMap.inr β (E βL[β] β) F)) p := | |
| hI.clm_comp (contDiffAt_const (c := ContinuousLinearMap.inr β (E βL[β] β) F)) | |
| exact (contDiffAt_const (c := ContinuousLinearMap.fst β E (F βL[β] β))).clm_comp hR | |
| omit [CompleteSpace E] [CompleteSpace F] in | |
| theorem vertical_nondegenerate_change {Ξ© : E βL[β] E βL[β] β} | |
| {A : E βL[β] F} {C : E βL[β] E} (hC : C.IsInvertible) | |
| (hV : β v, A v = 0 β (β w, A w = 0 β Ξ© v w = 0) β v = 0) : | |
| β v, (A.comp C.inverse) v = 0 β | |
| (β w, (A.comp C.inverse) w = 0 β (Ξ©.bilinearComp C.inverse C.inverse) v w = 0) β | |
| v = 0 := by | |
| intro v hv ho | |
| have he : C.inverse v = 0 := by | |
| apply hV _ hv | |
| intro w hw | |
| have hh := ho (C w) (by simpa only [ContinuousLinearMap.comp_apply,hC.inverse_apply_self] using hw) | |
| change Ξ© (C.inverse v) (C.inverse (C w)) = 0 at hh | |
| rw [hC.inverse_apply_self] at hh | |
| convert! hh using 1 | |
| exact hC.inverse.injective (by simpa only [map_zero] using he) | |
| variable [FiniteDimensional β E] [FiniteDimensional β F] | |
| omit [CompleteSpace E] [CompleteSpace F] in | |
| theorem symplecticHorizontalLift_change {Ξ© : E βL[β] E βL[β] β} | |
| {A : E βL[β] F} {C : E βL[β] E} (hC : C.IsInvertible) | |
| (hA : Surjective A) | |
| (hV : β v, A v = 0 β (β w, A w = 0 β Ξ© v w = 0) β v = 0) (b : F) : | |
| C (symplecticHorizontalLift Ξ© A b) = | |
| symplecticHorizontalLift (Ξ©.bilinearComp C.inverse C.inverse) (A.comp C.inverse) b := by | |
| have hAi : Surjective (A.comp C.inverse) := hA.comp hC.inverse.surjective | |
| have hVi := vertical_nondegenerate_change hC hV | |
| apply symplecticHorizontalLift_unique (horizontalSystem_isInvertible hAi hVi) hVi | |
| Β· simpa only [ContinuousLinearMap.comp_apply,hC.inverse_apply_self] using | |
| symplecticHorizontalLift_projects (horizontalSystem_isInvertible hA hV) b | |
| Β· intro w hw | |
| change Ξ© (C.inverse (C (symplecticHorizontalLift Ξ© A b))) (C.inverse w) = 0 | |
| rw [hC.inverse_apply_self] | |
| convert! symplecticHorizontalLift_orthogonal (horizontalSystem_isInvertible hA hV) b hw using 1 | |
| end | |
| section | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {M : Type*} [TopologicalSpace M] [ChartedSpace E M] [IsManifold π(β,E) β M] | |
| def manifoldBaseDifferential (g : M β F) (x : M) : E βL[β] F := | |
| mfderiv π(β,E) π(β,F) g x | |
| def manifoldBaseChart (g : M β F) (c : M) (y : E) : F := | |
| g ((extChartAt π(β,E) c).symm y) | |
| theorem manifoldBaseChart_contDiffAt {g : M β F} | |
| (hg : ContMDiff π(β,E) π(β,F) β g) {c : M} {y : E} | |
| (hy : y β (extChartAt π(β,E) c).target) : | |
| ContDiffAt β β (manifoldBaseChart g c) y := by | |
| exact (hg.contMDiffAt.comp y | |
| ((contMDiffOn_extChartAt_symm (I := π(β,E)) (n := β) c).contMDiffAt | |
| ((isOpen_extChartAt_target (I := π(β,E)) c).mem_nhds hy))).contDiffAt | |
| private theorem chart_fderiv_of_hasFDerivAt {f : E β F} {A : E βL[β] F} {x : E} | |
| (h : HasFDerivAt f A x) : fderiv β f x = A := h.fderiv | |
| theorem manifoldBaseChart_fderiv {g : M β F} | |
| (hg : ContMDiff π(β,E) π(β,F) β g) {c : M} {y : E} | |
| (hy : y β (extChartAt π(β,E) c).target) : | |
| fderiv β (manifoldBaseChart g c) y = | |
| (manifoldBaseDifferential (E := E) g ((extChartAt π(β,E) c).symm y)).comp | |
| (chartDifferential c ((extChartAt π(β,E) c).symm y)).inverse := by | |
| have hi := (contMDiffOn_extChartAt_symm (I := π(β,E)) (n := β) c).contMDiffAt | |
| ((isOpen_extChartAt_target (I := π(β,E)) c).mem_nhds hy) | |
| rw [chartDifferential_inverse hy] | |
| apply chart_fderiv_of_hasFDerivAt | |
| exact hasMFDerivAt_iff_hasFDerivAt.mp | |
| (((hg.mdifferentiable (by simp) _).hasMFDerivAt).comp y | |
| (hi.mdifferentiableAt (by simp)).hasMFDerivAt) | |
| def manifoldHorizontalField (Ξ© : ManifoldTwoForm E M) (g : M β F) (b : F) | |
| (x : M) : TangentSpace π(β,E) x := | |
| symplecticHorizontalLift (Ξ© x) (manifoldBaseDifferential (E := E) g x) b | |
| variable [FiniteDimensional β E] [FiniteDimensional β F] | |
| theorem chart_horizontalField | |
| {Ξ© : ManifoldTwoForm E M} {g : M β F} | |
| (hg : ContMDiff π(β,E) π(β,F) β g) | |
| (hA : β x, Surjective (manifoldBaseDifferential (E := E) g x)) | |
| (hV : β x v, manifoldBaseDifferential (E := E) g x v = 0 β | |
| (β w, manifoldBaseDifferential (E := E) g x w = 0 β Ξ© x v w = 0) β v = 0) | |
| (b : F) {c : M} {p : β Γ E} (hp : p.2 β (extChartAt π(β,E) c).target) : | |
| timeChartField (fun q => manifoldHorizontalField Ξ© g b q.2) c p = | |
| symplecticHorizontalLift (chartTwoForm Ξ© c p.2) (fderiv β (manifoldBaseChart g c) p.2) b := by | |
| let x := (extChartAt π(β,E) c).symm p.2 | |
| have hC : (chartDifferential (E := E) c x).IsInvertible := by | |
| convert! isInvertible_mfderiv_extChartAt (I := π(β,E)) | |
| ((extChartAt π(β,E) c).map_target hp) using 1 | |
| rw [manifoldBaseChart_fderiv hg hp] | |
| exact symplecticHorizontalLift_change hC (hA x) (hV x) b | |
| theorem manifoldHorizontalField_smooth | |
| {Ξ© : ManifoldTwoForm E M} {g : M β F} | |
| (hg : ContMDiff π(β,E) π(β,F) β g) | |
| (hΞ© : β c, ContDiffOn β β (chartTwoForm Ξ© c) (extChartAt π(β,E) c).target) | |
| (hA : β x, Surjective (manifoldBaseDifferential (E := E) g x)) | |
| (hV : β x v, manifoldBaseDifferential (E := E) g x v = 0 β | |
| (β w, manifoldBaseDifferential (E := E) g x w = 0 β Ξ© x v w = 0) β v = 0) (b : F) : | |
| ContMDiff π(β,E) (π(β,E)).tangent β | |
| (fun x => (β¨x,manifoldHorizontalField Ξ© g b xβ© : TangentBundle π(β,E) M)) := by | |
| have hs : ContMDiff ((π(β,β)).prod π(β,E)) (π(β,E)).tangent β | |
| (fun p : β Γ M => (β¨p.2,manifoldHorizontalField Ξ© g b p.2β© : TangentBundle π(β,E) M)) := by | |
| apply timeField_smooth_of_coordinates | |
| intro p | |
| let y := extChartAt π(β,E) p.2 p.2 | |
| have hy : y β (extChartAt π(β,E) p.2).target := mem_extChartAt_target p.2 | |
| have hC : (chartDifferential (E := E) p.2 ((extChartAt π(β,E) p.2).symm y)).IsInvertible := by | |
| convert! isInvertible_mfderiv_extChartAt (I := π(β,E)) | |
| ((extChartAt π(β,E) p.2).map_target hy) using 1 | |
| have hA' : Surjective (fderiv β (manifoldBaseChart g p.2) y) := by | |
| rw [manifoldBaseChart_fderiv hg hy] | |
| exact (hA _).comp hC.inverse.surjective | |
| have hV' : β v, fderiv β (manifoldBaseChart g p.2) y v = 0 β | |
| (β w, fderiv β (manifoldBaseChart g p.2) y w = 0 β chartTwoForm Ξ© p.2 y v w = 0) β v = 0 := by | |
| rw [manifoldBaseChart_fderiv hg hy] | |
| exact vertical_nondegenerate_change hC (hV _) | |
| have hS := symplecticHorizontalLift_contDiffAt | |
| ((hΞ© p.2).contDiffAt ((isOpen_extChartAt_target (I := π(β,E)) p.2).mem_nhds hy)) | |
| ((manifoldBaseChart_contDiffAt hg hy).fderiv_right (m := β) (by simp)) | |
| (horizontalSystem_isInvertible hA' hV') | |
| have hS' := (hS.clm_apply (contDiffAt_const (c := b))).comp (p.1,y) contDiffAt_snd | |
| apply hS'.congr_of_eventuallyEq | |
| filter_upwards [continuousAt_snd.preimage_mem_nhds | |
| ((isOpen_extChartAt_target (I := π(β,E)) p.2).mem_nhds hy)] with q hq | |
| exact chart_horizontalField hg hA hV b hq | |
| exact hs.comp ((contMDiff_const (c := (0 : β))).prodMk contMDiff_id) | |
| end | |
| section | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {M : Type*} [TopologicalSpace M] [ChartedSpace E M] [IsManifold π(β,E) β M] | |
| theorem manifold_isLocallyConstant_of_differential_zero {f : M β F} | |
| (hf : ContMDiff π(β,E) π(β,F) β f) | |
| (hdf : β x, manifoldBaseDifferential (E := E) f x = 0) : | |
| IsLocallyConstant f := by | |
| apply (IsLocallyConstant.iff_eventually_eq f).2 | |
| intro x | |
| let a := extChartAt π(β,E) x | |
| have hy : a x β a.target := mem_extChartAt_target x | |
| obtain β¨r,hr,hballβ© := Metric.isOpen_iff.mp | |
| (isOpen_extChartAt_target (I := π(β,E)) x) (a x) hy | |
| have hconst (z : E) (hz : z β Metric.ball (a x) r) : | |
| manifoldBaseChart f x z = manifoldBaseChart f x (a x) := by | |
| apply (convex_ball (a x) r).is_const_of_fderivWithin_eq_zero | |
| (fun y hy => ((manifoldBaseChart_contDiffAt hf (hball hy)).differentiableAt | |
| (by simp)).differentiableWithinAt) _ hz (Metric.mem_ball_self hr) | |
| intro y hy | |
| rw [fderivWithin_of_isOpen Metric.isOpen_ball hy,manifoldBaseChart_fderiv hf (hball hy),hdf] | |
| simp | |
| have hnear := (continuousAt_extChartAt (I := π(β,E)) x).preimage_mem_nhds | |
| (Metric.ball_mem_nhds (a x) hr) | |
| filter_upwards [hnear, (isOpen_extChartAt_source (I := π(β,E)) x).mem_nhds | |
| (mem_extChartAt_source x)] with z hz hzs | |
| have hc := hconst (a z) hz | |
| change f (a.symm (a z)) = f (a.symm (a x)) at hc | |
| simpa only [a.left_inv hzs,a.left_inv (mem_extChartAt_source x)] using hc | |
| theorem manifold_difference_constant {f g : M β F} | |
| (hf : ContMDiff π(β,E) π(β,F) β f) | |
| (hg : ContMDiff π(β,E) π(β,F) β g) | |
| (hd : β x, manifoldBaseDifferential (E := E) f x = manifoldBaseDifferential (E := E) g x) | |
| {S : Set M} (hS : IsPreconnected S) {x y : M} (hx : x β S) (hy : y β S) : | |
| f x - g x = f y - g y := by | |
| have hzero (z : M) : manifoldBaseDifferential (E := E) (fun w => f w - g w) z = 0 := by | |
| change mfderiv π(β,E) π(β,F) (f - g) z = 0 | |
| rw [mfderiv_sub (hf.mdifferentiable (by simp) z) (hg.mdifferentiable (by simp) z)] | |
| change manifoldBaseDifferential (E := E) f z - manifoldBaseDifferential (E := E) g z = 0 | |
| rw [hd z,sub_self] | |
| exact (manifold_isLocallyConstant_of_differential_zero (hf.sub hg) hzero).apply_eq_of_isPreconnected hS hx hy | |
| end | |
| section | |
| 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] | |
| namespace SmoothCircleAction | |
| def generator (A : SmoothCircleAction E M) (x : M) : E := | |
| manifoldMapDifferential (F := β) (fun s : β => A.slice s x) (0 : β) (1 : β) | |
| theorem generator_natural (A : SmoothCircleAction E M) (B : SmoothCircleAction F N) | |
| {f : M β N} (hf : ContMDiff π(β,E) π(β,F) β f) | |
| (heq : β s x, f (A.slice s x) = B.slice s (f x)) (x : M) : | |
| manifoldMapDifferential f x (A.generator x) = B.generator (f x) := by | |
| have hpath : ContMDiff π(β,β) π(β,E) β (fun s : β => A.slice s x) := | |
| A.smooth.comp (contMDiff_id.prodMk contMDiff_const) | |
| have he : (f β fun s : β => A.slice s x) = (fun s : β => B.slice s (f x)) := | |
| funext (fun s => heq s x) | |
| have hc : manifoldMapDifferential (f β fun s : β => A.slice s x) 0 = | |
| (manifoldMapDifferential f (A.slice 0 x)).comp | |
| (manifoldMapDifferential (fun s : β => A.slice s x) 0) := | |
| mfderiv_comp 0 (hf.mdifferentiable (by simp) _) (hpath.mdifferentiable (by simp) 0) | |
| have hz : A.slice 0 x = x := A.zero x | |
| rw [he,hz] at hc | |
| exact (congrArg (fun L : β βL[β] F => L 1) hc).symm | |
| end SmoothCircleAction | |
| variable [IsManifold π(β,E) β M] | |
| theorem equivariant_moment_difference_constant | |
| (A : SmoothCircleAction E M) (B : SmoothCircleAction F N) | |
| {Ξ©β : ManifoldTwoForm E M} {Ξ©β : ManifoldTwoForm F N} | |
| {f : M β N} (hf : ContMDiff π(β,E) π(β,F) β f) | |
| (heq : β s x, f (A.slice s x) = B.slice s (f x)) | |
| (hΞ© : β x u v, Ξ©β (f x) (manifoldMapDifferential f x u) | |
| (manifoldMapDifferential f x v) = Ξ©β x u v) | |
| {ΞΌβ : M β β} {ΞΌβ : N β β} | |
| (hΞΌβ : ContMDiff π(β,E) π(β,β) β ΞΌβ) | |
| (hΞΌβ : ContMDiff π(β,F) π(β,β) β ΞΌβ) | |
| (hmβ : β x v, manifoldBaseDifferential (E := E) ΞΌβ x v = -(Ξ©β x (A.generator x) v)) | |
| (hmβ : β x v, manifoldBaseDifferential (E := F) ΞΌβ x v = -(Ξ©β x (B.generator x) v)) | |
| {S : Set M} (hS : IsPreconnected S) {x y : M} (hx : x β S) (hy : y β S) : | |
| ΞΌβ (f x) - ΞΌβ x = ΞΌβ (f y) - ΞΌβ y := by | |
| apply manifold_difference_constant (hΞΌβ.comp hf) hΞΌβ _ hS hx hy | |
| intro z | |
| have hc : manifoldBaseDifferential (E := E) (ΞΌβ β f) z = | |
| (manifoldBaseDifferential (E := F) ΞΌβ (f z)).comp (manifoldMapDifferential f z) := | |
| mfderiv_comp z (hΞΌβ.mdifferentiable (by simp) _) (hf.mdifferentiable (by simp) z) | |
| ext v | |
| rw [hc] | |
| change manifoldBaseDifferential (E := F) ΞΌβ (f z) (manifoldMapDifferential f z v) = _ | |
| rw [hmβ,hmβ,βA.generator_natural B hf heq z,hΞ©] | |
| theorem equivariant_moment_normalized | |
| (A : SmoothCircleAction E M) (B : SmoothCircleAction F N) | |
| {Ξ©β : ManifoldTwoForm E M} {Ξ©β : ManifoldTwoForm F N} | |
| {f : M β N} (hf : ContMDiff π(β,E) π(β,F) β f) | |
| (heq : β s x, f (A.slice s x) = B.slice s (f x)) | |
| (hΞ© : β x u v, Ξ©β (f x) (manifoldMapDifferential f x u) | |
| (manifoldMapDifferential f x v) = Ξ©β x u v) | |
| {ΞΌβ : M β β} {ΞΌβ : N β β} | |
| (hΞΌβ : ContMDiff π(β,E) π(β,β) β ΞΌβ) | |
| (hΞΌβ : ContMDiff π(β,F) π(β,β) β ΞΌβ) | |
| (hmβ : β x v, manifoldBaseDifferential (E := E) ΞΌβ x v = -(Ξ©β x (A.generator x) v)) | |
| (hmβ : β x v, manifoldBaseDifferential (E := F) ΞΌβ x v = -(Ξ©β x (B.generator x) v)) | |
| {S : Set M} (hS : IsPreconnected S) {xβ : M} (hxβ : xβ β S) | |
| (hnorm : ΞΌβ (f xβ) = ΞΌβ xβ) : β x β S, ΞΌβ (f x) = ΞΌβ x := by | |
| intro x hx | |
| have he := equivariant_moment_difference_constant A B hf heq hΞ© hΞΌβ hΞΌβ hmβ hmβ hS hx hxβ | |
| rw [hnorm,sub_self] at he | |
| exact sub_eq_zero.mp he | |
| end | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| namespace SmoothCircleAction | |
| omit [FiniteDimensional β E] in | |
| theorem vector_smooth (A : SmoothCircleAction E E) : ContDiff β β A.toFun := by | |
| have h := A.smooth | |
| rw [βmodelWithCornersSelf_prod,chartedSpaceSelf_prod] at h | |
| exact contMDiff_iff_contDiff.mp h | |
| theorem averageOneForm_spatialDifferential (A : SmoothCircleAction E E) | |
| {f : β Γ E β β} (hf : ContDiff β β f) (t : β) (x : E) : | |
| A.averageOneForm (manifoldSpatialDifferential (E := E) f) t x = | |
| fderiv β (fun y => A.average f (t,y)) x := by | |
| have hg : ContDiff β β (fun p : β Γ E => f (t,A.slice p.1 p.2)) := | |
| hf.comp (contDiff_const.prodMk A.vector_smooth) | |
| have hd := (hasFDerivAt_fixed_integral hg x).fderiv | |
| change A.averageOneForm (manifoldSpatialDifferential (E := E) f) t x = | |
| fderiv β (fun y => β« s in (0:β)..1,f (t,A.slice s y)) x | |
| rw [hd] | |
| apply intervalIntegral.integral_congr | |
| intro s _ | |
| have hs : ContDiff β β (A.slice s) := contMDiff_iff_contDiff.mp (A.slice_smooth s) | |
| have hft : ContDiff β β (fun y => f (t,y)) := hf.comp (contDiff_const.prodMk contDiff_id) | |
| change (manifoldSpatialDifferential f t (A.slice s x)).comp (A.differential s x) = _ | |
| simp only [manifoldSpatialDifferential,differential,manifoldMapDifferential,mfderiv_eq_fderiv] | |
| exact (fderiv_comp x (hft.differentiable (by simp) _) (hs.differentiable (by simp) x)).symm | |
| theorem averaged_spatial_differential_generator_zero (A : SmoothCircleAction E E) | |
| {f : β Γ E β β} (hf : ContDiff β β f) (t : β) (x : E) : | |
| A.averageOneForm (manifoldSpatialDifferential (E := E) f) t x (A.generator x)=0 := by | |
| rw [A.averageOneForm_spatialDifferential hf] | |
| let G : E β β := fun y => A.average f (t,y) | |
| have hG : ContDiff β β G := contDiff_fixed_integral | |
| (hf.comp (contDiff_const.prodMk A.vector_smooth)) | |
| have hpath : ContDiff β β (fun s : β => A.slice s x) := | |
| A.vector_smooth.comp (contDiff_id.prodMk contDiff_const) | |
| have he : (G β fun s : β => A.slice s x)=(fun _ : β => G x) := | |
| funext fun s => A.average_invariant f t s x | |
| have hc := fderiv_comp (0:β) (hG.differentiable (by simp) _) | |
| (hpath.differentiable (by simp) 0) | |
| rw [he] at hc | |
| simp only [fderiv_const_apply] at hc | |
| have hz : A.slice 0 x=x := A.zero x | |
| rw [hz] at hc | |
| have hh := congrArg (fun L : β βL[β] β => L 1) hc | |
| simpa only [generator,manifoldMapDifferential,mfderiv_eq_fderiv, | |
| ContinuousLinearMap.comp_apply,zero_apply] using hh.symm | |
| omit [FiniteDimensional β E] in | |
| theorem differential_generator (A : SmoothCircleAction E E) (s : β) (x : E) : | |
| A.differential s x (A.generator x)=A.generator (A.slice s x) := by | |
| apply A.generator_natural A (A.slice_smooth s) | |
| intro r y | |
| change A.toFun (s,A.toFun (r,y))=A.toFun (r,A.toFun (s,y)) | |
| rw [βA.add,βA.add,add_comm] | |
| omit [FiniteDimensional β E] in | |
| theorem averageOneForm_generator_zero (A : SmoothCircleAction E E) | |
| {Ξ± : β β ManifoldOneForm E E} (hΞ± : SmoothOneFormFamily Ξ±) | |
| (ha : β t x,Ξ± t x (A.generator x)=0) (t : β) (x : E) : | |
| A.averageOneForm Ξ± t x (A.generator x)=0 := by | |
| rw [A.averageOneForm_apply hΞ±] | |
| have he : (fun s => parameterPullbackOneForm (E := E) (F := E) Ξ± A.toFun s t x (A.generator x))= | |
| (fun _ : β => (0:β)) := by | |
| funext s | |
| change Ξ± t (A.slice s x) (A.differential s x (A.generator x))=0 | |
| rw [A.differential_generator,ha] | |
| rw [he] | |
| simp | |
| omit [FiniteDimensional β E] in | |
| theorem averageOneForm_add (A : SmoothCircleAction E E) | |
| {Ξ± Ξ² : β β ManifoldOneForm E E} (hΞ± : SmoothOneFormFamily Ξ±) (hΞ² : SmoothOneFormFamily Ξ²) | |
| (t : β) (x : E) : A.averageOneForm (fun t x => Ξ± t x+Ξ² t x) t x= | |
| A.averageOneForm Ξ± t x+A.averageOneForm Ξ² t x := by | |
| change (β« s in (0:β)..1,(Ξ± t (A.slice s x)+Ξ² t (A.slice s x)).comp (A.differential s x))=_ | |
| simp only [ContinuousLinearMap.add_comp] | |
| exact intervalIntegral.integral_add | |
| ((A.pullbackOneForm_continuous hΞ± t x).intervalIntegrable 0 1) | |
| ((A.pullbackOneForm_continuous hΞ² t x).intervalIntegrable 0 1) | |
| theorem averaged_corrected_generator_zero (A : SmoothCircleAction E E) | |
| {Ξ± : β β ManifoldOneForm E E} (hΞ± : SmoothOneFormFamily Ξ±) | |
| (ha : β t x,Ξ± t x (A.generator x)=0) | |
| {f : β Γ E β β} (hf : ContDiff β β f) (t : β) (x : E) : | |
| A.averageOneForm (correctedOneForm (E := E) Ξ± f) t x (A.generator x)=0 := by | |
| have hdf : SmoothOneFormFamily (manifoldSpatialDifferential (E := E) f) := by | |
| have hD : ContDiff β β (fun p : β Γ E => manifoldSpatialDifferential (E := E) f p.1 p.2) := by | |
| have hh := (hf.fderiv_right (m := β) (by simp)).clm_comp | |
| (contDiff_const (c := ContinuousLinearMap.inr β β E)) | |
| convert! hh using 1 | |
| funext p | |
| simp only [manifoldSpatialDifferential,mfderiv_eq_fderiv] | |
| have hi : HasFDerivAt (fun y : E => (p.1,y)) (ContinuousLinearMap.inr β β E) p.2 := by | |
| convert! (hasFDerivAt_const (π := β) p.1 p.2).prodMk (hasFDerivAt_id p.2) using 1 | |
| exact ((hf.differentiable (by simp) p).hasFDerivAt.comp p.2 hi).fderiv | |
| intro z | |
| simpa only [vector_chartOneForm] using hD.contDiffOn | |
| change A.averageOneForm (fun t x => Ξ± t x+manifoldSpatialDifferential (E := E) f t x) t x (A.generator x)=0 | |
| rw [A.averageOneForm_add hΞ± hdf] | |
| simp only [add_apply,A.averageOneForm_generator_zero hΞ± ha, | |
| A.averaged_spatial_differential_generator_zero hf,add_zero] | |
| end SmoothCircleAction | |
| end PackingSufficiencySupport.Hamiltonian | |
| end | |
| end OAI | |