File: Mathlib/Topology/FiberBundle/Constructions.lean

full_name: Bundle.Trivial.topologicalSpace
code: instance topologicalSpace [t₁ : TopologicalSpace B]
    [t₂ : TopologicalSpace F] : TopologicalSpace (TotalSpace F (Trivial B F)) 
goal: TopologicalSpace (Bundle.TotalSpace F (Bundle.Trivial B F))

full_name: Bundle.Trivial.inducing_toProd
code: theorem inducing_toProd : Inducing (TotalSpace.toProd B F) 
goal: Inducing ⇑(Bundle.TotalSpace.toProd B F)

full_name: Bundle.Trivial.homeomorphProd
code: /-- Homeomorphism between the total space of the trivial bundle and the Cartesian product. -/
def homeomorphProd : TotalSpace F (Trivial B F) ≃ₜ B × F 
goal: Bundle.TotalSpace F (Bundle.Trivial B F) ≃ₜ B × F

full_name: Bundle.Trivial.trivialization
code: /-- Local trivialization for trivial bundle. -/
def trivialization : Trivialization F (π F (Bundle.Trivial B F)) 
goal: Trivialization F Bundle.TotalSpace.proj

full_name: Bundle.Trivial.trivialization_source
code: @[simp]
theorem trivialization_source : (trivialization B F).source = univ 
goal: (Bundle.Trivial.trivialization B F).source = Set.univ

full_name: Bundle.Trivial.trivialization_target
code: @[simp]
theorem trivialization_target : (trivialization B F).target = univ 
goal: (Bundle.Trivial.trivialization B F).target = Set.univ

full_name: Bundle.Trivial.fiberBundle
code: /-- Fiber bundle instance on the trivial bundle. -/
instance fiberBundle : FiberBundle F (Bundle.Trivial B F) 
goal: FiberBundle F (Bundle.Trivial B F)

full_name: Bundle.Trivial.eq_trivialization
code: theorem eq_trivialization (e : Trivialization F (π F (Bundle.Trivial B F)))
    [i : MemTrivializationAtlas e] : e = trivialization B F 
goal: e = Bundle.Trivial.trivialization B F

full_name: FiberBundle.Prod.topologicalSpace
code: /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
the induced topology from the diagonal embedding into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂`. -/
instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)) 
goal: TopologicalSpace (Bundle.TotalSpace (F₁ × F₂) fun x => E₁ x × E₂ x)

full_name: FiberBundle.Prod.inducing_diag
code: /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
`E₁`, `E₂` into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂` is `Inducing`. -/
theorem FiberBundle.Prod.inducing_diag :
    Inducing (fun p ↦ (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
      TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂) 
goal: Inducing fun p => ({ proj := p.proj, snd := p.snd.1 }, { proj := p.proj, snd := p.snd.2 })

full_name: Trivialization.Prod.toFun'
code: /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
function for the construction `Trivialization.prod`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`. -/
def Prod.toFun' : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → B × F₁ × F₂ 
goal: (Bundle.TotalSpace (F₁ × F₂) fun x => E₁ x × E₂ x) → B × F₁ × F₂

full_name: Trivialization.Prod.continuous_to_fun
code: theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
    (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) 
goal: ContinuousOn (Trivialization.Prod.toFun' e₁ e₂) (Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

full_name: Trivialization.Prod.invFun'
code: /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
function for the construction `Trivialization.prod`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`. -/
noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) 
goal: Bundle.TotalSpace (F₁ × F₂) fun x => E₁ x × E₂ x

full_name: Trivialization.Prod.left_inv
code: theorem Prod.left_inv {x : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)}
    (h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
    Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x 
goal: Trivialization.Prod.invFun' e₁ e₂ (Trivialization.Prod.toFun' e₁ e₂ x) = x

full_name: Trivialization.Prod.right_inv
code: theorem Prod.right_inv {x : B × F₁ × F₂}
    (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
    Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x 
goal: Trivialization.Prod.toFun' e₁ e₂ (Trivialization.Prod.invFun' e₁ e₂ x) = x

full_name: Trivialization.Prod.continuous_inv_fun
code: theorem Prod.continuous_inv_fun :
    ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) 
goal: ContinuousOn (Trivialization.Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ)

full_name: Trivialization.prod
code: /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
`e₁.baseSet ∩ e₂.baseSet`. -/
noncomputable def prod : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂)) 
goal: Trivialization (F₁ × F₂) Bundle.TotalSpace.proj

full_name: Trivialization.baseSet_prod
code: @[simp]
theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet 
goal: (e₁.prod e₂).baseSet = e₁.baseSet ∩ e₂.baseSet

full_name: Trivialization.prod_symm_apply
code: theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
    (prod e₁ e₂).toPartialEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ 
goal: ↑(e₁.prod e₂).symm (x, w₁, w₂) = { proj := x, snd := (e₁.symm x w₁, e₂.symm x w₂) }

full_name: FiberBundle.prod
code: /-- The product of two fiber bundles is a fiber bundle. -/
noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂) 
goal: FiberBundle (F₁ × F₂) fun x => E₁ x × E₂ x

full_name: instMemTrivializationAtlasProdProd
code: instance {e₁ : Trivialization F₁ (π F₁ E₁)} {e₂ : Trivialization F₂ (π F₂ E₂)}
    [MemTrivializationAtlas e₁] [MemTrivializationAtlas e₂] :
    MemTrivializationAtlas (e₁.prod e₂ : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂))) 
goal: MemTrivializationAtlas (e₁.prod e₂)

full_name: instTopologicalSpacePullback
code: instance [∀ x : B, TopologicalSpace (E x)] : ∀ x : B', TopologicalSpace ((f *ᵖ E) x) 
goal: TopologicalSpace ((f *ᵖ E) x)

full_name: pullbackTopology
code: /-- Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) 
goal: TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E))

full_name: wrapped._@.Mathlib.Topology.FiberBundle.Constructions._hyg.3236
code: /-- Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) 
goal: Subtype (Eq @definition✝)

full_name: pullbackTopology_def
code: /-- Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) 
goal: pullbackTopology F E f =
  TopologicalSpace.induced Bundle.TotalSpace.proj inst✝ ⊓ TopologicalSpace.induced (Bundle.Pullback.lift f) inst✝¹

full_name: definition._@.Mathlib.Topology.FiberBundle.Constructions._hyg.3236
code: /-- Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) 
goal: TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E))

full_name: Pullback.TotalSpace.topologicalSpace
code: /-- The topology on the total space of a pullback bundle is the coarsest topology for which both
the projections to the base and the map to the original bundle are continuous. -/
instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace F (f *ᵖ E)) 
goal: TopologicalSpace (Bundle.TotalSpace F (f *ᵖ E))

full_name: Pullback.continuous_proj
code: theorem Pullback.continuous_proj (f : B' → B) : Continuous (π F (f *ᵖ E)) 
goal: Continuous Bundle.TotalSpace.proj

full_name: Pullback.continuous_lift
code: theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B F E B' f) 
goal: Continuous (Bundle.Pullback.lift f)

full_name: inducing_pullbackTotalSpaceEmbedding
code: theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
    Inducing (@pullbackTotalSpaceEmbedding B F E B' f) 
goal: Inducing (Bundle.pullbackTotalSpaceEmbedding f)

full_name: Pullback.continuous_totalSpaceMk
code: theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
    {f : B' → B} {x : B'} : Continuous (@TotalSpace.mk _ F (f *ᵖ E) x) 
goal: Continuous (Bundle.TotalSpace.mk x)

full_name: Trivialization.pullback
code: /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K) :
    Trivialization F (π F ((f : B' → B) *ᵖ E)) 
goal: Trivialization F Bundle.TotalSpace.proj

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