ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- TopologicalSpace.Opens.infLELeft_apply
theorem infLELeft_apply (U V : Opens X) (x) :
    (infLELeft U V) x = ⟨x.1, (@inf_le_left _ _ U V : _ ≤ _) x.2⟩ 
Arguments: {X : TopCat} (U V : TopologicalSpace.Opens ↑X) (x : ↥(U ⊓ V))
Goal: (fun x => ⟨↑x, ⋯⟩) x = ⟨↑x, ⋯⟩
-- TopologicalSpace.Opens.infLELeft_apply_mk
@[simp]
theorem infLELeft_apply_mk (U V : Opens X) (x) (m) :
    (infLELeft U V) ⟨x, m⟩ = ⟨x, (@inf_le_left _ _ U V : _ ≤ _) m⟩ 
Arguments: {X : TopCat} (U V : TopologicalSpace.Opens ↑X) (x : ↑X) (m : x ∈ U ⊓ V)
Goal: (fun x => ⟨↑x, ⋯⟩) ⟨x, m⟩ = ⟨x, ⋯⟩
-- TopologicalSpace.Opens.leSupr_apply_mk
@[simp]
theorem leSupr_apply_mk {ι : Type*} (U : ι → Opens X) (i : ι) (x) (m) :
    (leSupr U i) ⟨x, m⟩ = ⟨x, (le_iSup U i : _) m⟩ 
Arguments: {X : TopCat} {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑X) (i : ι) (x : ↑X) (m : x ∈ U i)
Goal: (fun x => ⟨↑x, ⋯⟩) ⟨x, m⟩ = ⟨x, ⋯⟩
-- TopologicalSpace.Opens.toTopCat_map
@[simp]
theorem toTopCat_map (X : TopCat.{u}) {U V : Opens X} {f : U ⟶ V} {x} {h} :
    ((toTopCat X).map f) ⟨x, h⟩ = ⟨x, f.le h⟩ 
Arguments: (X : TopCat) {U V : TopologicalSpace.Opens ↑X} {f : U ⟶ V} {x : ↑X} {h : x ∈ U}
Goal: ((TopologicalSpace.Opens.toTopCat X).map f) ⟨x, h⟩ = ⟨x, ⋯⟩
-- TopologicalSpace.Opens.inclusion_apply
@[simps (config := .asFn)]
def inclusion {X : TopCat.{u}} (U : Opens X) : (toTopCat X).obj U ⟶ X 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: ⇑U.inclusion = Subtype.val
-- TopologicalSpace.Opens.coe_inclusion
@[simp]
theorem coe_inclusion {X : TopCat} {U : Opens X} :
    (inclusion U : U → X) = Subtype.val 
Arguments: {X : TopCat} {U : TopologicalSpace.Opens ↑X}
Goal: ⇑U.inclusion = Subtype.val
-- TopologicalSpace.Opens.openEmbedding
theorem openEmbedding {X : TopCat.{u}} (U : Opens X) : OpenEmbedding (inclusion U) 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: OpenEmbedding ⇑U.inclusion
-- TopologicalSpace.Opens.map_coe
@[simp]
theorem map_coe (f : X ⟶ Y) (U : Opens Y) : ((map f).obj U : Set X) = f ⁻¹' (U : Set Y) 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (U : TopologicalSpace.Opens ↑Y)
Goal: ↑((TopologicalSpace.Opens.map f).obj U) = ⇑f ⁻¹' ↑U
-- TopologicalSpace.Opens.map_obj
@[simp]
theorem map_obj (f : X ⟶ Y) (U) (p) : (map f).obj ⟨U, p⟩ = ⟨f ⁻¹' U, p.preimage f.continuous⟩ 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (U : Set ↑Y) (p : IsOpen U)
Goal: (TopologicalSpace.Opens.map f).obj { carrier := U, is_open' := p } = { carrier := ⇑f ⁻¹' U, is_open' := ⋯ }
-- TopologicalSpace.Opens.map_homOfLE
@[simp]
lemma map_homOfLE (f : X ⟶ Y) {U V : Opens Y} (e : U ≤ V) :
    (TopologicalSpace.Opens.map f).map (homOfLE e) =
      homOfLE (show (Opens.map f).obj U ≤ (Opens.map f).obj V from fun _ hx ↦ e hx) 
Arguments: {X Y : TopCat} (f : X ⟶ Y) {U V : TopologicalSpace.Opens ↑Y} (e : U ≤ V)
Goal: (TopologicalSpace.Opens.map f).map (CategoryTheory.homOfLE e) = CategoryTheory.homOfLE ⋯
-- TopologicalSpace.Opens.map_id_obj
@[simp]
theorem map_id_obj (U : Opens X) : (map (𝟙 X)).obj U = U 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: (TopologicalSpace.Opens.map (𝟙 X)).obj U = U
-- TopologicalSpace.Opens.map_id_obj'
@[simp 1100]
theorem map_id_obj' (U) (p) : (map (𝟙 X)).obj ⟨U, p⟩ = ⟨U, p⟩ 
Arguments: {X : TopCat} (U : Set ↑X) (p : IsOpen U)
Goal: (TopologicalSpace.Opens.map (𝟙 X)).obj { carrier := U, is_open' := p } = { carrier := U, is_open' := p }
-- TopologicalSpace.Opens.map_id_obj_unop
@[simp 1100]
theorem map_id_obj_unop (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).obj (unop U) = unop U 
Arguments: {X : TopCat} (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopologicalSpace.Opens.map (𝟙 X)).obj (Opposite.unop U) = Opposite.unop U
-- TopologicalSpace.Opens.op_map_id_obj
@[simp 1100]
theorem op_map_id_obj (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).op.obj U = U 
Arguments: {X : TopCat} (U : (TopologicalSpace.Opens ↑X)ᵒᵖ)
Goal: (TopologicalSpace.Opens.map (𝟙 X)).op.obj U = U
-- TopologicalSpace.Opens.map_top
@[simp]
lemma map_top (f : X ⟶ Y) : (Opens.map f).obj ⊤ = ⊤ 
Arguments: {X Y : TopCat} (f : X ⟶ Y)
Goal: (TopologicalSpace.Opens.map f).obj ⊤ = ⊤
-- TopologicalSpace.Opens.map_comp_obj
@[simp]
theorem map_comp_obj (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).obj U = (map f).obj ((map g).obj U) 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z)
Goal: (TopologicalSpace.Opens.map (f ≫ g)).obj U = (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj U)
-- TopologicalSpace.Opens.map_comp_obj'
@[simp]
theorem map_comp_obj' (f : X ⟶ Y) (g : Y ⟶ Z) (U) (p) :
    (map (f ≫ g)).obj ⟨U, p⟩ = (map f).obj ((map g).obj ⟨U, p⟩) 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Set ↑Z) (p : IsOpen U)
Goal: (TopologicalSpace.Opens.map (f ≫ g)).obj { carrier := U, is_open' := p } =
  (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p })
-- TopologicalSpace.Opens.map_comp_map
@[simp]
theorem map_comp_map (f : X ⟶ Y) (g : Y ⟶ Z) {U V} (i : U ⟶ V) :
    (map (f ≫ g)).map i = (map f).map ((map g).map i) 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) {U V : TopologicalSpace.Opens ↑Z} (i : U ⟶ V)
Goal: (TopologicalSpace.Opens.map (f ≫ g)).map i = (TopologicalSpace.Opens.map f).map ((TopologicalSpace.Opens.map g).map i)
-- TopologicalSpace.Opens.map_comp_obj_unop
@[simp]
theorem map_comp_obj_unop (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).obj (unop U) = (map f).obj ((map g).obj (unop U)) 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : (TopologicalSpace.Opens ↑Z)ᵒᵖ)
Goal: (TopologicalSpace.Opens.map (f ≫ g)).obj (Opposite.unop U) =
  (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj (Opposite.unop U))
-- TopologicalSpace.Opens.op_map_comp_obj
@[simp]
theorem op_map_comp_obj (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).op.obj U = (map f).op.obj ((map g).op.obj U) 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : (TopologicalSpace.Opens ↑Z)ᵒᵖ)
Goal: (TopologicalSpace.Opens.map (f ≫ g)).op.obj U =
  (TopologicalSpace.Opens.map f).op.obj ((TopologicalSpace.Opens.map g).op.obj U)
-- TopologicalSpace.Opens.map_iSup
theorem map_iSup (f : X ⟶ Y) {ι : Type*} (U : ι → Opens Y) :
    (map f).obj (iSup U) = iSup ((map f).obj ∘ U) 
Arguments: {X Y : TopCat} (f : X ⟶ Y) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑Y)
Goal: (TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U)
-- TopologicalSpace.Opens.mapId_inv_app
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X) 
Arguments: (X : TopCat) (U : TopologicalSpace.Opens ↑X)
Goal: (TopologicalSpace.Opens.mapId X).inv.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.mapId_hom_app
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X) 
Arguments: (X : TopCat) (U : TopologicalSpace.Opens ↑X)
Goal: (TopologicalSpace.Opens.mapId X).hom.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.map_id_eq
theorem map_id_eq : map (𝟙 X) = 𝟭 (Opens X) 
Arguments: (X : TopCat)
Goal: TopologicalSpace.Opens.map (𝟙 X) = 𝟭 (TopologicalSpace.Opens ↑X)
-- TopologicalSpace.Opens.mapComp_inv_app
@[simps]
def mapComp (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) ≅ map g ⋙ map f 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z)
Goal: (TopologicalSpace.Opens.mapComp f g).inv.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.mapComp_hom_app
@[simps]
def mapComp (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) ≅ map g ⋙ map f 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z)
Goal: (TopologicalSpace.Opens.mapComp f g).hom.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.map_comp_eq
theorem map_comp_eq (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) = map g ⋙ map f 
Arguments: {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: TopologicalSpace.Opens.map (f ≫ g) = TopologicalSpace.Opens.map g ⋙ TopologicalSpace.Opens.map f
-- TopologicalSpace.Opens.map_eq
theorem map_eq (f g : X ⟶ Y) (h : f = g) : map f = map g 
Arguments: {X Y : TopCat} (f g : X ⟶ Y) (h : f = g)
Goal: TopologicalSpace.Opens.map f = TopologicalSpace.Opens.map g
-- TopologicalSpace.Opens.mapIso_refl
@[simp]
theorem mapIso_refl (f : X ⟶ Y) (h) : mapIso f f h = Iso.refl (map _) 
Arguments: {X Y : TopCat} (f : X ⟶ Y) (h : f = f)
Goal: TopologicalSpace.Opens.mapIso f f h = CategoryTheory.Iso.refl (TopologicalSpace.Opens.map f)
-- TopologicalSpace.Opens.mapIso_hom_app
@[simp]
theorem mapIso_hom_app (f g : X ⟶ Y) (h : f = g) (U : Opens Y) :
    (mapIso f g h).hom.app U = eqToHom (by rw [h]) 
Arguments: {X Y : TopCat} (f g : X ⟶ Y) (h : f = g) (U : TopologicalSpace.Opens ↑Y)
Goal: (TopologicalSpace.Opens.mapIso f g h).hom.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.mapIso_inv_app
@[simp]
theorem mapIso_inv_app (f g : X ⟶ Y) (h : f = g) (U : Opens Y) :
    (mapIso f g h).inv.app U = eqToHom (by rw [h]) 
Arguments: {X Y : TopCat} (f g : X ⟶ Y) (h : f = g) (U : TopologicalSpace.Opens ↑Y)
Goal: (TopologicalSpace.Opens.mapIso f g h).inv.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.mapMapIso_functor
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
Arguments: {X Y : TopCat} (H : X ≅ Y)
Goal: (TopologicalSpace.Opens.mapMapIso H).functor = TopologicalSpace.Opens.map H.hom
-- TopologicalSpace.Opens.mapMapIso_inverse
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
Arguments: {X Y : TopCat} (H : X ≅ Y)
Goal: (TopologicalSpace.Opens.mapMapIso H).inverse = TopologicalSpace.Opens.map H.inv
-- TopologicalSpace.Opens.mapMapIso_unitIso
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
Arguments: {X Y : TopCat} (H : X ≅ Y)
Goal: (TopologicalSpace.Opens.mapMapIso H).unitIso = CategoryTheory.NatIso.ofComponents (fun U => CategoryTheory.eqToIso ⋯) ⋯
-- TopologicalSpace.Opens.mapMapIso_counitIso
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
Arguments: {X Y : TopCat} (H : X ≅ Y)
Goal: (TopologicalSpace.Opens.mapMapIso H).counitIso =
  CategoryTheory.NatIso.ofComponents (fun U => CategoryTheory.eqToIso ⋯) ⋯
-- IsOpenMap.functor_obj_coe
@[simps obj_coe]
def IsOpenMap.functor {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) : Opens X ⥤ Opens Y 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑f) (U : TopologicalSpace.Opens ↑X)
Goal: ↑(hf.functor.obj U) = ⇑f '' ↑U
-- OpenEmbedding.functor_obj_injective
lemma OpenEmbedding.functor_obj_injective {X Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding f) :
    Function.Injective hf.isOpenMap.functor.obj 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding ⇑f)
Goal: Function.Injective ⋯.functor.obj
-- TopologicalSpace.Opens.openEmbedding_obj_top
@[simp]
theorem openEmbedding_obj_top {X : TopCat} (U : Opens X) :
    U.openEmbedding.isOpenMap.functor.obj ⊤ = U 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: ⋯.functor.obj ⊤ = U
-- TopologicalSpace.Opens.inclusion_map_eq_top
@[simp]
theorem inclusion_map_eq_top {X : TopCat} (U : Opens X) : (Opens.map U.inclusion).obj U = ⊤ 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: (TopologicalSpace.Opens.map U.inclusion).obj U = ⊤
-- TopologicalSpace.Opens.adjunction_counit_app_self
@[simp]
theorem adjunction_counit_app_self {X : TopCat} (U : Opens X) :
    U.openEmbedding.isOpenMap.adjunction.counit.app U = eqToHom (by simp) 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: ⋯.adjunction.counit.app U = CategoryTheory.eqToHom ⋯
-- TopologicalSpace.Opens.inclusion_top_functor
theorem inclusion_top_functor (X : TopCat) :
    (@Opens.openEmbedding X ⊤).isOpenMap.functor = map (inclusionTopIso X).inv 
Arguments: (X : TopCat)
Goal: ⋯.functor = TopologicalSpace.Opens.map (TopologicalSpace.Opens.inclusionTopIso X).inv
-- TopologicalSpace.Opens.functor_obj_map_obj
theorem functor_obj_map_obj {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) (U : Opens Y) :
    hf.functor.obj ((Opens.map f).obj U) = hf.functor.obj ⊤ ⊓ U 
Arguments: {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑f) (U : TopologicalSpace.Opens ↑Y)
Goal: hf.functor.obj ((TopologicalSpace.Opens.map f).obj U) = hf.functor.obj ⊤ ⊓ U
-- TopologicalSpace.Opens.set_range_forget_map_inclusion
lemma set_range_forget_map_inclusion {X : TopCat} (U : Opens X) :
    Set.range ((forget TopCat).map (inclusion U)) = (U : Set X) 
Arguments: {X : TopCat} (U : TopologicalSpace.Opens ↑X)
Goal: Set.range ((CategoryTheory.forget TopCat).map U.inclusion) = ↑U
-- TopologicalSpace.Opens.functor_map_eq_inf
@[simp]
theorem functor_map_eq_inf {X : TopCat} (U V : Opens X) :
    U.openEmbedding.isOpenMap.functor.obj ((Opens.map U.inclusion).obj V) = V ⊓ U 
Arguments: {X : TopCat} (U V : TopologicalSpace.Opens ↑X)
Goal: ⋯.functor.obj ((TopologicalSpace.Opens.map U.inclusion).obj V) = V ⊓ U
-- TopologicalSpace.Opens.map_functor_eq'
theorem map_functor_eq' {X U : TopCat} (f : U ⟶ X) (hf : OpenEmbedding f) (V) :
    ((Opens.map f).obj <| hf.isOpenMap.functor.obj V) = V 
Arguments: {X U : TopCat} (f : U ⟶ X) (hf : OpenEmbedding ⇑f) (V : TopologicalSpace.Opens ↑U)
Goal: (TopologicalSpace.Opens.map f).obj (⋯.functor.obj V) = V
-- TopologicalSpace.Opens.map_functor_eq
@[simp]
theorem map_functor_eq {X : TopCat} {U : Opens X} (V : Opens U) :
    ((Opens.map U.inclusion).obj <| U.openEmbedding.isOpenMap.functor.obj V) = V 
Arguments: {X : TopCat} {U : TopologicalSpace.Opens ↑X} (V : TopologicalSpace.Opens ↥U)
Goal: (TopologicalSpace.Opens.map U.inclusion).obj (⋯.functor.obj V) = V
-- TopologicalSpace.Opens.adjunction_counit_map_functor
@[simp]
theorem adjunction_counit_map_functor {X : TopCat} {U : Opens X} (V : Opens U) :
    U.openEmbedding.isOpenMap.adjunction.counit.app (U.openEmbedding.isOpenMap.functor.obj V) =
      eqToHom (by dsimp; rw [map_functor_eq V]) 
Arguments: {X : TopCat} {U : TopologicalSpace.Opens ↑X} (V : TopologicalSpace.Opens ↥U)
Goal: ⋯.adjunction.counit.app (⋯.functor.obj V) = CategoryTheory.eqToHom ⋯
-- CompHausLike.is_compact
structure CompHausLike where
    toTop : TopCat
    [is_compact : CompactSpace toTop]
    [is_hausdorff : T2Space toTop]
    prop : P toTop
Arguments: {P : TopCat → Prop} (self : CompHausLike P)
Goal: CompactSpace ↑self.toTop
-- CompHausLike.prop
structure CompHausLike where
    toTop : TopCat
    [is_compact : CompactSpace toTop]
    [is_hausdorff : T2Space toTop]
    prop : P toTop
Arguments: {P : TopCat → Prop} (self : CompHausLike P)
Goal: P self.toTop
-- CompHausLike.is_hausdorff
structure CompHausLike where
    toTop : TopCat
    [is_compact : CompactSpace toTop]
    [is_hausdorff : T2Space toTop]
    prop : P toTop
Arguments: {P : TopCat → Prop} (self : CompHausLike P)
Goal: T2Space ↑self.toTop
-- CompHausLike.HasProp.hasProp
class HasProp : Prop where
  hasProp : P (TopCat.of X)
Arguments: {P : TopCat → Prop} {X : Type u} [TopologicalSpace X] [self : CompHausLike.HasProp P X]
Goal: P (TopCat.of X)
-- CompHausLike.coe_of
@[simp]
theorem coe_of : (CompHausLike.of P X : Type _) = X 
Arguments: (P : TopCat → Prop) (X : Type u) [TopologicalSpace X] [CompactSpace X] [T2Space X] [CompHausLike.HasProp P X]
Goal: ↑(CompHausLike.of P X).toTop = X
-- CompHausLike.coe_id
@[simp]
theorem coe_id (X : CompHausLike P) : (𝟙 ((forget (CompHausLike P)).obj X)) = id 
Arguments: (P : TopCat → Prop) (X : CompHausLike P)
Goal: 𝟙 ((CategoryTheory.forget (CompHausLike P)).obj X) = id
-- CompHausLike.coe_comp
@[simp]
theorem coe_comp {X Y Z : CompHausLike P} (f : X ⟶ Y) (g : Y ⟶ Z) :
    ((forget (CompHausLike P)).map f ≫ (forget (CompHausLike P)).map g) = g ∘ f 
Arguments: (P : TopCat → Prop) {X Y Z : CompHausLike P} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.forget (CompHausLike P)).map f ≫ (CategoryTheory.forget (CompHausLike P)).map g = ⇑g ∘ ⇑f
-- CompHausLike.toCompHausLike_map
@[simps]
def toCompHausLike {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
    CompHausLike P ⥤ CompHausLike P' 
Arguments: {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop)
Goal: ∀ {X Y : CompHausLike P} (f : X ⟶ Y), (CompHausLike.toCompHausLike h).map f = f
-- CompHausLike.toCompHausLike_obj
@[simps]
def toCompHausLike {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) :
    CompHausLike P ⥤ CompHausLike P' 
Arguments: {P P' : TopCat → Prop} (h : ∀ (X : CompHausLike P), P X.toTop → P' X.toTop) (X : CompHausLike P)
Goal: (CompHausLike.toCompHausLike h).obj X =
  let_fun this := ⋯;
  CompHausLike.of P' ↑X.toTop
-- CompHausLike.compHausLikeToTop_map
@[simps!]
def compHausLikeToTop : CompHausLike.{u} P ⥤ TopCat.{u} 
Arguments: (P : TopCat → Prop)
Goal: ∀ {X Y : CategoryTheory.InducedCategory TopCat CompHausLike.toTop} (f : X ⟶ Y),
  (CompHausLike.compHausLikeToTop P).map f = f
-- CompHausLike.compHausLikeToTop_obj
@[simps!]
def compHausLikeToTop : CompHausLike.{u} P ⥤ TopCat.{u} 
Arguments: (P : TopCat → Prop) (self : CompHausLike P)
Goal: (CompHausLike.compHausLikeToTop P).obj self = self.toTop
-- CompHausLike.epi_of_surjective
theorem epi_of_surjective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) (hf : Function.Surjective f) :
    Epi f 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ⟶ Y) (hf : Function.Surjective ⇑f)
Goal: CategoryTheory.Epi f
-- CompHausLike.mono_iff_injective
theorem mono_iff_injective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) :
    Mono f ↔ Function.Injective f 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ⟶ Y)
Goal: CategoryTheory.Mono f ↔ Function.Injective ⇑f
-- CompHausLike.isClosedMap
theorem isClosedMap {X Y : CompHausLike.{u} P} (f : X ⟶ Y) : IsClosedMap f 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ⟶ Y)
Goal: IsClosedMap ⇑f
-- CompHausLike.isIso_of_bijective
theorem isIso_of_bijective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) (bij : Function.Bijective f) :
    IsIso f 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ⟶ Y) (bij : Function.Bijective ⇑f)
Goal: CategoryTheory.IsIso f
-- CompHausLike.isoOfHomeo_hom_apply
@[simps!]
def isoOfHomeo {X Y : CompHausLike.{u} P} (f : X ≃ₜ Y) : X ≅ Y 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : ↑X.toTop ≃ₜ ↑Y.toTop) (a : ↑((CompHausLike.compHausLikeToTop P).obj X))
Goal: (CompHausLike.isoOfHomeo f).hom a = f a
-- CompHausLike.isoOfHomeo_inv_apply
@[simps!]
def isoOfHomeo {X Y : CompHausLike.{u} P} (f : X ≃ₜ Y) : X ≅ Y 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : ↑X.toTop ≃ₜ ↑Y.toTop) (a : ↑((CompHausLike.compHausLikeToTop P).obj Y))
Goal: (CompHausLike.isoOfHomeo f).inv a = f.symm a
-- CompHausLike.homeoOfIso_symm_apply
@[simps!]
def homeoOfIso {X Y : CompHausLike.{u} P} (f : X ≅ Y) : X ≃ₜ Y 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ≅ Y) (a : ↑Y.toTop)
Goal: (CompHausLike.homeoOfIso f).symm a = f.inv a
-- CompHausLike.homeoOfIso_apply
@[simps!]
def homeoOfIso {X Y : CompHausLike.{u} P} (f : X ≅ Y) : X ≃ₜ Y 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ≅ Y) (a : ↑X.toTop)
Goal: (CompHausLike.homeoOfIso f) a = f.hom a
-- CompHausLike.isoEquivHomeo_symm_apply
@[simps]
def isoEquivHomeo {X Y : CompHausLike.{u} P} : (X ≅ Y) ≃ (X ≃ₜ Y) 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : ↑X.toTop ≃ₜ ↑Y.toTop)
Goal: CompHausLike.isoEquivHomeo.symm f = CompHausLike.isoOfHomeo f
-- CompHausLike.isoEquivHomeo_apply
@[simps]
def isoEquivHomeo {X Y : CompHausLike.{u} P} : (X ≅ Y) ≃ (X ≃ₜ Y) 
Arguments: {P : TopCat → Prop} {X Y : CompHausLike P} (f : X ≅ Y)
Goal: CompHausLike.isoEquivHomeo f = CompHausLike.homeoOfIso f
-- LightProfinite.map_liftedLimit
lemma map_liftedLimit {C D J : Type*} [Category C] [Category D] [Category J] {K : J ⥤ C}
    {F : C ⥤ D} [CreatesLimit K F] {c : Cone (K ⋙ F)} (t : IsLimit c) (n : J) :
    (liftedLimitMapsToOriginal t).inv.hom ≫ F.map ((liftLimit t).π.app n) = c.π.app n 
Arguments: {C : Type u_1} {D : Type u_2} {J : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} J] {K : J ⥤ C} {F : C ⥤ D} [CategoryTheory.CreatesLimit K F] {c : CategoryTheory.Limits.Cone (K ⋙ F)} (t : CategoryTheory.Limits.IsLimit c) (n : J)
Goal: (CategoryTheory.liftedLimitMapsToOriginal t).inv.hom ≫ F.map ((CategoryTheory.liftLimit t).π.app n) = c.π.app n
-- LightProfinite.lightToProfinite_map_proj_eq
lemma lightToProfinite_map_proj_eq (n : ℕ) : lightToProfinite.map (S.proj n) =
    (lightToProfinite.obj S).asLimitCone.π.app _ 
Arguments: (S : LightProfinite) (n : ℕ)
Goal: lightToProfinite.map (S.proj n) =
  (lightToProfinite.obj S).asLimitCone.π.app
    ((CategoryTheory.Limits.sequentialFunctor (DiscreteQuotient ↑(lightToProfinite.obj S).toTop)).obj (Opposite.op n))
-- LightProfinite.proj_surjective
lemma proj_surjective (n : ℕ) : Function.Surjective (S.proj n) 
Arguments: (S : LightProfinite) (n : ℕ)
Goal: Function.Surjective ⇑(S.proj n)
-- LightProfinite.proj_comp_transitionMap
lemma proj_comp_transitionMap (n : ℕ) :
    S.proj (n + 1) ≫ S.diagram.map ⟨homOfLE (Nat.le_succ _)⟩ = S.proj n 
Arguments: (S : LightProfinite) (n : ℕ)
Goal: S.proj (n + 1) ≫ S.diagram.map (Opposite.op (CategoryTheory.homOfLE ⋯)) = S.proj n
-- LightProfinite.proj_comp_transitionMap'
lemma proj_comp_transitionMap' (n : ℕ) : S.transitionMap n ∘ S.proj (n + 1) = S.proj n 
Arguments: (S : LightProfinite) (n : ℕ)
Goal: ⇑(S.transitionMap n) ∘ ⇑(S.proj (n + 1)) = ⇑(S.proj n)
-- LightProfinite.proj_comp_transitionMapLE
lemma proj_comp_transitionMapLE {n m : ℕ} (h : n ≤ m) :
    S.proj m ≫ S.diagram.map ⟨homOfLE h⟩ = S.proj n 
Arguments: (S : LightProfinite) {n m : ℕ} (h : n ≤ m)
Goal: S.proj m ≫ S.diagram.map (Opposite.op (CategoryTheory.homOfLE h)) = S.proj n
-- LightProfinite.proj_comp_transitionMapLE'
lemma proj_comp_transitionMapLE' {n m : ℕ} (h : n ≤ m) :
    S.transitionMapLE h ∘ S.proj m  = S.proj n 
Arguments: (S : LightProfinite) {n m : ℕ} (h : n ≤ m)
Goal: ⇑(S.transitionMapLE h) ∘ ⇑(S.proj m) = ⇑(S.proj n)
-- LightProfinite.surjective_transitionMap
lemma surjective_transitionMap (n : ℕ) : Function.Surjective (S.transitionMap n) 
Arguments: (S : LightProfinite) (n : ℕ)
Goal: Function.Surjective ⇑(S.transitionMap n)
-- LightProfinite.surjective_transitionMapLE
lemma surjective_transitionMapLE {n m : ℕ} (h : n ≤ m) :
    Function.Surjective (S.transitionMapLE h) 
Arguments: (S : LightProfinite) {n m : ℕ} (h : n ≤ m)
Goal: Function.Surjective ⇑(S.transitionMapLE h)
-- LightProfinite.pullback.condition
@[reassoc]
lemma pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g 
Arguments: {X Y B : LightProfinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (LightProfinite.pullback.fst f g) f =
  CategoryTheory.CategoryStruct.comp (LightProfinite.pullback.snd f g) g
-- LightProfinite.pullback.lift_fst
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : LightProfinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a 
Arguments: {X Y B : LightProfinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : LightProfinite} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (LightProfinite.pullback.lift f g a b w) (LightProfinite.pullback.fst f g) = a
-- LightProfinite.pullback.lift_snd
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : LightProfinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.snd f g = b 
Arguments: {X Y B : LightProfinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : LightProfinite} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (LightProfinite.pullback.lift f g a b w) (LightProfinite.pullback.snd f g) = b
-- LightProfinite.pullback.hom_ext
lemma pullback.hom_ext {Z : LightProfinite.{u}} (a b : Z ⟶ pullback f g)
    (hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
    (hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b 
Arguments: {X Y B : LightProfinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : LightProfinite} (a b : Z ⟶ LightProfinite.pullback f g) (hfst :
  CategoryTheory.CategoryStruct.comp a (LightProfinite.pullback.fst f g) =
    CategoryTheory.CategoryStruct.comp b (LightProfinite.pullback.fst f g)) (hsnd :
  CategoryTheory.CategoryStruct.comp a (LightProfinite.pullback.snd f g) =
    CategoryTheory.CategoryStruct.comp b (LightProfinite.pullback.snd f g))
Goal: a = b