fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[simps -fullyApplied apply]
symmL (e : Trivialization F (π F E)) [e.IsLinear R] (b : B) : F →L[R] E b :=
{ e.symmₗ R b with
toFun := e.symm b -- given explicitly to help `simps`
cont := by
by_cases hb : b ∈ e.baseSet
· rw [(FiberBundle.totalSpaceMk_isInducing F E b).continuous_iff]
exact e.continuousOn_symm.comp_continuous (.prodMk_right _) fun x ↦
mk_mem_prod hb (mem_univ x)
· refine continuous_zero.congr fun x => (e.symm_apply_of_notMem hb x).symm }
variable {R} | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | symmL | Backwards map of `Trivialization.continuousLinearEquivAt`, defined everywhere. |
symmL_continuousLinearMapAt (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) (y : E b) : e.symmL R b (e.continuousLinearMapAt R b y) = y :=
e.symmₗ_linearMapAt hb y | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | symmL_continuousLinearMapAt | null |
continuousLinearMapAt_symmL (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) (y : F) : e.continuousLinearMapAt R b (e.symmL R b y) = y :=
e.linearMapAt_symmₗ hb y
variable (R) in | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuousLinearMapAt_symmL | null |
@[simps -fullyApplied apply symm_apply]
continuousLinearEquivAt (e : Trivialization F (π F E)) [e.IsLinear R] (b : B)
(hb : b ∈ e.baseSet) : E b ≃L[R] F :=
{ e.toPretrivialization.linearEquivAt R b hb with
toFun := fun y => (e ⟨b, y⟩).2 -- given explicitly to help `simps`
invFun := e.symm b -- given explicitly to help `simps`
continuous_toFun := (e.continuousOn.comp_continuous
(FiberBundle.totalSpaceMk_isInducing F E b).continuous fun _ => e.mem_source.mpr hb).snd
continuous_invFun := (e.symmL R b).continuous } | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuousLinearEquivAt | In a vector bundle, a trivialization in the fiber (which is a priori only linear)
is in fact a continuous linear equiv between the fibers and the model fiber. |
coe_continuousLinearEquivAt_eq (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) :
(e.continuousLinearEquivAt R b hb : E b → F) = e.continuousLinearMapAt R b :=
(e.coe_linearMapAt_of_mem hb).symm | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | coe_continuousLinearEquivAt_eq | null |
symm_continuousLinearEquivAt_eq (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) : ((e.continuousLinearEquivAt R b hb).symm : F → E b) = e.symmL R b :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | symm_continuousLinearEquivAt_eq | null |
continuousLinearEquivAt_apply' (e : Trivialization F (π F E)) [e.IsLinear R]
(x : TotalSpace F E) (hx : x ∈ e.source) :
e.continuousLinearEquivAt R x.proj (e.mem_source.1 hx) x.2 = (e x).2 := rfl
variable (R) | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuousLinearEquivAt_apply' | null |
apply_eq_prod_continuousLinearEquivAt (e : Trivialization F (π F E)) [e.IsLinear R] (b : B)
(hb : b ∈ e.baseSet) (z : E b) : e ⟨b, z⟩ = (b, e.continuousLinearEquivAt R b hb z) := by
ext
· refine e.coe_fst ?_
rw [e.source_eq]
exact hb
· simp only [continuousLinearEquivAt_apply] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | apply_eq_prod_continuousLinearEquivAt | null |
protected zeroSection (e : Trivialization F (π F E)) [e.IsLinear R] {x : B}
(hx : x ∈ e.baseSet) : e (zeroSection F E x) = (x, 0) := by
simp_rw [zeroSection, e.apply_eq_prod_continuousLinearEquivAt R x hx 0, map_zero]
variable {R} | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | zeroSection | null |
symm_apply_eq_mk_continuousLinearEquivAt_symm (e : Trivialization F (π F E)) [e.IsLinear R]
(b : B) (hb : b ∈ e.baseSet) (z : F) :
e.toOpenPartialHomeomorph.symm ⟨b, z⟩ = ⟨b, (e.continuousLinearEquivAt R b hb).symm z⟩ := by
have h : (b, z) ∈ e.target := by
rw [e.target_eq]
exact ⟨hb, mem_univ _⟩
apply e.injOn (e.map_target h)
· simpa only [e.source_eq, mem_preimage]
· simp_rw [e.right_inv h, coe_coe, e.apply_eq_prod_continuousLinearEquivAt R b hb,
ContinuousLinearEquiv.apply_symm_apply] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | symm_apply_eq_mk_continuousLinearEquivAt_symm | null |
comp_continuousLinearEquivAt_eq_coord_change (e e' : Trivialization F (π F E))
[e.IsLinear R] [e'.IsLinear R] {b : B} (hb : b ∈ e.baseSet ∩ e'.baseSet) :
(e.continuousLinearEquivAt R b hb.1).symm.trans (e'.continuousLinearEquivAt R b hb.2) =
coordChangeL R e e' b := by
ext v
rw [coordChangeL_apply e e' hb]
rfl | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | comp_continuousLinearEquivAt_eq_coord_change | null |
VectorBundleCore (ι : Type*) where
baseSet : ι → Set B
isOpen_baseSet : ∀ i, IsOpen (baseSet i)
indexAt : B → ι
mem_baseSet_at : ∀ x, x ∈ baseSet (indexAt x)
coordChange : ι → ι → B → F →L[R] F
coordChange_self : ∀ i, ∀ x ∈ baseSet i, ∀ v, coordChange i i x v = v
continuousOn_coordChange : ∀ i j, ContinuousOn (coordChange i j) (baseSet i ∩ baseSet j)
coordChange_comp : ∀ i j k, ∀ x ∈ baseSet i ∩ baseSet j ∩ baseSet k, ∀ v,
(coordChange j k x) (coordChange i j x v) = coordChange i k x v | structure | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | VectorBundleCore | Analogous construction of `FiberBundleCore` for vector bundles. This
construction gives a way to construct vector bundles from a structure registering how
trivialization changes act on fibers. |
trivialVectorBundleCore (ι : Type*) [Inhabited ι] : VectorBundleCore R B F ι where
baseSet _ := univ
isOpen_baseSet _ := isOpen_univ
indexAt := default
mem_baseSet_at x := mem_univ x
coordChange _ _ _ := ContinuousLinearMap.id R F
coordChange_self _ _ _ _ := rfl
coordChange_comp _ _ _ _ _ _ := rfl
continuousOn_coordChange _ _ := continuousOn_const | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivialVectorBundleCore | The trivial vector bundle core, in which all the changes of coordinates are the
identity. |
@[simps (attr := mfld_simps) -fullyApplied]
toFiberBundleCore : FiberBundleCore ι B F :=
{ Z with
coordChange := fun i j b => Z.coordChange i j b
continuousOn_coordChange := fun i j =>
isBoundedBilinearMap_apply.continuous.comp_continuousOn
((Z.continuousOn_coordChange i j).prodMap continuousOn_id) } | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | toFiberBundleCore | Natural identification to a `FiberBundleCore`. |
coordChange_linear_comp (i j k : ι) :
∀ x ∈ Z.baseSet i ∩ Z.baseSet j ∩ Z.baseSet k,
(Z.coordChange j k x).comp (Z.coordChange i j x) = Z.coordChange i k x :=
fun x hx => by
ext v
exact Z.coordChange_comp i j k x hx v | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | coordChange_linear_comp | null |
@[nolint unusedArguments]
Index := ι | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | Index | The index set of a vector bundle core, as a convenience function for dot notation |
@[nolint unusedArguments, reducible]
Base := B | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | Base | The base space of a vector bundle core, as a convenience function for dot notation |
@[nolint unusedArguments]
Fiber : B → Type _ :=
Z.toFiberBundleCore.Fiber | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | Fiber | The fiber of a vector bundle core, as a convenience function for dot notation and
typeclass inference |
topologicalSpaceFiber (x : B) : TopologicalSpace (Z.Fiber x) :=
Z.toFiberBundleCore.topologicalSpaceFiber x | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | topologicalSpaceFiber | null |
addCommGroupFiber (x : B) : AddCommGroup (Z.Fiber x) :=
inferInstanceAs (AddCommGroup F) | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | addCommGroupFiber | null |
moduleFiber (x : B) : Module R (Z.Fiber x) :=
inferInstanceAs (Module R F) | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | moduleFiber | null |
@[reducible, simp, mfld_simps]
protected proj : TotalSpace F Z.Fiber → B :=
TotalSpace.proj | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | proj | The projection from the total space of a fiber bundle core, on its base. |
@[nolint unusedArguments, reducible]
protected TotalSpace :=
Bundle.TotalSpace F Z.Fiber | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | TotalSpace | The total space of the vector bundle, as a convenience function for dot notation.
It is by definition equal to `Bundle.TotalSpace F Z.Fiber`. |
trivChange (i j : ι) : OpenPartialHomeomorph (B × F) (B × F) :=
Z.toFiberBundleCore.trivChange i j
@[simp, mfld_simps] | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivChange | Local homeomorphism version of the trivialization change. |
mem_trivChange_source (i j : ι) (p : B × F) :
p ∈ (Z.trivChange i j).source ↔ p.1 ∈ Z.baseSet i ∩ Z.baseSet j :=
Z.toFiberBundleCore.mem_trivChange_source i j p | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_trivChange_source | null |
toTopologicalSpace : TopologicalSpace Z.TotalSpace :=
Z.toFiberBundleCore.toTopologicalSpace
variable (b : B) (a : F)
@[simp, mfld_simps] | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | toTopologicalSpace | Topological structure on the total space of a vector bundle created from core, designed so
that all the local trivialization are continuous. |
coe_coordChange (i j : ι) : Z.toFiberBundleCore.coordChange i j b = Z.coordChange i j b :=
rfl | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | coe_coordChange | null |
localTriv (i : ι) : Trivialization F (π F Z.Fiber) :=
Z.toFiberBundleCore.localTriv i
@[simp, mfld_simps] | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv | One of the standard local trivializations of a vector bundle constructed from core, taken by
considering this in particular as a fiber bundle constructed from core. |
localTriv_apply {i : ι} (p : Z.TotalSpace) :
(Z.localTriv i) p = ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩ :=
rfl | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_apply | null |
localTriv.isLinear (i : ι) : (Z.localTriv i).IsLinear R where
linear x _ :=
{ map_add := fun _ _ => by simp only [map_add, localTriv_apply, mfld_simps]
map_smul := fun _ _ => by simp only [map_smul, localTriv_apply, mfld_simps] }
variable (i j : ι)
@[simp, mfld_simps] | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv.isLinear | The standard local trivializations of a vector bundle constructed from core are linear. |
mem_localTriv_source (p : Z.TotalSpace) : p ∈ (Z.localTriv i).source ↔ p.1 ∈ Z.baseSet i :=
Iff.rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_localTriv_source | null |
baseSet_at : Z.baseSet i = (Z.localTriv i).baseSet :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | baseSet_at | null |
mem_localTriv_target (p : B × F) :
p ∈ (Z.localTriv i).target ↔ p.1 ∈ (Z.localTriv i).baseSet :=
Z.toFiberBundleCore.mem_localTriv_target i p
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_localTriv_target | null |
localTriv_symm_fst (p : B × F) :
(Z.localTriv i).toOpenPartialHomeomorph.symm p =
⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_symm_fst | null |
localTriv_symm_apply {b : B} (hb : b ∈ (Z.localTriv i).baseSet) (v : F) :
(Z.localTriv i).symm b v = Z.coordChange i (Z.indexAt b) b v := by
apply (Z.localTriv i).symm_apply hb v
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_symm_apply | null |
localTriv_coordChange_eq {b : B}
(hb : b ∈ (Z.localTriv i).baseSet ∧ b ∈ (Z.localTriv j).baseSet) (v : F) :
(Z.localTriv i).coordChangeL R (Z.localTriv j) b v = Z.coordChange i j b v := by
rw [Trivialization.coordChangeL_apply', localTriv_symm_fst, localTriv_apply, coordChange_comp]
exacts [⟨⟨hb.1, Z.mem_baseSet_at b⟩, hb.2⟩, hb] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_coordChange_eq | null |
localTrivAt (b : B) : Trivialization F (π F Z.Fiber) :=
Z.localTriv (Z.indexAt b)
@[simp, mfld_simps] | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTrivAt | Preferred local trivialization of a vector bundle constructed from core, at a given point, as
a bundle trivialization |
localTrivAt_def : Z.localTriv (Z.indexAt b) = Z.localTrivAt b :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTrivAt_def | null |
mem_source_at : (⟨b, a⟩ : Z.TotalSpace) ∈ (Z.localTrivAt b).source := by
rw [localTrivAt, mem_localTriv_source]
exact Z.mem_baseSet_at b
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_source_at | null |
localTrivAt_apply (p : Z.TotalSpace) : Z.localTrivAt p.1 p = ⟨p.1, p.2⟩ :=
Z.toFiberBundleCore.localTrivAt_apply p
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTrivAt_apply | null |
localTrivAt_apply_mk (b : B) (a : F) : Z.localTrivAt b ⟨b, a⟩ = ⟨b, a⟩ :=
Z.localTrivAt_apply _
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTrivAt_apply_mk | null |
mem_localTrivAt_baseSet : b ∈ (Z.localTrivAt b).baseSet :=
Z.toFiberBundleCore.mem_localTrivAt_baseSet b | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_localTrivAt_baseSet | null |
fiberBundle : FiberBundle F Z.Fiber :=
Z.toFiberBundleCore.fiberBundle | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | fiberBundle | null |
protected trivializationAt : trivializationAt F Z.Fiber b = Z.localTrivAt b := rfl | lemma | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivializationAt | null |
vectorBundle : VectorBundle R F Z.Fiber where
trivialization_linear' := by
rintro _ ⟨i, rfl⟩
apply localTriv.isLinear
continuousOn_coordChange' := by
rintro _ _ ⟨i, rfl⟩ ⟨i', rfl⟩
refine (Z.continuousOn_coordChange i i').congr fun b hb => ?_
ext v
exact Z.localTriv_coordChange_eq i i' hb v | instance | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | vectorBundle | null |
@[continuity]
continuous_proj : Continuous Z.proj :=
Z.toFiberBundleCore.continuous_proj | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuous_proj | The projection on the base of a vector bundle created from core is continuous |
isOpenMap_proj : IsOpenMap Z.proj :=
Z.toFiberBundleCore.isOpenMap_proj
variable {i j}
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | isOpenMap_proj | The projection on the base of a vector bundle created from core is an open map |
localTriv_continuousLinearMapAt {b : B} (hb : b ∈ (Z.localTriv i).baseSet) :
(Z.localTriv i).continuousLinearMapAt R b = Z.coordChange (Z.indexAt b) i b := by
ext1 v
rw [(Z.localTriv i).continuousLinearMapAt_apply R, (Z.localTriv i).coe_linearMapAt_of_mem]
exacts [rfl, hb]
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_continuousLinearMapAt | null |
trivializationAt_continuousLinearMapAt {b₀ b : B}
(hb : b ∈ (trivializationAt F Z.Fiber b₀).baseSet) :
(trivializationAt F Z.Fiber b₀).continuousLinearMapAt R b =
Z.coordChange (Z.indexAt b) (Z.indexAt b₀) b :=
Z.localTriv_continuousLinearMapAt hb
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivializationAt_continuousLinearMapAt | null |
localTriv_symmL {b : B} (hb : b ∈ (Z.localTriv i).baseSet) :
(Z.localTriv i).symmL R b = Z.coordChange i (Z.indexAt b) b := by
ext1 v
rw [(Z.localTriv i).symmL_apply R, (Z.localTriv i).symm_apply]
exacts [rfl, hb]
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | localTriv_symmL | null |
trivializationAt_symmL {b₀ b : B} (hb : b ∈ (trivializationAt F Z.Fiber b₀).baseSet) :
(trivializationAt F Z.Fiber b₀).symmL R b = Z.coordChange (Z.indexAt b₀) (Z.indexAt b) b :=
Z.localTriv_symmL hb
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivializationAt_symmL | null |
trivializationAt_coordChange_eq {b₀ b₁ b : B}
(hb : b ∈ (trivializationAt F Z.Fiber b₀).baseSet ∩ (trivializationAt F Z.Fiber b₁).baseSet)
(v : F) :
(trivializationAt F Z.Fiber b₀).coordChangeL R (trivializationAt F Z.Fiber b₁) b v =
Z.coordChange (Z.indexAt b₀) (Z.indexAt b₁) b v :=
Z.localTriv_coordChange_eq _ _ hb v | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivializationAt_coordChange_eq | null |
VectorPrebundle where
pretrivializationAtlas : Set (Pretrivialization F (π F E))
pretrivialization_linear' : ∀ e, e ∈ pretrivializationAtlas → e.IsLinear R
pretrivializationAt : B → Pretrivialization F (π F E)
mem_base_pretrivializationAt : ∀ x : B, x ∈ (pretrivializationAt x).baseSet
pretrivialization_mem_atlas : ∀ x : B, pretrivializationAt x ∈ pretrivializationAtlas
exists_coordChange : ∀ᵉ (e ∈ pretrivializationAtlas) (e' ∈ pretrivializationAtlas),
∃ f : B → F →L[R] F, ContinuousOn f (e.baseSet ∩ e'.baseSet) ∧
∀ᵉ (b ∈ e.baseSet ∩ e'.baseSet) (v : F), f b v = (e' ⟨b, e.symm b v⟩).2
totalSpaceMk_isInducing : ∀ b : B, IsInducing (pretrivializationAt b ∘ .mk b) | structure | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | VectorPrebundle | This structure permits to define a vector bundle when trivializations are given as local
equivalences but there is not yet a topology on the total space or the fibers.
The total space is hence given a topology in such a way that there is a fiber bundle structure for
which the partial equivalences are also open partial homeomorphisms and hence vector bundle
trivializations. The topology on the fibers is induced from the one on the total space.
The field `exists_coordChange` is stated as an existential statement (instead of 3 separate
fields), since it depends on propositional information (namely `e e' ∈ pretrivializationAtlas`).
This makes it inconvenient to explicitly define a `coordChange` function when constructing a
`VectorPrebundle`. |
coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
(he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) (b : B) : F →L[R] F :=
Classical.choose (a.exists_coordChange e he e' he') b | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | coordChange | A randomly chosen coordinate change on a `VectorPrebundle`, given by
the field `exists_coordChange`. |
continuousOn_coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
(he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) :
ContinuousOn (a.coordChange he he') (e.baseSet ∩ e'.baseSet) :=
(Classical.choose_spec (a.exists_coordChange e he e' he')).1 | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuousOn_coordChange | null |
coordChange_apply (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
(he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
(hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
a.coordChange he he' b v = (e' ⟨b, e.symm b v⟩).2 :=
(Classical.choose_spec (a.exists_coordChange e he e' he')).2 b hb v | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | coordChange_apply | null |
mk_coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
(he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
(hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
(b, a.coordChange he he' b v) = e' ⟨b, e.symm b v⟩ := by
ext
· rw [e.mk_symm hb.1 v, e'.coe_fst', e.proj_symm_apply' hb.1]
rw [e.proj_symm_apply' hb.1]
exact hb.2
· exact a.coordChange_apply he he' hb v | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mk_coordChange | null |
toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
{ a with
continuous_trivChange := fun e he e' he' ↦ by
have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
isBoundedBilinearMap_apply.continuous.comp_continuousOn
((a.continuousOn_coordChange he' he).prodMap continuousOn_id)
rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
refine (continuousOn_fst.prodMk this).congr ?_
rintro ⟨b, f⟩ ⟨hb, -⟩
dsimp only [Function.comp_def, Prod.map]
rw [a.mk_coordChange _ _ hb, e'.mk_symm hb.1] } | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | toFiberPrebundle | Natural identification of `VectorPrebundle` as a `FiberPrebundle`. |
totalSpaceTopology (a : VectorPrebundle R F E) : TopologicalSpace (TotalSpace F E) :=
a.toFiberPrebundle.totalSpaceTopology | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | totalSpaceTopology | Topology on the total space that will make the prebundle into a bundle. |
trivializationOfMemPretrivializationAtlas (a : VectorPrebundle R F E)
{e : Pretrivialization F (π F E)} (he : e ∈ a.pretrivializationAtlas) :
@Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
a.toFiberPrebundle.trivializationOfMemPretrivializationAtlas he | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | trivializationOfMemPretrivializationAtlas | Promotion from a `Pretrivialization` in the `pretrivializationAtlas` of a
`VectorPrebundle` to a `Trivialization`. |
linear_trivializationOfMemPretrivializationAtlas (a : VectorPrebundle R F E)
{e : Pretrivialization F (π F E)} (he : e ∈ a.pretrivializationAtlas) :
letI := a.totalSpaceTopology
Trivialization.IsLinear R (trivializationOfMemPretrivializationAtlas a he) :=
letI := a.totalSpaceTopology
{ linear := (a.pretrivialization_linear' e he).linear }
variable (a : VectorPrebundle R F E) | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | linear_trivializationOfMemPretrivializationAtlas | null |
mem_trivialization_at_source (b : B) (x : E b) :
⟨b, x⟩ ∈ (a.pretrivializationAt b).source :=
a.toFiberPrebundle.mem_pretrivializationAt_source b x
@[simp] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | mem_trivialization_at_source | null |
totalSpaceMk_preimage_source (b : B) :
.mk b ⁻¹' (a.pretrivializationAt b).source = univ :=
a.toFiberPrebundle.totalSpaceMk_preimage_source b
@[continuity] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | totalSpaceMk_preimage_source | null |
continuous_totalSpaceMk (b : B) :
Continuous[_, a.totalSpaceTopology] (.mk b) :=
a.toFiberPrebundle.continuous_totalSpaceMk b | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | continuous_totalSpaceMk | null |
toFiberBundle : @FiberBundle B F _ _ _ a.totalSpaceTopology _ :=
a.toFiberPrebundle.toFiberBundle | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | toFiberBundle | Make a `FiberBundle` from a `VectorPrebundle`; auxiliary construction for
`VectorPrebundle.toVectorBundle`. |
toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
letI := a.totalSpaceTopology; letI := a.toFiberBundle
{ trivialization_linear' := by
rintro _ ⟨e, he, rfl⟩
apply linear_trivializationOfMemPretrivializationAtlas
continuousOn_coordChange' := by
rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
ext v
haveI h₁ := a.linear_trivializationOfMemPretrivializationAtlas he
haveI h₂ := a.linear_trivializationOfMemPretrivializationAtlas he'
rw [trivializationOfMemPretrivializationAtlas] at h₁ h₂
rw [a.coordChange_apply he he' hb v, ContinuousLinearEquiv.coe_coe,
Trivialization.coordChangeL_apply]
exacts [rfl, hb] } | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | toVectorBundle | Make a `VectorBundle` from a `VectorPrebundle`. Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). |
inCoordinates (x₀ x : B) (y₀ y : B') (ϕ : E x →SL[σ] E' y) : F →SL[σ] F' :=
((trivializationAt F' E' y₀).continuousLinearMapAt 𝕜₂ y).comp <|
ϕ.comp <| (trivializationAt F E x₀).symmL 𝕜₁ x
variable {E E' F F'} | def | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | inCoordinates | When `ϕ` is a continuous (semi)linear map between the fibers `E x` and `E' y` of two vector
bundles `E` and `E'`, `ContinuousLinearMap.inCoordinates F E F' E' x₀ x y₀ y ϕ` is a coordinate
change of this continuous linear map w.r.t. the chart around `x₀` and the chart around `y₀`.
It is defined by composing `ϕ` with appropriate coordinate changes given by the vector bundles
`E` and `E'`.
We use the operations `Trivialization.continuousLinearMapAt` and `Trivialization.symmL` in the
definition, instead of `Trivialization.continuousLinearEquivAt`, so that
`ContinuousLinearMap.inCoordinates` is defined everywhere (but see
`ContinuousLinearMap.inCoordinates_eq`).
This is the (second component of the) underlying function of a trivialization of the hom-bundle
(see `hom_trivializationAt_apply`). However, note that `ContinuousLinearMap.inCoordinates` is
defined even when `x` and `y` live in different base sets.
Therefore, it is also convenient when working with the hom-bundle between pulled back bundles. |
inCoordinates_eq {x₀ x : B} {y₀ y : B'} {ϕ : E x →SL[σ] E' y}
(hx : x ∈ (trivializationAt F E x₀).baseSet) (hy : y ∈ (trivializationAt F' E' y₀).baseSet) :
inCoordinates F E F' E' x₀ x y₀ y ϕ =
((trivializationAt F' E' y₀).continuousLinearEquivAt 𝕜₂ y hy : E' y →L[𝕜₂] F').comp
(ϕ.comp <|
(((trivializationAt F E x₀).continuousLinearEquivAt 𝕜₁ x hx).symm : F →L[𝕜₁] E x)) := by
ext
simp_rw [inCoordinates, ContinuousLinearMap.coe_comp', ContinuousLinearEquiv.coe_coe,
Trivialization.coe_continuousLinearEquivAt_eq, Trivialization.symm_continuousLinearEquivAt_eq] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | inCoordinates_eq | Rewrite `ContinuousLinearMap.inCoordinates` using continuous linear equivalences. |
protected _root_.VectorBundleCore.inCoordinates_eq {ι ι'} (Z : VectorBundleCore 𝕜₁ B F ι)
(Z' : VectorBundleCore 𝕜₂ B' F' ι') {x₀ x : B} {y₀ y : B'} (ϕ : F →SL[σ] F')
(hx : x ∈ Z.baseSet (Z.indexAt x₀)) (hy : y ∈ Z'.baseSet (Z'.indexAt y₀)) :
inCoordinates F Z.Fiber F' Z'.Fiber x₀ x y₀ y ϕ =
(Z'.coordChange (Z'.indexAt y) (Z'.indexAt y₀) y).comp
(ϕ.comp <| Z.coordChange (Z.indexAt x₀) (Z.indexAt x) x) := by
simp_rw [inCoordinates, Z'.trivializationAt_continuousLinearMapAt hy,
Z.trivializationAt_symmL hx] | theorem | Topology | [
"Mathlib.Analysis.Normed.Operator.BoundedLinearMaps",
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/VectorBundle/Basic.lean | _root_.VectorBundleCore.inCoordinates_eq | Rewrite `ContinuousLinearMap.inCoordinates` in a `VectorBundleCore`. |
trivialization.isLinear : (trivialization B F).IsLinear 𝕜 where
linear _ _ := ⟨fun _ _ => rfl, fun _ _ => rfl⟩
variable {𝕜} in | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | trivialization.isLinear | null |
trivialization.coordChangeL (b : B) :
(trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
ContinuousLinearEquiv.refl 𝕜 F := by
ext v
rw [Trivialization.coordChangeL_apply']
exacts [rfl, ⟨mem_univ _, mem_univ _⟩] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | trivialization.coordChangeL | null |
vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) where
trivialization_linear' e he := by
rw [eq_trivialization B F e]
infer_instance
continuousOn_coordChange' e e' he he' := by
obtain rfl := eq_trivialization B F e
obtain rfl := eq_trivialization B F e'
simp only [trivialization.coordChangeL]
exact continuous_const.continuousOn
@[simp] lemma linearMapAt_trivialization (x : B) :
(trivialization B F).linearMapAt 𝕜 x = LinearMap.id := by
ext v
rw [Trivialization.coe_linearMapAt_of_mem _ (by simp)]
rfl
@[simp] lemma continuousLinearMapAt_trivialization (x : B) :
(trivialization B F).continuousLinearMapAt 𝕜 x = ContinuousLinearMap.id 𝕜 F := by
ext; simp
@[simp] lemma symmₗ_trivialization (x : B) :
(trivialization B F).symmₗ 𝕜 x = LinearMap.id := by
ext; simp [Trivialization.coe_symmₗ, trivialization_symm_apply B F]
@[simp] lemma symmL_trivialization (x : B) :
(trivialization B F).symmL 𝕜 x = ContinuousLinearMap.id 𝕜 F := by
ext; simp [trivialization_symm_apply B F]
@[simp] lemma continuousLinearEquivAt_trivialization (x : B) :
(trivialization B F).continuousLinearEquivAt 𝕜 x (mem_univ _) =
ContinuousLinearEquiv.refl 𝕜 F := by
ext; simp | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | vectorBundle | null |
prod.isLinear [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] : (e₁.prod e₂).IsLinear 𝕜 where
linear := fun _ ⟨h₁, h₂⟩ =>
(((e₁.linear 𝕜 h₁).mk' _).prodMap ((e₂.linear 𝕜 h₂).mk' _)).isLinear
@[simp] | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | prod.isLinear | null |
coordChangeL_prod [e₁.IsLinear 𝕜] [e₁'.IsLinear 𝕜] [e₂.IsLinear 𝕜] [e₂'.IsLinear 𝕜] ⦃b⦄
(hb : (b ∈ e₁.baseSet ∧ b ∈ e₂.baseSet) ∧ b ∈ e₁'.baseSet ∧ b ∈ e₂'.baseSet) :
((e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b : F₁ × F₂ →L[𝕜] F₁ × F₂) =
(e₁.coordChangeL 𝕜 e₁' b : F₁ →L[𝕜] F₁).prodMap (e₂.coordChangeL 𝕜 e₂' b) := by
rw [ContinuousLinearMap.ext_iff, ContinuousLinearMap.coe_prodMap']
rintro ⟨v₁, v₂⟩
change
(e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b (v₁, v₂) =
(e₁.coordChangeL 𝕜 e₁' b v₁, e₂.coordChangeL 𝕜 e₂' b v₂)
rw [e₁.coordChangeL_apply e₁', e₂.coordChangeL_apply e₂', (e₁.prod e₂).coordChangeL_apply']
exacts [rfl, hb, ⟨hb.1.2, hb.2.2⟩, ⟨hb.1.1, hb.2.1⟩]
variable {e₁ e₂} [∀ x : B, TopologicalSpace (E₁ x)] [∀ x : B, TopologicalSpace (E₂ x)]
[FiberBundle F₁ E₁] [FiberBundle F₂ E₂] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | coordChangeL_prod | null |
prod_apply' [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] {x : B} (hx₁ : x ∈ e₁.baseSet)
(hx₂ : x ∈ e₂.baseSet) (v₁ : E₁ x) (v₂ : E₂ x) :
prod e₁ e₂ ⟨x, (v₁, v₂)⟩ =
⟨x, e₁.continuousLinearEquivAt 𝕜 x hx₁ v₁, e₂.continuousLinearEquivAt 𝕜 x hx₂ v₂⟩ :=
rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | prod_apply' | null |
VectorBundle.prod [VectorBundle 𝕜 F₁ E₁] [VectorBundle 𝕜 F₂ E₂] :
VectorBundle 𝕜 (F₁ × F₂) (E₁ ×ᵇ E₂) where
trivialization_linear' := by
rintro _ ⟨e₁, e₂, he₁, he₂, rfl⟩
infer_instance
continuousOn_coordChange' := by
rintro _ _ ⟨e₁, e₂, he₁, he₂, rfl⟩ ⟨e₁', e₂', he₁', he₂', rfl⟩
refine (((continuousOn_coordChange 𝕜 e₁ e₁').mono ?_).prod_mapL 𝕜
((continuousOn_coordChange 𝕜 e₂ e₂').mono ?_)).congr ?_ <;>
dsimp only [prod_baseSet, mfld_simps]
· mfld_set_tac
· mfld_set_tac
· rintro b hb
rw [ContinuousLinearMap.ext_iff]
rintro ⟨v₁, v₂⟩
change (e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b (v₁, v₂) =
(e₁.coordChangeL 𝕜 e₁' b v₁, e₂.coordChangeL 𝕜 e₂' b v₂)
rw [e₁.coordChangeL_apply e₁', e₂.coordChangeL_apply e₂', (e₁.prod e₂).coordChangeL_apply']
exacts [rfl, hb, ⟨hb.1.2, hb.2.2⟩, ⟨hb.1.1, hb.2.1⟩]
variable {𝕜 F₁ E₁ F₂ E₂}
@[simp] | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | VectorBundle.prod | The product of two vector bundles is a vector bundle. |
Trivialization.continuousLinearEquivAt_prod {e₁ : Trivialization F₁ (π F₁ E₁)}
{e₂ : Trivialization F₂ (π F₂ E₂)} [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] {x : B}
(hx : x ∈ (e₁.prod e₂).baseSet) :
(e₁.prod e₂).continuousLinearEquivAt 𝕜 x hx =
(e₁.continuousLinearEquivAt 𝕜 x hx.1).prodCongr (e₂.continuousLinearEquivAt 𝕜 x hx.2) := by
ext v : 2
obtain ⟨v₁, v₂⟩ := v
rw [(e₁.prod e₂).continuousLinearEquivAt_apply 𝕜, Trivialization.prod]
exact (congr_arg Prod.snd (prod_apply' 𝕜 hx.1 hx.2 v₁ v₂) :) | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | Trivialization.continuousLinearEquivAt_prod | null |
Trivialization.pullback_linear (e : Trivialization F (π F E)) [e.IsLinear 𝕜] (f : K) :
(Trivialization.pullback (B' := B') e f).IsLinear 𝕜 where
linear _ h := e.linear 𝕜 h | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | Trivialization.pullback_linear | null |
VectorBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E] [VectorBundle 𝕜 F E]
(f : K) : VectorBundle 𝕜 F ((f : B' → B) *ᵖ E) where
trivialization_linear' := by
rintro _ ⟨e, he, rfl⟩
infer_instance
continuousOn_coordChange' := by
rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
refine ((continuousOn_coordChange 𝕜 e e').comp
(map_continuous f).continuousOn fun b hb => hb).congr ?_
rintro b (hb : f b ∈ e.baseSet ∩ e'.baseSet); ext v
change ((e.pullback f).coordChangeL 𝕜 (e'.pullback f) b) v = (e.coordChangeL 𝕜 e' (f b)) v
rw [e.coordChangeL_apply e' hb, (e.pullback f).coordChangeL_apply' _]
exacts [rfl, hb] | instance | Topology | [
"Mathlib.Topology.FiberBundle.Constructions",
"Mathlib.Topology.VectorBundle.Basic",
"Mathlib.Analysis.Normed.Operator.Prod"
] | Mathlib/Topology/VectorBundle/Constructions.lean | VectorBundle.pullback | null |
continuousLinearMapCoordChange [e₁.IsLinear 𝕜₁] [e₁'.IsLinear 𝕜₁] [e₂.IsLinear 𝕜₂]
[e₂'.IsLinear 𝕜₂] (b : B) : (F₁ →SL[σ] F₂) →L[𝕜₂] F₁ →SL[σ] F₂ :=
((e₁'.coordChangeL 𝕜₁ e₁ b).symm.arrowCongrSL (e₂.coordChangeL 𝕜₂ e₂' b) :
(F₁ →SL[σ] F₂) ≃L[𝕜₂] F₁ →SL[σ] F₂)
variable {σ e₁ e₁' e₂ e₂'}
variable [∀ x, TopologicalSpace (E₁ x)] [FiberBundle F₁ E₁]
variable [∀ x, TopologicalSpace (E₂ x)] [FiberBundle F₂ E₂] | def | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMapCoordChange | A reducible type synonym for the bundle of continuous (semi)linear maps. -/
@[deprecated "Use the plain bundle syntax `fun (b : B) ↦ E₁ b →SL[σ] E₂ b` or
`fun (b : B) ↦ E₁ b →L[𝕜] E₂ b` instead" (since := "2025-06-12")]
protected abbrev Bundle.ContinuousLinearMap [∀ x, TopologicalSpace (E₁ x)]
[∀ x, TopologicalSpace (E₂ x)] : B → Type _ := fun x ↦ E₁ x →SL[σ] E₂ x
variable {E₁ E₂}
variable [TopologicalSpace B] (e₁ e₁' : Trivialization F₁ (π F₁ E₁))
(e₂ e₂' : Trivialization F₂ (π F₂ E₂))
namespace Pretrivialization
/-- Assume `eᵢ` and `eᵢ'` are trivializations of the bundles `Eᵢ` over base `B` with fiber `Fᵢ`
(`i ∈ {1,2}`), then `Pretrivialization.continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂'` is the
coordinate change function between the two induced (pre)trivializations
`Pretrivialization.continuousLinearMap σ e₁ e₂` and
`Pretrivialization.continuousLinearMap σ e₁' e₂'` of the bundle of continuous linear maps. |
continuousOn_continuousLinearMapCoordChange [RingHomIsometric σ]
[VectorBundle 𝕜₁ F₁ E₁] [VectorBundle 𝕜₂ F₂ E₂]
[MemTrivializationAtlas e₁] [MemTrivializationAtlas e₁'] [MemTrivializationAtlas e₂]
[MemTrivializationAtlas e₂'] :
ContinuousOn (continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂')
(e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet)) := by
have h₁ := (compSL F₁ F₂ F₂ σ (RingHom.id 𝕜₂)).continuous
have h₂ := (ContinuousLinearMap.flip (compSL F₁ F₁ F₂ (RingHom.id 𝕜₁) σ)).continuous
have h₃ := continuousOn_coordChange 𝕜₁ e₁' e₁
have h₄ := continuousOn_coordChange 𝕜₂ e₂ e₂'
refine ((h₁.comp_continuousOn (h₄.mono ?_)).clm_comp (h₂.comp_continuousOn (h₃.mono ?_))).congr ?_
· mfld_set_tac
· mfld_set_tac
· intro b _
ext L v
dsimp [continuousLinearMapCoordChange]
variable (σ e₁ e₁' e₂ e₂')
variable [e₁.IsLinear 𝕜₁] [e₁'.IsLinear 𝕜₁] [e₂.IsLinear 𝕜₂] [e₂'.IsLinear 𝕜₂] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousOn_continuousLinearMapCoordChange | null |
continuousLinearMap :
Pretrivialization (F₁ →SL[σ] F₂) (π (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) where
toFun p := ⟨p.1, .comp (e₂.continuousLinearMapAt 𝕜₂ p.1) (p.2.comp (e₁.symmL 𝕜₁ p.1))⟩
invFun p := ⟨p.1, .comp (e₂.symmL 𝕜₂ p.1) (p.2.comp (e₁.continuousLinearMapAt 𝕜₁ p.1))⟩
source := Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ
map_source' := fun ⟨_, _⟩ h ↦ ⟨h, Set.mem_univ _⟩
map_target' := fun ⟨_, _⟩ h ↦ h.1
left_inv' := fun ⟨x, L⟩ ⟨h₁, h₂⟩ ↦ by
simp only [TotalSpace.mk_inj]
ext (v : E₁ x)
dsimp only [comp_apply]
rw [Trivialization.symmL_continuousLinearMapAt, Trivialization.symmL_continuousLinearMapAt]
exacts [h₁, h₂]
right_inv' := fun ⟨x, f⟩ ⟨⟨h₁, h₂⟩, _⟩ ↦ by
simp only [Prod.mk_right_inj]
ext v
dsimp only [comp_apply]
rw [Trivialization.continuousLinearMapAt_symmL, Trivialization.continuousLinearMapAt_symmL]
exacts [h₁, h₂]
open_target := (e₁.open_baseSet.inter e₂.open_baseSet).prod isOpen_univ
baseSet := e₁.baseSet ∩ e₂.baseSet
open_baseSet := e₁.open_baseSet.inter e₂.open_baseSet
source_eq := rfl
target_eq := rfl
proj_toFun _ _ := rfl | def | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMap | Given trivializations `e₁`, `e₂` for vector bundles `E₁`, `E₂` over a base `B`,
`Pretrivialization.continuousLinearMap σ e₁ e₂` is the induced pretrivialization for the
continuous `σ`-semilinear maps from `E₁` to `E₂`. That is, the map which will later become a
trivialization, after the bundle of continuous semilinear maps is equipped with the right
topological vector bundle structure. |
continuousLinearMap.isLinear [∀ x, ContinuousAdd (E₂ x)] [∀ x, ContinuousSMul 𝕜₂ (E₂ x)] :
(Pretrivialization.continuousLinearMap σ e₁ e₂).IsLinear 𝕜₂ where
linear x _ :=
{ map_add := fun L L' ↦
show (e₂.continuousLinearMapAt 𝕜₂ x).comp ((L + L').comp (e₁.symmL 𝕜₁ x)) = _ by
simp_rw [add_comp, comp_add]
rfl
map_smul := fun c L ↦
show (e₂.continuousLinearMapAt 𝕜₂ x).comp ((c • L).comp (e₁.symmL 𝕜₁ x)) = _ by
simp_rw [smul_comp, comp_smulₛₗ, RingHom.id_apply]
rfl } | instance | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMap.isLinear | null |
continuousLinearMap_apply (p : TotalSpace (F₁ →SL[σ] F₂) fun x ↦ E₁ x →SL[σ] E₂ x) :
(continuousLinearMap σ e₁ e₂) p =
⟨p.1, .comp (e₂.continuousLinearMapAt 𝕜₂ p.1) (p.2.comp (e₁.symmL 𝕜₁ p.1))⟩ :=
rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMap_apply | null |
continuousLinearMap_symm_apply (p : B × (F₁ →SL[σ] F₂)) :
(continuousLinearMap σ e₁ e₂).toPartialEquiv.symm p =
⟨p.1, .comp (e₂.symmL 𝕜₂ p.1) (p.2.comp (e₁.continuousLinearMapAt 𝕜₁ p.1))⟩ :=
rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMap_symm_apply | null |
continuousLinearMap_symm_apply' {b : B} (hb : b ∈ e₁.baseSet ∩ e₂.baseSet)
(L : F₁ →SL[σ] F₂) :
(continuousLinearMap σ e₁ e₂).symm b L =
(e₂.symmL 𝕜₂ b).comp (L.comp <| e₁.continuousLinearMapAt 𝕜₁ b) := by
rw [symm_apply]
· rfl
· exact hb | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMap_symm_apply' | null |
continuousLinearMapCoordChange_apply (b : B)
(hb : b ∈ e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet)) (L : F₁ →SL[σ] F₂) :
continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂' b L =
(continuousLinearMap σ e₁' e₂' ⟨b, (continuousLinearMap σ e₁ e₂).symm b L⟩).2 := by
ext v
simp_rw [continuousLinearMapCoordChange, ContinuousLinearEquiv.coe_coe,
ContinuousLinearEquiv.arrowCongrSL_apply, continuousLinearMap_apply,
continuousLinearMap_symm_apply' σ e₁ e₂ hb.1, comp_apply, ContinuousLinearEquiv.coe_coe,
ContinuousLinearEquiv.symm_symm, Trivialization.continuousLinearMapAt_apply,
Trivialization.symmL_apply]
rw [e₂.coordChangeL_apply e₂', e₁'.coordChangeL_apply e₁, e₁.coe_linearMapAt_of_mem hb.1.1,
e₂'.coe_linearMapAt_of_mem hb.2.2]
exacts [⟨hb.2.1, hb.1.1⟩, ⟨hb.1.2, hb.2.2⟩] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousLinearMapCoordChange_apply | null |
Bundle.ContinuousLinearMap.vectorPrebundle :
VectorPrebundle 𝕜₂ (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) where
pretrivializationAtlas :=
{e | ∃ (e₁ : Trivialization F₁ (π F₁ E₁)) (e₂ : Trivialization F₂ (π F₂ E₂))
(_ : MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂),
e = Pretrivialization.continuousLinearMap σ e₁ e₂}
pretrivialization_linear' := by
rintro _ ⟨e₁, he₁, e₂, he₂, rfl⟩
infer_instance
pretrivializationAt x :=
Pretrivialization.continuousLinearMap σ (trivializationAt F₁ E₁ x) (trivializationAt F₂ E₂ x)
mem_base_pretrivializationAt x :=
⟨mem_baseSet_trivializationAt F₁ E₁ x, mem_baseSet_trivializationAt F₂ E₂ x⟩
pretrivialization_mem_atlas x :=
⟨trivializationAt F₁ E₁ x, trivializationAt F₂ E₂ x, inferInstance, inferInstance, rfl⟩
exists_coordChange := by
rintro _ ⟨e₁, e₂, he₁, he₂, rfl⟩ _ ⟨e₁', e₂', he₁', he₂', rfl⟩
exact ⟨continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂',
continuousOn_continuousLinearMapCoordChange,
continuousLinearMapCoordChange_apply σ e₁ e₁' e₂ e₂'⟩
totalSpaceMk_isInducing := by
intro b
let L₁ : E₁ b ≃L[𝕜₁] F₁ :=
(trivializationAt F₁ E₁ b).continuousLinearEquivAt 𝕜₁ b
(mem_baseSet_trivializationAt _ _ _)
let L₂ : E₂ b ≃L[𝕜₂] F₂ :=
(trivializationAt F₂ E₂ b).continuousLinearEquivAt 𝕜₂ b
(mem_baseSet_trivializationAt _ _ _)
let φ : (E₁ b →SL[σ] E₂ b) ≃L[𝕜₂] F₁ →SL[σ] F₂ := L₁.arrowCongrSL L₂
have : IsInducing fun x ↦ (b, φ x) := isInducing_const_prod.mpr φ.toHomeomorph.isInducing
convert this
ext f
dsimp [Pretrivialization.continuousLinearMap_apply]
rw [Trivialization.linearMapAt_def_of_mem _ (mem_baseSet_trivializationAt _ _ _)]
rfl | def | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Bundle.ContinuousLinearMap.vectorPrebundle | The continuous `σ`-semilinear maps between two topological vector bundles form a
`VectorPrebundle` (this is an auxiliary construction for the
`VectorBundle` instance, in which the pretrivializations are collated but no topology
on the total space is yet provided). |
Bundle.ContinuousLinearMap.topologicalSpaceTotalSpace :
TopologicalSpace (TotalSpace (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) :=
(Bundle.ContinuousLinearMap.vectorPrebundle σ F₁ E₁ F₂ E₂).totalSpaceTopology | instance | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Bundle.ContinuousLinearMap.topologicalSpaceTotalSpace | Topology on the total space of the continuous `σ`-semilinear maps between two "normable" vector
bundles over the same base. |
Bundle.ContinuousLinearMap.fiberBundle :
FiberBundle (F₁ →SL[σ] F₂) fun x ↦ E₁ x →SL[σ] E₂ x :=
(Bundle.ContinuousLinearMap.vectorPrebundle σ F₁ E₁ F₂ E₂).toFiberBundle | instance | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Bundle.ContinuousLinearMap.fiberBundle | The continuous `σ`-semilinear maps between two vector bundles form a fiber bundle. |
Bundle.ContinuousLinearMap.vectorBundle :
VectorBundle 𝕜₂ (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) :=
(Bundle.ContinuousLinearMap.vectorPrebundle σ F₁ E₁ F₂ E₂).toVectorBundle
variable [he₁ : MemTrivializationAtlas e₁] [he₂ : MemTrivializationAtlas e₂] {F₁ E₁ F₂ E₂} | instance | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Bundle.ContinuousLinearMap.vectorBundle | The continuous `σ`-semilinear maps between two vector bundles form a vector bundle. |
Trivialization.continuousLinearMap :
Trivialization (F₁ →SL[σ] F₂) (π (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) :=
VectorPrebundle.trivializationOfMemPretrivializationAtlas _ ⟨e₁, e₂, he₁, he₂, rfl⟩ | def | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Trivialization.continuousLinearMap | Given trivializations `e₁`, `e₂` in the atlas for vector bundles `E₁`, `E₂` over a base `B`,
the induced trivialization for the continuous `σ`-semilinear maps from `E₁` to `E₂`,
whose base set is `e₁.baseSet ∩ e₂.baseSet`. |
Bundle.ContinuousLinearMap.memTrivializationAtlas :
MemTrivializationAtlas
(e₁.continuousLinearMap σ e₂ :
Trivialization (F₁ →SL[σ] F₂) (π (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x))) where
out := ⟨_, ⟨e₁, e₂, by infer_instance, by infer_instance, rfl⟩, rfl⟩
variable {e₁ e₂}
@[simp] | instance | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Bundle.ContinuousLinearMap.memTrivializationAtlas | null |
Trivialization.baseSet_continuousLinearMap :
(e₁.continuousLinearMap σ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet :=
rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Trivialization.baseSet_continuousLinearMap | null |
Trivialization.continuousLinearMap_apply
(p : TotalSpace (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) :
e₁.continuousLinearMap σ e₂ p =
⟨p.1, (e₂.continuousLinearMapAt 𝕜₂ p.1 : _ →L[𝕜₂] _).comp
(p.2.comp (e₁.symmL 𝕜₁ p.1 : F₁ →L[𝕜₁] E₁ p.1) : F₁ →SL[σ] E₂ p.1)⟩ :=
rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Trivialization.continuousLinearMap_apply | null |
hom_trivializationAt (x₀ : B) :
trivializationAt (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) x₀ =
(trivializationAt F₁ E₁ x₀).continuousLinearMap σ (trivializationAt F₂ E₂ x₀) := rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | hom_trivializationAt | null |
hom_trivializationAt_apply (x₀ : B)
(x : TotalSpace (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) :
trivializationAt (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) x₀ x =
⟨x.1, inCoordinates F₁ E₁ F₂ E₂ x₀ x.1 x₀ x.1 x.2⟩ :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | hom_trivializationAt_apply | null |
hom_trivializationAt_source (x₀ : B) :
(trivializationAt (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) x₀).source =
π (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) ⁻¹'
((trivializationAt F₁ E₁ x₀).baseSet ∩ (trivializationAt F₂ E₂ x₀).baseSet) :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | hom_trivializationAt_source | null |
hom_trivializationAt_target (x₀ : B) :
(trivializationAt (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) x₀).target =
((trivializationAt F₁ E₁ x₀).baseSet ∩ (trivializationAt F₂ E₂ x₀).baseSet) ×ˢ Set.univ :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | hom_trivializationAt_target | null |
hom_trivializationAt_baseSet (x₀ : B) :
(trivializationAt (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x) x₀).baseSet =
((trivializationAt F₁ E₁ x₀).baseSet ∩ (trivializationAt F₂ E₂ x₀).baseSet) :=
rfl | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | hom_trivializationAt_baseSet | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.