The category of R-modules has finite biproducts

instance ModuleCat.instHasBinaryBiproducts {R : Type u} [Ring R] : CategoryTheory.Limits.HasBinaryBiproducts (ModuleCat R)

instance ModuleCat.instHasFiniteBiproducts {R : Type u} [Ring R] : CategoryTheory.Limits.HasFiniteBiproducts (ModuleCat R)

def ModuleCat.binaryProductLimitCone {R : Type u} [Ring R] (M N : ModuleCat R) : CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair M N)

Construct limit data for a binary product in ModuleCat R, using ModuleCat.of R (M × N).

@[simp]

theorem ModuleCat.binaryProductLimitCone_isLimit_lift {R : Type u} [Ring R] (M N : ModuleCat R) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair M N)) : (M.binaryProductLimitCone N).isLimit.lift s = ofHom ((Hom.hom (s.π.app { as := CategoryTheory.Limits.WalkingPair.left })).prod (Hom.hom (s.π.app { as := CategoryTheory.Limits.WalkingPair.right })))

@[simp]

theorem ModuleCat.binaryProductLimitCone_cone_pt {R : Type u} [Ring R] (M N : ModuleCat R) : (M.binaryProductLimitCone N).cone.pt = of R (↑M × ↑N)

@[simp]

theorem ModuleCat.binaryProductLimitCone_cone_π_app_left {R : Type u} [Ring R] (M N : ModuleCat R) : (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.left } = ofHom (LinearMap.fst R ↑M ↑N)

@[simp]

theorem ModuleCat.binaryProductLimitCone_cone_π_app_right {R : Type u} [Ring R] (M N : ModuleCat R) : (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.right } = ofHom (LinearMap.snd R ↑M ↑N)

noncomputable def ModuleCat.biprodIsoProd {R : Type u} [Ring R] (M N : ModuleCat R) : M ⊞ N ≅ of R (↑M × ↑N)

We verify that the biproduct in ModuleCat R is isomorphic to the cartesian product of the underlying types:

@[simp]

theorem ModuleCat.biprodIsoProd_inv_comp_fst {R : Type u} [Ring R] (M N : ModuleCat R) : CategoryTheory.CategoryStruct.comp (M.biprodIsoProd N).inv CategoryTheory.Limits.biprod.fst = ofHom (LinearMap.fst R ↑M ↑N)

theorem ModuleCat.biprodIsoProd_inv_comp_fst_apply {R : Type u} [Ring R] (M N : ModuleCat R) (x : CategoryTheory.ToType (of R (↑M × ↑N))) : (CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.fst) ((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) = x.1

@[simp]

theorem ModuleCat.biprodIsoProd_inv_comp_snd {R : Type u} [Ring R] (M N : ModuleCat R) : CategoryTheory.CategoryStruct.comp (M.biprodIsoProd N).inv CategoryTheory.Limits.biprod.snd = ofHom (LinearMap.snd R ↑M ↑N)

theorem ModuleCat.biprodIsoProd_inv_comp_snd_apply {R : Type u} [Ring R] (M N : ModuleCat R) (x : CategoryTheory.ToType (of R (↑M × ↑N))) : (CategoryTheory.ConcreteCategory.hom CategoryTheory.Limits.biprod.snd) ((CategoryTheory.ConcreteCategory.hom (M.biprodIsoProd N).inv) x) = x.2

def ModuleCat.HasLimit.lift {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) (s : CategoryTheory.Limits.Fan f) : s.pt ⟶ of R ((j : J) → ↑(f j))

The map from an arbitrary cone over an indexed family of abelian groups to the cartesian product of those groups.

@[simp]

theorem ModuleCat.HasLimit.lift_hom_apply {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) (s : CategoryTheory.Limits.Fan f) (x : ↑s.1) (j : J) : (Hom.hom (lift f s)) x j = (CategoryTheory.ConcreteCategory.hom (s.π.app { as := j })) x

def ModuleCat.HasLimit.productLimitCone {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) : CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor f)

Construct limit data for a product in ModuleCat R, using ModuleCat.of R (∀ j, F.obj j).

@[simp]

theorem ModuleCat.HasLimit.productLimitCone_cone_pt_isModule {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) : (productLimitCone f).cone.pt.isModule = Pi.module J (fun (j : J) => ↑(f j)) R

@[simp]

theorem ModuleCat.HasLimit.productLimitCone_isLimit_lift {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) (s : CategoryTheory.Limits.Fan f) : (productLimitCone f).isLimit.lift s = lift f s

@[simp]

theorem ModuleCat.HasLimit.productLimitCone_cone_pt_isAddCommGroup {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) : (productLimitCone f).cone.pt.isAddCommGroup = Pi.addCommGroup

@[simp]

theorem ModuleCat.HasLimit.productLimitCone_cone_π {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) : (productLimitCone f).cone.π = CategoryTheory.Discrete.natTrans fun (j : CategoryTheory.Discrete J) => ofHom (LinearMap.proj j.as)

@[simp]

theorem ModuleCat.HasLimit.productLimitCone_cone_pt_carrier {R : Type u} [Ring R] {J : Type w} (f : J → ModuleCat R) : ↑(productLimitCone f).cone.pt = ((j : J) → ↑(f j))

noncomputable def ModuleCat.biproductIsoPi {R : Type u} [Ring R] {J : Type} [Finite J] (f : J → ModuleCat R) : ⨁ f ≅ of R ((j : J) → ↑(f j))

We verify that the biproduct we've just defined is isomorphic to the ModuleCat R structure on the dependent function type.

@[simp]

theorem ModuleCat.biproductIsoPi_inv_comp_π {R : Type u} [Ring R] {J : Type} [Finite J] (f : J → ModuleCat R) (j : J) : CategoryTheory.CategoryStruct.comp (biproductIsoPi f).inv (CategoryTheory.Limits.biproduct.π f j) = ofHom (LinearMap.proj j)

theorem ModuleCat.biproductIsoPi_inv_comp_π_apply {R : Type u} [Ring R] {J : Type} [Finite J] (f : J → ModuleCat R) (j : J) (x : CategoryTheory.ToType (of R ((j : J) → ↑(f j)))) : (CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.biproduct.π f j)) ((CategoryTheory.ConcreteCategory.hom (biproductIsoPi f).inv) x) = x j

noncomputable def lequivProdOfRightSplitExact {R : Type u} {A : Type uA} {M : Type uM} {B : Type uB} [Ring R] [AddCommGroup A] [AddCommGroup B] [AddCommGroup M] [Module R A] [Module R B] [Module R M] {j : A →ₗ[R] M} {g : M →ₗ[R] B} {f : B →ₗ[R] M} (hj : Function.Injective ⇑j) (exac : LinearMap.range j = LinearMap.ker g) (h : g ∘ₗ f = LinearMap.id) : (A × B) ≃ₗ[R] M

The isomorphism A × B ≃ₗ[R] M coming from a right split exact sequence 0 ⟶ A ⟶ M ⟶ B ⟶ 0 of modules.

noncomputable def lequivProdOfLeftSplitExact {R : Type u} {A : Type uA} {M : Type uM} {B : Type uB} [Ring R] [AddCommGroup A] [AddCommGroup B] [AddCommGroup M] [Module R A] [Module R B] [Module R M] {j : A →ₗ[R] M} {g : M →ₗ[R] B} {f : M →ₗ[R] A} (hg : Function.Surjective ⇑g) (exac : LinearMap.range j = LinearMap.ker g) (h : f ∘ₗ j = LinearMap.id) : (A × B) ≃ₗ[R] M

The isomorphism A × B ≃ₗ[R] M coming from a left split exact sequence 0 ⟶ A ⟶ M ⟶ B ⟶ 0 of modules.