ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_inv
@[simps]
def mapIsoOfIsColimit {cc : CokernelCofork f} {cc' : CokernelCofork f'}
    (hf : IsColimit cc) (hf' : IsColimit cc')
    (φ : Arrow.mk f ≅ Arrow.mk f') : cc.pt ≅ cc'.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f} {cc' : CategoryTheory.Limits.CokernelCofork f'} (hf : CategoryTheory.Limits.IsColimit cc) (hf' : CategoryTheory.Limits.IsColimit cc') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f')
Goal: (CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit hf hf' φ).inv =
  CategoryTheory.Limits.CokernelCofork.mapOfIsColimit hf' cc φ.inv
-- CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_hom
@[simps]
def mapIsoOfIsColimit {cc : CokernelCofork f} {cc' : CokernelCofork f'}
    (hf : IsColimit cc) (hf' : IsColimit cc')
    (φ : Arrow.mk f ≅ Arrow.mk f') : cc.pt ≅ cc'.pt 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f} {cc' : CategoryTheory.Limits.CokernelCofork f'} (hf : CategoryTheory.Limits.IsColimit cc) (hf' : CategoryTheory.Limits.IsColimit cc') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f')
Goal: (CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit hf hf' φ).hom =
  CategoryTheory.Limits.CokernelCofork.mapOfIsColimit hf cc' φ.hom
-- CategoryTheory.Limits.coequalizer_as_cokernel
@[simp]
theorem coequalizer_as_cokernel : coequalizer.π f 0 = cokernel.π f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f]
Goal: CategoryTheory.Limits.coequalizer.π f 0 = CategoryTheory.Limits.cokernel.π f
-- CategoryTheory.Limits.cokernel.condition
@[reassoc (attr := simp)]
theorem cokernel.condition : f ≫ cokernel.π f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f]
Goal: f ≫ CategoryTheory.Limits.cokernel.π f = 0
-- CategoryTheory.Limits.cokernel.π_desc
@[reassoc (attr := simp)]
theorem cokernel.π_desc {W : C} (k : Y ⟶ W) (h : f ≫ k = 0) :
    cokernel.π f ≫ cokernel.desc f k h = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] {W : C} (k : Y ⟶ W) (h : f ≫ k = 0)
Goal: CategoryTheory.Limits.cokernel.π f ≫ CategoryTheory.Limits.cokernel.desc f k h = k
-- CategoryTheory.Limits.colimit_ι_zero_cokernel_desc
@[reassoc (attr := simp)]
lemma colimit_ι_zero_cokernel_desc {C : Type*} [Category C]
    [HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (h : f ≫ g = 0) [HasCokernel f] :
    colimit.ι (parallelPair f 0) WalkingParallelPair.zero ≫ cokernel.desc f g h = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (h : f ≫ g = 0) [CategoryTheory.Limits.HasCokernel f]
Goal: CategoryTheory.Limits.colimit.ι (CategoryTheory.Limits.parallelPair f 0)
      CategoryTheory.Limits.WalkingParallelPair.zero ≫
    CategoryTheory.Limits.cokernel.desc f g h =
  0
-- CategoryTheory.Limits.cokernel.desc_zero
@[simp]
theorem cokernel.desc_zero {W : C} {h} : cokernel.desc f (0 : Y ⟶ W) h = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] {W : C} {h : f ≫ 0 = 0}
Goal: CategoryTheory.Limits.cokernel.desc f 0 h = 0
-- CategoryTheory.Limits.cokernel.map_desc
theorem cokernel.map_desc {X Y Z X' Y' Z' : C} (f : X ⟶ Y) [HasCokernel f] (g : Y ⟶ Z)
    (w : f ≫ g = 0) (f' : X' ⟶ Y') [HasCokernel f'] (g' : Y' ⟶ Z') (w' : f' ≫ g' = 0) (p : X ⟶ X')
    (q : Y ⟶ Y') (r : Z ⟶ Z') (h₁ : f ≫ q = p ≫ f') (h₂ : g ≫ r = q ≫ g') :
    cokernel.map f f' p q h₁ ≫ cokernel.desc f' g' w' = cokernel.desc f g w ≫ r 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z X' Y' Z' : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] (g : Y ⟶ Z) (w : f ≫ g = 0) (f' : X' ⟶ Y') [CategoryTheory.Limits.HasCokernel f'] (g' : Y' ⟶ Z') (w' : f' ≫ g' = 0) (p : X ⟶ X') (q : Y ⟶ Y') (r : Z ⟶ Z') (h₁ : f ≫ q = p ≫ f') (h₂ : g ≫ r = q ≫ g')
Goal: CategoryTheory.Limits.cokernel.map f f' p q h₁ ≫ CategoryTheory.Limits.cokernel.desc f' g' w' =
  CategoryTheory.Limits.cokernel.desc f g w ≫ r
-- CategoryTheory.Limits.cokernel.mapIso_hom
@[simps]
def cokernel.mapIso {X' Y' : C} (f' : X' ⟶ Y') [HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y')
    (w : f ≫ q.hom = p.hom ≫ f') : cokernel f ≅ cokernel f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.Limits.HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y') (w : f ≫ q.hom = p.hom ≫ f')
Goal: (CategoryTheory.Limits.cokernel.mapIso f f' p q w).hom = CategoryTheory.Limits.cokernel.map f f' p.hom q.hom w
-- CategoryTheory.Limits.cokernel.mapIso_inv
@[simps]
def cokernel.mapIso {X' Y' : C} (f' : X' ⟶ Y') [HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y')
    (w : f ≫ q.hom = p.hom ≫ f') : cokernel f ≅ cokernel f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.Limits.HasCokernel f'] (p : X ≅ X') (q : Y ≅ Y') (w : f ≫ q.hom = p.hom ≫ f')
Goal: (CategoryTheory.Limits.cokernel.mapIso f f' p q w).inv = CategoryTheory.Limits.cokernel.map f' f p.inv q.inv ⋯
-- CategoryTheory.Limits.eq_zero_of_mono_cokernel
theorem eq_zero_of_mono_cokernel [Mono (cokernel.π f)] : f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Mono (CategoryTheory.Limits.cokernel.π f)]
Goal: f = 0
-- CategoryTheory.Limits.cokernelZeroIsoTarget_hom
@[simp]
theorem cokernelZeroIsoTarget_hom :
    cokernelZeroIsoTarget.hom = cokernel.desc (0 : X ⟶ Y) (𝟙 Y) (by simp) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
Goal: CategoryTheory.Limits.cokernelZeroIsoTarget.hom = CategoryTheory.Limits.cokernel.desc 0 (𝟙 Y) ⋯
-- CategoryTheory.Limits.cokernelZeroIsoTarget_inv
@[simp]
theorem cokernelZeroIsoTarget_inv : cokernelZeroIsoTarget.inv = cokernel.π (0 : X ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
Goal: CategoryTheory.Limits.cokernelZeroIsoTarget.inv = CategoryTheory.Limits.cokernel.π 0
-- CategoryTheory.Limits.cokernelIsoOfEq_refl
@[simp]
theorem cokernelIsoOfEq_refl {h : f = f} : cokernelIsoOfEq h = Iso.refl (cokernel f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] {h : f = f}
Goal: CategoryTheory.Limits.cokernelIsoOfEq h = CategoryTheory.Iso.refl (CategoryTheory.Limits.cokernel f)
-- CategoryTheory.Limits.π_comp_cokernelIsoOfEq_hom
@[reassoc (attr := simp)]
theorem π_comp_cokernelIsoOfEq_hom {f g : X ⟶ Y} [HasCokernel f] [HasCokernel g] (h : f = g) :
    cokernel.π f ≫ (cokernelIsoOfEq h).hom = cokernel.π g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel g] (h : f = g)
Goal: CategoryTheory.Limits.cokernel.π f ≫ (CategoryTheory.Limits.cokernelIsoOfEq h).hom = CategoryTheory.Limits.cokernel.π g
-- CategoryTheory.Limits.π_comp_cokernelIsoOfEq_inv
@[reassoc (attr := simp)]
theorem π_comp_cokernelIsoOfEq_inv {f g : X ⟶ Y} [HasCokernel f] [HasCokernel g] (h : f = g) :
    cokernel.π _ ≫ (cokernelIsoOfEq h).inv = cokernel.π _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel g] (h : f = g)
Goal: CategoryTheory.Limits.cokernel.π g ≫ (CategoryTheory.Limits.cokernelIsoOfEq h).inv = CategoryTheory.Limits.cokernel.π f
-- CategoryTheory.Limits.cokernelIsoOfEq_hom_comp_desc
@[reassoc (attr := simp)]
theorem cokernelIsoOfEq_hom_comp_desc {Z} {f g : X ⟶ Y} [HasCokernel f] [HasCokernel g] (h : f = g)
    (e : Y ⟶ Z) (he) :
    (cokernelIsoOfEq h).hom ≫ cokernel.desc _ e he = cokernel.desc _ e (by simp [h, he]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel g] (h : f = g) (e : Y ⟶ Z) (he : g ≫ e = 0)
Goal: (CategoryTheory.Limits.cokernelIsoOfEq h).hom ≫ CategoryTheory.Limits.cokernel.desc g e he =
  CategoryTheory.Limits.cokernel.desc f e ⋯
-- CategoryTheory.Limits.cokernelIsoOfEq_inv_comp_desc
@[reassoc (attr := simp)]
theorem cokernelIsoOfEq_inv_comp_desc {Z} {f g : X ⟶ Y} [HasCokernel f] [HasCokernel g] (h : f = g)
    (e : Y ⟶ Z) (he) :
    (cokernelIsoOfEq h).inv ≫ cokernel.desc _ e he = cokernel.desc _ e (by simp [← h, he]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel g] (h : f = g) (e : Y ⟶ Z) (he : f ≫ e = 0)
Goal: (CategoryTheory.Limits.cokernelIsoOfEq h).inv ≫ CategoryTheory.Limits.cokernel.desc f e he =
  CategoryTheory.Limits.cokernel.desc g e ⋯
-- CategoryTheory.Limits.cokernelIsoOfEq_trans
@[simp]
theorem cokernelIsoOfEq_trans {f g h : X ⟶ Y} [HasCokernel f] [HasCokernel g] [HasCokernel h]
    (w₁ : f = g) (w₂ : g = h) :
    cokernelIsoOfEq w₁ ≪≫ cokernelIsoOfEq w₂ = cokernelIsoOfEq (w₁.trans w₂) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f g h : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel g] [CategoryTheory.Limits.HasCokernel h] (w₁ : f = g) (w₂ : g = h)
Goal: CategoryTheory.Limits.cokernelIsoOfEq w₁ ≪≫ CategoryTheory.Limits.cokernelIsoOfEq w₂ =
  CategoryTheory.Limits.cokernelIsoOfEq ⋯
-- CategoryTheory.Limits.cokernel_not_mono_of_nonzero
theorem cokernel_not_mono_of_nonzero (w : f ≠ 0) : ¬Mono (cokernel.π f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] (w : f ≠ 0)
Goal: ¬CategoryTheory.Mono (CategoryTheory.Limits.cokernel.π f)
-- CategoryTheory.Limits.cokernel_not_iso_of_nonzero
theorem cokernel_not_iso_of_nonzero (w : f ≠ 0) : IsIso (cokernel.π f) → False 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasCokernel f] (w : f ≠ 0)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.cokernel.π f) → False
-- CategoryTheory.Limits.cokernelCompIsIso_inv
@[simps]
def cokernelCompIsIso {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasCokernel f] [IsIso g] :
    cokernel (f ≫ g) ≅ cokernel f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.cokernelCompIsIso f g).inv =
  CategoryTheory.Limits.cokernel.desc f (g ≫ CategoryTheory.Limits.cokernel.π (f ≫ g)) ⋯
-- CategoryTheory.Limits.cokernelCompIsIso_hom
@[simps]
def cokernelCompIsIso {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasCokernel f] [IsIso g] :
    cokernel (f ≫ g) ≅ cokernel f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.cokernelCompIsIso f g).hom =
  CategoryTheory.Limits.cokernel.desc (f ≫ g) (CategoryTheory.inv g ≫ CategoryTheory.Limits.cokernel.π f) ⋯
-- CategoryTheory.Limits.cokernelEpiComp_hom
@[simps]
def cokernelEpiComp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [Epi f] [HasCokernel g] :
    cokernel (f ≫ g) ≅ cokernel g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Epi f] [CategoryTheory.Limits.HasCokernel g]
Goal: (CategoryTheory.Limits.cokernelEpiComp f g).hom =
  CategoryTheory.Limits.cokernel.desc (f ≫ g) (CategoryTheory.Limits.cokernel.π g) ⋯
-- CategoryTheory.Limits.cokernelEpiComp_inv
@[simps]
def cokernelEpiComp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [Epi f] [HasCokernel g] :
    cokernel (f ≫ g) ≅ cokernel g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Epi f] [CategoryTheory.Limits.HasCokernel g]
Goal: (CategoryTheory.Limits.cokernelEpiComp f g).inv =
  CategoryTheory.Limits.cokernel.desc g (CategoryTheory.Limits.cokernel.π (f ≫ g)) ⋯
-- CategoryTheory.Limits.cokernel.π_of_epi
theorem cokernel.π_of_epi [HasCokernel f] [Epi f] : cokernel.π f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Epi f]
Goal: CategoryTheory.Limits.cokernel.π f = 0
-- CategoryTheory.Limits.MonoFactorisation.kernel_ι_comp
@[simp]
theorem MonoFactorisation.kernel_ι_comp [HasKernel f] (F : MonoFactorisation f) :
    kernel.ι f ≫ F.e = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] (F : CategoryTheory.Limits.MonoFactorisation f)
Goal: CategoryTheory.Limits.kernel.ι f ≫ F.e = 0
-- CategoryTheory.Limits.cokernelImageι_hom
@[simps]
def cokernelImageι {X Y : C} (f : X ⟶ Y) [HasImage f] [HasCokernel (image.ι f)] [HasCokernel f]
    [Epi (factorThruImage f)] : cokernel (image.ι f) ≅ cokernel f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] [CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.image.ι f)] [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Epi (CategoryTheory.Limits.factorThruImage f)]
Goal: (CategoryTheory.Limits.cokernelImageι f).hom =
  CategoryTheory.Limits.cokernel.desc (CategoryTheory.Limits.image.ι f) (CategoryTheory.Limits.cokernel.π f) ⋯
-- CategoryTheory.Limits.cokernelImageι_inv
@[simps]
def cokernelImageι {X Y : C} (f : X ⟶ Y) [HasImage f] [HasCokernel (image.ι f)] [HasCokernel f]
    [Epi (factorThruImage f)] : cokernel (image.ι f) ≅ cokernel f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] [CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.image.ι f)] [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Epi (CategoryTheory.Limits.factorThruImage f)]
Goal: (CategoryTheory.Limits.cokernelImageι f).inv =
  CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.image.ι f)) ⋯
-- CategoryTheory.Limits.cokernel.π_of_zero
theorem cokernel.π_of_zero : IsIso (cokernel.π (0 : X ⟶ Y)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.cokernel.π 0)
-- CategoryTheory.Limits.kernelComparison_comp_ι
@[reassoc (attr := simp)]
theorem kernelComparison_comp_ι [HasKernel f] [HasKernel (G.map f)] :
    kernelComparison f G ≫ kernel.ι (G.map f) = G.map (kernel.ι f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel (G.map f)]
Goal: CategoryTheory.Limits.kernelComparison f G ≫ CategoryTheory.Limits.kernel.ι (G.map f) =
  G.map (CategoryTheory.Limits.kernel.ι f)
-- CategoryTheory.Limits.map_lift_kernelComparison
@[reassoc (attr := simp)]
theorem map_lift_kernelComparison [HasKernel f] [HasKernel (G.map f)] {Z : C} {h : Z ⟶ X}
    (w : h ≫ f = 0) :
    G.map (kernel.lift _ h w) ≫ kernelComparison f G =
      kernel.lift _ (G.map h) (by simp only [← G.map_comp, w, Functor.map_zero]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel (G.map f)] {Z : C} {h : Z ⟶ X} (w : h ≫ f = 0)
Goal: G.map (CategoryTheory.Limits.kernel.lift f h w) ≫ CategoryTheory.Limits.kernelComparison f G =
  CategoryTheory.Limits.kernel.lift (G.map f) (G.map h) ⋯
-- CategoryTheory.Limits.kernelComparison_comp_kernel_map
@[reassoc]
theorem kernelComparison_comp_kernel_map {X' Y' : C} [HasKernel f] [HasKernel (G.map f)]
    (g : X' ⟶ Y') [HasKernel g] [HasKernel (G.map g)] (p : X ⟶ X') (q : Y ⟶ Y')
    (hpq : f ≫ q = p ≫ g) :
    kernelComparison f G ≫
        kernel.map (G.map f) (G.map g) (G.map p) (G.map q) (by rw [← G.map_comp, hpq, G.map_comp]) =
      G.map (kernel.map f g p q hpq) ≫ kernelComparison g G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X' Y' : C} [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel (G.map f)] (g : X' ⟶ Y') [CategoryTheory.Limits.HasKernel g] [CategoryTheory.Limits.HasKernel (G.map g)] (p : X ⟶ X') (q : Y ⟶ Y') (hpq : f ≫ q = p ≫ g)
Goal: CategoryTheory.Limits.kernelComparison f G ≫
    CategoryTheory.Limits.kernel.map (G.map f) (G.map g) (G.map p) (G.map q) ⋯ =
  G.map (CategoryTheory.Limits.kernel.map f g p q hpq) ≫ CategoryTheory.Limits.kernelComparison g G
-- CategoryTheory.Limits.π_comp_cokernelComparison
@[reassoc (attr := simp)]
theorem π_comp_cokernelComparison [HasCokernel f] [HasCokernel (G.map f)] :
    cokernel.π (G.map f) ≫ cokernelComparison f G = G.map (cokernel.π _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel (G.map f)]
Goal: CategoryTheory.Limits.cokernel.π (G.map f) ≫ CategoryTheory.Limits.cokernelComparison f G =
  G.map (CategoryTheory.Limits.cokernel.π f)
-- CategoryTheory.Limits.cokernelComparison_map_desc
@[reassoc (attr := simp)]
theorem cokernelComparison_map_desc [HasCokernel f] [HasCokernel (G.map f)] {Z : C} {h : Y ⟶ Z}
    (w : f ≫ h = 0) :
    cokernelComparison f G ≫ G.map (cokernel.desc _ h w) =
      cokernel.desc _ (G.map h) (by simp only [← G.map_comp, w, Functor.map_zero]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel (G.map f)] {Z : C} {h : Y ⟶ Z} (w : f ≫ h = 0)
Goal: CategoryTheory.Limits.cokernelComparison f G ≫ G.map (CategoryTheory.Limits.cokernel.desc f h w) =
  CategoryTheory.Limits.cokernel.desc (G.map f) (G.map h) ⋯
-- CategoryTheory.Limits.cokernel_map_comp_cokernelComparison
@[reassoc]
theorem cokernel_map_comp_cokernelComparison {X' Y' : C} [HasCokernel f] [HasCokernel (G.map f)]
    (g : X' ⟶ Y') [HasCokernel g] [HasCokernel (G.map g)] (p : X ⟶ X') (q : Y ⟶ Y')
    (hpq : f ≫ q = p ≫ g) :
    cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) (by rw [← G.map_comp, hpq, G.map_comp]) ≫
        cokernelComparison _ G =
      cokernelComparison _ G ≫ G.map (cokernel.map f g p q hpq) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X' Y' : C} [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel (G.map f)] (g : X' ⟶ Y') [CategoryTheory.Limits.HasCokernel g] [CategoryTheory.Limits.HasCokernel (G.map g)] (p : X ⟶ X') (q : Y ⟶ Y') (hpq : f ≫ q = p ≫ g)
Goal: CategoryTheory.Limits.cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) ⋯ ≫
    CategoryTheory.Limits.cokernelComparison g G =
  CategoryTheory.Limits.cokernelComparison f G ≫ G.map (CategoryTheory.Limits.cokernel.map f g p q hpq)
-- CategoryTheory.Limits.HasKernels.has_limit
class HasKernels : Prop where
  has_limit : ∀ {X Y : C} (f : X ⟶ Y), HasKernel f := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [self : CategoryTheory.Limits.HasKernels C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.HasKernel f
-- CategoryTheory.Limits.HasCokernels.has_colimit
class HasCokernels : Prop where
  has_colimit : ∀ {X Y : C} (f : X ⟶ Y), HasCokernel f := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [self : CategoryTheory.Limits.HasCokernels C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.HasCokernel f
-- CategoryTheory.Limits.Types.pUnitCocone_ι_app
@[simps]
def pUnitCocone : Cocone (constPUnitFunctor.{w} C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : C) (a : (CategoryTheory.Limits.Types.constPUnitFunctor C).obj X)
Goal: (CategoryTheory.Limits.Types.pUnitCocone C).ι.app X a = id a
-- CategoryTheory.Limits.Types.pUnitCocone_pt
@[simps]
def pUnitCocone : Cocone (constPUnitFunctor.{w} C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: (CategoryTheory.Limits.Types.pUnitCocone C).pt = PUnit.{w + 1}
-- CategoryTheory.Limits.Types.zigzag_of_eqvGen_quot_rel
theorem zigzag_of_eqvGen_quot_rel (F : C ⥤ Type w) (c d : Σ j, F.obj j)
    (h : EqvGen (Quot.Rel F) c d) : Zigzag c.1 d.1 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (c d : (j : C) × F.obj j) (h : EqvGen (CategoryTheory.Limits.Types.Quot.Rel F) c d)
Goal: CategoryTheory.Zigzag c.fst d.fst
-- CategoryTheory.Limits.Types.isConnected_iff_colimit_constPUnitFunctor_iso_pUnit
theorem isConnected_iff_colimit_constPUnitFunctor_iso_pUnit
    [HasColimit (constPUnitFunctor.{w} C)] :
    IsConnected C ↔ Nonempty (colimit (constPUnitFunctor.{w} C) ≅ PUnit) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.Types.constPUnitFunctor C)]
Goal: CategoryTheory.IsConnected C ↔
  Nonempty (CategoryTheory.Limits.colimit (CategoryTheory.Limits.Types.constPUnitFunctor C) ≅ PUnit.{w + 1})
-- CategoryTheory.Limits.Types.isConnected_iff_isColimit_pUnitCocone
theorem isConnected_iff_isColimit_pUnitCocone :
    IsConnected C ↔ Nonempty (IsColimit (pUnitCocone.{w} C)) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.IsConnected C ↔ Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.pUnitCocone C))
-- CategoryTheory.Limits.Types.isConnected_iff_of_final
theorem isConnected_iff_of_final (F : C ⥤ D) [CategoryTheory.Functor.Final F] :
    IsConnected C ↔ IsConnected D 
Arguments: {C : Type u} {D : Type u₂} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Final]
Goal: CategoryTheory.IsConnected C ↔ CategoryTheory.IsConnected D