Download data/lean/OAI/Geometry/ComplexBundle/Evaluation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Evaluation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Evaluation.lean
-
curl -L -o Evaluation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Evaluation.lean
31.2 kB
| import Mathlib.Analysis.Calculus.ContDiff.FiniteDimension | |
| import Mathlib.Analysis.Calculus.ContDiff.Operations | |
| import Mathlib.Analysis.Complex.Basic | |
| import Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | |
| import Mathlib.Geometry.Manifold.PartitionOfUnity | |
| import Mathlib.Geometry.Manifold.VectorBundle.Hom | |
| import Mathlib.LinearAlgebra.Complex.FiniteDimensional | |
| import Mathlib.LinearAlgebra.FiniteDimensional.Defs | |
| import Mathlib.Tactic.Module | |
| namespace OAI | |
| noncomputable section | |
| /-! Smooth generating sections, evaluation maps, and complex-linear bundle maps. -/ | |
| section | |
| open scoped ContDiff | |
| namespace Kaplansky | |
| section | |
| variable {V W : Type*} [NormedAddCommGroup V] [NormedSpace β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] {q : β} | |
| def tupleEvaluation (L : V βL[β] W) : (Fin q β V) βL[β] (Fin q β W) := | |
| ContinuousLinearMap.pi (fun i => L.comp (ContinuousLinearMap.proj i)) | |
| @[simp] theorem tupleEvaluation_apply (L : V βL[β] W) (v : Fin q β V) (i : Fin q) : | |
| tupleEvaluation L v i=L (v i) := rfl | |
| theorem tupleEvaluation_surjective (L : V βL[β] W) (hL : Function.Surjective L) : | |
| Function.Surjective (tupleEvaluation (q := q) L) := by | |
| intro w | |
| choose v hv using fun i => hL (w i) | |
| exact β¨v,funext hvβ© | |
| def tupleEvaluationLinear : (V βL[β] W) ββ[β] ((Fin q β V) βL[β] (Fin q β W)) where | |
| toFun := tupleEvaluation | |
| map_add' L K := by ext v i; rfl | |
| map_smul' c L := by ext v i; rfl | |
| variable [FiniteDimensional β V] [FiniteDimensional β W] | |
| def tupleEvaluationMap : (V βL[β] W) βL[β] ((Fin q β V) βL[β] (Fin q β W)) := | |
| tupleEvaluationLinear.toContinuousLinearMap | |
| theorem tupleEvaluation_smooth : ContDiff β β (tupleEvaluation (V := V) (W := W) (q := q)) := | |
| ((tupleEvaluationMap (V := V) (W := W) (q := q)).restrictScalars β).contDiff | |
| end | |
| variable {E F G H : Type*} | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| theorem complex_smul_decomposition (c : β) (v : E) : | |
| c β’ v=c.re β’ v+c.im β’ (Complex.I β’ v) := by | |
| calc | |
| c β’ v=((c.re : β)+(c.im : β)*Complex.I) β’ v := by rw [Complex.re_add_im] | |
| _ = _ := by rw [add_smul,mul_smul,Complex.coe_smul,Complex.coe_smul] | |
| /-- Upgrade a real-linear map commuting with the complex structure. -/ | |
| def complexOfCommuteI (f : E ββ[β] F) (hI : β v, f (Complex.I β’ v)=Complex.I β’ f v) : | |
| E ββ[β] F where | |
| toFun := f | |
| map_add' := f.map_add | |
| map_smul' c v := by | |
| rw [complex_smul_decomposition, map_add, map_smul, map_smul,hI] | |
| exact (complex_smul_decomposition c (f v)).symm | |
| /-- The canonical projection from real-linear maps to complex-linear maps. -/ | |
| def realComplexPart (f : E ββ[β] F) : E ββ[β] F where | |
| toFun v := (1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v)) | |
| map_add' v w := by simp only [smul_add,map_add]; module | |
| map_smul' c v := by | |
| change (1/2 : β) β’ (f (c β’ v)-Complex.I β’ f (Complex.I β’ (c β’ v))) = c β’ ((1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v))) | |
| simp only [smul_comm Complex.I c,map_smul,β smul_sub,smul_comm (1/2 : β) c] | |
| theorem realComplexPart_commute_I (f : E ββ[β] F) (v : E) : | |
| realComplexPart f (Complex.I β’ v)=Complex.I β’ realComplexPart f v := by | |
| change (1/2 : β) β’ (f (Complex.I β’ v)-Complex.I β’ f (Complex.I β’ (Complex.I β’ v))) = Complex.I β’ ((1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v))) | |
| rw [smul_comm Complex.I (1/2 : β)] | |
| simp only [smul_sub,smul_smul,Complex.I_mul_I,neg_one_smul,map_neg,smul_neg,sub_neg_eq_add] | |
| rw [add_comm] | |
| def complexPart (f : E βL[β] F) : E βL[β] F := | |
| { complexOfCommuteI (realComplexPart f.toLinearMap) (realComplexPart_commute_I f.toLinearMap) with | |
| cont := continuous_const.smul (f.continuous.sub | |
| (continuous_const.smul (f.continuous.comp (continuous_const.smul continuous_id)))) } | |
| @[simp] theorem complexPart_apply (f : E βL[β] F) (v : E) : | |
| complexPart f v=(1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v)) := rfl | |
| theorem complexPart_restrict (f : E βL[β] F) : complexPart (f.restrictScalars β)=f := by | |
| ext v | |
| change (1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v))=f v | |
| rw [map_smul,smul_smul,Complex.I_mul_I,neg_one_smul] | |
| module | |
| def complexProjectionLinear : (E βL[β] F) ββ[β] (E βL[β] F) where | |
| toFun := complexPart | |
| map_add' f g := by ext v; simp only [complexPart_apply,add_apply]; module | |
| map_smul' c f := by | |
| ext v | |
| change (1/2 : β) β’ (c β’ f v-Complex.I β’ (c β’ f (Complex.I β’ v))) = c β’ ((1/2 : β) β’ (f v-Complex.I β’ f (Complex.I β’ v))) | |
| simp only [smul_comm Complex.I c,β smul_sub,smul_comm (1/2 : β) c] | |
| theorem complexPart_natural | |
| [NormedAddCommGroup G] [NormedSpace β G] | |
| [NormedAddCommGroup H] [NormedSpace β H] | |
| (g : G βL[β] E) (f : E βL[β] F) (h : F βL[β] H) : | |
| complexPart ((h.restrictScalars β).comp (f.comp (g.restrictScalars β))) = | |
| h.comp ((complexPart f).comp g) := by | |
| ext v | |
| change (1/2 : β) β’ (h (f (g v))-Complex.I β’ h (f (g (Complex.I β’ v)))) = | |
| h ((1/2 : β) β’ (f (g v)-Complex.I β’ f (Complex.I β’ g v))) | |
| simp only [map_smul,map_sub] | |
| variable [FiniteDimensional β E] [FiniteDimensional β F] | |
| def complexProjection : (E βL[β] F) βL[β] (E βL[β] F) := | |
| complexProjectionLinear.toContinuousLinearMap | |
| theorem complexProjection_surjective : Function.Surjective (complexProjection (E := E) (F := F)) := | |
| fun f => β¨f.restrictScalars β,complexPart_restrict fβ© | |
| theorem complexProjection_smooth : ContDiff β β (complexProjection (E := E) (F := F)) := | |
| (complexProjection (E := E) (F := F)).contDiff | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Function Set Module | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky | |
| section | |
| variable {X H B F : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup F] [NormedSpace β F] [FiniteDimensional β F] | |
| (E : B β Type*) [β x, AddCommGroup (E x)] [β x, Module β (E x)] | |
| [β x, TopologicalSpace (E x)] [TopologicalSpace (TotalSpace F E)] | |
| [FiberBundle F E] [VectorBundle β F E] [ContMDiffVectorBundle β F E I] | |
| /-- A finite family of actual global smooth sections spanning every fiber. | |
| The sections are local frame vectors multiplied by a constructed subordinate | |
| partition of unity, so no global generation hypothesis is used. -/ | |
| theorem exists_finite_smooth_spanning_sections : | |
| β (n : β) (s : Fin n β β x, E x), | |
| (β i, ContMDiff I (I.prod π(β,F)) β (fun x => TotalSpace.mk' F x (s i x))) β§ | |
| β x, Submodule.span β (Set.range (fun i => s i x)) = β€ := by | |
| classical | |
| let U (x : B) := (trivializationAt F E x).baseSet | |
| obtain β¨ΞΉ, f, hfβ© := SmoothBumpCovering.exists_isSubordinate I isClosed_univ | |
| (U := U) (fun x _ => (trivializationAt F E x).open_baseSet.mem_nhds | |
| (mem_baseSet_trivializationAt F E x)) | |
| let : Fintype ΞΉ := f.fintype | |
| let Ο := f.toSmoothPartitionOfUnity | |
| have hΟ := hf.toSmoothPartitionOfUnity | |
| let b := finBasis β F | |
| let e (i : ΞΉ) := trivializationAt F E (f.c i) | |
| let s (i : ΞΉ Γ Fin (finrank β F)) (x : B) : E x := | |
| Ο i.1 x β’ (e i.1).symm x (b i.2) | |
| have hs : β i, ContMDiff I (I.prod π(β,F)) β | |
| (fun x => TotalSpace.mk' F x (s i x)) := by | |
| intro i | |
| apply ContMDiffOn.smul_section_of_tsupport (Ο i.1).contMDiff.contMDiffOn | |
| (e i.1).open_baseSet (hΟ i.1) | |
| apply ((e i.1).contMDiffOn_section_baseSet_iff).mpr | |
| apply (contMDiffOn_const (c := b i.2)).congr | |
| intro x hx | |
| simp only [(e i.1).apply_mk_symm hx] | |
| have hspan : β x, Submodule.span β (Set.range (fun i => s i x)) = β€ := by | |
| intro x | |
| obtain β¨i, hiβ© := Ο.exists_pos_of_mem (mem_univ x) | |
| have hx : x β (e i).baseSet := hΟ i (subset_closure (show x β support (Ο i) from ne_of_gt hi)) | |
| let W := Submodule.span β (Set.range (fun i => s i x)) | |
| have hb : β j, (e i).symm x (b j) β W := by | |
| intro j | |
| have hm : s (i,j) x β W := Submodule.subset_span β¨(i,j),rflβ© | |
| have := W.smul_mem ((Ο i x)β»ΒΉ) hm | |
| simpa only [s, smul_smul, inv_mul_cancelβ (ne_of_gt hi), one_smul] using this | |
| rw [Submodule.eq_top_iff'] | |
| intro v | |
| have heq : v = β j, (b.repr ((e i) β¨x,vβ©).2 j) β’ (e i).symm x (b j) := by | |
| have h := b.sum_repr ((e i) β¨x,vβ©).2 | |
| have hh := congrArg ((e i).symm x) h | |
| rw [(e i).symm_apply_apply_mk hx] at hh | |
| simpa only [β (e i).symmL_apply (R := β) hx, map_sum, map_smul] using hh.symm | |
| rw [heq] | |
| exact W.sum_mem (fun j _ => W.smul_mem _ (hb j)) | |
| let a := Fintype.equivFin (ΞΉ Γ Fin (finrank β F)) | |
| refine β¨Fintype.card (ΞΉ Γ Fin (finrank β F)),fun j => s (a.symm j),fun j => hs _,?_β© | |
| intro x | |
| have hr : Set.range (fun j => s (a.symm j) x) = Set.range (fun i => s i x) := by | |
| ext v | |
| constructor | |
| Β· rintro β¨j,rflβ©; exact β¨a.symm j,rflβ© | |
| Β· rintro β¨i,rflβ©; exact β¨a i,by simpβ© | |
| rw [hr] | |
| exact hspan x | |
| end | |
| section Algebra | |
| variable {B : Type*} {E : B β Type*} [β x, AddCommGroup (E x)] [β x, Module β (E x)] | |
| {n : β} | |
| /-- Evaluation of the complex coefficients of a finite family of sections. -/ | |
| def sectionEvaluation (s : Fin n β β x, E x) (x : B) : (Fin n β β) ββ[β] E x where | |
| toFun c := β i, c i β’ s i x | |
| map_add' c d := by simp [add_smul, Finset.sum_add_distrib] | |
| map_smul' a c := by simp [Finset.smul_sum, smul_smul] | |
| @[simp] theorem sectionEvaluation_single (s : Fin n β β x, E x) (x : B) (i : Fin n) : | |
| sectionEvaluation s x (Pi.single i 1) = s i x := by | |
| classical | |
| simp [sectionEvaluation, Pi.single_apply] | |
| /-- Real spanning suffices for surjectivity of the complex-linear evaluation. -/ | |
| theorem sectionEvaluation_surjective [β x, Module β (E x)] [β x, IsScalarTower β β (E x)] | |
| (s : Fin n β β x, E x) | |
| (hs : β x, Submodule.span β (Set.range (fun i => s i x)) = β€) (x : B) : | |
| Function.Surjective (sectionEvaluation s x) := by | |
| have h : Submodule.span β (Set.range (fun i => s i x)) β€ | |
| (LinearMap.range (sectionEvaluation s x)).restrictScalars β := by | |
| apply Submodule.span_le.mpr | |
| rintro v β¨i,rflβ© | |
| exact β¨Pi.single i 1,sectionEvaluation_single s x iβ© | |
| rw [hs x] at h | |
| intro v | |
| exact h (Submodule.mem_top : v β (β€ : Submodule β (E x))) | |
| end Algebra | |
| variable {X H B F : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup F] [NormedSpace β F] [FiniteDimensional β F] | |
| (E : B β Type*) [β x, AddCommGroup (E x)] [β x, Module β (E x)] | |
| [β x, Module β (E x)] [β x, IsScalarTower β β (E x)] | |
| [β x, TopologicalSpace (E x)] [TopologicalSpace (TotalSpace F E)] | |
| [FiberBundle F E] [VectorBundle β F E] [VectorBundle β F E] | |
| [ContMDiffVectorBundle β F E I] | |
| /-- The evaluation family in an actual bundle frame, with complex parameter | |
| space and real-smooth dependence on the base. -/ | |
| def sectionEvaluationCoordinates {n : β} (s : Fin n β β x, E x) | |
| (e : Trivialization F (Ο F E)) (x : B) : (Fin n β β) βL[β] F := | |
| β i, (ContinuousLinearMap.proj i).smulRight ((e β¨x,s i xβ©).2) | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β F] | |
| [β x, IsScalarTower β β (E x)] [VectorBundle β F E] [β x, Module β (E x)] in | |
| theorem sectionEvaluationCoordinates_apply {n : β} (s : Fin n β β x, E x) | |
| (e : Trivialization F (Ο F E)) [MemTrivializationAtlas e] | |
| (x : B) (hx : x β e.baseSet) (c : Fin n β β) : | |
| sectionEvaluationCoordinates E s e x c = (e β¨x,sectionEvaluation s x cβ©).2 := by | |
| change (β i, (ContinuousLinearMap.proj i).smulRight ((e β¨x,s i xβ©).2)) c = | |
| ((e.linear β hx).mk' _) (β i, c i β’ s i x) | |
| simp only [sum_apply, ContinuousLinearMap.smulRight_apply, | |
| ContinuousLinearMap.proj_apply, map_sum, map_smul, IsLinearMap.mk'_apply] | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] | |
| [FiniteDimensional β F] [β x, IsScalarTower β β (E x)] [VectorBundle β F E] | |
| [β x, Module β (E x)] in | |
| theorem sectionEvaluationCoordinates_smooth {n : β} (s : Fin n β β x, E x) | |
| (hs : β i, ContMDiff I (I.prod π(β,F)) β (fun x => TotalSpace.mk' F x (s i x))) | |
| (e : Trivialization F (Ο F E)) [MemTrivializationAtlas e] : | |
| ContMDiffOn I π(β,(Fin n β β) βL[β] F) β | |
| (sectionEvaluationCoordinates E s e) e.baseSet := by | |
| apply contMDiffOn_finsetSum | |
| intro i _ | |
| have hc := ((e.contMDiffOn_section_baseSet_iff).mp (hs i).contMDiffOn) | |
| exact (((ContinuousLinearMap.smulRightL β (Fin n β β) F) (ContinuousLinearMap.proj i)).restrictScalars β).contMDiff.comp_contMDiffOn hc | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β F] [VectorBundle β F E] in | |
| theorem sectionEvaluationCoordinates_surjective {n : β} (s : Fin n β β x, E x) | |
| (hs : β x, Submodule.span β (Set.range (fun i => s i x)) = β€) | |
| (e : Trivialization F (Ο F E)) [MemTrivializationAtlas e] | |
| (x : B) (hx : x β e.baseSet) : | |
| Function.Surjective (sectionEvaluationCoordinates E s e x) := by | |
| intro v | |
| obtain β¨c,hcβ© := sectionEvaluation_surjective s hs x (e.symm x v) | |
| refine β¨c,?_β© | |
| rw [sectionEvaluationCoordinates_apply E s e x hx, hc] | |
| exact congrArg Prod.snd (e.apply_mk_symm hx v) | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] | |
| [FiniteDimensional β F] [β x, IsScalarTower β β (E x)] in | |
| /-- Every fixed complex parameter gives an actual global smooth section. -/ | |
| theorem sectionEvaluation_smooth {n : β} (s : Fin n β β x, E x) | |
| (hs : β i, ContMDiff I (I.prod π(β,F)) β (fun x => TotalSpace.mk' F x (s i x))) | |
| (c : Fin n β β) : | |
| ContMDiff I (I.prod π(β,F)) β (fun x => TotalSpace.mk' F x (sectionEvaluation s x c)) := by | |
| intro x | |
| let e := trivializationAt F E x | |
| have hx : x β e.baseSet := mem_baseSet_trivializationAt F E x | |
| apply (e.contMDiffAt_section_iff hx).mpr | |
| have hc := ((sectionEvaluationCoordinates_smooth I E s hs e) x hx).contMDiffAt | |
| (e.open_baseSet.mem_nhds hx) | |
| have happ : ContDiff β β (fun L : (Fin n β β) βL[β] F => L c) := | |
| contDiff_id.clm_apply contDiff_const | |
| apply (((happ.restrict_scalars β).contDiffAt.contMDiffAt).comp x hc).congr_of_eventuallyEq | |
| filter_upwards [e.open_baseSet.mem_nhds hx] with y hy | |
| exact (sectionEvaluationCoordinates_apply E s e y hy c).symm | |
| /-- A constructed finite complex parameter space, with surjective evaluation | |
| and smooth coordinate maps in every bundle frame. -/ | |
| theorem exists_finite_complex_smooth_evaluation : | |
| β (n : β) (s : Fin n β β x, E x), | |
| (β i, ContMDiff I (I.prod π(β,F)) β (fun x => TotalSpace.mk' F x (s i x))) β§ | |
| (β x, Function.Surjective (sectionEvaluation s x)) β§ | |
| β (e : Trivialization F (Ο F E)) [MemTrivializationAtlas e], | |
| ContMDiffOn I π(β,(Fin n β β) βL[β] F) β | |
| (sectionEvaluationCoordinates E s e) e.baseSet β§ | |
| β x β e.baseSet, Function.Surjective (sectionEvaluationCoordinates E s e x) := by | |
| obtain β¨n,s,hs,hspanβ© := exists_finite_smooth_spanning_sections (F := F) I E | |
| exact β¨n,s,hs,sectionEvaluation_surjective s hspan,fun e _ => | |
| β¨sectionEvaluationCoordinates_smooth I E s hs e, | |
| sectionEvaluationCoordinates_surjective E s hspan eβ©β© | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Module Set | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky | |
| section | |
| variable {X H B Fβ Fβ : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| (Eβ Eβ : B β Type*) | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [TopologicalSpace (TotalSpace Fβ Eβ)] [TopologicalSpace (TotalSpace Fβ Eβ)] | |
| [FiberBundle Fβ Eβ] [FiberBundle Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [ContMDiffVectorBundle β Fβ Eβ I] [ContMDiffVectorBundle β Fβ Eβ I] | |
| def complexHomCoordinates | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] | |
| (s : β x, Eβ x βL[β] Eβ x) (x : B) : Fβ βL[β] Fβ := | |
| (eβ.continuousLinearMapAt β x).comp ((s x).comp (eβ.symmL β x)) | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] in | |
| theorem complexHomCoordinates_projected | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] | |
| (s : β x, Eβ x βL[β] Eβ x) (x : B) (hx : x β eβ.baseSet β© eβ.baseSet) : | |
| complexHomCoordinates Eβ Eβ eβ eβ (fun x => complexPart (s x)) x = | |
| complexPart (((eβ.continuousLinearMap (RingHom.id β) eβ) β¨x,s xβ©).2) := by | |
| have hβ : (eβ.symmL β x).restrictScalars β=eβ.symmL β x := by | |
| ext v | |
| change eβ.symmL β x v=eβ.symmL β x v | |
| rw [eβ.symmL_apply hx.1,eβ.symmL_apply hx.1] | |
| have hβ : (eβ.continuousLinearMapAt β x).restrictScalars β=eβ.continuousLinearMapAt β x := by | |
| ext v | |
| change eβ.continuousLinearMapAt β x v=eβ.continuousLinearMapAt β x v | |
| simp only [Trivialization.continuousLinearMapAt_apply,eβ.coe_linearMapAt_of_mem hx.2] | |
| have hn := complexPart_natural (eβ.symmL β x) (s x) (eβ.continuousLinearMapAt β x) | |
| rw [hβ,hβ] at hn | |
| exact hn.symm | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] in | |
| theorem complexHomCoordinates_projected_smooth | |
| (s : β x, Eβ x βL[β] Eβ x) | |
| (hs : ContMDiff I (I.prod π(β,Fβ βL[β] Fβ)) β | |
| (fun x => TotalSpace.mk' (Fβ βL[β] Fβ) x (s x))) | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] : | |
| ContMDiffOn I π(β,Fβ βL[β] Fβ) β | |
| (complexHomCoordinates Eβ Eβ eβ eβ (fun x => complexPart (s x))) | |
| (eβ.baseSet β© eβ.baseSet) := by | |
| let e := eβ.continuousLinearMap (RingHom.id β) eβ | |
| have hc := (e.contMDiffOn_section_baseSet_iff).mp hs.contMDiffOn | |
| have hp := (complexProjection (E := Fβ) (F := Fβ)).contMDiff.comp_contMDiffOn hc | |
| apply hp.congr | |
| intro x hx | |
| exact complexHomCoordinates_projected Eβ Eβ eβ eβ s x hx | |
| /-- Finite global Hom sections are constructed using the ordinary smooth | |
| real Hom bundle and the canonical complex-linear projection. Evaluation is | |
| surjective onto actual complex-linear fiber maps, and the projected sections | |
| are real-smooth in every pair of actual complex bundle frames. -/ | |
| theorem exists_finite_smooth_complex_hom_generators : | |
| β (n : β) (s : Fin n β β x, Eβ x βL[β] Eβ x), | |
| (β x, Function.Surjective (sectionEvaluation s x)) β§ | |
| β i (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ], | |
| ContMDiffOn I π(β,Fβ βL[β] Fβ) β (complexHomCoordinates Eβ Eβ eβ eβ (s i)) | |
| (eβ.baseSet β© eβ.baseSet) := by | |
| obtain β¨n,s,hs,hspanβ© := exists_finite_smooth_spanning_sections | |
| (F := Fβ βL[β] Fβ) I (fun x => Eβ x βL[β] Eβ x) | |
| let t (i : Fin n) (x : B) := complexPart (s i x) | |
| have ht : β x, Submodule.span β (Set.range (fun i => t i x))=β€ := by | |
| intro x | |
| let P : (Eβ x βL[β] Eβ x) ββ[β] (Eβ x βL[β] Eβ x) := complexProjectionLinear | |
| have hp : Function.Surjective P := fun f => β¨f.restrictScalars β,complexPart_restrict fβ© | |
| have hh := congrArg (Submodule.map P) (hspan x) | |
| rw [Submodule.map_span,Submodule.map_top,LinearMap.range_eq_top.mpr hp] at hh | |
| have he : P '' Set.range (fun i => s i x)=Set.range (fun i => t i x) := by | |
| ext v | |
| constructor | |
| Β· rintro β¨_,β¨i,rflβ©,rflβ©; exact β¨i,rflβ© | |
| Β· rintro β¨i,rflβ©; exact β¨s i x,β¨i,rflβ©,rflβ© | |
| rw [he] at hh | |
| exact hh | |
| exact β¨n,t,sectionEvaluation_surjective t ht,fun i eβ eβ _ _ => | |
| complexHomCoordinates_projected_smooth I Eβ Eβ (s i) (hs i) eβ eββ© | |
| end | |
| variable {X H B Fβ Fβ : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| (Eβ Eβ : B β Type*) | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [TopologicalSpace (TotalSpace Fβ Eβ)] [TopologicalSpace (TotalSpace Fβ Eβ)] | |
| [FiberBundle Fβ Eβ] [FiberBundle Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [ContMDiffVectorBundle β Fβ Eβ I] [ContMDiffVectorBundle β Fβ Eβ I] | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] in | |
| theorem realHomCoordinates_restrict | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] | |
| (s : β x, Eβ x βL[β] Eβ x) (x : B) (hx : x β eβ.baseSet β© eβ.baseSet) : | |
| (((eβ.continuousLinearMap (RingHom.id β) eβ) β¨x,(s x).restrictScalars ββ©).2) = | |
| (complexHomCoordinates Eβ Eβ eβ eβ s x).restrictScalars β := by | |
| ext v | |
| change eβ.continuousLinearMapAt β x (s x (eβ.symmL β x v)) = | |
| eβ.continuousLinearMapAt β x (s x (eβ.symmL β x v)) | |
| simp only [eβ.symmL_apply hx.1,Trivialization.continuousLinearMapAt_apply, | |
| eβ.coe_linearMapAt_of_mem hx.2] | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] | |
| [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] in | |
| /-- Complex frame-coordinate smoothness implies genuine smoothness of the | |
| section of the ordinary real Hom bundle. It is not merely a named predicate. -/ | |
| theorem smooth_realHom_of_complex_coordinates | |
| (s : β x, Eβ x βL[β] Eβ x) | |
| (hs : β (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ], | |
| ContMDiffOn I π(β,Fβ βL[β] Fβ) β (complexHomCoordinates Eβ Eβ eβ eβ s) | |
| (eβ.baseSet β© eβ.baseSet)) : | |
| ContMDiff I (I.prod π(β,Fβ βL[β] Fβ)) β | |
| (fun x => TotalSpace.mk' (Fβ βL[β] Fβ) x ((s x).restrictScalars β)) := by | |
| intro x | |
| let eβ := trivializationAt Fβ Eβ x | |
| let eβ := trivializationAt Fβ Eβ x | |
| let e := eβ.continuousLinearMap (RingHom.id β) eβ | |
| have hx : x β eβ.baseSet β© eβ.baseSet := | |
| β¨mem_baseSet_trivializationAt Fβ Eβ x,mem_baseSet_trivializationAt Fβ Eβ xβ© | |
| apply (e.contMDiffAt_section_iff hx).mpr | |
| have ho := eβ.open_baseSet.inter eβ.open_baseSet | |
| have hc := ((hs eβ eβ) x hx).contMDiffAt (ho.mem_nhds hx) | |
| have hh := (ContinuousLinearMap.restrictScalarsL β Fβ Fβ β β).contDiff.contDiffAt.contMDiffAt.comp x hc | |
| apply hh.congr_of_eventuallyEq | |
| filter_upwards [ho.mem_nhds hx] with y hy | |
| exact realHomCoordinates_restrict Eβ Eβ eβ eβ s y hy | |
| end Kaplansky | |
| end | |
| open Bundle Module Set | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky | |
| variable {X H B Fβ Fβ : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| [NormedAddCommGroup Fβ] [NormedSpace β Fβ] [FiniteDimensional β Fβ] | |
| (Eβ Eβ : B β Type*) | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [β x, NormedAddCommGroup (Eβ x)] [β x, NormedSpace β (Eβ x)] | |
| [TopologicalSpace (TotalSpace Fβ Eβ)] [TopologicalSpace (TotalSpace Fβ Eβ)] | |
| [FiberBundle Fβ Eβ] [FiberBundle Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] | |
| [ContMDiffVectorBundle β Fβ Eβ I] [ContMDiffVectorBundle β Fβ Eβ I] | |
| def homFrameLinear | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] (x : B) : | |
| (Eβ x βL[β] Eβ x) ββ[β] (Fβ βL[β] Fβ) where | |
| toFun T := (eβ.continuousLinearMapAt β x).comp (T.comp (eβ.symmL β x)) | |
| map_add' T S := by ext v; simp | |
| map_smul' c T := by ext v; simp | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] in | |
| theorem homFrameLinear_surjective | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] (x : B) | |
| (hx : x β eβ.baseSet β© eβ.baseSet) : | |
| Function.Surjective (homFrameLinear Eβ Eβ eβ eβ x) := by | |
| intro T | |
| refine β¨(eβ.symmL β x).comp (T.comp (eβ.continuousLinearMapAt β x)),?_β© | |
| ext v | |
| change eβ.continuousLinearMapAt β x (eβ.symmL β x | |
| (T (eβ.continuousLinearMapAt β x (eβ.symmL β x v))))=T v | |
| simp only [Trivialization.continuousLinearMapAt_apply,eβ.coe_linearMapAt_of_mem hx.1, | |
| eβ.coe_linearMapAt_of_mem hx.2,eβ.symmL_apply hx.1,eβ.symmL_apply hx.2, | |
| eβ.apply_mk_symm hx.1,eβ.apply_mk_symm hx.2] | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] in | |
| theorem homFrameLinear_commutes | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] (x : B) | |
| (hx : x β eβ.baseSet β© eβ.baseSet) (T : Eβ x βL[β] Eβ x) (v : Eβ x) : | |
| (eβ.toPretrivialization.linearEquivAt β x hx.2) (T v)= | |
| homFrameLinear Eβ Eβ eβ eβ x T ((eβ.toPretrivialization.linearEquivAt β x hx.1) v) := by | |
| change (eβ β¨x,T vβ©).2=eβ.continuousLinearMapAt β x (T (eβ.symmL β x ((eβ β¨x,vβ©).2))) | |
| simp only [eβ.symmL_apply hx.1,eβ.symm_apply_apply_mk hx.1, | |
| Trivialization.continuousLinearMapAt_apply,eβ.coe_linearMapAt_of_mem hx.2] | |
| def homEvaluationCoordinates {n : β} (s : Fin n β β x, Eβ x βL[β] Eβ x) | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] (x : B) : | |
| (Fin n β β) βL[β] (Fβ βL[β] Fβ) := | |
| β i, (ContinuousLinearMap.proj i).smulRight (complexHomCoordinates Eβ Eβ eβ eβ (s i) x) | |
| omit [T2Space B] [CompactSpace B] [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] | |
| [VectorBundle β Fβ Eβ] [VectorBundle β Fβ Eβ] in | |
| theorem homEvaluationCoordinates_apply {n : β} (s : Fin n β β x, Eβ x βL[β] Eβ x) | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] (x : B) (c : Fin n β β) : | |
| homEvaluationCoordinates Eβ Eβ s eβ eβ x c= | |
| homFrameLinear Eβ Eβ eβ eβ x (sectionEvaluation s x c) := by | |
| change (β i, (ContinuousLinearMap.proj i).smulRight (complexHomCoordinates Eβ Eβ eβ eβ (s i) x)) c = | |
| homFrameLinear Eβ Eβ eβ eβ x (β i, c i β’ s i x) | |
| simp only [sum_apply,ContinuousLinearMap.smulRight_apply, | |
| ContinuousLinearMap.proj_apply,map_sum,map_smul] | |
| rfl | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] | |
| [FiniteDimensional β Fβ] [FiniteDimensional β Fβ] [VectorBundle β Fβ Eβ] | |
| [VectorBundle β Fβ Eβ] [ContMDiffVectorBundle β Fβ Eβ I] | |
| [ContMDiffVectorBundle β Fβ Eβ I] in | |
| theorem homEvaluationCoordinates_smooth {n : β} (s : Fin n β β x, Eβ x βL[β] Eβ x) | |
| (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ] | |
| (hs : β i, ContMDiffOn I π(β,Fβ βL[β] Fβ) β | |
| (complexHomCoordinates Eβ Eβ eβ eβ (s i)) (eβ.baseSet β© eβ.baseSet)) : | |
| ContMDiffOn I π(β,(Fin n β β) βL[β] (Fβ βL[β] Fβ)) β | |
| (homEvaluationCoordinates Eβ Eβ s eβ eβ) (eβ.baseSet β© eβ.baseSet) := by | |
| apply contMDiffOn_finsetSum | |
| intro i _ | |
| have hh : ContDiff β β (fun A : Fβ βL[β] Fβ => (ContinuousLinearMap.proj i : (Fin n β β) βL[β] β).smulRight A) := | |
| contDiff_clm_apply_iff.mpr (fun c => contDiff_const.smul contDiff_id) | |
| exact (hh.restrict_scalars β).contMDiff.comp_contMDiffOn (hs i) | |
| theorem exists_finite_smooth_hom_evaluation : | |
| β (n : β) (s : Fin n β β x, Eβ x βL[β] Eβ x), | |
| (β x, Function.Surjective (sectionEvaluation s x)) β§ | |
| β (eβ : Trivialization Fβ (Ο Fβ Eβ)) (eβ : Trivialization Fβ (Ο Fβ Eβ)) | |
| [MemTrivializationAtlas eβ] [MemTrivializationAtlas eβ], | |
| ContMDiffOn I π(β,(Fin n β β) βL[β] (Fβ βL[β] Fβ)) β | |
| (homEvaluationCoordinates Eβ Eβ s eβ eβ) (eβ.baseSet β© eβ.baseSet) β§ | |
| β x β eβ.baseSet β© eβ.baseSet, | |
| Function.Surjective (homEvaluationCoordinates Eβ Eβ s eβ eβ x) := by | |
| obtain β¨n,s,hs,hsmβ© := exists_finite_smooth_complex_hom_generators (Fβ := Fβ) (Fβ := Fβ) I Eβ Eβ | |
| refine β¨n,s,hs,fun eβ eβ _ _ => β¨homEvaluationCoordinates_smooth I Eβ Eβ s eβ eβ | |
| (fun i => hsm i eβ eβ),fun x hx T => ?_β©β© | |
| obtain β¨R,hRβ© := homFrameLinear_surjective Eβ Eβ eβ eβ x hx T | |
| obtain β¨c,hcβ© := hs x R | |
| refine β¨c,?_β© | |
| rw [homEvaluationCoordinates_apply Eβ Eβ s eβ eβ x c,hc,hR] | |
| end Kaplansky | |
| end | |
| end OAI | |