Download data/lean/OAI/Geometry/ComplexBundle/Sections.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.87 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Sections.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Sections.lean
-
curl -L -o Sections.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Sections.lean
7.87 kB
| import Mathlib.Analysis.Complex.Basic | |
| import Mathlib.Topology.Algebra.Monoid | |
| import Mathlib.Topology.Compactification.OnePoint.Basic | |
| import Mathlib.Topology.Homotopy.Basic | |
| import Mathlib.Topology.VectorBundle.Basic | |
| namespace OAI | |
| noncomputable section | |
| /-! Gluing, homotopy, and operations on vector bundle sections. -/ | |
| section | |
| open Bundle Topology | |
| namespace Kaplansky | |
| section | |
| variable {B V : Type*} [TopologicalSpace B] | |
| [NormedAddCommGroup V] [NormedSpace β V] | |
| {E : B β Type*} [β b, AddCommGroup (E b)] [β b, Module β (E b)] | |
| [β b, TopologicalSpace (E b)] [TopologicalSpace (TotalSpace V E)] | |
| [FiberBundle V E] [VectorBundle β V E] | |
| /-- Addition over a varying base, with the actual total-space topology. -/ | |
| theorem continuous_bundle_add_over {X : Type*} [TopologicalSpace X] | |
| (b : X β B) (hb : Continuous b) (v w : β x, E (b x)) | |
| (hv : Continuous (fun x => TotalSpace.mk' V (b x) (v x))) | |
| (hw : Continuous (fun x => TotalSpace.mk' V (b x) (w x))) : | |
| Continuous (fun x => TotalSpace.mk' V (b x) (v x + w x)) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro x | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨hb.continuousAt, ?_β© | |
| have hv' := (FiberBundle.continuousAt_totalSpace V _ (xβ := x)).mp hv.continuousAt |>.2 | |
| have hw' := (FiberBundle.continuousAt_totalSpace V _ (xβ := x)).mp hw.continuousAt |>.2 | |
| apply (hv'.add hw').congr_of_eventuallyEq | |
| let e := trivializationAt V E (b x) | |
| have hn := hb.continuousAt (e.open_baseSet.mem_nhds (mem_baseSet_trivializationAt V E (b x))) | |
| filter_upwards [hn] with y hy | |
| exact (e.linear β hy).map_add (v y) (w y) | |
| /-- Scalar multiplication over a varying base. -/ | |
| theorem continuous_bundle_smul_over {X : Type*} [TopologicalSpace X] | |
| (b : X β B) (hb : Continuous b) (c : X β β) (hc : Continuous c) | |
| (v : β x, E (b x)) | |
| (hv : Continuous (fun x => TotalSpace.mk' V (b x) (v x))) : | |
| Continuous (fun x => TotalSpace.mk' V (b x) (c x β’ v x)) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro x | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨hb.continuousAt, ?_β© | |
| have hv' := (FiberBundle.continuousAt_totalSpace V _ (xβ := x)).mp hv.continuousAt |>.2 | |
| apply (hc.continuousAt.smul hv').congr_of_eventuallyEq | |
| let e := trivializationAt V E (b x) | |
| have hn := hb.continuousAt (e.open_baseSet.mem_nhds (mem_baseSet_trivializationAt V E (b x))) | |
| filter_upwards [hn] with y hy | |
| exact (e.linear β hy).map_smul (c y) (v y) | |
| /-- The genuine global affine homotopy of two continuous bundle sections. | |
| It permits intermediate degenerate zeros. -/ | |
| def bundleSectionHomotopy (s t : β b, E b) | |
| (hs : Continuous (fun b => TotalSpace.mk' V b (s b))) | |
| (ht : Continuous (fun b => TotalSpace.mk' V b (t b))) : | |
| ContinuousMap.Homotopy β¨_, hsβ© β¨_, htβ© where | |
| toFun z := β¨z.2, (1 - (z.1.val : β)) β’ s z.2 + (z.1.val : β) β’ t z.2β© | |
| continuous_toFun := by | |
| apply continuous_bundle_add_over Prod.snd continuous_snd | |
| Β· apply continuous_bundle_smul_over Prod.snd continuous_snd | |
| Β· exact continuous_const.sub (Complex.continuous_ofReal.comp (continuous_subtype_val.comp continuous_fst)) | |
| Β· exact hs.comp continuous_snd | |
| Β· apply continuous_bundle_smul_over Prod.snd continuous_snd | |
| Β· exact Complex.continuous_ofReal.comp (continuous_subtype_val.comp continuous_fst) | |
| Β· exact ht.comp continuous_snd | |
| map_zero_left b := by simp | |
| map_one_left b := by simp | |
| /-- The map of a section into the one-point compactification of its actual total space. -/ | |
| def compactifiedSection (s : β b, E b) | |
| (hs : Continuous (fun b => TotalSpace.mk' V b (s b))) : | |
| C(B, OnePoint (TotalSpace V E)) := | |
| β¨fun b => (TotalSpace.mk' V b (s b) : OnePoint (TotalSpace V E)), | |
| OnePoint.continuous_coe.comp hsβ© | |
| /-- Global section independence at the level of homotopy, without a | |
| regularity or finiteness assumption on any intermediate zero set. -/ | |
| def compactifiedSectionHomotopy (s t : β b, E b) | |
| (hs : Continuous (fun b => TotalSpace.mk' V b (s b))) | |
| (ht : Continuous (fun b => TotalSpace.mk' V b (t b))) : | |
| ContinuousMap.Homotopy (compactifiedSection s hs) (compactifiedSection t ht) := | |
| (ContinuousMap.Homotopy.refl β¨_, OnePoint.continuous_coeβ©).comp | |
| (bundleSectionHomotopy s t hs ht) | |
| end | |
| variable {π Y F I : Type*} [NontriviallyNormedField π] [TopologicalSpace Y] [NormedAddCommGroup F] [NormedSpace π F] | |
| /-- Gluing compatible local coordinate functions produces a continuous | |
| section of the ordinary, potentially nontrivial vector bundle. -/ | |
| theorem glue_core_section (H : VectorBundleCore π Y F I) | |
| (L : I β Y β F) (hL : β a, ContinuousOn (L a) (H.baseSet a)) | |
| (hcompat : β a b y, y β H.baseSet a β y β H.baseSet b β | |
| H.coordChange a b y (L a y) = L b y) : | |
| β s : β y, H.Fiber y, | |
| Continuous (fun y => TotalSpace.mk' F y (s y)) β§ | |
| β a y, y β H.baseSet a β (H.localTriv a β¨y,s yβ©).2 = L a y := by | |
| let s : β y, H.Fiber y := fun y => L (H.indexAt y) y | |
| have he (a : I) (y : Y) (hy : y β H.baseSet a) : | |
| (H.localTriv a β¨y,s yβ©).2 = L a y := | |
| hcompat (H.indexAt y) a y (H.mem_baseSet_at y) hy | |
| refine β¨s, ?_, heβ© | |
| rw [continuous_iff_continuousAt] | |
| intro y | |
| rw [FiberBundle.continuousAt_section] | |
| have hn := (H.isOpen_baseSet (H.indexAt y)).mem_nhds (H.mem_baseSet_at y) | |
| have hc := (hL (H.indexAt y) y (H.mem_baseSet_at y)).continuousAt hn | |
| apply hc.congr_of_eventuallyEq | |
| filter_upwards [hn] with z hz | |
| exact he (H.indexAt y) z hz | |
| end Kaplansky | |
| end | |
| open Bundle Topology | |
| namespace Kaplansky | |
| variable {π Y V : Type*} [NontriviallyNormedField π] [TopologicalSpace Y] | |
| variable [NormedAddCommGroup V] [NormedSpace π V] | |
| variable {E : Y β Type*} [β y, AddCommGroup (E y)] [β y, Module π (E y)] | |
| variable [β y, TopologicalSpace (E y)] [TopologicalSpace (TotalSpace V E)] | |
| variable [FiberBundle V E] [VectorBundle π V E] | |
| include π in | |
| /-- Finite sums of continuous local sections in an ordinary vector bundle. -/ | |
| theorem continuousOn_bundle_sum {ΞΉ : Type*} (u : Finset ΞΉ) (v : ΞΉ β β y, E y) {s : Set Y} | |
| (hv : β i β u, ContinuousOn (fun y => TotalSpace.mk' V y (v i y)) s) : | |
| ContinuousOn (fun y => TotalSpace.mk' V y (β i β u, v i y)) s := by | |
| intro y hy | |
| rw [FiberBundle.continuousWithinAt_section] | |
| have hc : ContinuousWithinAt | |
| (fun z => β i β u, ((trivializationAt V E y) β¨z,v i zβ©).2) s y := | |
| tendsto_finsetSum u (fun i hi => | |
| ((FiberBundle.continuousWithinAt_section V).mp (hv i hi y hy))) | |
| apply hc.congr_of_eventuallyEq | |
| Β· | |
| have hn := (trivializationAt V E y).open_baseSet.mem_nhds | |
| (mem_baseSet_trivializationAt V E y) | |
| filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds hn] with z hz | |
| exact (map_sum (((trivializationAt V E y).linear π hz).mk' _) (fun i => v i z) u) | |
| Β· exact map_sum (((trivializationAt V E y).linear π (mem_baseSet_trivializationAt V E y)).mk' _) (fun i => v i y) u | |
| /-- Scalar multiplication of continuous local sections. -/ | |
| theorem continuousOn_bundle_smul (f : Y β π) (v : β y, E y) {s : Set Y} | |
| (hf : ContinuousOn f s) (hv : ContinuousOn (fun y => TotalSpace.mk' V y (v y)) s) : | |
| ContinuousOn (fun y => TotalSpace.mk' V y (f y β’ v y)) s := by | |
| intro y hy | |
| rw [FiberBundle.continuousWithinAt_section] | |
| have hc := (hf y hy).smul ((FiberBundle.continuousWithinAt_section V).mp (hv y hy)) | |
| apply hc.congr_of_eventuallyEq | |
| Β· | |
| have hn := (trivializationAt V E y).open_baseSet.mem_nhds | |
| (mem_baseSet_trivializationAt V E y) | |
| filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds hn] with z hz | |
| exact (((trivializationAt V E y).linear π hz).map_smul (f z) (v z)) | |
| Β· exact ((trivializationAt V E y).linear π (mem_baseSet_trivializationAt V E y)).map_smul (f y) (v y) | |
| end Kaplansky | |
| end | |
| end OAI | |