File: Mathlib/Algebra/Category/ModuleCat/Kernels.lean

full_name: ModuleCat.kernelCone
code: /-- The kernel cone induced by the concrete kernel. -/
def kernelCone : KernelFork f 
goal: CategoryTheory.Limits.KernelFork f

full_name: ModuleCat.kernelIsLimit
code: /-- The kernel of a linear map is a kernel in the categorical sense. -/
def kernelIsLimit : IsLimit (kernelCone f) 
goal: CategoryTheory.Limits.IsLimit (ModuleCat.kernelCone f)

full_name: ModuleCat.cokernelCocone
code: /-- The cokernel cocone induced by the projection onto the quotient. -/
def cokernelCocone : CokernelCofork f 
goal: CategoryTheory.Limits.CokernelCofork f

full_name: ModuleCat.cokernelIsColimit
code: /-- The projection onto the quotient is a cokernel in the categorical sense. -/
def cokernelIsColimit : IsColimit (cokernelCocone f) 
goal: CategoryTheory.Limits.IsColimit (ModuleCat.cokernelCocone f)

full_name: ModuleCat.hasKernels_moduleCat
code: /-- The category of R-modules has kernels, given by the inclusion of the kernel submodule. -/
theorem hasKernels_moduleCat : HasKernels (ModuleCat R) 
goal: CategoryTheory.Limits.HasKernels (ModuleCat R)

full_name: ModuleCat.hasCokernels_moduleCat
code: /-- The category of R-modules has cokernels, given by the projection onto the quotient. -/
theorem hasCokernels_moduleCat : HasCokernels (ModuleCat R) 
goal: CategoryTheory.Limits.HasCokernels (ModuleCat R)

full_name: ModuleCat.kernelIsoKer
code: /-- The categorical kernel of a morphism in `ModuleCat`
agrees with the usual module-theoretical kernel.
-/
noncomputable def kernelIsoKer {G H : ModuleCat.{v} R} (f : G ⟶ H) :
    -- Porting note (#11036): broken dot notation
    kernel f ≅ ModuleCat.of R (LinearMap.ker f) 
goal: CategoryTheory.Limits.kernel f ≅ ModuleCat.of R ↥(LinearMap.ker f)

full_name: ModuleCat.kernelIsoKer_inv_kernel_ι
code: @[simp, elementwise]
    -- Porting note (#11036): broken dot notation
theorem kernelIsoKer_inv_kernel_ι : (kernelIsoKer f).inv ≫ kernel.ι f =
    (LinearMap.ker f).subtype 
goal: (ModuleCat.kernelIsoKer f).inv ≫ CategoryTheory.Limits.kernel.ι f = (LinearMap.ker f).subtype

full_name: ModuleCat.kernelIsoKer_hom_ker_subtype
code: @[simp, elementwise]
theorem kernelIsoKer_hom_ker_subtype :
    -- Porting note (#11036): broken dot notation
    (kernelIsoKer f).hom ≫ (LinearMap.ker f).subtype = kernel.ι f 
goal: (ModuleCat.kernelIsoKer f).hom ≫ (LinearMap.ker f).subtype = CategoryTheory.Limits.kernel.ι f

full_name: ModuleCat.cokernelIsoRangeQuotient
code: /-- The categorical cokernel of a morphism in `ModuleCat`
agrees with the usual module-theoretical quotient.
-/
noncomputable def cokernelIsoRangeQuotient {G H : ModuleCat.{v} R} (f : G ⟶ H) :
    -- Porting note (#11036): broken dot notation
    cokernel f ≅ ModuleCat.of R (H ⧸ LinearMap.range f) 
goal: CategoryTheory.Limits.cokernel f ≅ ModuleCat.of R (↑H ⧸ LinearMap.range f)

full_name: ModuleCat.cokernel_π_cokernelIsoRangeQuotient_hom
code: @[simp, elementwise]
theorem cokernel_π_cokernelIsoRangeQuotient_hom :
    cokernel.π f ≫ (cokernelIsoRangeQuotient f).hom = f.range.mkQ 
goal: CategoryTheory.Limits.cokernel.π f ≫ (ModuleCat.cokernelIsoRangeQuotient f).hom = (LinearMap.range f).mkQ

full_name: ModuleCat.range_mkQ_cokernelIsoRangeQuotient_inv
code: @[simp, elementwise]
theorem range_mkQ_cokernelIsoRangeQuotient_inv :
    ↿f.range.mkQ ≫ (cokernelIsoRangeQuotient f).inv = cokernel.π f 
goal: ModuleCat.asHomLeft (LinearMap.range f).mkQ ≫ (ModuleCat.cokernelIsoRangeQuotient f).inv =
  CategoryTheory.Limits.cokernel.π f

full_name: ModuleCat.cokernel_π_ext
code: theorem cokernel_π_ext {M N : ModuleCat.{u} R} (f : M ⟶ N) {x y : N} (m : M) (w : x = y + f m) :
    cokernel.π f x = cokernel.π f y 
goal: (CategoryTheory.Limits.cokernel.π f) x = (CategoryTheory.Limits.cokernel.π f) y