Download data/lean/OAI/Geometry/ComplexBundle/SmoothLine.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/SmoothLine.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/SmoothLine.lean
-
curl -L -o SmoothLine.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/SmoothLine.lean
12.8 kB
| import OAI.Geometry.BundleTests.Bundles | |
| import OAI.Geometry.ComplexBundle.Projective | |
| import OAI.Geometry.ComplexBundle.RealModel | |
| import Mathlib.Analysis.InnerProductSpace.Calculus | |
| namespace OAI | |
| noncomputable section | |
| /-! Smooth projective lines, product lines, finite sums, and restrictions. -/ | |
| section | |
| open Matrix Topology | |
| open scoped Manifold ContDiff ComplexOrder Matrix.Norms.Elementwise | |
| namespace Kaplansky.ComplexGrassmann | |
| variable {k : β} | |
| theorem contDiff_graphLineVector (F : GraphFrame 1 k) : ContDiff β β (graphLineVector F) := by | |
| have h : ContDiff β β (graphLineVector F) := by | |
| apply (EuclideanSpace.equiv (Fin (1+k)) β).symm.contDiff.comp | |
| apply F.symm.toContinuousLinearEquiv.contDiff.comp | |
| exact contDiff_const.prodMk (contDiff_id.clm_apply contDiff_const) | |
| exact h.restrict_scalars β | |
| theorem contDiff_vectorOuter {d : β} : ContDiff β β (vectorOuter (d := d)) := by | |
| apply contDiff_pi.mpr | |
| intro i | |
| apply contDiff_pi.mpr | |
| intro j | |
| have hi : ContDiff β β (fun v : EuclideanSpace β (Fin d) => v i) := | |
| ((EuclideanSpace.proj i : EuclideanSpace β (Fin d) βL[β] β).restrictScalars β).contDiff | |
| have hj : ContDiff β β (fun v : EuclideanSpace β (Fin d) => v j) := | |
| ((EuclideanSpace.proj j : EuclideanSpace β (Fin d) βL[β] β).restrictScalars β).contDiff | |
| exact hi.mul (Complex.conjCLE.contDiff.comp hj) | |
| theorem contDiff_graphLineProjection_val (F : GraphFrame 1 k) : | |
| ContDiff β β (fun A => (graphLineProjection F A).val) := by | |
| apply contDiff_vectorOuter.comp | |
| exact (((contDiff_graphLineVector F).norm β (graphLineVector_ne_zero F)).inv | |
| (fun A => norm_ne_zero_iff.mpr (graphLineVector_ne_zero F A))).smul (contDiff_graphLineVector F) | |
| -- Use the topology of the chosen matrix norm for both manifold models. | |
| local instance : TopologicalSpace (Matrix (Fin (1+k)) (Fin (1+k)) β) := | |
| (inferInstance : NormedAddCommGroup (Matrix (Fin (1+k)) (Fin (1+k)) β)).toUniformSpace.toTopologicalSpace | |
| /-- The actual projector matrix of a line is a smooth function on complex | |
| projective space, viewed as a real manifold. -/ | |
| theorem contMDiff_projectiveProjection_matrix : | |
| ContMDiff π(β,GraphSlope 1 k) π(β,Matrix (Fin (1+k)) (Fin (1+k)) β) β | |
| (fun P : Grassmann 1 k => ((projectiveProjectionEquiv k).symm P).val) := by | |
| intro P | |
| obtain β¨F,hFβ© := grassmann_atlas_covers P | |
| have hchart : ContMDiffAt π(β,GraphSlope 1 k) π(β,GraphSlope 1 k) β (grassmannChart F) P := | |
| contMDiffAt_of_mem_maximalAtlas (IsManifold.subset_maximalAtlas (Set.mem_range_self F)) hF | |
| have hc := (contDiff_graphLineProjection_val F).contDiffAt.contMDiffAt.comp P hchart | |
| apply hc.congr_of_eventuallyEq | |
| filter_upwards [(grassmannChart F).open_source.mem_nhds hF] with Q hQ | |
| have he : (projectiveProjectionEquiv k).symm Q = graphLineProjection F (grassmannChart F Q) := by | |
| apply (projectiveProjectionEquiv k).injective | |
| rw [Equiv.apply_symm_apply] | |
| exact ((graphLineProjection_point F _).trans (slopePoint_coordinate F Q hQ)).symm | |
| exact congrArg Subtype.val he | |
| end Kaplansky.ComplexGrassmann | |
| end | |
| section | |
| open Bundle Topology NormedSpace | |
| open scoped Manifold ContDiff Matrix.Norms.Elementwise | |
| namespace Kaplansky.ComplexGrassmann | |
| variable {k : β} | |
| def projectiveProjectionMap (k : β) : C(Grassmann 1 k,projectionSpace (1+k) 1) := | |
| β¨(projectiveProjectionEquiv k).symm,continuous_projectiveProjectionEquiv_symmβ© | |
| def projectiveHyperplaneCore (k : β) := | |
| pullbackLineCore (projectionDualLineCore (1+k)) (projectiveProjectionMap k) | |
| def matrixColumnLinear {d : β} (i : Fin d) : | |
| Matrix (Fin d) (Fin d) β ββ[β] EuclideanSpace β (Fin d) where | |
| toFun A := WithLp.toLp 2 (fun j => A j i) | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| theorem contMDiff_projectiveColumn (i : Fin (1+k)) : | |
| ContMDiff π(β,GraphSlope 1 k) π(β,EuclideanSpace β (Fin (1+k))) β | |
| (fun P => projectionColumn (projectiveProjectionMap k P) i) := by | |
| intro P | |
| exact ((matrixColumnLinear i).toContinuousLinearMap.restrictScalars β).contDiff.contDiffAt.contMDiffAt.comp P | |
| (contMDiff_projectiveProjection_matrix P) | |
| theorem contDiffAt_normalize {d : β} {v : EuclideanSpace β (Fin d)} (hv : vβ 0) : | |
| ContDiffAt β β (normalize (V := EuclideanSpace β (Fin d))) v := by | |
| exact ((contDiffAt_id.norm β hv).inv (norm_ne_zero_iff.mpr hv)).smul contDiffAt_id | |
| theorem contMDiffOn_projectiveUnitColumn (i : Fin (1+k)) : | |
| ContMDiffOn π(β,GraphSlope 1 k) π(β,EuclideanSpace β (Fin (1+k))) β | |
| (fun P => unitProjectionColumn (projectiveProjectionMap k P) i) | |
| ((projectiveHyperplaneCore k).baseSet i) := by | |
| intro P hP | |
| exact ((contDiffAt_normalize hP).contMDiffAt.comp P (contMDiff_projectiveColumn i P)).contMDiffWithinAt | |
| /-- The actual dual tautological-line transitions are real smooth. -/ | |
| theorem projectiveHyperplaneCore_transition_smooth (a b : Fin (1+k)) : | |
| ContMDiffOn π(β,GraphSlope 1 k) π(β,β βL[β] β) β | |
| ((projectiveHyperplaneCore k).coordChange a b) | |
| ((projectiveHyperplaneCore k).baseSet a β© (projectiveHyperplaneCore k).baseSet b) := by | |
| intro P hP | |
| have ha := ((contMDiffOn_projectiveUnitColumn a).mono Set.inter_subset_left) P hP | |
| have hb := ((contMDiffOn_projectiveUnitColumn b).mono Set.inter_subset_right) P hP | |
| have hi := (contDiff_inner (π := β)).contDiffAt.contMDiffAt.comp_contMDiffWithinAt P (hb.prodMk_space ha) | |
| have hs := Complex.conjCLE.contDiff.contDiffAt.contMDiffAt.comp_contMDiffWithinAt P hi | |
| let g : β βL[β] (β βL[β] β) := | |
| (ContinuousLinearMap.id β β).smulRight (ContinuousLinearMap.id β β) | |
| exact (g.restrictScalars β).contDiff.contDiffAt.contMDiffAt.comp_contMDiffWithinAt P hs | |
| end Kaplansky.ComplexGrassmann | |
| end | |
| section | |
| open Bundle Topology | |
| open scoped Manifold ContDiff | |
| namespace Kaplansky.ComplexGrassmann | |
| section | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] (K : ΞΉ β β) | |
| def productLineChartIndex : Option ΞΉ β Type | |
| | none => Unit | |
| | some i => Fin (1+K i) | |
| /-- Lβ is trivial; Lα΅’ is the actual hyperplane line pulled back from factor i. -/ | |
| def productLineCore (i : Option ΞΉ) : | |
| VectorBundleCore β (ProjectiveProduct K) β (productLineChartIndex K i) := | |
| match i with | |
| | none => trivialLineCore (ProjectiveProduct K) | |
| | some i => pullbackLineCore (projectiveHyperplaneCore (K i)) β¨fun P => P i,continuous_apply iβ© | |
| theorem productLineCore_transition_smooth (i : Option ΞΉ) | |
| (a b : productLineChartIndex K i) : | |
| ContMDiffOn π(β,ProjectiveProductModel K) π(β,β βL[β] β) β | |
| ((productLineCore K i).coordChange a b) | |
| ((productLineCore K i).baseSet a β© (productLineCore K i).baseSet b) := by | |
| cases i with | |
| | none => exact contMDiffOn_const | |
| | some i => | |
| exact (projectiveHyperplaneCore_transition_smooth a b).comp | |
| (contMDiff_projectiveProduct_apply K i).contMDiffOn (fun _ hx => hx) | |
| omit [Fintype ΞΉ] in | |
| theorem productLineCore_unitary (i : Option ΞΉ) | |
| (a b : productLineChartIndex K i) (P : ProjectiveProduct K) | |
| (ha : P β (productLineCore K i).baseSet a) | |
| (hb : P β (productLineCore K i).baseSet b) (z w : β) : | |
| inner β ((productLineCore K i).coordChange a b P z) | |
| ((productLineCore K i).coordChange a b P w) = inner β z w := by | |
| cases i with | |
| | none => rfl | |
| | some i => | |
| apply complex_unit_mul_inner | |
| simpa only [star_star,mul_comm,ContinuousMap.coe_mk] using | |
| projectionLineTransition_unitary a b (projectiveProjectionMap (K i) (P i)) ha hb | |
| instance productLineCore_contMDiffVectorBundle (i : Option ΞΉ) : | |
| ContMDiffVectorBundle β β (productLineCore K i).Fiber π(β,ProjectiveProductModel K) := | |
| complexCore_contMDiffVectorBundle _ _ (productLineCore_transition_smooth K i) | |
| end | |
| variable {ΞΉ S : Type*} [Fintype ΞΉ] [Fintype S] (K : ΞΉ β β) (label : S β Option ΞΉ) | |
| /-- The ordinary smooth Hermitian direct sum of the specified hyperplane | |
| pullbacks and trivial lines on the actual projective product. -/ | |
| def smoothLineSumCore := finiteLineSumCore (fun s => productLineCore K (label s)) | |
| abbrev SmoothLineSumBundle := (smoothLineSumCore K label).Fiber | |
| instance smoothLineSum_norm (P : ProjectiveProduct K) : | |
| NormedAddCommGroup (SmoothLineSumBundle K label P) := finiteLineSumFiberNormedAddCommGroup _ P | |
| instance smoothLineSum_inner (P : ProjectiveProduct K) : | |
| InnerProductSpace β (SmoothLineSumBundle K label P) := finiteLineSumFiberInnerProductSpace _ P | |
| instance smoothLineSum_contMDiffVectorBundle : | |
| ContMDiffVectorBundle β (EuclideanSpace β S) (SmoothLineSumBundle K label) | |
| π(β,ProjectiveProductModel K) := | |
| complexCore_contMDiffVectorBundle _ _ | |
| (finiteLineSumCore_transition_smooth _ _ (fun s => productLineCore_transition_smooth K (label s))) | |
| omit [Fintype ΞΉ] in | |
| theorem smoothLineSum_finrank (P : ProjectiveProduct K) : | |
| Module.finrank β (SmoothLineSumBundle K label P) = Fintype.card S := by | |
| change Module.finrank β (EuclideanSpace β S) = _ | |
| simp | |
| omit [Fintype ΞΉ] in | |
| theorem smoothLineSum_inner_continuousOn (A : Set (ProjectiveProduct K)) | |
| (v w : β P, SmoothLineSumBundle K label P) | |
| (hv : ContinuousOn (fun P => TotalSpace.mk' (EuclideanSpace β S) P (v P)) A) | |
| (hw : ContinuousOn (fun P => TotalSpace.mk' (EuclideanSpace β S) P (w P)) A) : | |
| ContinuousOn (fun P => inner β (v P) (w P)) A := | |
| finiteLineSum_inner_continuousOn _ (fun s => productLineCore_unitary K (label s)) A v w hv hw | |
| end Kaplansky.ComplexGrassmann | |
| end | |
| open Bundle Topology | |
| namespace Kaplansky.ComplexGrassmann | |
| variable {ΞΉ ΞΊ X : Type*} [Fintype ΞΉ] [Fintype ΞΊ] [TopologicalSpace X] | |
| (K : ΞΊ β β) (f : ΞΉ β ΞΊ) | |
| def projectiveRestrict : C(ProjectiveProduct K, ProjectiveProduct (fun i => K (f i))) := | |
| β¨fun x i => x (f i), continuous_pi (fun i => continuous_apply (f i))β© | |
| omit [Fintype ΞΉ] [Fintype ΞΊ] in | |
| /-- Restricting the base preserves the actual local line coordinates, for | |
| both the trivial line and every hyperplane pullback. -/ | |
| theorem continuous_productLine_restrict_iff (i : Option ΞΉ) | |
| (g : X β ProjectiveProduct K) (v : X β β) (hg : Continuous g) : | |
| Continuous (fun x => TotalSpace.mk' β (E := (productLineCore K (i.map f)).Fiber) (g x) (v x)) β | |
| Continuous (fun x => TotalSpace.mk' β (E := (productLineCore (fun i => K (f i)) i).Fiber) | |
| (projectiveRestrict K f (g x)) (v x)) := by | |
| cases i with | |
| | none => | |
| constructor <;> intro h <;> apply continuous_iff_continuousAt.mpr <;> intro x | |
| Β· rw [FiberBundle.continuousAt_totalSpace] | |
| exact β¨((projectiveRestrict K f).continuous.comp hg).continuousAt, | |
| ((FiberBundle.continuousAt_totalSpace β _).mp (h.continuousAt)).2β© | |
| Β· rw [FiberBundle.continuousAt_totalSpace] | |
| exact β¨hg.continuousAt, | |
| ((FiberBundle.continuousAt_totalSpace β _).mp (h.continuousAt)).2β© | |
| | some i => | |
| constructor <;> intro h <;> apply continuous_iff_continuousAt.mpr <;> intro x | |
| Β· rw [FiberBundle.continuousAt_totalSpace] | |
| exact β¨((projectiveRestrict K f).continuous.comp hg).continuousAt, | |
| ((FiberBundle.continuousAt_totalSpace β _).mp (h.continuousAt)).2β© | |
| Β· rw [FiberBundle.continuousAt_totalSpace] | |
| exact β¨hg.continuousAt, | |
| ((FiberBundle.continuousAt_totalSpace β _).mp (h.continuousAt)).2β© | |
| omit [Fintype ΞΉ] [Fintype ΞΊ] in | |
| /-- The finite orthogonal sum has the ordinary pullback topology under | |
| coordinate restriction. The base and fiber coordinates are explicit. -/ | |
| theorem continuous_lineSum_restrict_iff {S : Type*} [Fintype S] | |
| (label : S β Option ΞΉ) (g : X β ProjectiveProduct K) | |
| (v : X β EuclideanSpace β S) (hg : Continuous g) : | |
| Continuous (fun x => TotalSpace.mk' (EuclideanSpace β S) | |
| (E := SmoothLineSumBundle K (fun s => (label s).map f)) (g x) (v x)) β | |
| Continuous (fun x => TotalSpace.mk' (EuclideanSpace β S) | |
| (E := SmoothLineSumBundle (fun i => K (f i)) label) | |
| (projectiveRestrict K f (g x)) (v x)) := by | |
| constructor | |
| Β· intro h | |
| have hc := (continuous_finiteLineSum_iff | |
| (fun s => productLineCore K ((label s).map f)) _).mp h | |
| apply (continuous_finiteLineSum_iff | |
| (fun s => productLineCore (fun i => K (f i)) (label s)) _).mpr | |
| refine β¨(projectiveRestrict K f).continuous.comp hg,fun s => ?_β© | |
| exact (continuous_productLine_restrict_iff K f (label s) g (fun x => v x s) hg).mp (hc.2 s) | |
| Β· intro h | |
| have hc := (continuous_finiteLineSum_iff | |
| (fun s => productLineCore (fun i => K (f i)) (label s)) _).mp h | |
| apply (continuous_finiteLineSum_iff | |
| (fun s => productLineCore K ((label s).map f)) _).mpr | |
| refine β¨hg,fun s => ?_β© | |
| exact (continuous_productLine_restrict_iff K f (label s) g (fun x => v x s) hg).mpr (hc.2 s) | |
| end Kaplansky.ComplexGrassmann | |
| end | |
| end OAI | |