ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_map_left
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (P : CategoryTheory.Limits.IndObjectPresentation A)
Goal: ∀ {X Y : P.I} (f : X ⟶ Y), (P.toCostructuredArrow.map f).left = P.F.map f
-- CategoryTheory.Limits.IndObjectPresentation.toCostructuredArrow_obj_left
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (P : CategoryTheory.Limits.IndObjectPresentation A) (X : P.I)
Goal: (P.toCostructuredArrow.obj X).left = P.F.obj X
-- CategoryTheory.Limits.IndObjectPresentation.yoneda_F
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).F = CategoryTheory.Functor.fromPUnit X
-- CategoryTheory.Limits.IndObjectPresentation.yoneda_I
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).I = CategoryTheory.Discrete PUnit.{v + 1}
-- CategoryTheory.Limits.IndObjectPresentation.yoneda_ℐ
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).ℐ = CategoryTheory.discreteCategory PUnit.{v + 1}
-- CategoryTheory.Limits.IndObjectPresentation.yoneda_ι_app
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) (s : CategoryTheory.Discrete PUnit.{v + 1})
Goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).ι.app s =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.fromPUnit X).comp CategoryTheory.yoneda).obj s)
-- CategoryTheory.Limits.IndObjectPresentation.yoneda_isColimit_desc
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C) (s : CategoryTheory.Limits.Cocone ((CategoryTheory.Functor.fromPUnit X).comp CategoryTheory.yoneda))
Goal: (CategoryTheory.Limits.IndObjectPresentation.yoneda X).isColimit.desc s = s.ι.app { as := PUnit.unit }
-- CategoryTheory.Limits.IsIndObject.nonempty_presentation
structure IsIndObject (A : Cᵒᵖ ⥤ Type v) : Prop where
  mk' :: nonempty_presentation : Nonempty (IndObjectPresentation A)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (self : CategoryTheory.Limits.IsIndObject A)
Goal: Nonempty (CategoryTheory.Limits.IndObjectPresentation A)
-- CategoryTheory.Limits.IsIndObject.mk
theorem IsIndObject.mk {A : Cᵒᵖ ⥤ Type v} (P : IndObjectPresentation A) : IsIndObject A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (P : CategoryTheory.Limits.IndObjectPresentation A)
Goal: CategoryTheory.Limits.IsIndObject A
-- CategoryTheory.Limits.isIndObject_yoneda
theorem isIndObject_yoneda (X : C) : IsIndObject (yoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : C)
Goal: CategoryTheory.Limits.IsIndObject (CategoryTheory.yoneda.obj X)
-- CategoryTheory.Limits.IsIndObject.map
theorem map {A B : Cᵒᵖ ⥤ Type v} (η : A ⟶ B) [IsIso η] : IsIndObject A → IsIndObject B
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : A ⟶ B) [CategoryTheory.IsIso η]
Goal: CategoryTheory.Limits.IsIndObject A → CategoryTheory.Limits.IsIndObject B
-- CategoryTheory.Limits.IsIndObject.iff_of_iso
theorem iff_of_iso {A B : Cᵒᵖ ⥤ Type v} (η : A ⟶ B) [IsIso η] : IsIndObject A ↔ IsIndObject B 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : A ⟶ B) [CategoryTheory.IsIso η]
Goal: CategoryTheory.Limits.IsIndObject A ↔ CategoryTheory.Limits.IsIndObject B
-- CategoryTheory.Limits.IsIndObject.isFiltered
theorem isFiltered (h : IsIndObject A) : IsFiltered (CostructuredArrow yoneda A) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (h : CategoryTheory.Limits.IsIndObject A)
Goal: CategoryTheory.IsFiltered (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
-- CategoryTheory.Limits.IsIndObject.finallySmall
theorem finallySmall (h : IsIndObject A) : FinallySmall.{v} (CostructuredArrow yoneda A) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (h : CategoryTheory.Limits.IsIndObject A)
Goal: CategoryTheory.FinallySmall (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
-- CategoryTheory.Limits.isIndObject_of_isFiltered_of_finallySmall
theorem isIndObject_of_isFiltered_of_finallySmall (A : Cᵒᵖ ⥤ Type v)
    [IsFiltered (CostructuredArrow yoneda A)] [FinallySmall.{v} (CostructuredArrow yoneda A)] :
    IsIndObject A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) [CategoryTheory.IsFiltered (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)] [CategoryTheory.FinallySmall (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)]
Goal: CategoryTheory.Limits.IsIndObject A
-- CategoryTheory.Limits.isIndObject_iff
theorem isIndObject_iff (A : Cᵒᵖ ⥤ Type v) : IsIndObject A ↔
    (IsFiltered (CostructuredArrow yoneda A) ∧ FinallySmall.{v} (CostructuredArrow yoneda A)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: CategoryTheory.Limits.IsIndObject A ↔
  CategoryTheory.IsFiltered (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) ∧
    CategoryTheory.FinallySmall (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
-- CategoryTheory.Limits.Types.descSet_spec
lemma descSet_spec (s : Set c.pt) (ls : Set lc.pt) :
    descSet hc ls = s ↔ ∀ j x, lc.ι.app j ⟨x⟩ ∈ ls ↔ c.ι.app j x ∈ s 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) {lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})} (s : Set c.pt) (ls : Set lc.pt)
Goal: CategoryTheory.Limits.Types.descSet hc ls = s ↔ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ ls ↔ c.ι.app j x ∈ s
-- CategoryTheory.Limits.Types.mem_descSet_singleton
lemma mem_descSet_singleton {x : lc.pt} {j : J} {y : K.obj j} :
    c.ι.app j y ∈ descSet hc {x} ↔ lc.ι.app j ⟨y⟩ = x 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) {lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})} {x : lc.pt} {j : J} {y : K.obj j}
Goal: c.ι.app j y ∈ CategoryTheory.Limits.Types.descSet hc {x} ↔ lc.ι.app j { down := y } = x
-- CategoryTheory.Limits.Types.descSet_univ
lemma descSet_univ : descSet hc (@Set.univ lc.pt) = Set.univ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u}))
Goal: CategoryTheory.Limits.Types.descSet hc Set.univ = Set.univ
-- CategoryTheory.Limits.Types.iUnion_descSet_singleton
lemma iUnion_descSet_singleton : ⋃ x : lc.pt, descSet hc {x} = Set.univ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u}))
Goal: ⋃ x, CategoryTheory.Limits.Types.descSet hc {x} = Set.univ
-- CategoryTheory.Limits.Types.descSet_empty
lemma descSet_empty : descSet hc (∅ : Set lc.pt) = ∅ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u}))
Goal: CategoryTheory.Limits.Types.descSet hc ∅ = ∅
-- CategoryTheory.Limits.Types.descSet_inter_of_ne
lemma descSet_inter_of_ne (x y : lc.pt) (hn : x ≠ y) : descSet hc {x} ∩ descSet hc {y} = ∅ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})) (x y : lc.pt) (hn : x ≠ y)
Goal: CategoryTheory.Limits.Types.descSet hc {x} ∩ CategoryTheory.Limits.Types.descSet hc {y} = ∅
-- CategoryTheory.Limits.Types.exists_unique_mem_descSet
lemma exists_unique_mem_descSet (x : c.pt) : ∃! y : lc.pt, x ∈ descSet hc {y} 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})) (x : c.pt)
Goal: ∃! y, x ∈ CategoryTheory.Limits.Types.descSet hc {y}
-- CategoryTheory.Limits.Types.descFun_apply_spec
lemma descFun_apply_spec {x : c.pt} {y : lc.pt} : descFun hc lc x = y ↔ x ∈ descSet hc {y} 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})) {x : c.pt} {y : lc.pt}
Goal: CategoryTheory.Limits.Types.descFun hc lc x = y ↔ x ∈ CategoryTheory.Limits.Types.descSet hc {y}
-- CategoryTheory.Limits.Types.descFun_spec
lemma descFun_spec (f : c.pt → lc.pt) :
    f = descFun hc lc ↔ ∀ j, f ∘ c.ι.app j = lc.ι.app j ∘ ULift.up 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_2, u_1} J] {K : CategoryTheory.Functor J (Type u)} {c : CategoryTheory.Limits.Cocone K} (hc : CategoryTheory.Limits.IsColimit c) (lc : CategoryTheory.Limits.Cocone (K.comp CategoryTheory.uliftFunctor.{v, u})) (f : c.pt → lc.pt)
Goal: f = CategoryTheory.Limits.Types.descFun hc lc ↔ ∀ (j : J), f ∘ c.ι.app j = lc.ι.app j ∘ ULift.up
-- CategoryTheory.Limits.Types.FilteredColimit.rel_of_quot_rel
theorem rel_of_quot_rel (x y : Σ j, F.obj j) :
    Quot.Rel F x y → FilteredColimit.Rel.{v, u} F x y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) (x y : (j : J) × F.obj j)
Goal: CategoryTheory.Limits.Types.Quot.Rel F x y → CategoryTheory.Limits.Types.FilteredColimit.Rel F x y
-- CategoryTheory.Limits.Types.FilteredColimit.eqvGen_quot_rel_of_rel
theorem eqvGen_quot_rel_of_rel (x y : Σ j, F.obj j) :
    FilteredColimit.Rel.{v, u} F x y → EqvGen (Quot.Rel F) x y 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) (x y : (j : J) × F.obj j)
Goal: CategoryTheory.Limits.Types.FilteredColimit.Rel F x y → EqvGen (CategoryTheory.Limits.Types.Quot.Rel F) x y
-- CategoryTheory.Limits.Types.FilteredColimit.rel_equiv
protected theorem rel_equiv : _root_.Equivalence (FilteredColimit.Rel.{v, u} F) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.IsFilteredOrEmpty J]
Goal: Equivalence (CategoryTheory.Limits.Types.FilteredColimit.Rel F)
-- CategoryTheory.Limits.Types.FilteredColimit.rel_eq_eqvGen_quot_rel
protected theorem rel_eq_eqvGen_quot_rel :
    FilteredColimit.Rel.{v, u} F = EqvGen (Quot.Rel F) 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.IsFilteredOrEmpty J]
Goal: CategoryTheory.Limits.Types.FilteredColimit.Rel F = EqvGen (CategoryTheory.Limits.Types.Quot.Rel F)
-- CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff_aux
theorem colimit_eq_iff_aux {i j : J} {xi : F.obj i} {xj : F.obj j} :
    (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj ↔
      FilteredColimit.Rel.{v, u} F ⟨i, xi⟩ ⟨j, xj⟩ 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.IsFilteredOrEmpty J] [CategoryTheory.Limits.HasColimit F] {i j : J} {xi : F.obj i} {xj : F.obj j}
Goal: (CategoryTheory.Limits.Types.colimitCocone F).ι.app i xi = (CategoryTheory.Limits.Types.colimitCocone F).ι.app j xj ↔
  CategoryTheory.Limits.Types.FilteredColimit.Rel F ⟨i, xi⟩ ⟨j, xj⟩
-- CategoryTheory.Limits.Types.FilteredColimit.isColimit_eq_iff
theorem isColimit_eq_iff {t : Cocone F} (ht : IsColimit t) {i j : J} {xi : F.obj i} {xj : F.obj j} :
    t.ι.app i xi = t.ι.app j xj ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.IsFilteredOrEmpty J] [CategoryTheory.Limits.HasColimit F] {t : CategoryTheory.Limits.Cocone F} (ht : CategoryTheory.Limits.IsColimit t) {i j : J} {xi : F.obj i} {xj : F.obj j}
Goal: t.ι.app i xi = t.ι.app j xj ↔ ∃ k f g, F.map f xi = F.map g xj
-- CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff
theorem colimit_eq_iff {i j : J} {xi : F.obj i} {xj : F.obj j} :
    colimit.ι F i xi = colimit.ι F j xj ↔
      ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj 
Arguments: {J : Type v} [CategoryTheory.Category.{w, v} J] (F : J ⥤ Type u) [CategoryTheory.IsFilteredOrEmpty J] [CategoryTheory.Limits.HasColimit F] {i j : J} {xi : F.obj i} {xj : F.obj j}
Goal: CategoryTheory.Limits.colimit.ι F i xi = CategoryTheory.Limits.colimit.ι F j xj ↔ ∃ k f g, F.map f xi = F.map g xj
-- CategoryTheory.ProdPreservesConnectedLimits.γ₂_app
@[simps]
def γ₂ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ K 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] [CategoryTheory.Limits.HasBinaryProducts C] {J : Type v₂} [CategoryTheory.SmallCategory J] {K : J ⥤ C} (X : C) (Y : J)
Goal: (CategoryTheory.ProdPreservesConnectedLimits.γ₂ X).app Y = CategoryTheory.Limits.prod.snd
-- CategoryTheory.ProdPreservesConnectedLimits.γ₁_app
@[simps]
def γ₁ {K : J ⥤ C} (X : C) : K ⋙ prod.functor.obj X ⟶ (Functor.const J).obj X 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] [CategoryTheory.Limits.HasBinaryProducts C] {J : Type v₂} [CategoryTheory.SmallCategory J] {K : J ⥤ C} (X : C) (Y : J)
Goal: (CategoryTheory.ProdPreservesConnectedLimits.γ₁ X).app Y = CategoryTheory.Limits.prod.fst
-- CategoryTheory.ProdPreservesConnectedLimits.forgetCone_pt
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] [CategoryTheory.Limits.HasBinaryProducts C] {J : Type v₂} [CategoryTheory.SmallCategory J] {X : C} {K : J ⥤ C} (s : CategoryTheory.Limits.Cone (K ⋙ CategoryTheory.Limits.prod.functor.obj X))
Goal: (CategoryTheory.ProdPreservesConnectedLimits.forgetCone s).pt = s.pt
-- CategoryTheory.ProdPreservesConnectedLimits.forgetCone_π
@[simps]
def forgetCone {X : C} {K : J ⥤ C} (s : Cone (K ⋙ prod.functor.obj X)) : Cone K 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] [CategoryTheory.Limits.HasBinaryProducts C] {J : Type v₂} [CategoryTheory.SmallCategory J] {X : C} {K : J ⥤ C} (s : CategoryTheory.Limits.Cone (K ⋙ CategoryTheory.Limits.prod.functor.obj X))
Goal: (CategoryTheory.ProdPreservesConnectedLimits.forgetCone s).π = s.π ≫ CategoryTheory.ProdPreservesConnectedLimits.γ₂ X
-- CategoryTheory.Limits.asEmptyCone_π_app
@[simps]
def asEmptyCone (X : C) : Cone (Functor.empty.{0} C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) (X_1 : CategoryTheory.Discrete PEmpty.{1})
Goal: (CategoryTheory.Limits.asEmptyCone X).π.app X_1 = id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim)
-- CategoryTheory.Limits.asEmptyCone_pt
@[simps]
def asEmptyCone (X : C) : Cone (Functor.empty.{0} C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Limits.asEmptyCone X).pt = X
-- CategoryTheory.Limits.asEmptyCocone_pt
@[simps]
def asEmptyCocone (X : C) : Cocone (Functor.empty.{0} C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: (CategoryTheory.Limits.asEmptyCocone X).pt = X
-- CategoryTheory.Limits.asEmptyCocone_ι_app
@[simps]
def asEmptyCocone (X : C) : Cocone (Functor.empty.{0} C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) (X_1 : CategoryTheory.Discrete PEmpty.{1})
Goal: (CategoryTheory.Limits.asEmptyCocone X).ι.app X_1 = id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim)
-- CategoryTheory.Limits.IsTerminal.hom_ext
theorem IsTerminal.hom_ext {X Y : C} (t : IsTerminal X) (f g : Y ⟶ X) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X) (f g : Y ⟶ X)
Goal: f = g
-- CategoryTheory.Limits.IsTerminal.comp_from
@[simp]
theorem IsTerminal.comp_from {Z : C} (t : IsTerminal Z) {X Y : C} (f : X ⟶ Y) :
    f ≫ t.from Y = t.from X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z : C} (t : CategoryTheory.Limits.IsTerminal Z) {X Y : C} (f : X ⟶ Y)
Goal: f ≫ t.from Y = t.from X
-- CategoryTheory.Limits.IsTerminal.from_self
@[simp]
theorem IsTerminal.from_self {X : C} (t : IsTerminal X) : t.from X = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (t : CategoryTheory.Limits.IsTerminal X)
Goal: t.from X = 𝟙 X
-- CategoryTheory.Limits.IsInitial.hom_ext
theorem IsInitial.hom_ext {X Y : C} (t : IsInitial X) (f g : X ⟶ Y) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsInitial X) (f g : X ⟶ Y)
Goal: f = g
-- CategoryTheory.Limits.IsInitial.to_comp
@[simp]
theorem IsInitial.to_comp {X : C} (t : IsInitial X) {Y Z : C} (f : Y ⟶ Z) : t.to Y ≫ f = t.to Z 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (t : CategoryTheory.Limits.IsInitial X) {Y Z : C} (f : Y ⟶ Z)
Goal: t.to Y ≫ f = t.to Z
-- CategoryTheory.Limits.IsInitial.to_self
@[simp]
theorem IsInitial.to_self {X : C} (t : IsInitial X) : t.to X = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (t : CategoryTheory.Limits.IsInitial X)
Goal: t.to X = 𝟙 X
-- CategoryTheory.Limits.IsTerminal.isSplitMono_from
theorem IsTerminal.isSplitMono_from {X Y : C} (t : IsTerminal X) (f : X ⟶ Y) : IsSplitMono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X) (f : X ⟶ Y)
Goal: CategoryTheory.IsSplitMono f
-- CategoryTheory.Limits.IsInitial.isSplitEpi_to
theorem IsInitial.isSplitEpi_to {X Y : C} (t : IsInitial X) (f : Y ⟶ X) : IsSplitEpi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsInitial X) (f : Y ⟶ X)
Goal: CategoryTheory.IsSplitEpi f
-- CategoryTheory.Limits.IsTerminal.mono_from
theorem IsTerminal.mono_from {X Y : C} (t : IsTerminal X) (f : X ⟶ Y) : Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X) (f : X ⟶ Y)
Goal: CategoryTheory.Mono f
-- CategoryTheory.Limits.IsInitial.epi_to
theorem IsInitial.epi_to {X Y : C} (t : IsInitial X) (f : Y ⟶ X) : Epi f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsInitial X) (f : Y ⟶ X)
Goal: CategoryTheory.Epi f
-- CategoryTheory.Limits.IsTerminal.uniqueUpToIso_inv
@[simps]
def IsTerminal.uniqueUpToIso {T T' : C} (hT : IsTerminal T) (hT' : IsTerminal T') : T ≅ T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T T' : C} (hT : CategoryTheory.Limits.IsTerminal T) (hT' : CategoryTheory.Limits.IsTerminal T')
Goal: (hT.uniqueUpToIso hT').inv = hT.from T'
-- CategoryTheory.Limits.IsTerminal.uniqueUpToIso_hom
@[simps]
def IsTerminal.uniqueUpToIso {T T' : C} (hT : IsTerminal T) (hT' : IsTerminal T') : T ≅ T' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {T T' : C} (hT : CategoryTheory.Limits.IsTerminal T) (hT' : CategoryTheory.Limits.IsTerminal T')
Goal: (hT.uniqueUpToIso hT').hom = hT'.from T
-- CategoryTheory.Limits.IsInitial.uniqueUpToIso_hom
@[simps]
def IsInitial.uniqueUpToIso {I I' : C} (hI : IsInitial I) (hI' : IsInitial I') : I ≅ I' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I I' : C} (hI : CategoryTheory.Limits.IsInitial I) (hI' : CategoryTheory.Limits.IsInitial I')
Goal: (hI.uniqueUpToIso hI').hom = hI.to I'
-- CategoryTheory.Limits.IsInitial.uniqueUpToIso_inv
@[simps]
def IsInitial.uniqueUpToIso {I I' : C} (hI : IsInitial I) (hI' : IsInitial I') : I ≅ I' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I I' : C} (hI : CategoryTheory.Limits.IsInitial I) (hI' : CategoryTheory.Limits.IsInitial I')
Goal: (hI.uniqueUpToIso hI').inv = hI'.to I
-- CategoryTheory.Limits.hasTerminalChangeDiagram
theorem hasTerminalChangeDiagram (h : HasLimit F₁) : HasLimit F₂ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {F₁ : CategoryTheory.Discrete PEmpty.{w + 1} ⥤ C} {F₂ : CategoryTheory.Discrete PEmpty.{w' + 1} ⥤ C} (h : CategoryTheory.Limits.HasLimit F₁)
Goal: CategoryTheory.Limits.HasLimit F₂
-- CategoryTheory.Limits.hasTerminalChangeUniverse
theorem hasTerminalChangeUniverse [h : HasLimitsOfShape (Discrete.{w} PEmpty) C] :
    HasLimitsOfShape (Discrete.{w'} PEmpty) C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [h : CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete PEmpty.{w + 1}) C]
Goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete PEmpty.{w' + 1}) C
-- CategoryTheory.Limits.hasInitialChangeDiagram
theorem hasInitialChangeDiagram (h : HasColimit F₁) : HasColimit F₂ 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] {F₁ : CategoryTheory.Discrete PEmpty.{w + 1} ⥤ C} {F₂ : CategoryTheory.Discrete PEmpty.{w' + 1} ⥤ C} (h : CategoryTheory.Limits.HasColimit F₁)
Goal: CategoryTheory.Limits.HasColimit F₂
-- CategoryTheory.Limits.hasInitialChangeUniverse
theorem hasInitialChangeUniverse [h : HasColimitsOfShape (Discrete.{w} PEmpty) C] :
    HasColimitsOfShape (Discrete.{w'} PEmpty) C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [h : CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete PEmpty.{w + 1}) C]
Goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete PEmpty.{w' + 1}) C
-- CategoryTheory.Limits.hasTerminal_of_unique
theorem hasTerminal_of_unique (X : C) [h : ∀ Y : C, Unique (Y ⟶ X)] : HasTerminal C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) [h : (Y : C) → Unique (Y ⟶ X)]
Goal: CategoryTheory.Limits.HasTerminal C
-- CategoryTheory.Limits.IsTerminal.hasTerminal
theorem IsTerminal.hasTerminal {X : C} (h : IsTerminal X) : HasTerminal C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (h : CategoryTheory.Limits.IsTerminal X)
Goal: CategoryTheory.Limits.HasTerminal C
-- CategoryTheory.Limits.hasInitial_of_unique
theorem hasInitial_of_unique (X : C) [h : ∀ Y : C, Unique (X ⟶ Y)] : HasInitial C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) [h : (Y : C) → Unique (X ⟶ Y)]
Goal: CategoryTheory.Limits.HasInitial C
-- CategoryTheory.Limits.IsInitial.hasInitial
theorem IsInitial.hasInitial {X : C} (h : IsInitial X) : HasInitial C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (h : CategoryTheory.Limits.IsInitial X)
Goal: CategoryTheory.Limits.HasInitial C
-- CategoryTheory.Limits.terminal.hom_ext
@[ext] theorem terminal.hom_ext [HasTerminal C] {P : C} (f g : P ⟶ ⊤_ C) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C] {P : C} (f g : P ⟶ ⊤_ C)
Goal: f = g
-- CategoryTheory.Limits.initial.hom_ext
@[ext] theorem initial.hom_ext [HasInitial C] {P : C} (f g : ⊥_ C ⟶ P) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] {P : C} (f g : ⊥_ C ⟶ P)
Goal: f = g