l3lab/ntp-mathlib huggingface dataset:
/-- Construction of a limit cone for a functor `J ⥤ ShortComplex C` using the limits
of the three components `J ⥤ C`. -/
noncomputable def limitCone : Cone F :=
  Cone.mk (ShortComplex.mk (limMap (whiskerLeft F π₁Toπ₂)) (limMap (whiskerLeft F π₂Toπ₃))
      (by aesop_cat))
    { app := fun j => Hom.mk (limit.π _ _) (limit.π _ _) (limit.π _ _)
        (by aesop_cat) (by aesop_cat)
      naturality := fun _ _ f => by
        ext
        all_goals
          dsimp
          

Proof state:
case h₂
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.22452, u_1} J
inst✝⁴ : Category.{?u.22456, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ 𝟙 (limit (F ⋙ π₂)) ≫ limit.π (F ⋙ π₂) x✝ = limit.π (F ⋙ π₂) x✝¹ ≫ (F.map f).τ₂

Next tactic:
erw [id_comp, limit.w]
/-- Construction of a limit cone for a functor `J ⥤ ShortComplex C` using the limits
of the three components `J ⥤ C`. -/
noncomputable def limitCone : Cone F :=
  Cone.mk (ShortComplex.mk (limMap (whiskerLeft F π₁Toπ₂)) (limMap (whiskerLeft F π₂Toπ₃))
      (by aesop_cat))
    { app := fun j => Hom.mk (limit.π _ _) (limit.π _ _) (limit.π _ _)
        (by aesop_cat) (by aesop_cat)
      naturality := fun _ _ f => by
        ext
        all_goals
          

Proof state:
case h₃
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.22452, u_1} J
inst✝⁴ : Category.{?u.22456, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ (((Functor.const J).obj
              (mk (limMap (whiskerLeft F π₁Toπ₂)) (limMap (whiskerLeft F π₂Toπ₃))
                (_ : limMap (whiskerLeft F π₁Toπ₂) ≫ limMap (whiskerLeft F π₂Toπ₃) = 0))).map
          f ≫
        (fun j => Hom.mk (limit.π (F ⋙ π₁) j) (limit.π (F ⋙ π₂) j) (limit.π (F ⋙ π₃) j)) x✝).τ₃ =
    ((fun j => Hom.mk (limit.π (F ⋙ π₁) j) (limit.π (F ⋙ π₂) j) (limit.π (F ⋙ π₃) j)) x✝¹ ≫ F.map f).τ₃

Next tactic:
dsimp
/-- Construction of a limit cone for a functor `J ⥤ ShortComplex C` using the limits
of the three components `J ⥤ C`. -/
noncomputable def limitCone : Cone F :=
  Cone.mk (ShortComplex.mk (limMap (whiskerLeft F π₁Toπ₂)) (limMap (whiskerLeft F π₂Toπ₃))
      (by aesop_cat))
    { app := fun j => Hom.mk (limit.π _ _) (limit.π _ _) (limit.π _ _)
        (by aesop_cat) (by aesop_cat)
      naturality := fun _ _ f => by
        ext
        all_goals
          dsimp
          

Proof state:
case h₃
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.22452, u_1} J
inst✝⁴ : Category.{?u.22456, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ 𝟙 (limit (F ⋙ π₃)) ≫ limit.π (F ⋙ π₃) x✝ = limit.π (F ⋙ π₃) x✝¹ ≫ (F.map f).τ₃

Next tactic:
erw [id_comp, limit.w]
/-- `limitCone F` becomes limit after the application of `π₁ : ShortComplex C ⥤ C`. -/
noncomputable def isLimitπ₁MapConeLimitCone : IsLimit (π₁.mapCone (limitCone F)) :=
  (IsLimit.ofIsoLimit (limit.isLimit _) (Cones.ext (Iso.refl _) (by 

Proof state:
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.39868, u_1} J
inst✝⁴ : Category.{?u.39872, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
⊢ ∀ (j : J),
    (limit.cone (F ⋙ π₁)).π.app j = (Iso.refl (limit.cone (F ⋙ π₁)).pt).hom ≫ (π₁.mapCone (limitCone F)).π.app j

Next tactic:
aesop_cat
/-- `limitCone F` becomes limit after the application of `π₂ : ShortComplex C ⥤ C`. -/
noncomputable def isLimitπ₂MapConeLimitCone : IsLimit (π₂.mapCone (limitCone F)) :=
  (IsLimit.ofIsoLimit (limit.isLimit _) (Cones.ext (Iso.refl _) (by 

Proof state:
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.45617, u_1} J
inst✝⁴ : Category.{?u.45621, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
⊢ ∀ (j : J),
    (limit.cone (F ⋙ π₂)).π.app j = (Iso.refl (limit.cone (F ⋙ π₂)).pt).hom ≫ (π₂.mapCone (limitCone F)).π.app j

Next tactic:
aesop_cat
/-- `limitCone F` becomes limit after the application of `π₃ : ShortComplex C ⥤ C`. -/
noncomputable def isLimitπ₃MapConeLimitCone : IsLimit (π₃.mapCone (limitCone F)) :=
  (IsLimit.ofIsoLimit (limit.isLimit _) (Cones.ext (Iso.refl _) (by 

Proof state:
J : Type u_1
C : Type u_2
inst✝⁵ : Category.{?u.51366, u_1} J
inst✝⁴ : Category.{?u.51370, u_2} C
inst✝³ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
inst✝² : HasLimit (F ⋙ π₁)
inst✝¹ : HasLimit (F ⋙ π₂)
inst✝ : HasLimit (F ⋙ π₃)
⊢ ∀ (j : J),
    (limit.cone (F ⋙ π₃)).π.app j = (Iso.refl (limit.cone (F ⋙ π₃)).pt).hom ≫ (π₃.mapCone (limitCone F)).π.app j

Next tactic:
aesop_cat
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
⊢ (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (π₁.mapCocone c).ι.app j ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
have eq₁ := h₁.fac (π₁.mapCocone s)
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₁ : ∀ (j : J), (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) = (π₁.mapCocone s).ι.app j
⊢ (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (π₁.mapCocone c).ι.app j ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
have eq₂ := h₂.fac (π₂.mapCocone s)
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₁ : ∀ (j : J), (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) = (π₁.mapCocone s).ι.app j
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
⊢ (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (π₁.mapCocone c).ι.app j ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
have eq₁₂ := fun j => (c.ι.app j).comm₁₂
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₁ : ∀ (j : J), (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) = (π₁.mapCocone s).ι.app j
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
eq₁₂ : ∀ (j : J), (c.ι.app j).τ₁ ≫ (((Functor.const J).obj c.pt).obj j).f = (F.obj j).f ≫ (c.ι.app j).τ₂
⊢ (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (π₁.mapCocone c).ι.app j ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
have eq₁₂' := fun j => (s.ι.app j).comm₁₂
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₁ : ∀ (j : J), (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) = (π₁.mapCocone s).ι.app j
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
eq₁₂ : ∀ (j : J), (c.ι.app j).τ₁ ≫ (((Functor.const J).obj c.pt).obj j).f = (F.obj j).f ≫ (c.ι.app j).τ₂
eq₁₂' : ∀ (j : J), (s.ι.app j).τ₁ ≫ (((Functor.const J).obj s.pt).obj j).f = (F.obj j).f ≫ (s.ι.app j).τ₂
⊢ (π₁.mapCocone c).ι.app j ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (π₁.mapCocone c).ι.app j ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₁ : ∀ (j : J), (c.ι.app j).τ₁ ≫ IsColimit.desc h₁ (π₁.mapCocone s) = (s.ι.app j).τ₁
eq₂ : ∀ (j : J), (c.ι.app j).τ₂ ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (s.ι.app j).τ₂
eq₁₂ : ∀ (j : J), (c.ι.app j).τ₁ ≫ c.pt.f = (F.obj j).f ≫ (c.ι.app j).τ₂
eq₁₂' : ∀ (j : J), (s.ι.app j).τ₁ ≫ s.pt.f = (F.obj j).f ≫ (s.ι.app j).τ₂
⊢ (c.ι.app j).τ₁ ≫ IsColimit.desc h₁ (π₁.mapCocone s) ≫ s.pt.f =
    (c.ι.app j).τ₁ ≫ c.pt.f ≫ IsColimit.desc h₂ (π₂.mapCocone s)

Next tactic:
rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂]
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
⊢ (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (π₂.mapCocone c).ι.app j ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
have eq₂ := h₂.fac (π₂.mapCocone s)
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
⊢ (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (π₂.mapCocone c).ι.app j ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
have eq₃ := h₃.fac (π₃.mapCocone s)
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₃ := h₃.fac (π₃.mapCocone s)
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
eq₃ : ∀ (j : J), (π₃.mapCocone c).ι.app j ≫ IsColimit.desc h₃ (π₃.mapCocone s) = (π₃.mapCocone s).ι.app j
⊢ (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (π₂.mapCocone c).ι.app j ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
have eq₂₃ := fun j => (c.ι.app j).comm₂₃
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₃ := h₃.fac (π₃.mapCocone s)
        have eq₂₃ := fun j => (c.ι.app j).comm₂₃
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
eq₃ : ∀ (j : J), (π₃.mapCocone c).ι.app j ≫ IsColimit.desc h₃ (π₃.mapCocone s) = (π₃.mapCocone s).ι.app j
eq₂₃ : ∀ (j : J), (c.ι.app j).τ₂ ≫ (((Functor.const J).obj c.pt).obj j).g = (F.obj j).g ≫ (c.ι.app j).τ₃
⊢ (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (π₂.mapCocone c).ι.app j ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
have eq₂₃' := fun j => (s.ι.app j).comm₂₃
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₃ := h₃.fac (π₃.mapCocone s)
        have eq₂₃ := fun j => (c.ι.app j).comm₂₃
        have eq₂₃' := fun j => (s.ι.app j).comm₂₃
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₂ : ∀ (j : J), (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (π₂.mapCocone s).ι.app j
eq₃ : ∀ (j : J), (π₃.mapCocone c).ι.app j ≫ IsColimit.desc h₃ (π₃.mapCocone s) = (π₃.mapCocone s).ι.app j
eq₂₃ : ∀ (j : J), (c.ι.app j).τ₂ ≫ (((Functor.const J).obj c.pt).obj j).g = (F.obj j).g ≫ (c.ι.app j).τ₃
eq₂₃' : ∀ (j : J), (s.ι.app j).τ₂ ≫ (((Functor.const J).obj s.pt).obj j).g = (F.obj j).g ≫ (s.ι.app j).τ₃
⊢ (π₂.mapCocone c).ι.app j ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (π₂.mapCocone c).ι.app j ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
dsimp at eq₂ eq₃ eq₂₃ eq₂₃' ⊢
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₃ := h₃.fac (π₃.mapCocone s)
        have eq₂₃ := fun j => (c.ι.app j).comm₂₃
        have eq₂₃' := fun j => (s.ι.app j).comm₂₃
        dsimp at eq₂ eq₃ eq₂₃ eq₂₃' ⊢
        

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
eq₂ : ∀ (j : J), (c.ι.app j).τ₂ ≫ IsColimit.desc h₂ (π₂.mapCocone s) = (s.ι.app j).τ₂
eq₃ : ∀ (j : J), (c.ι.app j).τ₃ ≫ IsColimit.desc h₃ (π₃.mapCocone s) = (s.ι.app j).τ₃
eq₂₃ : ∀ (j : J), (c.ι.app j).τ₂ ≫ c.pt.g = (F.obj j).g ≫ (c.ι.app j).τ₃
eq₂₃' : ∀ (j : J), (s.ι.app j).τ₂ ≫ s.pt.g = (F.obj j).g ≫ (s.ι.app j).τ₃
⊢ (c.ι.app j).τ₂ ≫ IsColimit.desc h₂ (π₂.mapCocone s) ≫ s.pt.g =
    (c.ι.app j).τ₂ ≫ c.pt.g ≫ IsColimit.desc h₃ (π₃.mapCocone s)

Next tactic:
rw [reassoc_of% (eq₂ j), eq₂₃', reassoc_of% eq₂₃, eq₃]
/-- If a cocone with values in `ShortComplex C` is such that it becomes colimit
when we apply the three projections `ShortComplex C ⥤ C`, then it is colimit. -/
def isColimitOfIsColimitπ (c : Cocone F)
    (h₁ : IsColimit (π₁.mapCocone c)) (h₂ : IsColimit (π₂.mapCocone c))
    (h₃ : IsColimit (π₃.mapCocone c)) : IsColimit c where
  desc s :=
    { τ₁ := h₁.desc (π₁.mapCocone s)
      τ₂ := h₂.desc (π₂.mapCocone s)
      τ₃ := h₃.desc (π₃.mapCocone s)
      comm₁₂ := h₁.hom_ext (fun j => by
        have eq₁ := h₁.fac (π₁.mapCocone s)
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₁₂ := fun j => (c.ι.app j).comm₁₂
        have eq₁₂' := fun j => (s.ι.app j).comm₁₂
        dsimp at eq₁ eq₂ eq₁₂ eq₁₂' ⊢
        rw [reassoc_of% (eq₁ j), eq₁₂', reassoc_of% eq₁₂, eq₂])
      comm₂₃ := h₂.hom_ext (fun j => by
        have eq₂ := h₂.fac (π₂.mapCocone s)
        have eq₃ := h₃.fac (π₃.mapCocone s)
        have eq₂₃ := fun j => (c.ι.app j).comm₂₃
        have eq₂₃' := fun j => (s.ι.app j).comm₂₃
        dsimp at eq₂ eq₃ eq₂₃ eq₂₃' ⊢
        rw [reassoc_of% (eq₂ j), eq₂₃', reassoc_of% eq₂₃, eq₃]) }
  fac s j := by
    

Proof state:
J : Type u_1
C : Type u_2
inst✝² : Category.{?u.90493, u_1} J
inst✝¹ : Category.{?u.90497, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
c : Cocone F
h₁ : IsColimit (π₁.mapCocone c)
h₂ : IsColimit (π₂.mapCocone c)
h₃ : IsColimit (π₃.mapCocone c)
s : Cocone F
j : J
⊢ c.ι.app j ≫
      (fun s =>
          Hom.mk (IsColimit.desc h₁ (π₁.mapCocone s)) (IsColimit.desc h₂ (π₂.mapCocone s))
            (IsColimit.desc h₃ (π₃.mapCocone s)))
        s =
    s.ι.app j

Next tactic:
ext