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 ... | 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 expli... | 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 _⟩
app... | 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... | 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, Continuo... | 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
conti... | 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_... | 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_ba... | 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_coo... | 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_at... | 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 ... |
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... | 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', ... | 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
... | 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.pret... | 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 ... | 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
`V... |
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 ap... |
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 <|
... | 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'.coo... | 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.coordChange... | 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₂.coordC... | 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 (((con... | 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₂.continuousLi... | 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 ((cont... | 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, ... | 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, TopologicalSpa... |
continuousOn_continuousLinearMapCoordChange [RingHomIsometric σ]
[VectorBundle 𝕜₁ F₁ E₁] [VectorBundle 𝕜₂ F₂ E₂]
[MemTrivializationAtlas e₁] [MemTrivializationAtlas e₁'] [MemTrivializationAtlas e₂]
[MemTrivializationAtlas e₂'] :
ContinuousOn (continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂')
(e₁.b... | 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.TotalSp... | 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 ... |
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... | 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 [continuousLinearMap... | 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 = Pretriviali... | 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.