ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.PreservesKernel.iso_hom
@[simp]
theorem PreservesKernel.iso_hom : (PreservesKernel.iso G f).hom = kernelComparison f G 
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] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel (G.map f)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) G]
Goal: (CategoryTheory.Limits.PreservesKernel.iso G f).hom = CategoryTheory.Limits.kernelComparison f G
-- CategoryTheory.Limits.kernel_map_comp_preserves_kernel_iso_inv
@[reassoc]
theorem kernel_map_comp_preserves_kernel_iso_inv {X' Y' : C} (g : X' ⟶ Y') [HasKernel g]
    [HasKernel (G.map g)] [PreservesLimit (parallelPair g 0) G] (p : X ⟶ X') (q : Y ⟶ Y')
    (hpq : f ≫ q = p ≫ g) :
    kernel.map (G.map f) (G.map g) (G.map p) (G.map q) (by rw [← G.map_comp, hpq, G.map_comp]) ≫
        (PreservesKernel.iso G _).inv =
      (PreservesKernel.iso G _).inv ≫ G.map (kernel.map f g p q hpq) 
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] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel (G.map f)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) G] {X' Y' : C} (g : X' ⟶ Y') [CategoryTheory.Limits.HasKernel g] [CategoryTheory.Limits.HasKernel (G.map g)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair g 0) G] (p : X ⟶ X') (q : Y ⟶ Y') (hpq : f ≫ q = p ≫ g)
Goal: CategoryTheory.Limits.kernel.map (G.map f) (G.map g) (G.map p) (G.map q) ⋯ ≫
    (CategoryTheory.Limits.PreservesKernel.iso G g).inv =
  (CategoryTheory.Limits.PreservesKernel.iso G f).inv ≫ G.map (CategoryTheory.Limits.kernel.map f g p q hpq)
-- CategoryTheory.Limits.CokernelCofork.map_condition
@[reassoc (attr := simp)]
lemma map_condition : G.map f ≫ G.map c.π = 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.CokernelCofork f) (G : C ⥤ D) [G.PreservesZeroMorphisms]
Goal: G.map f ≫ G.map (CategoryTheory.Limits.Cofork.π c) = 0
-- CategoryTheory.Limits.CokernelCofork.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.CokernelCofork f) (G : C ⥤ D) [G.PreservesZeroMorphisms]
Goal: CategoryTheory.Limits.Cofork.π (c.map G) = G.map (CategoryTheory.Limits.Cofork.π c)
-- CategoryTheory.Limits.PreservesCokernel.iso_inv
@[simp]
theorem PreservesCokernel.iso_inv : (PreservesCokernel.iso G f).inv = cokernelComparison f G 
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] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel (G.map f)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) G]
Goal: (CategoryTheory.Limits.PreservesCokernel.iso G f).inv = CategoryTheory.Limits.cokernelComparison f G
-- CategoryTheory.Limits.preserves_cokernel_iso_comp_cokernel_map
@[reassoc]
theorem preserves_cokernel_iso_comp_cokernel_map {X' Y' : C} (g : X' ⟶ Y') [HasCokernel g]
    [HasCokernel (G.map g)] [PreservesColimit (parallelPair g 0) G] (p : X ⟶ X') (q : Y ⟶ Y')
    (hpq : f ≫ q = p ≫ g) :
    (PreservesCokernel.iso G _).hom ≫
        cokernel.map (G.map f) (G.map g) (G.map p) (G.map q)
          (by rw [← G.map_comp, hpq, G.map_comp]) =
      G.map (cokernel.map f g p q hpq) ≫ (PreservesCokernel.iso G _).hom 
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] (G : C ⥤ D) [G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasCokernel f] [CategoryTheory.Limits.HasCokernel (G.map f)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) G] {X' Y' : C} (g : X' ⟶ Y') [CategoryTheory.Limits.HasCokernel g] [CategoryTheory.Limits.HasCokernel (G.map g)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair g 0) G] (p : X ⟶ X') (q : Y ⟶ Y') (hpq : f ≫ q = p ≫ g)
Goal: (CategoryTheory.Limits.PreservesCokernel.iso G f).hom ≫
    CategoryTheory.Limits.cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) ⋯ =
  G.map (CategoryTheory.Limits.cokernel.map f g p q hpq) ≫ (CategoryTheory.Limits.PreservesCokernel.iso G g).hom
-- CategoryTheory.Limits.KernelFork.condition
@[reassoc (attr := simp)]
theorem KernelFork.condition (s : KernelFork f) : Fork.ι s ≫ f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.KernelFork f)
Goal: CategoryTheory.Limits.Fork.ι s ≫ f = 0
-- CategoryTheory.Limits.KernelFork.app_one
theorem KernelFork.app_one (s : KernelFork f) : s.π.app one = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.KernelFork f)
Goal: s.π.app CategoryTheory.Limits.WalkingParallelPair.one = 0
-- CategoryTheory.Limits.KernelFork.ι_ofι
@[simp]
theorem KernelFork.ι_ofι {X Y P : C} (f : X ⟶ Y) (ι : P ⟶ X) (w : ι ≫ f = 0) :
    Fork.ι (KernelFork.ofι ι w) = ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y P : C} (f : X ⟶ Y) (ι : P ⟶ X) (w : ι ≫ f = 0)
Goal: CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι ι w) = ι
-- CategoryTheory.Limits.isKernelCompMono_lift
theorem isKernelCompMono_lift {c : KernelFork f} (i : IsLimit c) {Z} (g : Y ⟶ Z) [hg : Mono g]
    {h : X ⟶ Z} (hh : h = f ≫ g) (s : KernelFork h) :
    (isKernelCompMono i g hh).lift s = i.lift (Fork.ofι s.ι (by
      rw [← cancel_mono g, Category.assoc, ← hh]
      simp)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.KernelFork f} (i : CategoryTheory.Limits.IsLimit c) {Z : C} (g : Y ⟶ Z) [hg : CategoryTheory.Mono g] {h : X ⟶ Z} (hh : h = f ≫ g) (s : CategoryTheory.Limits.KernelFork h)
Goal: (CategoryTheory.Limits.isKernelCompMono i g hh).lift s =
  i.lift (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Limits.Fork.ι s) ⋯)
-- CategoryTheory.Limits.KernelFork.IsLimit.isIso_ι
lemma KernelFork.IsLimit.isIso_ι {X Y : C} {f : X ⟶ Y} (c : KernelFork f)
    (hc : IsLimit c) (hf : f = 0) : IsIso c.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (c : CategoryTheory.Limits.KernelFork f) (hc : CategoryTheory.Limits.IsLimit c) (hf : f = 0)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.Fork.ι c)
-- CategoryTheory.Limits.KernelFork.mapOfIsLimit_ι
@[reassoc (attr := simp)]
lemma mapOfIsLimit_ι (kf : KernelFork f) {kf' : KernelFork f'} (hf' : IsLimit kf')
    (φ : Arrow.mk f ⟶ Arrow.mk f') :
    kf.mapOfIsLimit hf' φ ≫ kf'.ι = kf.ι ≫ φ.left 
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'} (kf : CategoryTheory.Limits.KernelFork f) {kf' : CategoryTheory.Limits.KernelFork f'} (hf' : CategoryTheory.Limits.IsLimit kf') (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f')
Goal: kf.mapOfIsLimit hf' φ ≫ CategoryTheory.Limits.Fork.ι kf' = CategoryTheory.Limits.Fork.ι kf ≫ φ.left
-- CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv
@[simps]
def mapIsoOfIsLimit {kf : KernelFork f} {kf' : KernelFork f'}
    (hf : IsLimit kf) (hf' : IsLimit kf')
    (φ : Arrow.mk f ≅ Arrow.mk f') : kf.pt ≅ kf'.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'} {kf : CategoryTheory.Limits.KernelFork f} {kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf) (hf' : CategoryTheory.Limits.IsLimit kf') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f')
Goal: (CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit hf hf' φ).inv = kf'.mapOfIsLimit hf φ.inv
-- CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_hom
@[simps]
def mapIsoOfIsLimit {kf : KernelFork f} {kf' : KernelFork f'}
    (hf : IsLimit kf) (hf' : IsLimit kf')
    (φ : Arrow.mk f ≅ Arrow.mk f') : kf.pt ≅ kf'.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'} {kf : CategoryTheory.Limits.KernelFork f} {kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf) (hf' : CategoryTheory.Limits.IsLimit kf') (φ : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f')
Goal: (CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit hf hf' φ).hom = kf.mapOfIsLimit hf' φ.hom
-- CategoryTheory.Limits.equalizer_as_kernel
@[simp]
theorem equalizer_as_kernel : equalizer.ι f 0 = kernel.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f]
Goal: CategoryTheory.Limits.equalizer.ι f 0 = CategoryTheory.Limits.kernel.ι f
-- CategoryTheory.Limits.kernel.condition
@[reassoc (attr := simp)]
theorem kernel.condition : kernel.ι f ≫ f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f]
Goal: CategoryTheory.Limits.kernel.ι f ≫ f = 0
-- CategoryTheory.Limits.kernel.lift_ι
@[reassoc (attr := simp)]
theorem kernel.lift_ι {W : C} (k : W ⟶ X) (h : k ≫ f = 0) : kernel.lift f k h ≫ kernel.ι f = k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} (k : W ⟶ X) (h : k ≫ f = 0)
Goal: CategoryTheory.Limits.kernel.lift f k h ≫ CategoryTheory.Limits.kernel.ι f = k
-- CategoryTheory.Limits.kernel.lift_zero
@[simp]
theorem kernel.lift_zero {W : C} {h} : kernel.lift f (0 : W ⟶ X) h = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {W : C} {h : 0 ≫ f = 0}
Goal: CategoryTheory.Limits.kernel.lift f 0 h = 0
-- CategoryTheory.Limits.kernel.lift_map
theorem kernel.lift_map {X Y Z X' Y' Z' : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasKernel g] (w : f ≫ g = 0)
    (f' : X' ⟶ Y') (g' : Y' ⟶ Z') [HasKernel g'] (w' : f' ≫ g' = 0) (p : X ⟶ X') (q : Y ⟶ Y')
    (r : Z ⟶ Z') (h₁ : f ≫ q = p ≫ f') (h₂ : g ≫ r = q ≫ g') :
    kernel.lift g f w ≫ kernel.map g g' q r h₂ = p ≫ kernel.lift g' f' w' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z X' Y' Z' : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasKernel g] (w : f ≫ g = 0) (f' : X' ⟶ Y') (g' : Y' ⟶ Z') [CategoryTheory.Limits.HasKernel g'] (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.kernel.lift g f w ≫ CategoryTheory.Limits.kernel.map g g' q r h₂ =
  p ≫ CategoryTheory.Limits.kernel.lift g' f' w'
-- CategoryTheory.Limits.kernel.mapIso_inv
@[simps]
def kernel.mapIso {X' Y' : C} (f' : X' ⟶ Y') [HasKernel f'] (p : X ≅ X') (q : Y ≅ Y')
    (w : f ≫ q.hom = p.hom ≫ f') : kernel f ≅ kernel f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.Limits.HasKernel f'] (p : X ≅ X') (q : Y ≅ Y') (w : f ≫ q.hom = p.hom ≫ f')
Goal: (CategoryTheory.Limits.kernel.mapIso f f' p q w).inv = CategoryTheory.Limits.kernel.map f' f p.inv q.inv ⋯
-- CategoryTheory.Limits.kernel.mapIso_hom
@[simps]
def kernel.mapIso {X' Y' : C} (f' : X' ⟶ Y') [HasKernel f'] (p : X ≅ X') (q : Y ≅ Y')
    (w : f ≫ q.hom = p.hom ≫ f') : kernel f ≅ kernel f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.Limits.HasKernel f'] (p : X ≅ X') (q : Y ≅ Y') (w : f ≫ q.hom = p.hom ≫ f')
Goal: (CategoryTheory.Limits.kernel.mapIso f f' p q w).hom = CategoryTheory.Limits.kernel.map f f' p.hom q.hom w
-- CategoryTheory.Limits.eq_zero_of_epi_kernel
theorem eq_zero_of_epi_kernel [Epi (kernel.ι f)] : f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Epi (CategoryTheory.Limits.kernel.ι f)]
Goal: f = 0
-- CategoryTheory.Limits.kernelZeroIsoSource_hom
@[simp]
theorem kernelZeroIsoSource_hom : kernelZeroIsoSource.hom = kernel.ι (0 : X ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
Goal: CategoryTheory.Limits.kernelZeroIsoSource.hom = CategoryTheory.Limits.kernel.ι 0
-- CategoryTheory.Limits.kernelZeroIsoSource_inv
@[simp]
theorem kernelZeroIsoSource_inv :
    kernelZeroIsoSource.inv = kernel.lift (0 : X ⟶ Y) (𝟙 X) (by simp) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
Goal: CategoryTheory.Limits.kernelZeroIsoSource.inv = CategoryTheory.Limits.kernel.lift 0 (𝟙 X) ⋯
-- CategoryTheory.Limits.kernelIsoOfEq_refl
@[simp]
theorem kernelIsoOfEq_refl {h : f = f} : kernelIsoOfEq h = Iso.refl (kernel f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasKernel f] {h : f = f}
Goal: CategoryTheory.Limits.kernelIsoOfEq h = CategoryTheory.Iso.refl (CategoryTheory.Limits.kernel f)
-- CategoryTheory.Limits.kernelIsoOfEq_hom_comp_ι
@[reassoc (attr := simp)]
theorem kernelIsoOfEq_hom_comp_ι {f g : X ⟶ Y} [HasKernel f] [HasKernel g] (h : f = g) :
    (kernelIsoOfEq h).hom ≫ kernel.ι g = kernel.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel g] (h : f = g)
Goal: (CategoryTheory.Limits.kernelIsoOfEq h).hom ≫ CategoryTheory.Limits.kernel.ι g = CategoryTheory.Limits.kernel.ι f
-- CategoryTheory.Limits.kernelIsoOfEq_inv_comp_ι
@[reassoc (attr := simp)]
theorem kernelIsoOfEq_inv_comp_ι {f g : X ⟶ Y} [HasKernel f] [HasKernel g] (h : f = g) :
    (kernelIsoOfEq h).inv ≫ kernel.ι _ = kernel.ι _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f g : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] [CategoryTheory.Limits.HasKernel g] (h : f = g)
Goal: (CategoryTheory.Limits.kernelIsoOfEq h).inv ≫ CategoryTheory.Limits.kernel.ι f = CategoryTheory.Limits.kernel.ι g
-- CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom
@[reassoc (attr := simp)]
theorem lift_comp_kernelIsoOfEq_hom {Z} {f g : X ⟶ Y} [HasKernel f] [HasKernel g] (h : f = g)
    (e : Z ⟶ X) (he) :
    kernel.lift _ e he ≫ (kernelIsoOfEq h).hom = kernel.lift _ 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.HasKernel f] [CategoryTheory.Limits.HasKernel g] (h : f = g) (e : Z ⟶ X) (he : e ≫ f = 0)
Goal: CategoryTheory.Limits.kernel.lift f e he ≫ (CategoryTheory.Limits.kernelIsoOfEq h).hom =
  CategoryTheory.Limits.kernel.lift g e ⋯
-- CategoryTheory.Limits.lift_comp_kernelIsoOfEq_inv
@[reassoc (attr := simp)]
theorem lift_comp_kernelIsoOfEq_inv {Z} {f g : X ⟶ Y} [HasKernel f] [HasKernel g] (h : f = g)
    (e : Z ⟶ X) (he) :
    kernel.lift _ e he ≫ (kernelIsoOfEq h).inv = kernel.lift _ 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.HasKernel f] [CategoryTheory.Limits.HasKernel g] (h : f = g) (e : Z ⟶ X) (he : e ≫ g = 0)
Goal: CategoryTheory.Limits.kernel.lift g e he ≫ (CategoryTheory.Limits.kernelIsoOfEq h).inv =
  CategoryTheory.Limits.kernel.lift f e ⋯
-- CategoryTheory.Limits.kernelIsoOfEq_trans
@[simp]
theorem kernelIsoOfEq_trans {f g h : X ⟶ Y} [HasKernel f] [HasKernel g] [HasKernel h] (w₁ : f = g)
    (w₂ : g = h) : kernelIsoOfEq w₁ ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq (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.HasKernel f] [CategoryTheory.Limits.HasKernel g] [CategoryTheory.Limits.HasKernel h] (w₁ : f = g) (w₂ : g = h)
Goal: CategoryTheory.Limits.kernelIsoOfEq w₁ ≪≫ CategoryTheory.Limits.kernelIsoOfEq w₂ = CategoryTheory.Limits.kernelIsoOfEq ⋯
-- CategoryTheory.Limits.kernel_not_epi_of_nonzero
theorem kernel_not_epi_of_nonzero (w : f ≠ 0) : ¬Epi (kernel.ι f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] (w : f ≠ 0)
Goal: ¬CategoryTheory.Epi (CategoryTheory.Limits.kernel.ι f)
-- CategoryTheory.Limits.kernel_not_iso_of_nonzero
theorem kernel_not_iso_of_nonzero (w : f ≠ 0) : IsIso (kernel.ι f) → False 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasKernel f] (w : f ≠ 0)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.kernel.ι f) → False
-- CategoryTheory.Limits.kernelCompMono_hom
@[simps]
def kernelCompMono {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasKernel f] [Mono g] :
    kernel (f ≫ g) ≅ kernel 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.HasKernel f] [CategoryTheory.Mono g]
Goal: (CategoryTheory.Limits.kernelCompMono f g).hom =
  CategoryTheory.Limits.kernel.lift f (CategoryTheory.Limits.kernel.ι (f ≫ g)) ⋯
-- CategoryTheory.Limits.kernelCompMono_inv
@[simps]
def kernelCompMono {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasKernel f] [Mono g] :
    kernel (f ≫ g) ≅ kernel 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.HasKernel f] [CategoryTheory.Mono g]
Goal: (CategoryTheory.Limits.kernelCompMono f g).inv =
  CategoryTheory.Limits.kernel.lift (f ≫ g) (CategoryTheory.Limits.kernel.ι f) ⋯
-- CategoryTheory.Limits.kernelIsIsoComp_hom
@[simps]
def kernelIsIsoComp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] [HasKernel g] :
    kernel (f ≫ g) ≅ kernel 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.IsIso f] [CategoryTheory.Limits.HasKernel g]
Goal: (CategoryTheory.Limits.kernelIsIsoComp f g).hom =
  CategoryTheory.Limits.kernel.lift g (CategoryTheory.Limits.kernel.ι (f ≫ g) ≫ f) ⋯
-- CategoryTheory.Limits.kernelIsIsoComp_inv
@[simps]
def kernelIsIsoComp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] [HasKernel g] :
    kernel (f ≫ g) ≅ kernel 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.IsIso f] [CategoryTheory.Limits.HasKernel g]
Goal: (CategoryTheory.Limits.kernelIsIsoComp f g).inv =
  CategoryTheory.Limits.kernel.lift (f ≫ g) (CategoryTheory.Limits.kernel.ι g ≫ CategoryTheory.inv f) ⋯
-- CategoryTheory.Limits.kernel.ι_of_mono
theorem kernel.ι_of_mono [HasKernel f] [Mono f] : kernel.ι 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.HasKernel f] [CategoryTheory.Mono f]
Goal: CategoryTheory.Limits.kernel.ι f = 0
-- CategoryTheory.Limits.kernel.ι_of_zero
theorem kernel.ι_of_zero : IsIso (kernel.ι (0 : X ⟶ Y)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.kernel.ι 0)
-- CategoryTheory.Limits.CokernelCofork.condition
@[reassoc (attr := simp)]
theorem CokernelCofork.condition (s : CokernelCofork f) : f ≫ s.π = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.CokernelCofork f)
Goal: f ≫ CategoryTheory.Limits.Cofork.π s = 0
-- CategoryTheory.Limits.CokernelCofork.π_eq_zero
theorem CokernelCofork.π_eq_zero (s : CokernelCofork f) : s.ι.app zero = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (s : CategoryTheory.Limits.CokernelCofork f)
Goal: s.ι.app CategoryTheory.Limits.WalkingParallelPair.zero = 0
-- CategoryTheory.Limits.CokernelCofork.π_ofπ
@[simp]
theorem CokernelCofork.π_ofπ {X Y P : C} (f : X ⟶ Y) (π : Y ⟶ P) (w : f ≫ π = 0) :
    Cofork.π (CokernelCofork.ofπ π w) = π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y P : C} (f : X ⟶ Y) (π : Y ⟶ P) (w : f ≫ π = 0)
Goal: CategoryTheory.Limits.Cofork.π (CategoryTheory.Limits.CokernelCofork.ofπ π w) = π
-- CategoryTheory.Limits.isCokernelEpiComp_desc
@[simp]
theorem isCokernelEpiComp_desc {c : CokernelCofork f} (i : IsColimit c) {W} (g : W ⟶ X) [hg : Epi g]
    {h : W ⟶ Y} (hh : h = g ≫ f) (s : CokernelCofork h) :
    (isCokernelEpiComp i g hh).desc s =
      i.desc
        (Cofork.ofπ s.π
          (by
            rw [← cancel_epi g, ← Category.assoc, ← hh]
            simp)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.CokernelCofork f} (i : CategoryTheory.Limits.IsColimit c) {W : C} (g : W ⟶ X) [hg : CategoryTheory.Epi g] {h : W ⟶ Y} (hh : h = g ≫ f) (s : CategoryTheory.Limits.CokernelCofork h)
Goal: (CategoryTheory.Limits.isCokernelEpiComp i g hh).desc s =
  i.desc (CategoryTheory.Limits.Cofork.ofπ (CategoryTheory.Limits.Cofork.π s) ⋯)
-- CategoryTheory.Limits.CokernelCofork.IsColimit.isIso_π
lemma CokernelCofork.IsColimit.isIso_π {X Y : C} {f : X ⟶ Y} (c : CokernelCofork f)
    (hc : IsColimit c) (hf : f = 0) : IsIso c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} (c : CategoryTheory.Limits.CokernelCofork f) (hc : CategoryTheory.Limits.IsColimit c) (hf : f = 0)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.Cofork.π c)
-- CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit
@[reassoc (attr := simp)]
lemma π_mapOfIsColimit {cc : CokernelCofork f} (hf : IsColimit cc) (cc' : CokernelCofork f')
    (φ : Arrow.mk f ⟶ Arrow.mk f') :
    cc.π ≫ mapOfIsColimit hf cc' φ = φ.right ≫ cc'.π 
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} (hf : CategoryTheory.Limits.IsColimit cc) (cc' : CategoryTheory.Limits.CokernelCofork f') (φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk f')
Goal: CategoryTheory.Limits.Cofork.π cc ≫ CategoryTheory.Limits.CokernelCofork.mapOfIsColimit hf cc' φ =
  φ.right ≫ CategoryTheory.Limits.Cofork.π cc'