File: Mathlib/Topology/Category/TopCat/Basic.lean

full_name: TopCat
code: /-- The category of topological spaces and continuous maps. -/
@[to_additive existing TopCat]
def TopCat : Type (u + 1) 
goal: Type (u + 1)

full_name: TopCat.bundledHom
code: instance bundledHom : BundledHom @ContinuousMap 
goal: CategoryTheory.BundledHom ContinuousMap

full_name: TopCat.concreteCategory
code: instance concreteCategory : ConcreteCategory TopCat 
goal: CategoryTheory.ConcreteCategory TopCat

full_name: TopCat.instCoeSortType
code: instance : CoeSort TopCat Type* 
goal: CoeSort TopCat (Type u_1)

full_name: TopCat.topologicalSpaceUnbundled
code: instance topologicalSpaceUnbundled (X : TopCat) : TopologicalSpace X 
goal: TopologicalSpace ↑X

full_name: TopCat.instFunLike
code: instance instFunLike (X Y : TopCat) : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: TopCat.instMonoidHomClass
code: instance instMonoidHomClass (X Y : TopCat) : ContinuousMapClass (X ⟶ Y) X Y 
goal: ContinuousMapClass (X ⟶ Y) ↑X ↑Y

full_name: TopCat.id_app
code: theorem id_app (X : TopCat.{u}) (x : ↑X) : (𝟙 X : X ⟶ X) x = x 
goal: (𝟙 X) x = x

full_name: TopCat.comp_app
code: theorem comp_app {X Y Z : TopCat.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
    (f ≫ g : X → Z) x = g (f x) 
goal: (f ≫ g) x = g (f x)

full_name: TopCat.coe_id
code: @[simp] theorem coe_id (X : TopCat.{u}) : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: TopCat.coe_comp
code: @[simp] theorem coe_comp {X Y Z : TopCat.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: TopCat.hom_inv_id_apply
code: @[simp]
lemma hom_inv_id_apply {X Y : TopCat} (f : X ≅ Y) (x : X) : f.inv (f.hom x) = x 
goal: f.inv (f.hom x) = x

full_name: TopCat.inv_hom_id_apply
code: @[simp]
lemma inv_hom_id_apply {X Y : TopCat} (f : X ≅ Y) (y : Y) : f.hom (f.inv y) = y 
goal: f.hom (f.inv y) = y

full_name: TopCat.of
code: /-- Construct a bundled `Top` from the underlying type and the typeclass. -/
def of (X : Type u) [TopologicalSpace X] : TopCat 
goal: TopCat

full_name: TopCat.topologicalSpace_coe
code: instance topologicalSpace_coe (X : TopCat) : TopologicalSpace X 
goal: TopologicalSpace ↑X

full_name: TopCat.topologicalSpace_forget
code: @[instance] abbrev topologicalSpace_forget
    (X : TopCat) : TopologicalSpace <| (forget TopCat).obj X 
goal: TopologicalSpace ((CategoryTheory.forget TopCat).obj X)

full_name: TopCat.coe_of
code: @[simp]
theorem coe_of (X : Type u) [TopologicalSpace X] : (of X : Type u) = X 
goal: ↑(TopCat.of X) = X

full_name: TopCat.coe_of_of
code: /--
Replace a function coercion for a morphism `TopCat.of X ⟶ TopCat.of Y` with the definitionally
equal function coercion for a continuous map `C(X, Y)`.
-/
@[simp] theorem coe_of_of {X Y : Type u} [TopologicalSpace X] [TopologicalSpace Y]
    {f : C(X, Y)} {x} :
    @DFunLike.coe (TopCat.of X ⟶ TopCat.of Y) ((CategoryTheory.forget TopCat).obj (TopCat.of X))
      (fun _ ↦ (CategoryTheory.forget TopCat).obj (TopCat.of Y)) ConcreteCategory.instFunLike
      f x =
    @DFunLike.coe C(X, Y) X
      (fun _ ↦ Y) _
      f x 
goal: f x = f x

full_name: TopCat.inhabited
code: instance inhabited : Inhabited TopCat 
goal: Inhabited TopCat

full_name: TopCat.hom_apply
code: lemma hom_apply {X Y : TopCat} (f : X ⟶ Y) (x : X) : f x = ContinuousMap.toFun f x 
goal: f x = f.toFun x

full_name: TopCat.discrete
code: /-- The discrete topology on any type. -/
def discrete : Type u ⥤ TopCat.{u} 
goal: Type u ⥤ TopCat

full_name: TopCat.instDiscreteTopologyαTopologicalSpaceObjDiscrete
code: instance {X : Type u} : DiscreteTopology (discrete.obj X) 
goal: DiscreteTopology ↑(TopCat.discrete.obj X)

full_name: TopCat.trivial
code: /-- The trivial topology on any type. -/
def trivial : Type u ⥤ TopCat.{u} 
goal: Type u ⥤ TopCat

full_name: TopCat.isoOfHomeo
code: /-- Any homeomorphisms induces an isomorphism in `Top`. -/
@[simps]
def isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : X ≅ Y 
goal: X ≅ Y

full_name: TopCat.isoOfHomeo_hom
code: /-- Any homeomorphisms induces an isomorphism in `Top`. -/
@[simps]
def isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : X ≅ Y 
goal: (TopCat.isoOfHomeo f).hom = f.toContinuousMap

full_name: TopCat.isoOfHomeo_inv
code: /-- Any homeomorphisms induces an isomorphism in `Top`. -/
@[simps]
def isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : X ≅ Y 
goal: (TopCat.isoOfHomeo f).inv = f.symm.toContinuousMap

full_name: TopCat.homeoOfIso
code: /-- Any isomorphism in `Top` induces a homeomorphism. -/
@[simps]
def homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : X ≃ₜ Y 
goal: ↑X ≃ₜ ↑Y

full_name: TopCat.homeoOfIso_apply
code: /-- Any isomorphism in `Top` induces a homeomorphism. -/
@[simps]
def homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : X ≃ₜ Y 
goal: (TopCat.homeoOfIso f) a = f.hom a

full_name: TopCat.homeoOfIso_symm_apply
code: /-- Any isomorphism in `Top` induces a homeomorphism. -/
@[simps]
def homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : X ≃ₜ Y 
goal: (TopCat.homeoOfIso f).symm a = f.inv a

full_name: TopCat.of_isoOfHomeo
code: @[simp]
theorem of_isoOfHomeo {X Y : TopCat.{u}} (f : X ≃ₜ Y) : homeoOfIso (isoOfHomeo f) = f 
goal: TopCat.homeoOfIso (TopCat.isoOfHomeo f) = f

full_name: TopCat.of_homeoOfIso
code: @[simp]
theorem of_homeoOfIso {X Y : TopCat.{u}} (f : X ≅ Y) : isoOfHomeo (homeoOfIso f) = f 
goal: TopCat.isoOfHomeo (TopCat.homeoOfIso f) = f

full_name: TopCat.openEmbedding_iff_comp_isIso
code: theorem openEmbedding_iff_comp_isIso {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding f 
goal: OpenEmbedding ⇑(f ≫ g) ↔ OpenEmbedding ⇑f

full_name: TopCat.openEmbedding_iff_comp_isIso'
code: @[simp]
theorem openEmbedding_iff_comp_isIso' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding f 
goal: OpenEmbedding ((CategoryTheory.forget TopCat).map f ≫ (CategoryTheory.forget TopCat).map g) ↔ OpenEmbedding ⇑f

full_name: TopCat.openEmbedding_iff_isIso_comp
code: theorem openEmbedding_iff_isIso_comp {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding (f ≫ g) ↔ OpenEmbedding g 
goal: OpenEmbedding ⇑(f ≫ g) ↔ OpenEmbedding ⇑g

full_name: TopCat.openEmbedding_iff_isIso_comp'
code: @[simp]
theorem openEmbedding_iff_isIso_comp' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding g 
goal: OpenEmbedding ((CategoryTheory.forget TopCat).map f ≫ (CategoryTheory.forget TopCat).map g) ↔ OpenEmbedding ⇑g