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

full_name: AddCommGrp.instHasBinaryBiproducts
code: instance : HasBinaryBiproducts AddCommGrp 
goal: CategoryTheory.Limits.HasBinaryBiproducts AddCommGrp

full_name: AddCommGrp.instHasFiniteBiproducts
code: instance : HasFiniteBiproducts AddCommGrp 
goal: CategoryTheory.Limits.HasFiniteBiproducts AddCommGrp

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

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

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

full_name: AddCommGrp.binaryProductLimitCone_cone_π_app_left
code: @[simp]
theorem binaryProductLimitCone_cone_π_app_left (G H : AddCommGrp.{u}) :
    (binaryProductLimitCone G H).cone.π.app ⟨WalkingPair.left⟩ = AddMonoidHom.fst G H 
goal: (G.binaryProductLimitCone H).cone.π.app { as := CategoryTheory.Limits.WalkingPair.left } = AddMonoidHom.fst ↑G ↑H

full_name: AddCommGrp.binaryProductLimitCone_cone_π_app_right
code: @[simp]
theorem binaryProductLimitCone_cone_π_app_right (G H : AddCommGrp.{u}) :
    (binaryProductLimitCone G H).cone.π.app ⟨WalkingPair.right⟩ = AddMonoidHom.snd G H 
goal: (G.binaryProductLimitCone H).cone.π.app { as := CategoryTheory.Limits.WalkingPair.right } = AddMonoidHom.snd ↑G ↑H

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

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

full_name: AddCommGrp.biprodIsoProd_inv_comp_fst
code: @[simp, elementwise]
theorem biprodIsoProd_inv_comp_fst (G H : AddCommGrp.{u}) :
    (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H 
goal: (G.biprodIsoProd H).inv ≫ CategoryTheory.Limits.biprod.fst = AddMonoidHom.fst ↑G ↑H

full_name: AddCommGrp.biprodIsoProd_inv_comp_snd
code: @[simp, elementwise]
theorem biprodIsoProd_inv_comp_snd (G H : AddCommGrp.{u}) :
    (biprodIsoProd G H).inv ≫ biprod.snd = AddMonoidHom.snd G H 
goal: (G.biprodIsoProd H).inv ≫ CategoryTheory.Limits.biprod.snd = AddMonoidHom.snd ↑G ↑H

full_name: AddCommGrp.HasLimit.lift
code: /-- The map from an arbitrary cone over an indexed family of abelian groups
to the cartesian product of those groups.
-/
-- This was marked `@[simps]` until we made `AddCommGrp.coe_of` a simp lemma,
-- after which the simp normal form linter complains.
-- The generated simp lemmas were not used in Mathlib.
-- Possible solution: higher priority function coercions that remove the `of`?
-- @[simps]
def lift (s : Fan f) : s.pt ⟶ AddCommGrp.of (∀ j, f j) 
goal: s.pt ⟶ AddCommGrp.of ((j : J) → ↑(f j))

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

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

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

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

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

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

full_name: AddCommGrp.biproductIsoPi_inv_comp_π
code: @[simp, elementwise]
theorem biproductIsoPi_inv_comp_π (f : J → AddCommGrp.{u}) (j : J) :
    (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j 
goal: (AddCommGrp.biproductIsoPi f).inv ≫ CategoryTheory.Limits.biproduct.π f j = Pi.evalAddMonoidHom (fun j => ↑(f j)) j