-- Module: Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory
Goal:
C : Type u
inst : Category.{v, u} C
FC : C → C → Type u_1
CC : C → Type w
inst_1 : (X Y : C) → FunLike.{u_1 + 1, w + 1, w + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{w, v, u, u_1} C FC (CC := CC)
inst_3 :
  HasForget₂.{w, v, u, u_1, w, w + 1, w} C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)
inst_4 : Preadditive.{v, u} C
inst_5 :
  Functor.Additive.{v, u, w, w + 1}
    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w))
      (CD := AddCommGrpCat.carrier))
inst_6 :
  Functor.PreservesHomology.{v, u, w, w + 1}
    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w))
      (CD := AddCommGrpCat.carrier))
S : ShortComplex.{v, u} C
inst_7 : S.HasHomology
x₂ :
  (↑(Functor.obj.{v, w, u, w + 1}
        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w))
          (CD := AddCommGrpCat.carrier))
        S.X₂) :
    Type w)
hx₂ :
  Eq (α :=
    (↑(Functor.obj.{v, w, u, w + 1}
          (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w))
            (CD := AddCommGrpCat.carrier))
          S.X₃) :
      Type w))
    ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
            AddCommGrpCat.carrier) (X :=
            Functor.obj.{v, w, u, w + 1}
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
              S.X₂)
            (Functor.map
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
              S.g) :
          (a : (↑((forget₂ C Ab).obj S.X₂) : Type w)) → (↑((forget₂ C Ab).obj S.X₃) : Type w))
        x₂ :
      (↑(Functor.obj.{v, w, u, w + 1}
            (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
              (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
            S.X₃) :
        Type w))
    (0 :
      (↑(Functor.obj.{v, w, u, w + 1}
            (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
              (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
            S.X₃) :
        Type w))
this :
  (ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
          AddCommGrpCat.carrier) (X :=
          cycles
            (S.map
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
          (iCycles
            (S.map
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
        (a : (↑(S.map (forget₂ C Ab)).cycles : Type w)) → (↑((forget₂ C Ab).obj S.X₂) : Type w))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
              AddCommGrpCat.carrier) (X :=
              AddCommGrpCat.of
                ↥(AddMonoidHom.ker
                    (AddCommGrpCat.Hom.hom
                      (Functor.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                        S.g))))
              (Y :=
              cycles
                (S.map
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
              (Iso.inv
                (abCyclesIso
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))) :
            (a : ↥(AddCommGrpCat.Hom.hom ((forget₂ C Ab).map S.g)).ker) → (↑(S.map (forget₂ C Ab)).cycles : Type w))
          (Subtype.mk (p :=
            fun
              (x :
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w)) ↦
            Membership.mem (γ :=
              AddSubgroup
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w))
              (AddMonoidHom.ker
                (AddCommGrpCat.Hom.hom
                  (Functor.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                    S.g)))
              x)
            x₂ hx₂) :
        (↑(cycles
              (S.map
                (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                  (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
          Type w)) =
    x₂
rw :
  ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
            AddCommGrpCat.carrier) (X :=
            cycles
              (S.map
                (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                  (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
            (CategoryStruct.comp (Y :=
                Functor.obj.{v, w, u, w + 1}
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                  S.cycles)
                (Iso.hom
                  (S.mapCyclesIso
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
                (Functor.map
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                  S.iCycles) :
              cycles
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))) ⟶
                Functor.obj.{v, w, u, w + 1}
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                  S.X₂) :
          (↑(cycles
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
              Type w) →+
            (↑(Functor.obj.{v, w, u, w + 1}
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                  S.X₂) :
              Type w)) :
        (a : (↑(S.map (forget₂ C Ab)).cycles : Type w)) → (↑((forget₂ C Ab).obj S.X₂) : Type w))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
              AddCommGrpCat.carrier) (X :=
              AddCommGrpCat.of
                ↥(AddMonoidHom.ker
                    (AddCommGrpCat.Hom.hom
                      (Functor.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                        S.g))))
              (Y :=
              cycles
                (S.map
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
              (Iso.inv
                (abCyclesIso
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))) :
            (a : ↥(AddCommGrpCat.Hom.hom ((forget₂ C Ab).map S.g)).ker) → (↑(S.map (forget₂ C Ab)).cycles : Type w))
          (Subtype.mk (p :=
            fun
              (x :
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w)) ↦
            Membership.mem (γ :=
              AddSubgroup
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w))
              (AddMonoidHom.ker
                (AddCommGrpCat.Hom.hom
                  (Functor.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                    S.g)))
              x)
            x₂ hx₂) :
        (↑(cycles
              (S.map
                (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                  (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
          Type w)) =
    x₂
rw₁ :
  (ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
          AddCommGrpCat.carrier) (X :=
          cycles
            (S.map
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
          (iCycles
            (S.map
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
        (a : (↑(S.map (forget₂ C Ab)).cycles : Type w)) → (↑((forget₂ C Ab).obj S.X₂) : Type w))
      ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
              AddCommGrpCat.carrier) (X :=
              AddCommGrpCat.of
                ↥(AddMonoidHom.ker
                    (AddCommGrpCat.Hom.hom
                      (Functor.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                        S.g))))
              (Y :=
              cycles
                (S.map
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
              (Iso.inv
                (abCyclesIso
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))) :
            (a : ↥(AddCommGrpCat.Hom.hom ((forget₂ C Ab).map S.g)).ker) → (↑(S.map (forget₂ C Ab)).cycles : Type w))
          (Subtype.mk (p :=
            fun
              (x :
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w)) ↦
            Membership.mem (γ :=
              AddSubgroup
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.X₂) :
                  Type w))
              (AddMonoidHom.ker
                (AddCommGrpCat.Hom.hom
                  (Functor.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                    S.g)))
              x)
            x₂ hx₂) :
        (↑(cycles
              (S.map
                (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                  (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
          Type w)) =
    x₂
rw₂ rw₃ : x₂ = x₂
⊢ (ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
          AddCommGrpCat.carrier) (X :=
          Functor.obj.{v, w, u, w + 1}
            (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
              (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
            S.cycles)
          (Functor.map
            (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
              (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
            S.iCycles) :
        (a : (↑((forget₂ C Ab).obj S.cycles) : Type w)) → (↑((forget₂ C Ab).obj S.X₂) : Type w))
      (((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
                AddCommGrpCat.carrier) (X :=
                cycles
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
                (Y :=
                Functor.obj.{v, w, u, w + 1}
                  (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                    (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                  S.cycles)
                (Iso.hom
                    (S.mapCyclesIso
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))) :
                  cycles
                      (S.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))) ⟶
                    Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.cycles) :
              (↑(cycles
                      (S.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
                  Type w) →+
                (↑(Functor.obj.{v, w, u, w + 1}
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                      S.cycles) :
                  Type w)) :
            (a : (↑(S.map (forget₂ C Ab)).cycles : Type w)) → (↑((forget₂ C Ab).obj S.cycles) : Type w))
          ((ConcreteCategory.hom (FC := fun (x1 x2 : AddCommGrpCat.{w}) ↦ (↑x1 : Type w) →+ (↑x2 : Type w)) (CC :=
                  AddCommGrpCat.carrier) (X :=
                  AddCommGrpCat.of
                    ↥(AddMonoidHom.ker
                        (AddCommGrpCat.Hom.hom
                          (Functor.map
                            (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                              (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                            S.g))))
                  (Y :=
                  cycles
                    (S.map
                      (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                        (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))
                  (Iso.inv
                    (abCyclesIso
                      (S.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))))) :
                (a : ↥(AddCommGrpCat.Hom.hom ((forget₂ C Ab).map S.g)).ker) → (↑(S.map (forget₂ C Ab)).cycles : Type w))
              (Subtype.mk (p :=
                fun
                  (x :
                    (↑(Functor.obj.{v, w, u, w + 1}
                          (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                            (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                          S.X₂) :
                      Type w)) ↦
                Membership.mem (γ :=
                  AddSubgroup
                    (↑(Functor.obj.{v, w, u, w + 1}
                          (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                            (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                          S.X₂) :
                      Type w))
                  (AddMonoidHom.ker
                    (AddCommGrpCat.Hom.hom
                      (Functor.map
                        (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                          (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
                        S.g)))
                  x)
                x₂ hx₂) :
            (↑(cycles
                  (S.map
                    (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                      (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier)))) :
              Type w)) :
        (↑(Functor.obj.{v, w, u, w + 1}
              (forget₂ C (FC := FC) (CC := CC) Ab (FD := fun (x1 x2 : AddCommGrpCat.{w}) ↦
                (↑x1 : Type w) →+ (↑x2 : Type w)) (CD := AddCommGrpCat.carrier))
              S.cycles) :
          Type w)) =
    x₂

Tactic:
rw [← ConcreteCategory.comp_apply, S.mapCyclesIso_hom_iCycles (forget₂ C Ab), this]

Premises used: CategoryTheory.ConcreteCategory.comp_apply, Ab, CategoryTheory.forget₂, CategoryTheory.ShortComplex.mapCyclesIso_hom_iCycles