ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_right
theorem ofSigmaCofork_ι_app_right (c : Cofork I.fstSigmaMap I.sndSigmaMap) (b) :
    (ofSigmaCofork I c).ι.app (WalkingMultispan.right b) = (Sigma.ι I.right b : _) ≫ c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (c : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap) (b : I.R)
Goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).ι.app (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) c.π
-- CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_right'
@[simp]
theorem ofSigmaCofork_ι_app_right' (c : Cofork I.fstSigmaMap I.sndSigmaMap) (b) :
    π (ofSigmaCofork I c) b = (Sigma.ι I.right b : _) ≫ c.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (c : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap) (b : I.R)
Goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).π b =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) c.π
-- CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_obj
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (K : CategoryTheory.Limits.Multicofork I)
Goal: I.toSigmaCoforkFunctor.obj K = K.toSigmaCofork
-- CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_map_hom
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multicofork I} (f : K₁ ⟶ K₂)
Goal: (I.toSigmaCoforkFunctor.map f).hom = f.hom
-- CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_map_hom
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] {K₁ K₂ : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap} (f : K₁ ⟶ K₂)
Goal: (I.ofSigmaCoforkFunctor.map f).hom = f.hom
-- CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_obj
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (c : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap)
Goal: I.ofSigmaCoforkFunctor.obj c = CategoryTheory.Limits.Multicofork.ofSigmaCofork I c
-- CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: I.multicoforkEquivSigmaCofork.inverse = I.ofSigmaCoforkFunctor
-- CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_functor
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: I.multicoforkEquivSigmaCofork.functor = I.toSigmaCoforkFunctor
-- CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_counitIso
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: I.multicoforkEquivSigmaCofork.counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Cofork.ext
        (CategoryTheory.Iso.refl ((I.ofSigmaCoforkFunctor.comp I.toSigmaCoforkFunctor).obj K).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_unitIso
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: I.multicoforkEquivSigmaCofork.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Multicofork I)).obj K).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.Multiequalizer.multifork_ι
@[simp]
theorem multifork_ι (a) : (Multiequalizer.multifork I).ι a = Multiequalizer.ι I a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] (a : I.L)
Goal: (CategoryTheory.Limits.Multiequalizer.multifork I).ι a = CategoryTheory.Limits.Multiequalizer.ι I a
-- CategoryTheory.Limits.Multiequalizer.multifork_π_app_left
@[simp]
theorem multifork_π_app_left (a) :
    (Multiequalizer.multifork I).π.app (WalkingMulticospan.left a) = Multiequalizer.ι I a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] (a : I.L)
Goal: (CategoryTheory.Limits.Multiequalizer.multifork I).π.app (CategoryTheory.Limits.WalkingMulticospan.left a) =
  CategoryTheory.Limits.Multiequalizer.ι I a
-- CategoryTheory.Limits.Multiequalizer.condition
@[reassoc]
theorem condition (b) :
    Multiequalizer.ι I (I.fstTo b) ≫ I.fst b = Multiequalizer.ι I (I.sndTo b) ≫ I.snd b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (I.fstTo b)) (I.fst b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (I.sndTo b)) (I.snd b)
-- CategoryTheory.Limits.Multiequalizer.lift_ι
@[reassoc] -- Porting note (#10618): simp can prove this, removed attribute
theorem lift_ι (W : C) (k : ∀ a, W ⟶ I.left a)
    (h : ∀ b, k (I.fstTo b) ≫ I.fst b = k (I.sndTo b) ≫ I.snd b) (a) :
    Multiequalizer.lift I _ k h ≫ Multiequalizer.ι I a = k _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] (W : C) (k : (a : I.L) → W ⟶ I.left a) (h :
  ∀ (b : I.R),
    CategoryTheory.CategoryStruct.comp (k (I.fstTo b)) (I.fst b) =
      CategoryTheory.CategoryStruct.comp (k (I.sndTo b)) (I.snd b)) (a : I.L)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.lift I W k h)
    (CategoryTheory.Limits.Multiequalizer.ι I a) =
  k a
-- CategoryTheory.Limits.Multiequalizer.hom_ext
@[ext]
theorem hom_ext {W : C} (i j : W ⟶ multiequalizer I)
    (h : ∀ a, i ≫ Multiequalizer.ι I a = j ≫ Multiequalizer.ι I a) : i = j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] {W : C} (i j : W ⟶ CategoryTheory.Limits.multiequalizer I) (h :
  ∀ (a : I.L),
    CategoryTheory.CategoryStruct.comp i (CategoryTheory.Limits.Multiequalizer.ι I a) =
      CategoryTheory.CategoryStruct.comp j (CategoryTheory.Limits.Multiequalizer.ι I a))
Goal: i = j
-- CategoryTheory.Limits.Multiequalizer.ιPi_π
@[reassoc (attr := simp)]
theorem ιPi_π (a) : ιPi I ≫ Pi.π I.left a = ι I a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (a : I.L)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ιPi I) (CategoryTheory.Limits.Pi.π I.left a) =
  CategoryTheory.Limits.Multiequalizer.ι I a
-- CategoryTheory.Limits.Multicoequalizer.multicofork_π
@[simp]
theorem multicofork_π (b) : (Multicoequalizer.multicofork I).π b = Multicoequalizer.π I b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] (b : I.R)
Goal: (CategoryTheory.Limits.Multicoequalizer.multicofork I).π b = CategoryTheory.Limits.Multicoequalizer.π I b
-- CategoryTheory.Limits.Multicoequalizer.multicofork_ι_app_right
theorem multicofork_ι_app_right (b) :
    (Multicoequalizer.multicofork I).ι.app (WalkingMultispan.right b) = Multicoequalizer.π I b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] (b : I.R)
Goal: (CategoryTheory.Limits.Multicoequalizer.multicofork I).ι.app (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.Limits.Multicoequalizer.π I b
-- CategoryTheory.Limits.Multicoequalizer.multicofork_ι_app_right'
@[simp]
theorem multicofork_ι_app_right' (b) :
    colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.right b) = π I b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] (b : I.R)
Goal: CategoryTheory.Limits.colimit.ι I.multispan (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.Limits.Multicoequalizer.π I b
-- CategoryTheory.Limits.Multicoequalizer.condition
@[reassoc]
theorem condition (a) :
    I.fst a ≫ Multicoequalizer.π I (I.fstFrom a) = I.snd a ≫ Multicoequalizer.π I (I.sndFrom a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] (a : I.L)
Goal: CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (I.fstFrom a)) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.Limits.Multicoequalizer.π I (I.sndFrom a))
-- CategoryTheory.Limits.Multicoequalizer.π_desc
@[reassoc] -- Porting note (#10618): simp can prove this, removed attribute
theorem π_desc (W : C) (k : ∀ b, I.right b ⟶ W)
    (h : ∀ a, I.fst a ≫ k (I.fstFrom a) = I.snd a ≫ k (I.sndFrom a)) (b) :
    Multicoequalizer.π I b ≫ Multicoequalizer.desc I _ k h = k _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] (W : C) (k : (b : I.R) → I.right b ⟶ W) (h :
  ∀ (a : I.L),
    CategoryTheory.CategoryStruct.comp (I.fst a) (k (I.fstFrom a)) =
      CategoryTheory.CategoryStruct.comp (I.snd a) (k (I.sndFrom a))) (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b)
    (CategoryTheory.Limits.Multicoequalizer.desc I W k h) =
  k b
-- CategoryTheory.Limits.Multicoequalizer.hom_ext
@[ext]
theorem hom_ext {W : C} (i j : multicoequalizer I ⟶ W)
    (h : ∀ b, Multicoequalizer.π I b ≫ i = Multicoequalizer.π I b ≫ j) : i = j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] {W : C} (i j : CategoryTheory.Limits.multicoequalizer I ⟶ W) (h :
  ∀ (b : I.R),
    CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b) i =
      CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b) j)
Goal: i = j
-- CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ
@[reassoc (attr := simp)]
theorem ι_sigmaπ (b) : Sigma.ι I.right b ≫ sigmaπ I = π I b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b)
    (CategoryTheory.Limits.Multicoequalizer.sigmaπ I) =
  CategoryTheory.Limits.Multicoequalizer.π I b
-- CategoryTheory.kernelOpUnop_hom
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.kernelOpUnop f).hom =
  (CategoryTheory.Limits.kernel.lift f.op (CategoryTheory.Limits.cokernel.π f).op ⋯).unop
-- CategoryTheory.kernelOpUnop_inv
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.kernelOpUnop f).inv = CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.kernel.ι f.op).unop ⋯
-- CategoryTheory.cokernelOpUnop_inv
@[simps]
def cokernelOpUnop : (cokernel f.op).unop ≅ kernel f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.cokernelOpUnop f).inv =
  (CategoryTheory.Limits.cokernel.desc f.op (CategoryTheory.Limits.kernel.ι f).op ⋯).unop
-- CategoryTheory.cokernelOpUnop_hom
@[simps]
def cokernelOpUnop : (cokernel f.op).unop ≅ kernel f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.cokernelOpUnop f).hom =
  CategoryTheory.Limits.kernel.lift f (CategoryTheory.Limits.cokernel.π f.op).unop ⋯
-- CategoryTheory.kernelUnopOp_inv
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.kernelUnopOp g).inv = CategoryTheory.Limits.cokernel.desc g (CategoryTheory.Limits.kernel.ι g.unop).op ⋯
-- CategoryTheory.kernelUnopOp_hom
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.kernelUnopOp g).hom =
  (CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯).op
-- CategoryTheory.cokernelUnopOp_inv
@[simps!]
def cokernelUnopOp : Opposite.op (cokernel g.unop) ≅ kernel g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.cokernelUnopOp g).inv =
  (CategoryTheory.Limits.cokernel.desc g.unop (CategoryTheory.Limits.kernel.ι g).unop ⋯).op
-- CategoryTheory.cokernelUnopOp_hom
@[simps!]
def cokernelUnopOp : Opposite.op (cokernel g.unop) ≅ kernel g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.cokernelUnopOp g).hom =
  CategoryTheory.Limits.kernel.lift g (CategoryTheory.Limits.cokernel.π g.unop).op ⋯
-- CategoryTheory.cokernel.π_op
theorem cokernel.π_op :
    (cokernel.π f.op).unop =
      (cokernelOpUnop f).hom ≫ kernel.ι f ≫ eqToHom (Opposite.unop_op _).symm 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.cokernel.π f.op).unop =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.cokernelOpUnop f).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.kernel.ι_op
theorem kernel.ι_op :
    (kernel.ι f.op).unop = eqToHom (Opposite.unop_op _) ≫ cokernel.π f ≫ (kernelOpUnop f).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Limits.kernel.ι f.op).unop =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π f) (CategoryTheory.kernelOpUnop f).inv)
-- CategoryTheory.kernelOpOp_inv
@[simps!]
def kernelOpOp : kernel f.op ≅ Opposite.op (cokernel f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.kernelOpOp f).inv = CategoryTheory.Limits.kernel.lift f.op (CategoryTheory.Limits.cokernel.π f).op ⋯
-- CategoryTheory.kernelOpOp_hom
@[simps!]
def kernelOpOp : kernel f.op ≅ Opposite.op (cokernel f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.kernelOpOp f).hom =
  (CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.kernel.ι f.op).unop ⋯).op
-- CategoryTheory.cokernelOpOp_hom
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.cokernelOpOp f).hom = CategoryTheory.Limits.cokernel.desc f.op (CategoryTheory.Limits.kernel.ι f).op ⋯
-- CategoryTheory.cokernelOpOp_inv
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.cokernelOpOp f).inv =
  (CategoryTheory.Limits.kernel.lift f (CategoryTheory.Limits.cokernel.π f.op).unop ⋯).op
-- CategoryTheory.kernelUnopUnop_hom
@[simps!]
def kernelUnopUnop : kernel g.unop ≅ (cokernel g).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.kernelUnopUnop g).hom =
  (CategoryTheory.Limits.cokernel.desc g (CategoryTheory.Limits.kernel.ι g.unop).op ⋯).unop
-- CategoryTheory.kernelUnopUnop_inv
@[simps!]
def kernelUnopUnop : kernel g.unop ≅ (cokernel g).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.kernelUnopUnop g).inv =
  CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯
-- CategoryTheory.kernel.ι_unop
theorem kernel.ι_unop :
    (kernel.ι g.unop).op = eqToHom (Opposite.op_unop _) ≫ cokernel.π g ≫ (kernelUnopOp g).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.Limits.kernel.ι g.unop).op =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π g) (CategoryTheory.kernelUnopOp g).inv)
-- CategoryTheory.cokernel.π_unop
theorem cokernel.π_unop :
    (cokernel.π g.unop).op =
      (cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (Opposite.op_unop _).symm 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.Limits.cokernel.π g.unop).op =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.cokernelUnopOp g).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι g) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.cokernelUnopUnop_inv
@[simps!]
def cokernelUnopUnop : cokernel g.unop ≅ (kernel g).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.cokernelUnopUnop g).inv =
  (CategoryTheory.Limits.kernel.lift g (CategoryTheory.Limits.cokernel.π g.unop).op ⋯).unop
-- CategoryTheory.cokernelUnopUnop_hom
@[simps!]
def cokernelUnopUnop : cokernel g.unop ≅ (kernel g).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: (CategoryTheory.cokernelUnopUnop g).hom =
  CategoryTheory.Limits.cokernel.desc g.unop (CategoryTheory.Limits.kernel.ι g).unop ⋯
-- CategoryTheory.image_ι_op_comp_imageUnopOp_hom
theorem image_ι_op_comp_imageUnopOp_hom :
    (image.ι g.unop).op ≫ (imageUnopOp g).hom = factorThruImage g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι g.unop).op (CategoryTheory.imageUnopOp g).hom =
  CategoryTheory.Limits.factorThruImage g
-- CategoryTheory.imageUnopOp_hom_comp_image_ι
theorem imageUnopOp_hom_comp_image_ι :
    (imageUnopOp g).hom ≫ image.ι g = (factorThruImage g.unop).op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.imageUnopOp g).hom (CategoryTheory.Limits.image.ι g) =
  (CategoryTheory.Limits.factorThruImage g.unop).op
-- CategoryTheory.factorThruImage_comp_imageUnopOp_inv
theorem factorThruImage_comp_imageUnopOp_inv :
    factorThruImage g ≫ (imageUnopOp g).inv = (image.ι g.unop).op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage g) (CategoryTheory.imageUnopOp g).inv =
  (CategoryTheory.Limits.image.ι g.unop).op
-- CategoryTheory.imageUnopOp_inv_comp_op_factorThruImage
theorem imageUnopOp_inv_comp_op_factorThruImage :
    (imageUnopOp g).inv ≫ (factorThruImage g.unop).op = image.ι g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {A B : Cᵒᵖ} (g : A ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.imageUnopOp g).inv
    (CategoryTheory.Limits.factorThruImage g.unop).op =
  CategoryTheory.Limits.image.ι g
-- CategoryTheory.Abelian.has_injective_coseparator
theorem has_injective_coseparator [HasLimits C] [EnoughInjectives C] (G : C) (hG : IsSeparator G) :
    ∃ G : C, Injective G ∧ IsCoseparator G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.EnoughInjectives C] (G : C) (hG : CategoryTheory.IsSeparator G)
Goal: ∃ G, CategoryTheory.Injective G ∧ CategoryTheory.IsCoseparator G
-- CategoryTheory.Abelian.has_projective_separator
theorem has_projective_separator [HasColimits C] [EnoughProjectives C] (G : C)
    (hG : IsCoseparator G) : ∃ G : C, Projective G ∧ IsSeparator G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasColimits C] [CategoryTheory.EnoughProjectives C] (G : C) (hG : CategoryTheory.IsCoseparator G)
Goal: ∃ G, CategoryTheory.Projective G ∧ CategoryTheory.IsSeparator G
-- CategoryTheory.Abelian.image.fac
protected theorem image.fac : Abelian.factorThruImage f ≫ image.ι f = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Abelian.factorThruImage f ≫ CategoryTheory.Abelian.image.ι f = f
-- CategoryTheory.Abelian.coimage.fac
protected theorem coimage.fac : coimage.π f ≫ Abelian.factorThruCoimage f = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Abelian.coimage.π f ≫ CategoryTheory.Abelian.factorThruCoimage f = f