-- Module: Mathlib.Algebra.Category.Grp.AB
Goal:
J : Type u
inst : SmallCategory J
inst_1 : IsFiltered J
X Y : Discrete J ⥤ AddCommGrpCat
f : X ⟶ Y
hf : Epi f
iX : limit X ≅ AddCommGrpCat.of ((i : J) → (↑(X.obj { as := i }) : Type u)) :=
  Iso.trans (Y := ∏ᶜ fun (j : J) ↦ X.obj { as := j }) (Iso.symm (Pi.isoLimit X))
    (IsLimit.conePointUniqueUpToIso (limit.isLimit (Discrete.functor fun (j : J) ↦ X.obj { as := j }))
      (LimitCone.isLimit (AddCommGrpCat.HasLimit.productLimitCone fun (j : J) ↦ X.obj { as := j })))
iY : limit Y ≅ AddCommGrpCat.of ((i : J) → (↑(Y.obj { as := i }) : Type u)) :=
  Iso.trans (Y := ∏ᶜ fun (j : J) ↦ Y.obj { as := j }) (Iso.symm (Pi.isoLimit Y))
    (IsLimit.conePointUniqueUpToIso (limit.isLimit (Discrete.functor fun (j : J) ↦ Y.obj { as := j }))
      (LimitCone.isLimit (AddCommGrpCat.HasLimit.productLimitCone fun (j : J) ↦ Y.obj { as := j })))
g : (i : J) → (↑(X.obj { as := i }) : Type u)
j : J
h :
  Eq (α := (↑(Y.obj { as := j }) : Type u))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{u}) ↦ (↑x1 : Type u) →+ (↑x2 : Type u)) (CC :=
            AddCommGrpCat.carrier) (X := X.obj { as := j }) (f.app { as := j }) :
          (a : (↑(X.obj { as := j }) : Type u)) → (↑(Y.obj { as := j }) : Type u))
        (g j) :
      (↑(Y.obj { as := j }) : Type u))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{u}) ↦ (↑x1 : Type u) →+ (↑x2 : Type u)) (CC :=
            AddCommGrpCat.carrier) (X := limit Y) (Y := Y.obj { as := j }) ((getLimitCone Y).cone.π.app { as := j }) :
          (a : (↑(limit Y) : Type u)) → (↑(Y.obj { as := j }) : Type u))
        (((AddCommGrpCat.Hom.hom' (limit.lift Y ((Cone.postcompose f).obj (Pi.cone X))) :
                (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u) →+ (↑(limit Y) : Type u)) :
              (a : (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) → (↑(limit Y) : Type u))
            (((AddCommGrpCat.Hom.hom'
                      (limit.lift (Discrete.functor fun (j : J) ↦ X.obj { as := j })
                        { pt := AddCommGrpCat.of ((j : J) → (↑(X.obj { as := j }) : Type u)),
                          π :=
                            Discrete.natTrans fun (j : Discrete J) ↦
                              AddCommGrpCat.ofHom
                                (Pi.evalAddMonoidHom (fun (j : J) ↦ (↑(X.obj { as := j }) : Type u)) j.as) }) :
                    (↑(AddCommGrpCat.of ((i : J) → (↑(X.obj { as := i }) : Type u))) : Type u) →+
                      (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) :
                  (a : (i : J) → (↑(X.obj { as := i }) : Type u)) → (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u))
                g :
              (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) :
          (↑(limit Y) : Type u)) :
      (↑(Y.obj { as := j }) : Type u))
⊢ Eq (α := (↑(Functor.obj (Discrete.functor fun (j : J) ↦ Y.obj { as := j }) { as := j : Discrete J }) : Type u))
    (Pi.map (α := fun (i : J) ↦ (↑(X.obj { as := i }) : Type u)) (β := fun (i : J) ↦ (↑(Y.obj { as := i }) : Type u))
        (fun (i : J) ↦
          (⇑(ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{u}) ↦ (↑x1 : Type u) →+ (↑x2 : Type u)) (CC :=
                AddCommGrpCat.carrier) (X := X.obj { as := i }) (f.app { as := i })) :
            (a : (↑(X.obj { as := i }) : Type u)) → (↑(Y.obj { as := i }) : Type u)))
        g j :
      (↑(Y.obj { as := j }) : Type u))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{u}) ↦ (↑x1 : Type u) →+ (↑x2 : Type u)) (CC :=
            AddCommGrpCat.carrier) (X := limit Y) (Y :=
            Functor.obj (Discrete.functor fun (j : J) ↦ Y.obj { as := j }) { as := j : Discrete J })
            (CategoryStruct.comp (Y := limit (J := Discrete J) (Discrete.functor fun (j : J) ↦ Y.obj { as := j }))
              (IsLimit.lift (productIsProduct' Y) (getLimitCone Y).cone)
              (limit.π (Discrete.functor fun (j : J) ↦ Y.obj { as := j }) { as := j })) :
          (a : (↑(limit Y) : Type u)) →
            (↑((Discrete.functor fun (j : J) ↦ Y.obj { as := j }).obj { as := j }) : Type u))
        (((AddCommGrpCat.Hom.hom' (limit.lift Y ((Cone.postcompose f).obj (Pi.cone X))) :
                (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u) →+ (↑(limit Y) : Type u)) :
              (a : (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) → (↑(limit Y) : Type u))
            (((AddCommGrpCat.Hom.hom'
                      (limit.lift (Discrete.functor fun (j : J) ↦ X.obj { as := j })
                        { pt := AddCommGrpCat.of ((j : J) → (↑(X.obj { as := j }) : Type u)),
                          π :=
                            Discrete.natTrans fun (j : Discrete J) ↦
                              AddCommGrpCat.ofHom
                                (Pi.evalAddMonoidHom (fun (j : J) ↦ (↑(X.obj { as := j }) : Type u)) j.as) }) :
                    (↑(AddCommGrpCat.of ((i : J) → (↑(X.obj { as := i }) : Type u))) : Type u) →+
                      (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) :
                  (a : (↑(AddCommGrpCat.of ((i : J) → (↑(X.obj { as := i }) : Type u))) : Type u)) →
                    (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u))
                g :
              (↑(∏ᶜ fun (j : J) ↦ X.obj { as := j }) : Type u)) :
          (↑(limit Y) : Type u)) :
      (↑(Functor.obj (Discrete.functor fun (j : J) ↦ Y.obj { as := j }) { as := j : Discrete J }) : Type u))

Tactic:
simp only [Discrete.functor_obj_eq_as, productIsProduct', limit.lift_π, Fan.mk_pt,
          Fan.mk_π_app, Pi.map_apply]

Premises used: CategoryTheory.Limits.productIsProduct', CategoryTheory.Discrete.functor_obj_eq_as, CategoryTheory.Limits.Fan.mk_pt, CategoryTheory.Limits.limit.lift_π, CategoryTheory.Limits.Fan.mk_π_app, Pi.map_apply