File: Mathlib/CategoryTheory/Abelian/Opposite.lean

full_name: CategoryTheory.instAbelianOpposite
code: instance : Abelian Cᵒᵖ 
goal: CategoryTheory.Abelian Cᵒᵖ

full_name: CategoryTheory.kernelOpUnop
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f 
goal: Opposite.unop (CategoryTheory.Limits.kernel f.op) ≅ CategoryTheory.Limits.cokernel f

full_name: CategoryTheory.kernelOpUnop_hom
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f 
goal: (CategoryTheory.kernelOpUnop f).hom =
  (CategoryTheory.Limits.kernel.lift f.op (CategoryTheory.Limits.cokernel.π f).op ⋯).unop

full_name: CategoryTheory.kernelOpUnop_inv
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f 
goal: (CategoryTheory.kernelOpUnop f).inv = CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.kernel.ι f.op).unop ⋯

full_name: CategoryTheory.cokernelOpUnop_inv
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps]
def cokernelOpUnop : (cokernel f.op).unop ≅ kernel f 
goal: (CategoryTheory.cokernelOpUnop f).inv =
  (CategoryTheory.Limits.cokernel.desc f.op (CategoryTheory.Limits.kernel.ι f).op ⋯).unop

full_name: CategoryTheory.cokernelOpUnop_hom
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps]
def cokernelOpUnop : (cokernel f.op).unop ≅ kernel f 
goal: (CategoryTheory.cokernelOpUnop f).hom =
  CategoryTheory.Limits.kernel.lift f (CategoryTheory.Limits.cokernel.π f.op).unop ⋯

full_name: CategoryTheory.cokernelOpUnop
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps]
def cokernelOpUnop : (cokernel f.op).unop ≅ kernel f 
goal: Opposite.unop (CategoryTheory.Limits.cokernel f.op) ≅ CategoryTheory.Limits.kernel f

full_name: CategoryTheory.kernelUnopOp
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g 
goal: Opposite.op (CategoryTheory.Limits.kernel g.unop) ≅ CategoryTheory.Limits.cokernel g

full_name: CategoryTheory.kernelUnopOp_inv
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g 
goal: (CategoryTheory.kernelUnopOp g).inv = CategoryTheory.Limits.cokernel.desc g (CategoryTheory.Limits.kernel.ι g.unop).op ⋯

full_name: CategoryTheory.kernelUnopOp_hom
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g 
goal: (CategoryTheory.kernelUnopOp g).hom =
  (CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯).op

full_name: CategoryTheory.cokernelUnopOp_inv
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopOp : Opposite.op (cokernel g.unop) ≅ kernel g 
goal: (CategoryTheory.cokernelUnopOp g).inv =
  (CategoryTheory.Limits.cokernel.desc g.unop (CategoryTheory.Limits.kernel.ι g).unop ⋯).op

full_name: CategoryTheory.cokernelUnopOp
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopOp : Opposite.op (cokernel g.unop) ≅ kernel g 
goal: Opposite.op (CategoryTheory.Limits.cokernel g.unop) ≅ CategoryTheory.Limits.kernel g

full_name: CategoryTheory.cokernelUnopOp_hom
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopOp : Opposite.op (cokernel g.unop) ≅ kernel g 
goal: (CategoryTheory.cokernelUnopOp g).hom =
  CategoryTheory.Limits.kernel.lift g (CategoryTheory.Limits.cokernel.π g.unop).op ⋯

full_name: CategoryTheory.cokernel.π_op
code: theorem cokernel.π_op :
    (cokernel.π f.op).unop =
      (cokernelOpUnop f).hom ≫ kernel.ι f ≫ eqToHom (Opposite.unop_op _).symm 
goal: (CategoryTheory.Limits.cokernel.π f.op).unop =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.cokernelOpUnop f).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.kernel.ι_op
code: theorem kernel.ι_op :
    (kernel.ι f.op).unop = eqToHom (Opposite.unop_op _) ≫ cokernel.π f ≫ (kernelOpUnop f).inv 
goal: (CategoryTheory.Limits.kernel.ι f.op).unop =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π f) (CategoryTheory.kernelOpUnop f).inv)

full_name: CategoryTheory.kernelOpOp_inv
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps!]
def kernelOpOp : kernel f.op ≅ Opposite.op (cokernel f) 
goal: (CategoryTheory.kernelOpOp f).inv = CategoryTheory.Limits.kernel.lift f.op (CategoryTheory.Limits.cokernel.π f).op ⋯

full_name: CategoryTheory.kernelOpOp_hom
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps!]
def kernelOpOp : kernel f.op ≅ Opposite.op (cokernel f) 
goal: (CategoryTheory.kernelOpOp f).hom =
  (CategoryTheory.Limits.cokernel.desc f (CategoryTheory.Limits.kernel.ι f.op).unop ⋯).op

full_name: CategoryTheory.kernelOpOp
code: /-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps!]
def kernelOpOp : kernel f.op ≅ Opposite.op (cokernel f) 
goal: CategoryTheory.Limits.kernel f.op ≅ Opposite.op (CategoryTheory.Limits.cokernel f)

full_name: CategoryTheory.cokernelOpOp
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f) 
goal: CategoryTheory.Limits.cokernel f.op ≅ Opposite.op (CategoryTheory.Limits.kernel f)

full_name: CategoryTheory.cokernelOpOp_hom
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f) 
goal: (CategoryTheory.cokernelOpOp f).hom = CategoryTheory.Limits.cokernel.desc f.op (CategoryTheory.Limits.kernel.ι f).op ⋯

full_name: CategoryTheory.cokernelOpOp_inv
code: /-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f) 
goal: (CategoryTheory.cokernelOpOp f).inv =
  (CategoryTheory.Limits.kernel.lift f (CategoryTheory.Limits.cokernel.π f.op).unop ⋯).op

full_name: CategoryTheory.kernelUnopUnop_hom
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopUnop : kernel g.unop ≅ (cokernel g).unop 
goal: (CategoryTheory.kernelUnopUnop g).hom =
  (CategoryTheory.Limits.cokernel.desc g (CategoryTheory.Limits.kernel.ι g.unop).op ⋯).unop

full_name: CategoryTheory.kernelUnopUnop
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopUnop : kernel g.unop ≅ (cokernel g).unop 
goal: CategoryTheory.Limits.kernel g.unop ≅ Opposite.unop (CategoryTheory.Limits.cokernel g)

full_name: CategoryTheory.kernelUnopUnop_inv
code: /-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopUnop : kernel g.unop ≅ (cokernel g).unop 
goal: (CategoryTheory.kernelUnopUnop g).inv =
  CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯

full_name: CategoryTheory.kernel.ι_unop
code: theorem kernel.ι_unop :
    (kernel.ι g.unop).op = eqToHom (Opposite.op_unop _) ≫ cokernel.π g ≫ (kernelUnopOp g).inv 
goal: (CategoryTheory.Limits.kernel.ι g.unop).op =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π g) (CategoryTheory.kernelUnopOp g).inv)

full_name: CategoryTheory.cokernel.π_unop
code: theorem cokernel.π_unop :
    (cokernel.π g.unop).op =
      (cokernelUnopOp g).hom ≫ kernel.ι g ≫ eqToHom (Opposite.op_unop _).symm 
goal: (CategoryTheory.Limits.cokernel.π g.unop).op =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.cokernelUnopOp g).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι g) (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.cokernelUnopUnop_inv
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopUnop : cokernel g.unop ≅ (kernel g).unop 
goal: (CategoryTheory.cokernelUnopUnop g).inv =
  (CategoryTheory.Limits.kernel.lift g (CategoryTheory.Limits.cokernel.π g.unop).op ⋯).unop

full_name: CategoryTheory.cokernelUnopUnop
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopUnop : cokernel g.unop ≅ (kernel g).unop 
goal: CategoryTheory.Limits.cokernel g.unop ≅ Opposite.unop (CategoryTheory.Limits.kernel g)

full_name: CategoryTheory.cokernelUnopUnop_hom
code: /-- The cokernel of `g.unop` is the opposite of `kernel g`. -/
@[simps!]
def cokernelUnopUnop : cokernel g.unop ≅ (kernel g).unop 
goal: (CategoryTheory.cokernelUnopUnop g).hom =
  CategoryTheory.Limits.cokernel.desc g.unop (CategoryTheory.Limits.kernel.ι g).unop ⋯

full_name: CategoryTheory.imageUnopOp
code: /-- The opposite of the image of `g.unop` is the image of `g.` -/
def imageUnopOp : Opposite.op (image g.unop) ≅ image g 
goal: Opposite.op (CategoryTheory.Limits.image g.unop) ≅ CategoryTheory.Limits.image g

full_name: CategoryTheory.imageOpOp
code: /-- The opposite of the image of `f` is the image of `f.op`. -/
def imageOpOp : Opposite.op (image f) ≅ image f.op 
goal: Opposite.op (CategoryTheory.Limits.image f) ≅ CategoryTheory.Limits.image f.op

full_name: CategoryTheory.imageOpUnop
code: /-- The image of `f.op` is the opposite of the image of `f`. -/
def imageOpUnop : (image f.op).unop ≅ image f 
goal: Opposite.unop (CategoryTheory.Limits.image f.op) ≅ CategoryTheory.Limits.image f

full_name: CategoryTheory.imageUnopUnop
code: /-- The image of `g` is the opposite of the image of `g.unop.` -/
def imageUnopUnop : (image g).unop ≅ image g.unop 
goal: Opposite.unop (CategoryTheory.Limits.image g) ≅ CategoryTheory.Limits.image g.unop

full_name: CategoryTheory.image_ι_op_comp_imageUnopOp_hom
code: theorem image_ι_op_comp_imageUnopOp_hom :
    (image.ι g.unop).op ≫ (imageUnopOp g).hom = factorThruImage g 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.image.ι g.unop).op (CategoryTheory.imageUnopOp g).hom =
  CategoryTheory.Limits.factorThruImage g

full_name: CategoryTheory.imageUnopOp_hom_comp_image_ι
code: theorem imageUnopOp_hom_comp_image_ι :
    (imageUnopOp g).hom ≫ image.ι g = (factorThruImage g.unop).op 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.imageUnopOp g).hom (CategoryTheory.Limits.image.ι g) =
  (CategoryTheory.Limits.factorThruImage g.unop).op

full_name: CategoryTheory.factorThruImage_comp_imageUnopOp_inv
code: theorem factorThruImage_comp_imageUnopOp_inv :
    factorThruImage g ≫ (imageUnopOp g).inv = (image.ι g.unop).op 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage g) (CategoryTheory.imageUnopOp g).inv =
  (CategoryTheory.Limits.image.ι g.unop).op

full_name: CategoryTheory.imageUnopOp_inv_comp_op_factorThruImage
code: theorem imageUnopOp_inv_comp_op_factorThruImage :
    (imageUnopOp g).inv ≫ (factorThruImage g.unop).op = image.ι g 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.imageUnopOp g).inv
    (CategoryTheory.Limits.factorThruImage g.unop).op =
  CategoryTheory.Limits.image.ι g