math / data /lean /OAI /Geometry /ComplexBundle /Evaluation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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