File: Mathlib/Topology/VectorBundle/Constructions.lean

full_name: Bundle.Trivial.trivialization.isLinear
code: instance trivialization.isLinear : (trivialization B F).IsLinear 𝕜 
goal: Trivialization.IsLinear 𝕜 (Bundle.Trivial.trivialization B F)

full_name: Bundle.Trivial.trivialization.coordChangeL
code: theorem trivialization.coordChangeL (b : B) :
    (trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
      ContinuousLinearEquiv.refl 𝕜 F 
goal: Trivialization.coordChangeL 𝕜 (Bundle.Trivial.trivialization B F) (Bundle.Trivial.trivialization B F) b =
  ContinuousLinearEquiv.refl 𝕜 F

full_name: Bundle.Trivial.vectorBundle
code: instance vectorBundle : VectorBundle 𝕜 F (Bundle.Trivial B F) 
goal: VectorBundle 𝕜 F (Bundle.Trivial B F)

full_name: Trivialization.prod.isLinear
code: instance prod.isLinear [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] : (e₁.prod e₂).IsLinear 𝕜 
goal: Trivialization.IsLinear 𝕜 (e₁.prod e₂)

full_name: Trivialization.coordChangeL_prod
code: @[simp]
theorem coordChangeL_prod [e₁.IsLinear 𝕜] [e₁'.IsLinear 𝕜] [e₂.IsLinear 𝕜] [e₂'.IsLinear 𝕜] ⦃b⦄
    (hb : b ∈ (e₁.prod e₂).baseSet ∩ (e₁'.prod 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) 
goal: ↑(Trivialization.coordChangeL 𝕜 (e₁.prod e₂) (e₁'.prod e₂') b) =
  (↑(Trivialization.coordChangeL 𝕜 e₁ e₁' b)).prodMap ↑(Trivialization.coordChangeL 𝕜 e₂ e₂' b)

full_name: Trivialization.prod_apply
code: theorem 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₂⟩ 
goal: ↑(e₁.prod e₂) { proj := x, snd := (v₁, v₂) } =
  (x, (Trivialization.continuousLinearEquivAt 𝕜 e₁ x hx₁) v₁, (Trivialization.continuousLinearEquivAt 𝕜 e₂ x hx₂) v₂)

full_name: VectorBundle.prod
code: /-- The product of two vector bundles is a vector bundle. -/
instance VectorBundle.prod [VectorBundle 𝕜 F₁ E₁] [VectorBundle 𝕜 F₂ E₂] :
    VectorBundle 𝕜 (F₁ × F₂) (E₁ ×ᵇ E₂) 
goal: VectorBundle 𝕜 (F₁ × F₂) fun x => E₁ x × E₂ x

full_name: Trivialization.continuousLinearEquivAt_prod
code: @[simp] -- Porting note: changed arguments to make `simpNF` happy: merged `hx₁` and `hx₂` into `hx`
theorem 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).prod (e₂.continuousLinearEquivAt 𝕜 x hx.2) 
goal: Trivialization.continuousLinearEquivAt 𝕜 (e₁.prod e₂) x hx =
  (Trivialization.continuousLinearEquivAt 𝕜 e₁ x ⋯).prod (Trivialization.continuousLinearEquivAt 𝕜 e₂ x ⋯)

full_name: instAddCommMonoidPullback
code: instance [i : ∀ x : B, AddCommMonoid (E x)] (x : B') : AddCommMonoid ((f *ᵖ E) x) 
goal: AddCommMonoid ((f *ᵖ E) x)

full_name: instModulePullback
code: instance [Semiring R] [∀ x : B, AddCommMonoid (E x)] [i : ∀ x, Module R (E x)] (x : B') :
    Module R ((f *ᵖ E) x) 
goal: Module R ((f *ᵖ E) x)

full_name: Trivialization.pullback_linear
code: instance Trivialization.pullback_linear (e : Trivialization F (π F E)) [e.IsLinear 𝕜] (f : K) :
    (Trivialization.pullback (B' := B') e f).IsLinear 𝕜 
goal: Trivialization.IsLinear 𝕜 (e.pullback f)

full_name: VectorBundle.pullback
code: instance VectorBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E] [VectorBundle 𝕜 F E]
    (f : K) : VectorBundle 𝕜 F ((f : B' → B) *ᵖ E) 
goal: VectorBundle 𝕜 F (⇑f *ᵖ E)