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

full_name: ModuleCat.instHasBinaryBiproducts
code: instance : HasBinaryBiproducts (ModuleCat.{v} R) 
goal: CategoryTheory.Limits.HasBinaryBiproducts (ModuleCat R)

full_name: ModuleCat.instHasFiniteBiproducts
code: instance : HasFiniteBiproducts (ModuleCat.{v} R) 
goal: CategoryTheory.Limits.HasFiniteBiproducts (ModuleCat R)

full_name: ModuleCat.binaryProductLimitCone
code: /-- Construct limit data for a binary product in `ModuleCat R`, using `ModuleCat.of R (M × N)`.
-/
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (M N : ModuleCat.{v} R) : Limits.LimitCone (pair M N) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair M N)

full_name: ModuleCat.binaryProductLimitCone_isLimit_lift
code: /-- Construct limit data for a binary product in `ModuleCat R`, using `ModuleCat.of R (M × N)`.
-/
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (M N : ModuleCat.{v} R) : Limits.LimitCone (pair M N) 
goal: (M.binaryProductLimitCone N).isLimit.lift s =
  LinearMap.prod (s.π.app { as := CategoryTheory.Limits.WalkingPair.left })
    (s.π.app { as := CategoryTheory.Limits.WalkingPair.right })

full_name: ModuleCat.binaryProductLimitCone_cone_pt
code: /-- Construct limit data for a binary product in `ModuleCat R`, using `ModuleCat.of R (M × N)`.
-/
@[simps cone_pt isLimit_lift]
def binaryProductLimitCone (M N : ModuleCat.{v} R) : Limits.LimitCone (pair M N) 
goal: (M.binaryProductLimitCone N).cone.pt = ModuleCat.of R (↑M × ↑N)

full_name: ModuleCat.binaryProductLimitCone_cone_π_app_left
code: @[simp]
theorem binaryProductLimitCone_cone_π_app_left (M N : ModuleCat.{v} R) :
    (binaryProductLimitCone M N).cone.π.app ⟨WalkingPair.left⟩ = LinearMap.fst R M N 
goal: (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.left } = LinearMap.fst R ↑M ↑N

full_name: ModuleCat.binaryProductLimitCone_cone_π_app_right
code: @[simp]
theorem binaryProductLimitCone_cone_π_app_right (M N : ModuleCat.{v} R) :
    (binaryProductLimitCone M N).cone.π.app ⟨WalkingPair.right⟩ = LinearMap.snd R M N 
goal: (M.binaryProductLimitCone N).cone.π.app { as := CategoryTheory.Limits.WalkingPair.right } = LinearMap.snd R ↑M ↑N

full_name: ModuleCat.biprodIsoProd_hom_apply
code: /-- We verify that the biproduct in `ModuleCat R` is isomorphic to
the cartesian product of the underlying types:
-/
@[simps! hom_apply]
noncomputable def biprodIsoProd (M N : ModuleCat.{v} R) :
    (M ⊞ N : ModuleCat.{v} R) ≅ ModuleCat.of R (M × N) 
goal: (M.biprodIsoProd N).hom i = (CategoryTheory.Limits.biprod.fst i, CategoryTheory.Limits.biprod.snd i)

full_name: ModuleCat.biprodIsoProd
code: /-- We verify that the biproduct in `ModuleCat R` is isomorphic to
the cartesian product of the underlying types:
-/
@[simps! hom_apply]
noncomputable def biprodIsoProd (M N : ModuleCat.{v} R) :
    (M ⊞ N : ModuleCat.{v} R) ≅ ModuleCat.of R (M × N) 
goal: M ⊞ N ≅ ModuleCat.of R (↑M × ↑N)

full_name: ModuleCat.biprodIsoProd_inv_comp_fst
code: @[simp, elementwise]
theorem biprodIsoProd_inv_comp_fst (M N : ModuleCat.{v} R) :
    (biprodIsoProd M N).inv ≫ biprod.fst = LinearMap.fst R M N 
goal: (M.biprodIsoProd N).inv ≫ CategoryTheory.Limits.biprod.fst = LinearMap.fst R ↑M ↑N

full_name: ModuleCat.biprodIsoProd_inv_comp_snd
code: @[simp, elementwise]
theorem biprodIsoProd_inv_comp_snd (M N : ModuleCat.{v} R) :
    (biprodIsoProd M N).inv ≫ biprod.snd = LinearMap.snd R M N 
goal: (M.biprodIsoProd N).inv ≫ CategoryTheory.Limits.biprod.snd = LinearMap.snd R ↑M ↑N

full_name: ModuleCat.HasLimit.lift_apply
code: /-- The map from an arbitrary cone over an indexed family of abelian groups
to the cartesian product of those groups.
-/
@[simps]
def lift (s : Fan f) : s.pt ⟶ ModuleCat.of R (∀ j, f j) 
goal: (ModuleCat.HasLimit.lift f s) x j = (s.π.app { as := j }) x

full_name: ModuleCat.HasLimit.lift
code: /-- The map from an arbitrary cone over an indexed family of abelian groups
to the cartesian product of those groups.
-/
@[simps]
def lift (s : Fan f) : s.pt ⟶ ModuleCat.of R (∀ j, f j) 
goal: s.pt ⟶ ModuleCat.of R ((j : J) → ↑(f j))

full_name: ModuleCat.HasLimit.productLimitCone_cone_pt
code: /-- Construct limit data for a product in `ModuleCat R`, using `ModuleCat.of R (∀ j, F.obj j)`.
-/
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
goal: (ModuleCat.HasLimit.productLimitCone f).cone.pt = ModuleCat.of R ((j : J) → ↑(f j))

full_name: ModuleCat.HasLimit.productLimitCone_cone_π
code: /-- Construct limit data for a product in `ModuleCat R`, using `ModuleCat.of R (∀ j, F.obj j)`.
-/
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
goal: (ModuleCat.HasLimit.productLimitCone f).cone.π = CategoryTheory.Discrete.natTrans fun j => LinearMap.proj j.as

full_name: ModuleCat.HasLimit.productLimitCone_isLimit_lift
code: /-- Construct limit data for a product in `ModuleCat R`, using `ModuleCat.of R (∀ j, F.obj j)`.
-/
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
goal: (ModuleCat.HasLimit.productLimitCone f).isLimit.lift s = ModuleCat.HasLimit.lift f s

full_name: ModuleCat.HasLimit.productLimitCone
code: /-- Construct limit data for a product in `ModuleCat R`, using `ModuleCat.of R (∀ j, F.obj j)`.
-/
@[simps]
def productLimitCone : Limits.LimitCone (Discrete.functor f) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor f)

full_name: ModuleCat.biproductIsoPi_hom_apply
code: /-- We verify that the biproduct we've just defined is isomorphic to the `ModuleCat R` structure
on the dependent function type.
-/
@[simps! hom_apply]
noncomputable def biproductIsoPi [Finite J] (f : J → ModuleCat.{v} R) :
    ((⨁ f) : ModuleCat.{v} R) ≅ ModuleCat.of R (∀ j, f j) 
goal: (ModuleCat.biproductIsoPi f).hom x j = (CategoryTheory.Limits.biproduct.π f j) x

full_name: ModuleCat.biproductIsoPi
code: /-- We verify that the biproduct we've just defined is isomorphic to the `ModuleCat R` structure
on the dependent function type.
-/
@[simps! hom_apply]
noncomputable def biproductIsoPi [Finite J] (f : J → ModuleCat.{v} R) :
    ((⨁ f) : ModuleCat.{v} R) ≅ ModuleCat.of R (∀ j, f j) 
goal: ⨁ f ≅ ModuleCat.of R ((j : J) → ↑(f j))

full_name: ModuleCat.biproductIsoPi_inv_comp_π
code: @[simp, elementwise]
theorem biproductIsoPi_inv_comp_π [Finite J] (f : J → ModuleCat.{v} R) (j : J) :
    (biproductIsoPi f).inv ≫ biproduct.π f j = (LinearMap.proj j : (∀ j, f j) →ₗ[R] f j) 
goal: (ModuleCat.biproductIsoPi f).inv ≫ CategoryTheory.Limits.biproduct.π f j = LinearMap.proj j

full_name: lequivProdOfRightSplitExact
code: /-- The isomorphism `A × B ≃ₗ[R] M` coming from a right split exact sequence `0 ⟶ A ⟶ M ⟶ B ⟶ 0`
of modules. -/
noncomputable def lequivProdOfRightSplitExact {f : B →ₗ[R] M} (hj : Function.Injective j)
    (exac : LinearMap.range j = LinearMap.ker g) (h : g.comp f = LinearMap.id) : (A × B) ≃ₗ[R] M 
goal: (A × B) ≃ₗ[R] M

full_name: lequivProdOfLeftSplitExact
code: /-- The isomorphism `A × B ≃ₗ[R] M` coming from a left split exact sequence `0 ⟶ A ⟶ M ⟶ B ⟶ 0`
of modules. -/
noncomputable def lequivProdOfLeftSplitExact {f : M →ₗ[R] A} (hg : Function.Surjective g)
    (exac : LinearMap.range j = LinearMap.ker g) (h : f.comp j = LinearMap.id) : (A × B) ≃ₗ[R] M 
goal: (A × B) ≃ₗ[R] M