File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

full_name: TopCat.piπ
code: /-- The projection from the product as a bundled continuous map. -/
abbrev piπ {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) : TopCat.of (∀ i, α i) ⟶ α i 
goal: TopCat.of ((i : ι) → ↑(α i)) ⟶ α i

full_name: TopCat.piFan_π_app
code: /-- The explicit fan of a family of topological spaces given by the pi type. -/
@[simps! pt π_app]
def piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α 
goal: (TopCat.piFan α).π.app X = TopCat.piπ α X.as

full_name: TopCat.piFan_pt
code: /-- The explicit fan of a family of topological spaces given by the pi type. -/
@[simps! pt π_app]
def piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α 
goal: (TopCat.piFan α).pt = TopCat.of ((i : ι) → ↑(α i))

full_name: TopCat.piFan
code: /-- The explicit fan of a family of topological spaces given by the pi type. -/
@[simps! pt π_app]
def piFan {ι : Type v} (α : ι → TopCat.{max v u}) : Fan α 
goal: CategoryTheory.Limits.Fan α

full_name: TopCat.piFanIsLimit
code: /-- The constructed fan is indeed a limit -/
def piFanIsLimit {ι : Type v} (α : ι → TopCat.{max v u}) : IsLimit (piFan α) 
goal: CategoryTheory.Limits.IsLimit (TopCat.piFan α)

full_name: TopCat.piIsoPi
code: /-- The product is homeomorphic to the product of the underlying spaces,
equipped with the product topology.
-/
def piIsoPi {ι : Type v} (α : ι → TopCat.{max v u}) : ∏ᶜ α ≅ TopCat.of (∀ i, α i) 
goal: ∏ᶜ α ≅ TopCat.of ((i : ι) → ↑(α i))

full_name: TopCat.piIsoPi_inv_π
code: @[reassoc (attr := simp)]
theorem piIsoPi_inv_π {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
    (piIsoPi α).inv ≫ Pi.π α i = piπ α i 
goal: (TopCat.piIsoPi α).inv ≫ CategoryTheory.Limits.Pi.π α i = TopCat.piπ α i

full_name: TopCat.piIsoPi_inv_π_apply
code: theorem piIsoPi_inv_π_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : ∀ i, α i) :
    (Pi.π α i : _) ((piIsoPi α).inv x) = x i 
goal: (CategoryTheory.Limits.Pi.π α i) ((TopCat.piIsoPi α).inv x) = x i

full_name: TopCat.piIsoPi_hom_apply
code: theorem piIsoPi_hom_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι)
    (x : (∏ᶜ α : TopCat.{max v u})) : (piIsoPi α).hom x i = (Pi.π α i : _) x 
goal: (TopCat.piIsoPi α).hom x i = (CategoryTheory.Limits.Pi.π α i) x

full_name: TopCat.sigmaι
code: /-- The inclusion to the coproduct as a bundled continuous map. -/
abbrev sigmaι {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) : α i ⟶ TopCat.of (Σi, α i) 
goal: α i ⟶ TopCat.of ((i : ι) × ↑(α i))

full_name: TopCat.sigmaCofan_ι_app
code: /-- The explicit cofan of a family of topological spaces given by the sigma type. -/
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α 
goal: (TopCat.sigmaCofan α).ι.app X = TopCat.sigmaι α X.as

full_name: TopCat.sigmaCofan_pt
code: /-- The explicit cofan of a family of topological spaces given by the sigma type. -/
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α 
goal: (TopCat.sigmaCofan α).pt = TopCat.of ((i : ι) × ↑(α i))

full_name: TopCat.sigmaCofan
code: /-- The explicit cofan of a family of topological spaces given by the sigma type. -/
@[simps! pt ι_app]
def sigmaCofan {ι : Type v} (α : ι → TopCat.{max v u}) : Cofan α 
goal: CategoryTheory.Limits.Cofan α

full_name: TopCat.sigmaCofanIsColimit
code: /-- The constructed cofan is indeed a colimit -/
def sigmaCofanIsColimit {ι : Type v} (β : ι → TopCat.{max v u}) : IsColimit (sigmaCofan β) 
goal: CategoryTheory.Limits.IsColimit (TopCat.sigmaCofan β)

full_name: TopCat.sigmaIsoSigma
code: /-- The coproduct is homeomorphic to the disjoint union of the topological spaces.
-/
def sigmaIsoSigma {ι : Type v} (α : ι → TopCat.{max v u}) : ∐ α ≅ TopCat.of (Σi, α i) 
goal: ∐ α ≅ TopCat.of ((i : ι) × ↑(α i))

full_name: TopCat.sigmaIsoSigma_hom_ι
code: @[reassoc (attr := simp)]
theorem sigmaIsoSigma_hom_ι {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) :
    Sigma.ι α i ≫ (sigmaIsoSigma α).hom = sigmaι α i 
goal: CategoryTheory.Limits.Sigma.ι α i ≫ (TopCat.sigmaIsoSigma α).hom = TopCat.sigmaι α i

full_name: TopCat.sigmaIsoSigma_hom_ι_apply
code: theorem sigmaIsoSigma_hom_ι_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
    (sigmaIsoSigma α).hom ((Sigma.ι α i : _) x) = Sigma.mk i x 
goal: (TopCat.sigmaIsoSigma α).hom ((CategoryTheory.Limits.Sigma.ι α i) x) = ⟨i, x⟩

full_name: TopCat.sigmaIsoSigma_inv_apply
code: theorem sigmaIsoSigma_inv_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
    (sigmaIsoSigma α).inv ⟨i, x⟩ = (Sigma.ι α i : _) x 
goal: (TopCat.sigmaIsoSigma α).inv ⟨i, x⟩ = (CategoryTheory.Limits.Sigma.ι α i) x

full_name: TopCat.induced_of_isLimit
code: theorem induced_of_isLimit {F : J ⥤ TopCat.{max v u}} (C : Cone F) (hC : IsLimit C) :
    C.pt.str = ⨅ j, (F.obj j).str.induced (C.π.app j) 
goal: C.pt.str = ⨅ j, TopologicalSpace.induced (⇑(C.π.app j)) (F.obj j).str

full_name: TopCat.limit_topology
code: theorem limit_topology (F : J ⥤ TopCat.{max v u}) :
    (limit F).str = ⨅ j, (F.obj j).str.induced (limit.π F j) 
goal: (CategoryTheory.Limits.limit F).str = ⨅ j, TopologicalSpace.induced (⇑(CategoryTheory.Limits.limit.π F j)) (F.obj j).str

full_name: TopCat.prodFst
code: /-- The first projection from the product. -/
abbrev prodFst {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ X 
goal: TopCat.of (↑X × ↑Y) ⟶ X

full_name: TopCat.prodSnd
code: /-- The second projection from the product. -/
abbrev prodSnd {X Y : TopCat.{u}} : TopCat.of (X × Y) ⟶ Y 
goal: TopCat.of (↑X × ↑Y) ⟶ Y

full_name: TopCat.prodBinaryFan
code: /-- The explicit binary cofan of `X, Y` given by `X × Y`. -/
def prodBinaryFan (X Y : TopCat.{u}) : BinaryFan X Y 
goal: CategoryTheory.Limits.BinaryFan X Y

full_name: TopCat.prodBinaryFanIsLimit
code: /-- The constructed binary fan is indeed a limit -/
def prodBinaryFanIsLimit (X Y : TopCat.{u}) : IsLimit (prodBinaryFan X Y) 
goal: CategoryTheory.Limits.IsLimit (X.prodBinaryFan Y)

full_name: TopCat.prodIsoProd
code: /-- The homeomorphism between `X ⨯ Y` and the set-theoretic product of `X` and `Y`,
equipped with the product topology.
-/
def prodIsoProd (X Y : TopCat.{u}) : X ⨯ Y ≅ TopCat.of (X × Y) 
goal: X ⨯ Y ≅ TopCat.of (↑X × ↑Y)

full_name: TopCat.prodIsoProd_hom_fst
code: @[reassoc (attr := simp)]
theorem prodIsoProd_hom_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).hom ≫ prodFst = Limits.prod.fst 
goal: (X.prodIsoProd Y).hom ≫ TopCat.prodFst = CategoryTheory.Limits.prod.fst

full_name: TopCat.prodIsoProd_hom_snd
code: @[reassoc (attr := simp)]
theorem prodIsoProd_hom_snd (X Y : TopCat.{u}) :
    (prodIsoProd X Y).hom ≫ prodSnd = Limits.prod.snd 
goal: (X.prodIsoProd Y).hom ≫ TopCat.prodSnd = CategoryTheory.Limits.prod.snd

full_name: TopCat.prodIsoProd_hom_apply
code: theorem prodIsoProd_hom_apply {X Y : TopCat.{u}} (x : ↑ (X ⨯ Y)) :
    (prodIsoProd X Y).hom x = ((Limits.prod.fst : X ⨯ Y ⟶ _) x,
    (Limits.prod.snd : X ⨯ Y ⟶ _) x) 
goal: (X.prodIsoProd Y).hom x = (CategoryTheory.Limits.prod.fst x, CategoryTheory.Limits.prod.snd x)

full_name: TopCat.prodIsoProd_inv_fst
code: @[reassoc (attr := simp), elementwise]
theorem prodIsoProd_inv_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).inv ≫ Limits.prod.fst = prodFst 
goal: (X.prodIsoProd Y).inv ≫ CategoryTheory.Limits.prod.fst = TopCat.prodFst

full_name: TopCat.prodIsoProd_inv_snd
code: @[reassoc (attr := simp), elementwise]
theorem prodIsoProd_inv_snd (X Y : TopCat.{u}) :
    (prodIsoProd X Y).inv ≫ Limits.prod.snd = prodSnd 
goal: (X.prodIsoProd Y).inv ≫ CategoryTheory.Limits.prod.snd = TopCat.prodSnd

full_name: TopCat.prod_topology
code: theorem prod_topology {X Y : TopCat.{u}} :
    (X ⨯ Y).str =
      induced (Limits.prod.fst : X ⨯ Y ⟶ _) X.str ⊓
        induced (Limits.prod.snd : X ⨯ Y ⟶ _) Y.str 
goal: (X ⨯ Y).str =
  TopologicalSpace.induced (⇑CategoryTheory.Limits.prod.fst) X.str ⊓
    TopologicalSpace.induced (⇑CategoryTheory.Limits.prod.snd) Y.str

full_name: TopCat.range_prod_map
code: theorem range_prod_map {W X Y Z : TopCat.{u}} (f : W ⟶ Y) (g : X ⟶ Z) :
    Set.range (Limits.prod.map f g) =
      (Limits.prod.fst : Y ⨯ Z ⟶ _) ⁻¹' Set.range f ∩
        (Limits.prod.snd : Y ⨯ Z ⟶ _) ⁻¹' Set.range g 
goal: Set.range ⇑(CategoryTheory.Limits.prod.map f g) =
  ⇑CategoryTheory.Limits.prod.fst ⁻¹' Set.range ⇑f ∩ ⇑CategoryTheory.Limits.prod.snd ⁻¹' Set.range ⇑g

full_name: TopCat.inducing_prod_map
code: theorem inducing_prod_map {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Inducing f)
    (hg : Inducing g) : Inducing (Limits.prod.map f g) 
goal: Inducing ⇑(CategoryTheory.Limits.prod.map f g)

full_name: TopCat.embedding_prod_map
code: theorem embedding_prod_map {W X Y Z : TopCat.{u}} {f : W ⟶ X} {g : Y ⟶ Z} (hf : Embedding f)
    (hg : Embedding g) : Embedding (Limits.prod.map f g) 
goal: Embedding ⇑(CategoryTheory.Limits.prod.map f g)

full_name: TopCat.binaryCofan
code: /-- The binary coproduct cofan in `TopCat`. -/
protected def binaryCofan (X Y : TopCat.{u}) : BinaryCofan X Y 
goal: CategoryTheory.Limits.BinaryCofan X Y

full_name: TopCat.binaryCofanIsColimit
code: /-- The constructed binary coproduct cofan in `TopCat` is the coproduct. -/
def binaryCofanIsColimit (X Y : TopCat.{u}) : IsColimit (TopCat.binaryCofan X Y) 
goal: CategoryTheory.Limits.IsColimit (X.binaryCofan Y)

full_name: TopCat.binaryCofan_isColimit_iff
code: theorem binaryCofan_isColimit_iff {X Y : TopCat} (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔
      OpenEmbedding c.inl ∧ OpenEmbedding c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) 
goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔
  OpenEmbedding ⇑c.inl ∧ OpenEmbedding ⇑c.inr ∧ IsCompl (Set.range ⇑c.inl) (Set.range ⇑c.inr)