ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Fork.π_comp_hom
@[reassoc (attr := simp)]
theorem Fork.π_comp_hom {s t : Cofork f g} (f : s ⟶ t) : s.π ≫ f.hom = t.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Cofork f g}
Goal: ∀ (f_1 : s ⟶ t), CategoryTheory.CategoryStruct.comp s.π f_1.hom = t.π
-- CategoryTheory.Limits.Cofork.ext_hom
@[simps]
def Cofork.ext {s t : Cofork f g} (i : s.pt ≅ t.pt) (w : s.π ≫ i.hom = t.π := by aesop_cat) :
    s ≅ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Cofork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π := by aesop_cat)
Goal: (CategoryTheory.Limits.Cofork.ext i w).hom = CategoryTheory.Limits.Cofork.mkHom i.hom w
-- CategoryTheory.Limits.Cofork.ext_inv
@[simps]
def Cofork.ext {s t : Cofork f g} (i : s.pt ≅ t.pt) (w : s.π ≫ i.hom = t.π := by aesop_cat) :
    s ≅ t 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s t : CategoryTheory.Limits.Cofork f g} (i : s.pt ≅ t.pt) (w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π := by aesop_cat)
Goal: (CategoryTheory.Limits.Cofork.ext i w).inv = CategoryTheory.Limits.Cofork.mkHom i.inv ⋯
-- CategoryTheory.Limits.equalizer.fork_ι
@[simp]
theorem equalizer.fork_ι : (equalizer.fork f g).ι = equalizer.ι f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: (CategoryTheory.Limits.equalizer.fork f g).ι = CategoryTheory.Limits.equalizer.ι f g
-- CategoryTheory.Limits.equalizer.fork_π_app_zero
@[simp]
theorem equalizer.fork_π_app_zero : (equalizer.fork f g).π.app zero = equalizer.ι f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: (CategoryTheory.Limits.equalizer.fork f g).π.app CategoryTheory.Limits.WalkingParallelPair.zero =
  CategoryTheory.Limits.equalizer.ι f g
-- CategoryTheory.Limits.equalizer.condition
@[reassoc]
theorem equalizer.condition : equalizer.ι f g ≫ f = equalizer.ι f g ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.ι f g) f =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.ι f g) g
-- CategoryTheory.Limits.equalizer.lift_ι
@[reassoc]
theorem equalizer.lift_ι {W : C} (k : W ⟶ X) (h : k ≫ f = k ≫ g) :
    equalizer.lift k h ≫ equalizer.ι f g = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasEqualizer f g] {W : C} (k : W ⟶ X) (h : CategoryTheory.CategoryStruct.comp k f = CategoryTheory.CategoryStruct.comp k g)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.lift k h) (CategoryTheory.Limits.equalizer.ι f g) =
  k
-- CategoryTheory.Limits.equalizer.hom_ext
@[ext]
theorem equalizer.hom_ext {W : C} {k l : W ⟶ equalizer f g}
    (h : k ≫ equalizer.ι f g = l ≫ equalizer.ι f g) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasEqualizer f g] {W : C} {k l : W ⟶ CategoryTheory.Limits.equalizer f g} (h :
  CategoryTheory.CategoryStruct.comp k (CategoryTheory.Limits.equalizer.ι f g) =
    CategoryTheory.CategoryStruct.comp l (CategoryTheory.Limits.equalizer.ι f g))
Goal: k = l
-- CategoryTheory.Limits.equalizer.existsUnique
theorem equalizer.existsUnique {W : C} (k : W ⟶ X) (h : k ≫ f = k ≫ g) :
    ∃! l : W ⟶ equalizer f g, l ≫ equalizer.ι f g = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasEqualizer f g] {W : C} (k : W ⟶ X) (h : CategoryTheory.CategoryStruct.comp k f = CategoryTheory.CategoryStruct.comp k g)
Goal: ∃! l, CategoryTheory.CategoryStruct.comp l (CategoryTheory.Limits.equalizer.ι f g) = k
-- CategoryTheory.Limits.mono_of_isLimit_fork
theorem mono_of_isLimit_fork {c : Fork f g} (i : IsLimit c) : Mono (Fork.ι c) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {c : CategoryTheory.Limits.Fork f g} (i : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.Mono c.ι
-- CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_eq
theorem isIso_limit_cone_parallelPair_of_eq (h₀ : f = g) {c : Fork f g} (h : IsLimit c) :
    IsIso c.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (h₀ : f = g) {c : CategoryTheory.Limits.Fork f g} (h : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.IsIso c.ι
-- CategoryTheory.Limits.equalizer.ι_of_eq
theorem equalizer.ι_of_eq [HasEqualizer f g] (h : f = g) : IsIso (equalizer.ι f g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasEqualizer f g] (h : f = g)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.equalizer.ι f g)
-- CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_self
theorem isIso_limit_cone_parallelPair_of_self {c : Fork f f} (h : IsLimit c) : IsIso c.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.Fork f f} (h : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.IsIso c.ι
-- CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_epi
theorem isIso_limit_cone_parallelPair_of_epi {c : Fork f g} (h : IsLimit c) [Epi c.ι] : IsIso c.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {c : CategoryTheory.Limits.Fork f g} (h : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Epi c.ι]
Goal: CategoryTheory.IsIso c.ι
-- CategoryTheory.Limits.eq_of_epi_fork_ι
theorem eq_of_epi_fork_ι (t : Fork f g) [Epi (Fork.ι t)] : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Fork f g) [CategoryTheory.Epi t.ι]
Goal: f = g
-- CategoryTheory.Limits.eq_of_epi_equalizer
theorem eq_of_epi_equalizer [HasEqualizer f g] [Epi (equalizer.ι f g)] : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasEqualizer f g] [CategoryTheory.Epi (CategoryTheory.Limits.equalizer.ι f g)]
Goal: f = g
-- CategoryTheory.Limits.equalizer.isoSourceOfSelf_hom
@[simp]
theorem equalizer.isoSourceOfSelf_hom : (equalizer.isoSourceOfSelf f).hom = equalizer.ι f f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.equalizer.isoSourceOfSelf f).hom = CategoryTheory.Limits.equalizer.ι f f
-- CategoryTheory.Limits.equalizer.isoSourceOfSelf_inv
@[simp]
theorem equalizer.isoSourceOfSelf_inv :
    (equalizer.isoSourceOfSelf f).inv = equalizer.lift (𝟙 X) (by simp) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.equalizer.isoSourceOfSelf f).inv =
  CategoryTheory.Limits.equalizer.lift (CategoryTheory.CategoryStruct.id X) ⋯
-- CategoryTheory.Limits.coequalizer.cofork_π
@[simp]
theorem coequalizer.cofork_π : (coequalizer.cofork f g).π = coequalizer.π f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g]
Goal: (CategoryTheory.Limits.coequalizer.cofork f g).π = CategoryTheory.Limits.coequalizer.π f g
-- CategoryTheory.Limits.coequalizer.cofork_ι_app_one
theorem coequalizer.cofork_ι_app_one : (coequalizer.cofork f g).ι.app one = coequalizer.π f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g]
Goal: (CategoryTheory.Limits.coequalizer.cofork f g).ι.app CategoryTheory.Limits.WalkingParallelPair.one =
  CategoryTheory.Limits.coequalizer.π f g
-- CategoryTheory.Limits.coequalizer.condition
@[reassoc]
theorem coequalizer.condition : f ≫ coequalizer.π f g = g ≫ coequalizer.π f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasCoequalizer f g]
Goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.coequalizer.π f g) =
  CategoryTheory.CategoryStruct.comp g (CategoryTheory.Limits.coequalizer.π f g)
-- CategoryTheory.Limits.coequalizer.π_desc
@[reassoc]
theorem coequalizer.π_desc {W : C} (k : Y ⟶ W) (h : f ≫ k = g ≫ k) :
    coequalizer.π f g ≫ coequalizer.desc k h = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g)
    (CategoryTheory.Limits.coequalizer.desc k h) =
  k
-- CategoryTheory.Limits.coequalizer.π_colimMap_desc
theorem coequalizer.π_colimMap_desc {X' Y' Z : C} (f' g' : X' ⟶ Y') [HasCoequalizer f' g']
    (p : X ⟶ X') (q : Y ⟶ Y') (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') (h : Y' ⟶ Z)
    (wh : f' ≫ h = g' ≫ h) :
    coequalizer.π f g ≫ colimMap (parallelPairHom f g f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] {X' Y' Z : C} (f' g' : X' ⟶ Y') [CategoryTheory.Limits.HasCoequalizer f' g'] (p : X ⟶ X') (q : Y ⟶ Y') (wf : CategoryTheory.CategoryStruct.comp f q = CategoryTheory.CategoryStruct.comp p f') (wg : CategoryTheory.CategoryStruct.comp g q = CategoryTheory.CategoryStruct.comp p g') (h : Y' ⟶ Z) (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g)
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom f g f' g' p q wf wg))
      (CategoryTheory.Limits.coequalizer.desc h wh)) =
  CategoryTheory.CategoryStruct.comp q h
-- CategoryTheory.Limits.coequalizer.hom_ext
@[ext]
theorem coequalizer.hom_ext {W : C} {k l : coequalizer f g ⟶ W}
    (h : coequalizer.π f g ≫ k = coequalizer.π f g ≫ l) : k = l 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] {W : C} {k l : CategoryTheory.Limits.coequalizer f g ⟶ W} (h :
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) k =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) l)
Goal: k = l
-- CategoryTheory.Limits.coequalizer.existsUnique
theorem coequalizer.existsUnique {W : C} (k : Y ⟶ W) (h : f ≫ k = g ≫ k) :
    ∃! d : coequalizer f g ⟶ W, coequalizer.π f g ≫ d = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] {W : C} (k : Y ⟶ W) (h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k)
Goal: ∃! d, CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) d = k
-- CategoryTheory.Limits.epi_of_isColimit_cofork
theorem epi_of_isColimit_cofork {c : Cofork f g} (i : IsColimit c) : Epi c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {c : CategoryTheory.Limits.Cofork f g} (i : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.Epi c.π
-- CategoryTheory.Limits.isIso_colimit_cocone_parallelPair_of_eq
theorem isIso_colimit_cocone_parallelPair_of_eq (h₀ : f = g) {c : Cofork f g} (h : IsColimit c) :
    IsIso c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (h₀ : f = g) {c : CategoryTheory.Limits.Cofork f g} (h : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.IsIso c.π
-- CategoryTheory.Limits.coequalizer.π_of_eq
theorem coequalizer.π_of_eq [HasCoequalizer f g] (h : f = g) : IsIso (coequalizer.π f g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] (h : f = g)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.coequalizer.π f g)
-- CategoryTheory.Limits.isIso_colimit_cocone_parallelPair_of_self
theorem isIso_colimit_cocone_parallelPair_of_self {c : Cofork f f} (h : IsColimit c) : IsIso c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.Cofork f f} (h : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.IsIso c.π
-- CategoryTheory.Limits.isIso_limit_cocone_parallelPair_of_epi
theorem isIso_limit_cocone_parallelPair_of_epi {c : Cofork f g} (h : IsColimit c) [Mono c.π] :
    IsIso c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {c : CategoryTheory.Limits.Cofork f g} (h : CategoryTheory.Limits.IsColimit c) [CategoryTheory.Mono c.π]
Goal: CategoryTheory.IsIso c.π
-- CategoryTheory.Limits.eq_of_mono_cofork_π
theorem eq_of_mono_cofork_π (t : Cofork f g) [Mono (Cofork.π t)] : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g) [CategoryTheory.Mono t.π]
Goal: f = g
-- CategoryTheory.Limits.eq_of_mono_coequalizer
theorem eq_of_mono_coequalizer [HasCoequalizer f g] [Mono (coequalizer.π f g)] : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Mono (CategoryTheory.Limits.coequalizer.π f g)]
Goal: f = g
-- CategoryTheory.Limits.coequalizer.isoTargetOfSelf_hom
@[simp]
theorem coequalizer.isoTargetOfSelf_hom :
    (coequalizer.isoTargetOfSelf f).hom = coequalizer.desc (𝟙 Y) (by simp) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.coequalizer.isoTargetOfSelf f).hom =
  CategoryTheory.Limits.coequalizer.desc (CategoryTheory.CategoryStruct.id Y) ⋯
-- CategoryTheory.Limits.coequalizer.isoTargetOfSelf_inv
@[simp]
theorem coequalizer.isoTargetOfSelf_inv : (coequalizer.isoTargetOfSelf f).inv = coequalizer.π f f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.coequalizer.isoTargetOfSelf f).inv = CategoryTheory.Limits.coequalizer.π f f
-- CategoryTheory.Limits.equalizerComparison_comp_π
@[reassoc (attr := simp)]
theorem equalizerComparison_comp_π [HasEqualizer f g] [HasEqualizer (G.map f) (G.map g)] :
    equalizerComparison f g G ≫ equalizer.ι (G.map f) (G.map g) = G.map (equalizer.ι f g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasEqualizer f g] [CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerComparison f g G)
    (CategoryTheory.Limits.equalizer.ι (G.map f) (G.map g)) =
  G.map (CategoryTheory.Limits.equalizer.ι f g)
-- CategoryTheory.Limits.map_lift_equalizerComparison
@[reassoc (attr := simp)]
theorem map_lift_equalizerComparison [HasEqualizer f g] [HasEqualizer (G.map f) (G.map g)] {Z : C}
    {h : Z ⟶ X} (w : h ≫ f = h ≫ g) :
    G.map (equalizer.lift h w) ≫ equalizerComparison f g G =
      equalizer.lift (G.map h) (by simp only [← G.map_comp, w]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasEqualizer f g] [CategoryTheory.Limits.HasEqualizer (G.map f) (G.map g)] {Z : C} {h : Z ⟶ X} (w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g)
Goal: CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.equalizer.lift h w))
    (CategoryTheory.Limits.equalizerComparison f g G) =
  CategoryTheory.Limits.equalizer.lift (G.map h) ⋯
-- CategoryTheory.Limits.ι_comp_coequalizerComparison
@[reassoc (attr := simp)]
theorem ι_comp_coequalizerComparison [HasCoequalizer f g] [HasCoequalizer (G.map f) (G.map g)] :
    coequalizer.π _ _ ≫ coequalizerComparison f g G = G.map (coequalizer.π _ _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π (G.map f) (G.map g))
    (CategoryTheory.Limits.coequalizerComparison f g G) =
  G.map (CategoryTheory.Limits.coequalizer.π f g)
-- CategoryTheory.Limits.coequalizerComparison_map_desc
@[reassoc (attr := simp)]
theorem coequalizerComparison_map_desc [HasCoequalizer f g] [HasCoequalizer (G.map f) (G.map g)]
    {Z : C} {h : Y ⟶ Z} (w : f ≫ h = g ≫ h) :
    coequalizerComparison f g G ≫ G.map (coequalizer.desc h w) =
      coequalizer.desc (G.map h) (by simp only [← G.map_comp, w]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasCoequalizer f g] [CategoryTheory.Limits.HasCoequalizer (G.map f) (G.map g)] {Z : C} {h : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizerComparison f g G)
    (G.map (CategoryTheory.Limits.coequalizer.desc h w)) =
  CategoryTheory.Limits.coequalizer.desc (G.map h) ⋯
-- CategoryTheory.Limits.hasEqualizers_of_hasLimit_parallelPair
theorem hasEqualizers_of_hasLimit_parallelPair
    [∀ {X Y : C} {f g : X ⟶ Y}, HasLimit (parallelPair f g)] : HasEqualizers C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [∀ {X Y : C} {f g : X ⟶ Y}, CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair f g)]
Goal: CategoryTheory.Limits.HasEqualizers C
-- CategoryTheory.Limits.hasCoequalizers_of_hasColimit_parallelPair
theorem hasCoequalizers_of_hasColimit_parallelPair
    [∀ {X Y : C} {f g : X ⟶ Y}, HasColimit (parallelPair f g)] : HasCoequalizers C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [∀ {X Y : C} {f g : X ⟶ Y}, CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f g)]
Goal: CategoryTheory.Limits.HasCoequalizers C
-- CategoryTheory.Limits.coneOfIsSplitMono_pt
-- @[simps (config := { rhsMd := semireducible })] Porting note: no semireducible
@[simps!]
noncomputable def coneOfIsSplitMono : Fork (𝟙 Y) (retraction f ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitMono f]
Goal: (CategoryTheory.Limits.coneOfIsSplitMono f).pt = X
-- CategoryTheory.Limits.coneOfIsSplitMono_π_app
-- @[simps (config := { rhsMd := semireducible })] Porting note: no semireducible
@[simps!]
noncomputable def coneOfIsSplitMono : Fork (𝟙 Y) (retraction f ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitMono f]
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
    CategoryTheory.Limits.WalkingParallelPair.rec (motive := fun t =>
      X_1 = t →
        (X ⟶
          (CategoryTheory.Limits.parallelPair (CategoryTheory.CategoryStruct.id Y)
                (CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f)).obj
            X_1))
      (fun h => ⋯ ▸ f) (fun h => ⋯ ▸ f) X_1 ⋯
-- CategoryTheory.Limits.coneOfIsSplitMono_ι
@[simp]
theorem coneOfIsSplitMono_ι : (coneOfIsSplitMono f).ι = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitMono f]
Goal: (CategoryTheory.Limits.coneOfIsSplitMono f).ι = f
-- CategoryTheory.Limits.hasEqualizer_comp_mono
@[instance]
theorem hasEqualizer_comp_mono [HasEqualizer f g] {Z : C} (h : Y ⟶ Z) [Mono h] :
    HasEqualizer (f ≫ h) (g ≫ h) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y) [CategoryTheory.Limits.HasEqualizer f g] {Z : C} (h : Y ⟶ Z) [CategoryTheory.Mono h]
Goal: CategoryTheory.Limits.HasEqualizer (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.CategoryStruct.comp g h)
-- CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork_retraction
@[simps]
def splitMonoOfIdempotentOfIsLimitFork {X : C} {f : X ⟶ X} (hf : f ≫ f = f) {c : Fork (𝟙 X) f}
    (i : IsLimit c) : SplitMono c.ι 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X} (hf : CategoryTheory.CategoryStruct.comp f f = f) {c : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsLimit c)
Goal: (CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork C hf i).retraction =
  i.lift (CategoryTheory.Limits.Fork.ofι f ⋯)
-- CategoryTheory.Limits.coconeOfIsSplitEpi_ι_app
-- @[simps (config := { rhsMd := semireducible })] Porting note: no semireducible
@[simps!]
noncomputable def coconeOfIsSplitEpi : Cofork (𝟙 X) (f ≫ section_ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitEpi f]
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingParallelPair),
  (CategoryTheory.Limits.coconeOfIsSplitEpi f).ι.app X_1 = CategoryTheory.Limits.WalkingParallelPair.rec f f X_1
-- CategoryTheory.Limits.coconeOfIsSplitEpi_pt
-- @[simps (config := { rhsMd := semireducible })] Porting note: no semireducible
@[simps!]
noncomputable def coconeOfIsSplitEpi : Cofork (𝟙 X) (f ≫ section_ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitEpi f]
Goal: (CategoryTheory.Limits.coconeOfIsSplitEpi f).pt = Y
-- CategoryTheory.Limits.coconeOfIsSplitEpi_π
@[simp]
theorem coconeOfIsSplitEpi_π : (coconeOfIsSplitEpi f).π = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsSplitEpi f]
Goal: (CategoryTheory.Limits.coconeOfIsSplitEpi f).π = f
-- CategoryTheory.Limits.hasCoequalizer_epi_comp
theorem hasCoequalizer_epi_comp [HasCoequalizer f g] {W : C} (h : W ⟶ X) [Epi h] :
    HasCoequalizer (h ≫ f) (h ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCoequalizer f g] {W : C} (h : W ⟶ X) [CategoryTheory.Epi h]
Goal: CategoryTheory.Limits.HasCoequalizer (CategoryTheory.CategoryStruct.comp h f) (CategoryTheory.CategoryStruct.comp h g)
-- CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork_section_
@[simps]
def splitEpiOfIdempotentOfIsColimitCofork {X : C} {f : X ⟶ X} (hf : f ≫ f = f) {c : Cofork (𝟙 X) f}
    (i : IsColimit c) : SplitEpi c.π 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X} (hf : CategoryTheory.CategoryStruct.comp f f = f) {c : CategoryTheory.Limits.Cofork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsColimit c)
Goal: (CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork C hf i).section_ =
  i.desc (CategoryTheory.Limits.Cofork.ofπ f ⋯)
-- CategoryTheory.Limits.KernelFork.map_condition
@[reassoc (attr := simp)]
lemma map_condition : G.map c.ι ≫ G.map f = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] {X Y : C} {f : X ⟶ Y} (c : CategoryTheory.Limits.KernelFork f) (G : C ⥤ D) [G.PreservesZeroMorphisms]
Goal: G.map (CategoryTheory.Limits.Fork.ι c) ≫ G.map f = 0
-- CategoryTheory.Limits.KernelFork.map_ι
@[simp]
lemma map_ι : (c.map G).ι = G.map c.ι 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] {X Y : C} {f : X ⟶ Y} (c : CategoryTheory.Limits.KernelFork f) (G : C ⥤ D) [G.PreservesZeroMorphisms]
Goal: CategoryTheory.Limits.Fork.ι (c.map G) = G.map (CategoryTheory.Limits.Fork.ι c)