Download data/lean/OAI/Geometry/ComplexBundle/Tensor.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Tensor.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Tensor.lean
-
curl -L -o Tensor.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Tensor.lean
11.1 kB
| import OAI.Geometry.ComplexBundle.DirectSum | |
| import OAI.Geometry.ComplexBundle.Sections | |
| namespace OAI | |
| noncomputable section | |
| /-! Tensor line bundles, metrics, and finite frames. -/ | |
| section | |
| open Bundle Topology | |
| namespace Kaplansky | |
| section | |
| theorem complexLineMap_scalar (L : β βL[β] β) (z : β) : L z = z * L 1 := by | |
| have h := L.map_smul z (1 : β) | |
| simpa using h | |
| variable {B J K : Type*} [TopologicalSpace B] | |
| (C : VectorBundleCore β B β J) (D : VectorBundleCore β B β K) | |
| /-- Tensor product of two actual line cores. Its transition functions | |
| are the products of the two line transition functions. -/ | |
| def tensorLineCore : VectorBundleCore β B β (J Γ K) where | |
| baseSet i := C.baseSet i.1 β© D.baseSet i.2 | |
| isOpen_baseSet i := (C.isOpen_baseSet i.1).inter (D.isOpen_baseSet i.2) | |
| indexAt x := (C.indexAt x,D.indexAt x) | |
| mem_baseSet_at x := β¨C.mem_baseSet_at x,D.mem_baseSet_at xβ© | |
| coordChange i j x := (C.coordChange i.1 j.1 x 1 * D.coordChange i.2 j.2 x 1) β’ | |
| ContinuousLinearMap.id β β | |
| coordChange_self i x hx z := by | |
| rw [C.coordChange_self i.1 x hx.1, D.coordChange_self i.2 x hx.2] | |
| simp | |
| continuousOn_coordChange i j := by | |
| have hc := ((C.continuousOn_coordChange i.1 j.1).mono | |
| (fun x (hx : x β (C.baseSet i.1 β© D.baseSet i.2) β© (C.baseSet j.1 β© D.baseSet j.2)) => | |
| β¨hx.1.1,hx.2.1β©)).clm_apply (continuousOn_const (c := (1 : β))) | |
| have hd := ((D.continuousOn_coordChange i.2 j.2).mono | |
| (fun x (hx : x β (C.baseSet i.1 β© D.baseSet i.2) β© (C.baseSet j.1 β© D.baseSet j.2)) => | |
| β¨hx.1.2,hx.2.2β©)).clm_apply (continuousOn_const (c := (1 : β))) | |
| exact (hc.mul hd).smul continuousOn_const | |
| coordChange_comp i j k x hx z := by | |
| have hc := C.coordChange_comp i.1 j.1 k.1 x | |
| β¨β¨hx.1.1.1,hx.1.2.1β©,hx.2.1β© (1 : β) | |
| have hd := D.coordChange_comp i.2 j.2 k.2 x | |
| β¨β¨hx.1.1.2,hx.1.2.2β©,hx.2.2β© (1 : β) | |
| rw [complexLineMap_scalar] at hc hd | |
| change (C.coordChange j.1 k.1 x 1 * D.coordChange j.2 k.2 x 1) * | |
| ((C.coordChange i.1 j.1 x 1 * D.coordChange i.2 j.2 x 1) * z) = | |
| (C.coordChange i.1 k.1 x 1 * D.coordChange i.2 k.2 x 1) * z | |
| rw [β hc, β hd] | |
| ring | |
| /-- Multiplication in core fibers is the tensor pairing. This formula | |
| is compatible with every tensor-product chart. -/ | |
| def tensorLinePair (x : B) (v : C.Fiber x) (w : D.Fiber x) : (tensorLineCore C D).Fiber x := | |
| (show β from v) * (show β from w) | |
| theorem tensorLinePair_chart (i : J Γ K) (x : B) (v : C.Fiber x) (w : D.Fiber x) : | |
| ((tensorLineCore C D).localTriv i β¨x,tensorLinePair C D x v wβ©).2 = | |
| (C.localTriv i.1 β¨x,vβ©).2 * (D.localTriv i.2 β¨x,wβ©).2 := by | |
| change β at v w | |
| change (C.coordChange (C.indexAt x) i.1 x 1 * D.coordChange (D.indexAt x) i.2 x 1) * | |
| ((show β from v) * (show β from w)) = | |
| C.coordChange (C.indexAt x) i.1 x v * D.coordChange (D.indexAt x) i.2 x w | |
| rw [complexLineMap_scalar (C.coordChange (C.indexAt x) i.1 x) v, | |
| complexLineMap_scalar (D.coordChange (D.indexAt x) i.2 x) w] | |
| ring | |
| /-- Products of continuous sections are continuous in the tensor | |
| bundle topology; the chart compatibility, not fiberwise continuity alone, | |
| establishes the statement. -/ | |
| theorem continuous_tensorLinePair_section (s : β x, C.Fiber x) (t : β x, D.Fiber x) | |
| (hs : Continuous (fun x => TotalSpace.mk' β x (s x))) | |
| (ht : Continuous (fun x => TotalSpace.mk' β x (t x))) : | |
| Continuous (fun x => TotalSpace.mk' β x (tensorLinePair C D x (s x) (t x))) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro x | |
| rw [FiberBundle.continuousAt_section] | |
| have hc := (FiberBundle.continuousAt_section β x).mp hs.continuousAt | |
| have hd := (FiberBundle.continuousAt_section β x).mp ht.continuousAt | |
| apply (hc.mul hd).congr_of_eventuallyEq | |
| exact Filter.Eventually.of_forall (fun y => | |
| tensorLinePair_chart C D ((C.indexAt x),(D.indexAt x)) y (s y) (t y)) | |
| theorem tensorLinePair_ne_zero (x : B) (v : C.Fiber x) (w : D.Fiber x) | |
| (hv : v β 0) (hw : w β 0) : tensorLinePair C D x v w β 0 := by | |
| change (show β from v) * (show β from w) β 0 | |
| exact mul_ne_zero hv hw | |
| end | |
| variable {B J : Type} [TopologicalSpace B] | |
| (C : VectorBundleCore β B β J) (u : β b, C.Fiber b) | |
| (hu : β b, u b β 0) | |
| /-- Coordinates relative to an actual nowhere-zero line section. -/ | |
| def lineFrameEquiv (b : B) : C.Fiber b ββ[β] β where | |
| toFun z := (show β from z) / (show β from u b) | |
| invFun z := z * (show β from u b) | |
| left_inv z := by | |
| change ((show β from z) / (show β from u b)) * (show β from u b) = (show β from z) | |
| exact div_mul_cancelβ _ (hu b) | |
| right_inv z := by | |
| change (z * (show β from u b)) / (show β from u b) = z | |
| exact mul_div_cancel_rightβ _ (hu b) | |
| map_add' z w := add_div _ _ _ | |
| map_smul' c z := by change (c*(show β from z))/_ = c*((show β from z)/_); ring | |
| theorem lineFrameEquiv_chart (b : B) (z : C.Fiber b) (i : J) (hi : b β C.baseSet i) : | |
| lineFrameEquiv C u hu b z = | |
| (C.localTriv i β¨b,zβ©).2 / (C.localTriv i β¨b,u bβ©).2 := by | |
| have hc : C.coordChange (C.indexAt b) i b 1 β 0 := by | |
| intro hz | |
| have he := C.coordChange_comp (C.indexAt b) i (C.indexAt b) b | |
| β¨β¨C.mem_baseSet_at b,hiβ©,C.mem_baseSet_at bβ© 1 | |
| rw [hz, map_zero, C.coordChange_self _ _ (C.mem_baseSet_at b)] at he | |
| exact zero_ne_one he | |
| change (show β from z) / (show β from u b) = | |
| C.coordChange (C.indexAt b) i b z / C.coordChange (C.indexAt b) i b (u b) | |
| rw [complexLineMap_scalar (C.coordChange (C.indexAt b) i b) z, | |
| complexLineMap_scalar (C.coordChange (C.indexAt b) i b) (u b)] | |
| exact (mul_div_mul_right _ _ hc).symm | |
| variable (hc : Continuous (fun b => TotalSpace.mk' β b (u b))) | |
| /-- A nonzero continuous frame gives a homeomorphism for the original | |
| line-core topology, with complex-linear fibers. -/ | |
| def lineFrameHomeomorph : TotalSpace β C.Fiber ββ B Γ β where | |
| toFun z := (z.proj,lineFrameEquiv C u hu z.proj z.2) | |
| invFun z := β¨z.1,(lineFrameEquiv C u hu z.1).symm z.2β© | |
| left_inv z := by | |
| obtain β¨b,zβ© := z | |
| exact congrArg (TotalSpace.mk' β b) ((lineFrameEquiv C u hu b).symm_apply_apply z) | |
| right_inv z := Prod.ext rfl ((lineFrameEquiv C u hu z.1).apply_symm_apply z.2) | |
| continuous_toFun := by | |
| apply (FiberBundle.continuous_proj _ _).prodMk | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| let i := C.indexAt z.proj | |
| have hp := FiberBundle.continuous_proj β C.Fiber | |
| have hv := ((C.localTriv i).continuousAt | |
| ((C.localTriv i).mem_source.mpr (C.mem_baseSet_at z.proj))).snd | |
| have hw : ContinuousAt (fun w : TotalSpace β C.Fiber => | |
| (C.localTriv i β¨w.proj,u w.projβ©).2) z := | |
| ((FiberBundle.continuousAt_section β z.proj).mp hc.continuousAt).comp hp.continuousAt | |
| have hn : (C.localTriv i β¨z.proj,u z.projβ©).2 β 0 := by | |
| change C.coordChange (C.indexAt z.proj) i z.proj (u z.proj) β 0 | |
| intro h | |
| exact hu z.proj ((C.coordChange_self _ _ (C.mem_baseSet_at z.proj) (u z.proj)).symm.trans h) | |
| apply (hv.div hw hn).congr_of_eventuallyEq | |
| filter_upwards [hp.continuousAt ((C.isOpen_baseSet i).mem_nhds | |
| (C.mem_baseSet_at z.proj))] with w hw | |
| exact lineFrameEquiv_chart C u hu w.proj w.2 i hw | |
| continuous_invFun := by | |
| exact continuous_bundle_smul_over Prod.fst continuous_fst Prod.snd continuous_snd | |
| (fun z : B Γ β => u z.1) (hc.comp continuous_fst) | |
| variable {S : Type} [Fintype S] {I : S β Type} | |
| (D : β s, VectorBundleCore β B β (I s)) | |
| (v : β s b, (D s).Fiber b) (hn : β s b, v s b β 0) | |
| (hv : β s, Continuous (fun b => TotalSpace.mk' β b (v s b))) | |
| def finiteLineFrameEquiv (b : B) : | |
| (finiteLineSumCore D).Fiber b ββ[β] (S β β) := | |
| (EuclideanSpace.equiv S β).toLinearEquiv.trans | |
| (LinearEquiv.piCongrRight (fun s => lineFrameEquiv (D s) (v s) (hn s) b)) | |
| def finiteLineFrameHomeomorph : | |
| TotalSpace (EuclideanSpace β S) (finiteLineSumCore D).Fiber ββ B Γ (S β β) where | |
| toFun z := (z.proj,finiteLineFrameEquiv D v hn z.proj z.2) | |
| invFun z := β¨z.1,(finiteLineFrameEquiv D v hn z.1).symm z.2β© | |
| left_inv z := by | |
| obtain β¨b,wβ© := z | |
| exact congrArg (TotalSpace.mk' _ b) ((finiteLineFrameEquiv D v hn b).symm_apply_apply w) | |
| right_inv z := Prod.ext rfl ((finiteLineFrameEquiv D v hn z.1).apply_symm_apply z.2) | |
| continuous_toFun := by | |
| apply (FiberBundle.continuous_proj _ _).prodMk | |
| apply continuous_pi | |
| intro s | |
| exact continuous_snd.comp ((lineFrameHomeomorph (D s) (v s) (hn s) (hv s)).continuous.comp | |
| (continuous_finiteLineSumComponent D s)) | |
| continuous_invFun := by | |
| apply (continuous_finiteLineSum_iff _ _).mpr | |
| refine β¨continuous_fst,fun s => ?_β© | |
| exact (lineFrameHomeomorph (D s) (v s) (hn s) (hv s)).symm.continuous.comp | |
| (continuous_fst.prodMk ((continuous_apply s).comp continuous_snd)) | |
| theorem finiteLineFrameHomeomorph_zero_iff | |
| (z : TotalSpace (EuclideanSpace β S) (finiteLineSumCore D).Fiber) : | |
| (finiteLineFrameHomeomorph D v hn hv z).2 = 0 β z.2 = 0 := | |
| (finiteLineFrameEquiv D v hn z.proj).map_eq_zero_iff | |
| end Kaplansky | |
| end | |
| open Bundle Topology | |
| open scoped InnerProductSpace | |
| namespace Kaplansky | |
| variable {B J K : Type*} [TopologicalSpace B] | |
| (C : VectorBundleCore β B β J) (D : VectorBundleCore β B β K) | |
| theorem tensorLineCore_coordChange_eq_comp (i j : J Γ K) (x : B) (z : β) : | |
| (tensorLineCore C D).coordChange i j x z = | |
| C.coordChange i.1 j.1 x (D.coordChange i.2 j.2 x z) := by | |
| change (C.coordChange i.1 j.1 x 1 * D.coordChange i.2 j.2 x 1) * z = _ | |
| rw [complexLineMap_scalar (C.coordChange i.1 j.1 x) (D.coordChange i.2 j.2 x z), | |
| complexLineMap_scalar (D.coordChange i.2 j.2 x) z] | |
| ring | |
| /-- Tensoring unitary line transitions preserves the actual Hermitian | |
| metric. No determinant or orientation premise is required. -/ | |
| theorem tensorLineCore_unitary | |
| (hC : β i j x, x β C.baseSet i β x β C.baseSet j β β z w : β, | |
| inner β (C.coordChange i j x z) (C.coordChange i j x w) = inner β z w) | |
| (hD : β i j x, x β D.baseSet i β x β D.baseSet j β β z w : β, | |
| inner β (D.coordChange i j x z) (D.coordChange i j x w) = inner β z w) | |
| (i j : J Γ K) (x : B) (hi : x β (tensorLineCore C D).baseSet i) | |
| (hj : x β (tensorLineCore C D).baseSet j) (z w : β) : | |
| inner β ((tensorLineCore C D).coordChange i j x z) | |
| ((tensorLineCore C D).coordChange i j x w) = inner β z w := by | |
| rw [tensorLineCore_coordChange_eq_comp, tensorLineCore_coordChange_eq_comp, | |
| hC i.1 j.1 x hi.1 hj.1, hD i.2 j.2 x hi.2 hj.2] | |
| theorem tensorLineSum_unitary {S : Type*} [Fintype S] {J K : S β Type*} | |
| (C : β s, VectorBundleCore β B β (J s)) (D : β s, VectorBundleCore β B β (K s)) | |
| (hC : LineCoreIsUnitary C) (hD : LineCoreIsUnitary D) : | |
| LineCoreIsUnitary (fun s => tensorLineCore (C s) (D s)) := | |
| fun s => tensorLineCore_unitary (C s) (D s) (hC s) (hD s) | |
| end Kaplansky | |
| end | |
| end OAI | |