[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : X✝ ⟶ Y✝
i : ι
h : i = j
⊢ X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) i = X✝
[PROOFSTEP]
dsimp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : X✝ ⟶ Y✝
i : ι
h : i = j
⊢ (if i = j then X✝ else 0) = X✝
[PROOFSTEP]
rw [if_pos h]
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : X✝ ⟶ Y✝
i : ι
h : i = j
⊢ Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) i
[PROOFSTEP]
dsimp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : X✝ ⟶ Y✝
i : ι
h : i = j
⊢ Y✝ = if i = j then Y✝ else 0
[PROOFSTEP]
rw [if_pos h]
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
⊢ { obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
          map := fun {X Y} f =>
            Hom.mk fun i =>
              if h : i = j then
                eqToHom
                    (_ :
                      HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                  f ≫
                    eqToHom
                      (_ :
                        Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
              else 0 }.map
      (𝟙 A) =
    𝟙
      ({ obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
            map := fun {X Y} f =>
              Hom.mk fun i =>
                if h : i = j then
                  eqToHom
                      (_ :
                        HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                    f ≫
                      eqToHom
                        (_ :
                          Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                else 0 }.obj
        A)
[PROOFSTEP]
ext
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i✝ : ι
⊢ Hom.f
      ({ obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
            map := fun {X Y} f =>
              Hom.mk fun i =>
                if h : i = j then
                  eqToHom
                      (_ :
                        HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                    f ≫
                      eqToHom
                        (_ :
                          Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                else 0 }.map
        (𝟙 A))
      i✝ =
    Hom.f
      (𝟙
        ({ obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
              map := fun {X Y} f =>
                Hom.mk fun i =>
                  if h : i = j then
                    eqToHom
                        (_ :
                          HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i =
                            X) ≫
                      f ≫
                        eqToHom
                          (_ :
                            Y =
                              HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                  else 0 }.obj
          A))
      i✝
[PROOFSTEP]
dsimp
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i✝ : ι
⊢ (if h : i✝ = j then eqToHom (_ : (if i✝ = j then A else 0) = A) ≫ 𝟙 A ≫ eqToHom (_ : A = if i✝ = j then A else 0)
    else 0) =
    𝟙 (if i✝ = j then A else 0)
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i✝ : ι
h : i✝ = j
⊢ eqToHom (_ : (if i✝ = j then A else 0) = A) ≫ 𝟙 A ≫ eqToHom (_ : A = if i✝ = j then A else 0) =
    𝟙 (if i✝ = j then A else 0)
[PROOFSTEP]
subst h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
A : V
i✝ : ι
⊢ eqToHom (_ : (if i✝ = i✝ then A else 0) = A) ≫ 𝟙 A ≫ eqToHom (_ : A = if i✝ = i✝ then A else 0) =
    𝟙 (if i✝ = i✝ then A else 0)
[PROOFSTEP]
simp
[GOAL]
case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i✝ : ι
h : ¬i✝ = j
⊢ 0 = 𝟙 (if i✝ = j then A else 0)
[PROOFSTEP]
rw [if_neg h]
[GOAL]
case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
i✝ : ι
h : ¬i✝ = j
⊢ 0 = 𝟙 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
          map := fun {X Y} f =>
            Hom.mk fun i =>
              if h : i = j then
                eqToHom
                    (_ :
                      HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                  f ≫
                    eqToHom
                      (_ :
                        Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
              else 0 }.map
      (f ≫ g) =
    { obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
            map := fun {X Y} f =>
              Hom.mk fun i =>
                if h : i = j then
                  eqToHom
                      (_ :
                        HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                    f ≫
                      eqToHom
                        (_ :
                          Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                else 0 }.map
        f ≫
      { obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
            map := fun {X Y} f =>
              Hom.mk fun i =>
                if h : i = j then
                  eqToHom
                      (_ :
                        HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                    f ≫
                      eqToHom
                        (_ :
                          Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                else 0 }.map
        g
[PROOFSTEP]
ext
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ι
⊢ Hom.f
      ({ obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
            map := fun {X Y} f =>
              Hom.mk fun i =>
                if h : i = j then
                  eqToHom
                      (_ :
                        HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i = X) ≫
                    f ≫
                      eqToHom
                        (_ :
                          Y = HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                else 0 }.map
        (f ≫ g))
      i✝ =
    Hom.f
      ({ obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
              map := fun {X Y} f =>
                Hom.mk fun i =>
                  if h : i = j then
                    eqToHom
                        (_ :
                          HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i =
                            X) ≫
                      f ≫
                        eqToHom
                          (_ :
                            Y =
                              HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                  else 0 }.map
          f ≫
        { obj := fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0,
              map := fun {X Y} f =>
                Hom.mk fun i =>
                  if h : i = j then
                    eqToHom
                        (_ :
                          HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X) i =
                            X) ≫
                      f ≫
                        eqToHom
                          (_ :
                            Y =
                              HomologicalComplex.X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y) i)
                  else 0 }.map
          g)
      i✝
[PROOFSTEP]
dsimp
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ι
⊢ (if h : i✝ = j then
      eqToHom (_ : (if i✝ = j then X✝ else 0) = X✝) ≫ (f ≫ g) ≫ eqToHom (_ : Z✝ = if i✝ = j then Z✝ else 0)
    else 0) =
    (if h : i✝ = j then eqToHom (_ : (if i✝ = j then X✝ else 0) = X✝) ≫ f ≫ eqToHom (_ : Y✝ = if i✝ = j then Y✝ else 0)
      else 0) ≫
      if h : i✝ = j then eqToHom (_ : (if i✝ = j then Y✝ else 0) = Y✝) ≫ g ≫ eqToHom (_ : Z✝ = if i✝ = j then Z✝ else 0)
      else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ι
h : i✝ = j
⊢ eqToHom (_ : (if i✝ = j then X✝ else 0) = X✝) ≫ (f ≫ g) ≫ eqToHom (_ : Z✝ = if i✝ = j then Z✝ else 0) =
    (eqToHom (_ : (if i✝ = j then X✝ else 0) = X✝) ≫ f ≫ eqToHom (_ : Y✝ = if i✝ = j then Y✝ else 0)) ≫
      eqToHom (_ : (if i✝ = j then Y✝ else 0) = Y✝) ≫ g ≫ eqToHom (_ : Z✝ = if i✝ = j then Z✝ else 0)
[PROOFSTEP]
subst h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ι
⊢ eqToHom (_ : (if i✝ = i✝ then X✝ else 0) = X✝) ≫ (f ≫ g) ≫ eqToHom (_ : Z✝ = if i✝ = i✝ then Z✝ else 0) =
    (eqToHom (_ : (if i✝ = i✝ then X✝ else 0) = X✝) ≫ f ≫ eqToHom (_ : Y✝ = if i✝ = i✝ then Y✝ else 0)) ≫
      eqToHom (_ : (if i✝ = i✝ then Y✝ else 0) = Y✝) ≫ g ≫ eqToHom (_ : Z✝ = if i✝ = i✝ then Z✝ else 0)
[PROOFSTEP]
simp
[GOAL]
case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
i✝ : ι
h : ¬i✝ = j
⊢ 0 = 0 ≫ 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : V
⊢ X ((single V c j).obj A) j = A
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A B : V
f : A ⟶ B
⊢ Hom.f ((single V c j).map f) j = (singleObjXSelf V c j A).hom ≫ f ≫ (singleObjXSelf V c j B).inv
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
a₁✝ a₂✝ : X✝ ⟶ Y✝
w : (single V c j).map a₁✝ = (single V c j).map a₂✝
⊢ a₁✝ = a₂✝
[PROOFSTEP]
have := congr_hom w j
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
a₁✝ a₂✝ : X✝ ⟶ Y✝
w : (single V c j).map a₁✝ = (single V c j).map a₂✝
this : Hom.f ((single V c j).map a₁✝) j = Hom.f ((single V c j).map a₂✝) j
⊢ a₁✝ = a₂✝
[PROOFSTEP]
dsimp at this 
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
a₁✝ a₂✝ : X✝ ⟶ Y✝
w : (single V c j).map a₁✝ = (single V c j).map a₂✝
this :
  (if h : j = j then
      eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) j = X✝) ≫
        a₁✝ ≫ eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) j)
    else 0) =
    if h : j = j then
      eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) j = X✝) ≫
        a₂✝ ≫ eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) j)
    else 0
⊢ a₁✝ = a₂✝
[PROOFSTEP]
simp only [dif_pos] at this 
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
a₁✝ a₂✝ : X✝ ⟶ Y✝
w : (single V c j).map a₁✝ = (single V c j).map a₂✝
this :
  eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) j = X✝) ≫
      a₁✝ ≫ eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) j) =
    eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) j = X✝) ≫
      a₂✝ ≫ eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) j)
⊢ a₁✝ = a₂✝
[PROOFSTEP]
rw [← IsIso.inv_comp_eq, inv_eqToHom, eqToHom_trans_assoc, eqToHom_refl, Category.id_comp, ← IsIso.comp_inv_eq,
  Category.assoc, inv_eqToHom, eqToHom_trans, eqToHom_refl, Category.comp_id] at this 
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
a₁✝ a₂✝ : X✝ ⟶ Y✝
w : (single V c j).map a₁✝ = (single V c j).map a₂✝
this : a₁✝ = a₂✝
⊢ a₁✝ = a₂✝
[PROOFSTEP]
exact this
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
⊢ X✝ = X ((single V c j).obj X✝) j
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
⊢ X ((single V c j).obj Y✝) j = Y✝
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
⊢ (single V c j).map
      ((fun {X Y} f =>
          eqToHom (_ : X = if j = j then X else 0) ≫ Hom.f f j ≫ eqToHom (_ : (if j = j then Y else 0) = Y))
        f) =
    f
[PROOFSTEP]
ext i
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
⊢ Hom.f
      ((single V c j).map
        ((fun {X Y} f =>
            eqToHom (_ : X = if j = j then X else 0) ≫ Hom.f f j ≫ eqToHom (_ : (if j = j then Y else 0) = Y))
          f))
      i =
    Hom.f f i
[PROOFSTEP]
dsimp
[GOAL]
case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
⊢ (if h : i = j then
      eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) i = X✝) ≫
        (eqToHom (_ : X✝ = if j = j then X✝ else 0) ≫ Hom.f f j ≫ eqToHom (_ : (if j = j then Y✝ else 0) = Y✝)) ≫
          eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) i)
    else 0) =
    Hom.f f i
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
h : i = j
⊢ eqToHom (_ : X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) X✝) i = X✝) ≫
      (eqToHom (_ : X✝ = if j = j then X✝ else 0) ≫ Hom.f f j ≫ eqToHom (_ : (if j = j then Y✝ else 0) = Y✝)) ≫
        eqToHom (_ : Y✝ = X ((fun A => mk (fun i => if i = j then A else 0) fun i j_1 => 0) Y✝) i) =
    Hom.f f i
[PROOFSTEP]
subst h
[GOAL]
case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
X✝ Y✝ : V
i : ι
f : (single V c i).obj X✝ ⟶ (single V c i).obj Y✝
⊢ eqToHom (_ : X ((fun A => mk (fun i_1 => if i_1 = i then A else 0) fun i_1 j => 0) X✝) i = X✝) ≫
      (eqToHom (_ : X✝ = if i = i then X✝ else 0) ≫ Hom.f f i ≫ eqToHom (_ : (if i = i then Y✝ else 0) = Y✝)) ≫
        eqToHom (_ : Y✝ = X ((fun A => mk (fun i_1 => if i_1 = i then A else 0) fun i_1 j => 0) Y✝) i) =
    Hom.f f i
[PROOFSTEP]
simp
[GOAL]
case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
h : ¬i = j
⊢ 0 = Hom.f f i
[PROOFSTEP]
symm
[GOAL]
case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
h : ¬i = j
⊢ Hom.f f i = 0
[PROOFSTEP]
apply zero_of_target_iso_zero
[GOAL]
case neg.i
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
h : ¬i = j
⊢ X ((single V c j).obj Y✝) i ≅ 0
[PROOFSTEP]
dsimp
[GOAL]
case neg.i
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
X✝ Y✝ : V
f : (single V c j).obj X✝ ⟶ (single V c j).obj Y✝
i : ι
h : ¬i = j
⊢ (if i = j then Y✝ else 0) ≅ 0
[PROOFSTEP]
rw [if_neg h]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ {
          obj := fun X =>
            HomologicalComplex.mk
              (fun n =>
                match n with
                | 0 => X
                | Nat.succ n => 0)
              fun i j => 0,
          map := fun {X Y} f =>
            Hom.mk fun n =>
              match n with
              | 0 => f
              | Nat.succ n => 0 }.map
      (𝟙 X) =
    𝟙
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.obj
        X)
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (𝟙 X))
      Nat.zero =
    Hom.f
      (𝟙
        ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.obj
          X))
      Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (𝟙 X))
      (Nat.succ n✝) =
    Hom.f
      (𝟙
        ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.obj
          X))
      (Nat.succ n✝)
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ {
          obj := fun X =>
            HomologicalComplex.mk
              (fun n =>
                match n with
                | 0 => X
                | Nat.succ n => 0)
              fun i j => 0,
          map := fun {X Y} f =>
            Hom.mk fun n =>
              match n with
              | 0 => f
              | Nat.succ n => 0 }.map
      (f ≫ g) =
    {
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        f ≫
      {
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        g
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (f ≫ g))
      Nat.zero =
    Hom.f
      ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          f ≫
        {
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          g)
      Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
n✝ : ℕ
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (f ≫ g))
      (Nat.succ n✝) =
    Hom.f
      ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          f ≫
        {
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          g)
      (Nat.succ n✝)
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ dTo ((single₀ V).obj X) j = 0
[PROOFSTEP]
rw [dTo_eq ((single₀ V).obj X) rfl]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ (xPrevIso ((single₀ V).obj X) (_ : j + 1 = j + 1)).hom ≫ d ((single₀ V).obj X) (j + 1) j = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ dFrom ((single₀ V).obj X) i = 0
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ dFrom ((single₀ V).obj X) Nat.zero = 0
[PROOFSTEP]
rw [dFrom_eq_zero]
[GOAL]
case zero.h
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ ¬ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero (ComplexShape.next (ComplexShape.down ℕ) Nat.zero)
[PROOFSTEP]
simp
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ dFrom ((single₀ V).obj X) (Nat.succ n✝) = 0
[PROOFSTEP]
erw [dFrom_eq ((single₀ V).obj X) rfl]
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ d ((single₀ V).obj X) (n✝ + 1) n✝ ≫ (xNextIso ((single₀ V).obj X) (_ : n✝ + 1 = n✝ + 1)).inv = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X : V
⊢ dTo ((single₀ V).obj X) 0 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X : V
⊢ dFrom ((single₀ V).obj X) 0 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ (single₀ V ⋙ homologyFunctor V (ComplexShape.down ℕ) 0).map f ≫
      ((fun X =>
            homology.congr (_ : dTo ((single₀ V).obj X) 0 ≫ dFrom ((single₀ V).obj X) 0 = 0) (_ : 0 ≫ 0 = 0) (_ : 0 = 0)
                (_ : d ((single₀ V).obj X) 0 (ComplexShape.next (ComplexShape.down ℕ) 0) = 0) ≪≫
              homologyZeroZero)
          Y✝).hom =
    ((fun X =>
            homology.congr (_ : dTo ((single₀ V).obj X) 0 ≫ dFrom ((single₀ V).obj X) 0 = 0) (_ : 0 ≫ 0 = 0) (_ : 0 = 0)
                (_ : d ((single₀ V).obj X) 0 (ComplexShape.next (ComplexShape.down ℕ) 0) = 0) ≪≫
              homologyZeroZero)
          X✝).hom ≫
      (𝟭 V).map f
[PROOFSTEP]
dsimp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0)
        (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (Hom.sqTo ((single₀ V).map f) 0)
        (Hom.sqFrom ((single₀ V).map f) 0)
        (_ : (Hom.sqTo ((single₀ V).map f) 0).right = (Hom.sqTo ((single₀ V).map f) 0).right) ≫
      homology.map (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (_ : 0 ≫ 0 = 0)
          (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj Y✝) 0)) (𝟙 Y✝))
          (CommaMorphism.mk (𝟙 Y✝) (𝟙 (xNext ((single₀ V).obj Y✝) 0)))
          (_ :
            (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
        homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
          (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0) =
    (homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) (_ : 0 ≫ 0 = 0)
          (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj X✝) 0)) (𝟙 X✝))
          (CommaMorphism.mk (𝟙 X✝) (𝟙 (xNext ((single₀ V).obj X✝) 0)))
          (_ :
            (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
        homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
          (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0)) ≫
      f
[PROOFSTEP]
ext
[GOAL]
case p
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ homology.π (dTo ((single₀ V).obj X✝) 0) (dFrom ((single₀ V).obj X✝) 0)
        (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) ≫
      homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0)
          (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (Hom.sqTo ((single₀ V).map f) 0)
          (Hom.sqFrom ((single₀ V).map f) 0)
          (_ : (Hom.sqTo ((single₀ V).map f) 0).right = (Hom.sqTo ((single₀ V).map f) 0).right) ≫
        homology.map (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (_ : 0 ≫ 0 = 0)
            (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj Y✝) 0)) (𝟙 Y✝))
            (CommaMorphism.mk (𝟙 Y✝) (𝟙 (xNext ((single₀ V).obj Y✝) 0)))
            (_ :
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
                (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
          homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
            (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0) =
    homology.π (dTo ((single₀ V).obj X✝) 0) (dFrom ((single₀ V).obj X✝) 0)
        (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) ≫
      (homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) (_ : 0 ≫ 0 = 0)
            (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj X✝) 0)) (𝟙 X✝))
            (CommaMorphism.mk (𝟙 X✝) (𝟙 (xNext ((single₀ V).obj X✝) 0)))
            (_ :
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
                (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
          homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
            (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0)) ≫
        f
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
n : ℕ
X : V
⊢ dTo ((single₀ V).obj X) (n + 1) = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
n : ℕ
X : V
⊢ dFrom ((single₀ V).obj X) (n + 1) = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
⊢ d C 1 0 ≫ Hom.f f 0 = 0
[PROOFSTEP]
rw [← f.comm 1 0]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
⊢ Hom.f f 1 ≫ d ((single₀ V).obj X) 1 0 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
i j : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) i j
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        i ≫
      d ((single₀ V).obj X) i j =
    d C i j ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
rcases i with (_ | _ | i)
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
j : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero j
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero ≫
      d ((single₀ V).obj X) Nat.zero j =
    d C Nat.zero j ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases j
[GOAL]
case succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
j : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ Nat.zero) j
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ Nat.zero) ≫
      d ((single₀ V).obj X) (Nat.succ Nat.zero) j =
    d C (Nat.succ Nat.zero) j ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases j
[GOAL]
case succ.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
j i : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) j
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ i)) ≫
      d ((single₀ V).obj X) (Nat.succ (Nat.succ i)) j =
    d C (Nat.succ (Nat.succ i)) j ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases j
[GOAL]
case zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero ≫
      d ((single₀ V).obj X) Nat.zero Nat.zero =
    d C Nat.zero Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case zero.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero (Nat.succ n✝)
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero ≫
      d ((single₀ V).obj X) Nat.zero (Nat.succ n✝) =
    d C Nat.zero (Nat.succ n✝) ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ n✝)
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case succ.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ Nat.zero) Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ Nat.zero) ≫
      d ((single₀ V).obj X) (Nat.succ Nat.zero) Nat.zero =
    d C (Nat.succ Nat.zero) Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case succ.zero.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ Nat.zero) (Nat.succ n✝)
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ Nat.zero) ≫
      d ((single₀ V).obj X) (Nat.succ Nat.zero) (Nat.succ n✝) =
    d C (Nat.succ Nat.zero) (Nat.succ n✝) ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ n✝)
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case succ.succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
i : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ i)) ≫
      d ((single₀ V).obj X) (Nat.succ (Nat.succ i)) Nat.zero =
    d C (Nat.succ (Nat.succ i)) Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case succ.succ.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
i n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) (Nat.succ n✝)
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ i)) ≫
      d ((single₀ V).obj X) (Nat.succ (Nat.succ i)) (Nat.succ n✝) =
    d C (Nat.succ (Nat.succ i)) (Nat.succ n✝) ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        (Nat.succ n✝)
[PROOFSTEP]
simp only [single₀_obj_X_d, comp_zero]
[GOAL]
case zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero Nat.zero
⊢ 0 = d C Nat.zero Nat.zero ≫ ↑f
[PROOFSTEP]
rw [C.shape, zero_comp]
[GOAL]
case zero.zero.a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero Nat.zero
⊢ ¬ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero Nat.zero
[PROOFSTEP]
simp
[GOAL]
case succ.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ Nat.zero) Nat.zero
⊢ 0 = d C (Nat.succ Nat.zero) Nat.zero ≫ ↑f
[PROOFSTEP]
exact f.2.symm
[GOAL]
case succ.succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
i : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) Nat.zero
⊢ 0 = d C (Nat.succ (Nat.succ i)) Nat.zero ≫ ↑f
[PROOFSTEP]
rw [C.shape, zero_comp]
[GOAL]
case succ.succ.zero.a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : { f // d C 1 0 ≫ f = 0 }
i : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) Nat.zero
⊢ ¬ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ (Nat.succ i)) Nat.zero
[PROOFSTEP]
exact i.succ_succ_ne_one.symm
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
⊢ (fun f =>
        Hom.mk fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
      ((fun f => { val := Hom.f f 0, property := (_ : d C 1 0 ≫ Hom.f f 0 = 0) }) f) =
    f
[PROOFSTEP]
ext i
[GOAL]
case h
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
i : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : d C 1 0 ≫ Hom.f f 0 = 0) }) f))
      i =
    Hom.f f i
[PROOFSTEP]
rcases i with ⟨⟩
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : d C 1 0 ≫ Hom.f f 0 = 0) }) f))
      Nat.zero =
    Hom.f f Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
n✝ : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : d C 1 0 ≫ Hom.f f 0 = 0) }) f))
      (Nat.succ n✝) =
    Hom.f f (Nat.succ n✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C ⟶ (single₀ V).obj X
n✝ : ℕ
⊢ 0 = Hom.f f (Nat.succ n✝)
[PROOFSTEP]
ext
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
⊢ Function.RightInverse
    (fun f =>
      Hom.mk fun i =>
        match i with
        | 0 => ↑f
        | Nat.succ n => 0)
    fun f => { val := Hom.f f 0, property := (_ : d C 1 0 ≫ Hom.f f 0 = 0) }
[PROOFSTEP]
aesop_cat
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f g : C ⟶ (single₀ V).obj X
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(toSingle₀Equiv C X) f = ↑(toSingle₀Equiv C X) g
[PROOFSTEP]
ext
[GOAL]
case a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f g : C ⟶ (single₀ V).obj X
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(↑(toSingle₀Equiv C X) f) = ↑(↑(toSingle₀Equiv C X) g)
[PROOFSTEP]
exact h
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
i j : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) i j
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        i ≫
      d C i j =
    d ((single₀ V).obj X) i j ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero j
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero j =
    d ((single₀ V).obj X) Nat.zero j ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases j
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
j n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ n✝) j
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        (Nat.succ n✝) ≫
      d C (Nat.succ n✝) j =
    d ((single₀ V).obj X) (Nat.succ n✝) j ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
cases j
[GOAL]
case zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero Nat.zero
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero Nat.zero =
    d ((single₀ V).obj X) Nat.zero Nat.zero ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [shape, ComplexShape.down_Rel, Nat.one_ne_zero, not_false_iff, zero_comp, single₀_obj_X_d, Nat.zero_eq,
  add_eq_zero, comp_zero]
[GOAL]
case zero.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero (Nat.succ n✝)
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero (Nat.succ n✝) =
    d ((single₀ V).obj X) Nat.zero (Nat.succ n✝) ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        (Nat.succ n✝)
[PROOFSTEP]
simp only [shape, ComplexShape.down_Rel, Nat.one_ne_zero, not_false_iff, zero_comp, single₀_obj_X_d, Nat.zero_eq,
  add_eq_zero, comp_zero]
[GOAL]
case succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ n✝) Nat.zero
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        (Nat.succ n✝) ≫
      d C (Nat.succ n✝) Nat.zero =
    d ((single₀ V).obj X) (Nat.succ n✝) Nat.zero ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [shape, ComplexShape.down_Rel, Nat.one_ne_zero, not_false_iff, zero_comp, single₀_obj_X_d, Nat.zero_eq,
  add_eq_zero, comp_zero]
[GOAL]
case succ.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
n✝¹ n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.down ℕ) (Nat.succ n✝¹) (Nat.succ n✝)
⊢ (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        (Nat.succ n✝¹) ≫
      d C (Nat.succ n✝¹) (Nat.succ n✝) =
    d ((single₀ V).obj X) (Nat.succ n✝¹) (Nat.succ n✝) ≫
      (fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
        (Nat.succ n✝)
[PROOFSTEP]
simp only [shape, ComplexShape.down_Rel, Nat.one_ne_zero, not_false_iff, zero_comp, single₀_obj_X_d, Nat.zero_eq,
  add_eq_zero, comp_zero]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ (fun f =>
        Hom.mk fun i =>
          match i with
          | 0 => f
          | Nat.succ n => 0)
      ((fun f => Hom.f f 0) f) =
    f
[PROOFSTEP]
ext i
[GOAL]
case h
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
i : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => f
            | Nat.succ n => 0)
        ((fun f => Hom.f f 0) f))
      i =
    Hom.f f i
[PROOFSTEP]
cases i
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => f
            | Nat.succ n => 0)
        ((fun f => Hom.f f 0) f))
      Nat.zero =
    Hom.f f Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
n✝ : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => f
            | Nat.succ n => 0)
        ((fun f => Hom.f f 0) f))
      (Nat.succ n✝) =
    Hom.f f (Nat.succ n✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
n✝ : ℕ
⊢ 0 = Hom.f f (Nat.succ n✝)
[PROOFSTEP]
ext
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ HomologicalComplex.X ((single₀ V).obj X) i ⟶ HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ HomologicalComplex.X ((single₀ V).obj X) Nat.zero ⟶
    HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero
[PROOFSTEP]
exact 𝟙 _
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n✝) ⟶
    HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n✝)
[PROOFSTEP]
exact 𝟙 _
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶ HomologicalComplex.X ((single₀ V).obj X) i
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero ⟶
    HomologicalComplex.X ((single₀ V).obj X) Nat.zero
[PROOFSTEP]
exact 𝟙 _
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n✝) ⟶
    HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n✝)
[PROOFSTEP]
exact 𝟙 _
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i))
      0 =
    Hom.f (𝟙 ((single₀ V).obj X)) 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ ((Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t →
            (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
              HomologicalComplex.X ((single₀ V).obj X) i))
          i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
          (fun n h =>
            (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
          (_ : i = i)) ≫
      Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t →
            (HomologicalComplex.X ((single₀ V).obj X) i ⟶
              HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
          i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
          (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i)) =
    𝟙 ((single V (ComplexShape.down ℕ) 0).obj X)
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i))
      Nat.zero =
    Hom.f (𝟙 ((single V (ComplexShape.down ℕ) 0).obj X)) Nat.zero
[PROOFSTEP]
dsimp
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ 𝟙 (if 0 = 0 then X else 0) ≫ 𝟙 X = 𝟙 (if 0 = 0 then X else 0)
[PROOFSTEP]
simp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i))
      (Nat.succ n✝) =
    Hom.f (𝟙 ((single V (ComplexShape.down ℕ) 0).obj X)) (Nat.succ n✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ 𝟙 (if Nat.succ n✝ = 0 then X else 0) ≫ 𝟙 0 = 𝟙 (if Nat.succ n✝ = 0 then X else 0)
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ (single₀ V).map f ≫
      ((fun X =>
            Iso.mk
              (Hom.mk fun i =>
                Nat.casesOn (motive := fun t =>
                  i = t →
                    (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                      HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                  i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                  (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                  (_ : i = i))
              (Hom.mk fun i =>
                Nat.casesOn (motive := fun t =>
                  i = t →
                    (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                      HomologicalComplex.X ((single₀ V).obj X) i))
                  i
                  (fun h =>
                    (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                  (fun n h =>
                    (_ : Nat.succ n = i) ▸
                      𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                  (_ : i = i)))
          Y✝).hom =
    ((fun X =>
            Iso.mk
              (Hom.mk fun i =>
                Nat.casesOn (motive := fun t =>
                  i = t →
                    (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                      HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                  i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                  (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                  (_ : i = i))
              (Hom.mk fun i =>
                Nat.casesOn (motive := fun t =>
                  i = t →
                    (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                      HomologicalComplex.X ((single₀ V).obj X) i))
                  i
                  (fun h =>
                    (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                  (fun n h =>
                    (_ : Nat.succ n = i) ▸
                      𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                  (_ : i = i)))
          X✝).hom ≫
      (single V (ComplexShape.down ℕ) 0).map f
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ Hom.f
      ((single₀ V).map f ≫
        ((fun X =>
              Iso.mk
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                        HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                    i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                    (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                    (_ : i = i))
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                        HomologicalComplex.X ((single₀ V).obj X) i))
                    i
                    (fun h =>
                      (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                    (fun n h =>
                      (_ : Nat.succ n = i) ▸
                        𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                    (_ : i = i)))
            Y✝).hom)
      Nat.zero =
    Hom.f
      (((fun X =>
              Iso.mk
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                        HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                    i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                    (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                    (_ : i = i))
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                        HomologicalComplex.X ((single₀ V).obj X) i))
                    i
                    (fun h =>
                      (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                    (fun n h =>
                      (_ : Nat.succ n = i) ▸
                        𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                    (_ : i = i)))
            X✝).hom ≫
        (single V (ComplexShape.down ℕ) 0).map f)
      Nat.zero
[PROOFSTEP]
aesop_cat
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
n✝ : ℕ
⊢ Hom.f
      ((single₀ V).map f ≫
        ((fun X =>
              Iso.mk
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                        HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                    i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                    (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                    (_ : i = i))
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                        HomologicalComplex.X ((single₀ V).obj X) i))
                    i
                    (fun h =>
                      (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                    (fun n h =>
                      (_ : Nat.succ n = i) ▸
                        𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                    (_ : i = i)))
            Y✝).hom)
      (Nat.succ n✝) =
    Hom.f
      (((fun X =>
              Iso.mk
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                        HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i))
                    i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
                    (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n)))
                    (_ : i = i))
                (Hom.mk fun i =>
                  Nat.casesOn (motive := fun t =>
                    i = t →
                      (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) i ⟶
                        HomologicalComplex.X ((single₀ V).obj X) i))
                    i
                    (fun h =>
                      (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) Nat.zero))
                    (fun n h =>
                      (_ : Nat.succ n = i) ▸
                        𝟙 (HomologicalComplex.X ((single V (ComplexShape.down ℕ) 0).obj X) (Nat.succ n)))
                    (_ : i = i)))
            X✝).hom ≫
        (single V (ComplexShape.down ℕ) 0).map f)
      (Nat.succ n✝)
[PROOFSTEP]
aesop_cat
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ {
          obj := fun X =>
            HomologicalComplex.mk
              (fun n =>
                match n with
                | 0 => X
                | Nat.succ n => 0)
              fun i j => 0,
          map := fun {X Y} f =>
            Hom.mk fun n =>
              match n with
              | 0 => f
              | Nat.succ n => 0 }.map
      (𝟙 X) =
    𝟙
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.obj
        X)
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (𝟙 X))
      Nat.zero =
    Hom.f
      (𝟙
        ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.obj
          X))
      Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (𝟙 X))
      (Nat.succ n✝) =
    Hom.f
      (𝟙
        ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.obj
          X))
      (Nat.succ n✝)
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ {
          obj := fun X =>
            HomologicalComplex.mk
              (fun n =>
                match n with
                | 0 => X
                | Nat.succ n => 0)
              fun i j => 0,
          map := fun {X Y} f =>
            Hom.mk fun n =>
              match n with
              | 0 => f
              | Nat.succ n => 0 }.map
      (f ≫ g) =
    {
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        f ≫
      {
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        g
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (f ≫ g))
      Nat.zero =
    Hom.f
      ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          f ≫
        {
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          g)
      Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X✝ Y✝ Z✝ : V
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
n✝ : ℕ
⊢ Hom.f
      ({
            obj := fun X =>
              HomologicalComplex.mk
                (fun n =>
                  match n with
                  | 0 => X
                  | Nat.succ n => 0)
                fun i j => 0,
            map := fun {X Y} f =>
              Hom.mk fun n =>
                match n with
                | 0 => f
                | Nat.succ n => 0 }.map
        (f ≫ g))
      (Nat.succ n✝) =
    Hom.f
      ({
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          f ≫
        {
              obj := fun X =>
                HomologicalComplex.mk
                  (fun n =>
                    match n with
                    | 0 => X
                    | Nat.succ n => 0)
                  fun i j => 0,
              map := fun {X Y} f =>
                Hom.mk fun n =>
                  match n with
                  | 0 => f
                  | Nat.succ n => 0 }.map
          g)
      (Nat.succ n✝)
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ dFrom ((single₀ V).obj X) j = 0
[PROOFSTEP]
rw [dFrom_eq ((single₀ V).obj X) rfl]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
j : ℕ
⊢ d ((single₀ V).obj X) j (j + 1) ≫ (xNextIso ((single₀ V).obj X) (_ : j + 1 = j + 1)).inv = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ dTo ((single₀ V).obj X) i = 0
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ dTo ((single₀ V).obj X) Nat.zero = 0
[PROOFSTEP]
rw [dTo_eq_zero]
[GOAL]
case zero.h
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ ¬ComplexShape.Rel (ComplexShape.up ℕ) (ComplexShape.prev (ComplexShape.up ℕ) Nat.zero) Nat.zero
[PROOFSTEP]
simp
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ dTo ((single₀ V).obj X) (Nat.succ n✝) = 0
[PROOFSTEP]
erw [dTo_eq ((single₀ V).obj X) rfl]
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ (xPrevIso ((single₀ V).obj X) (_ : n✝ + 1 = n✝ + 1)).hom ≫ d ((single₀ V).obj X) n✝ (n✝ + 1) = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X : V
⊢ dTo ((single₀ V).obj X) 0 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X : V
⊢ dFrom ((single₀ V).obj X) 0 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ (single₀ V ⋙ homologyFunctor V (ComplexShape.up ℕ) 0).map f ≫
      ((fun X =>
            homology.congr (_ : dTo ((single₀ V).obj X) 0 ≫ dFrom ((single₀ V).obj X) 0 = 0) (_ : 0 ≫ 0 = 0)
                (_ : d ((single₀ V).obj X) (ComplexShape.prev (ComplexShape.up ℕ) 0) 0 = 0) (_ : 0 = 0) ≪≫
              homologyZeroZero)
          Y✝).hom =
    ((fun X =>
            homology.congr (_ : dTo ((single₀ V).obj X) 0 ≫ dFrom ((single₀ V).obj X) 0 = 0) (_ : 0 ≫ 0 = 0)
                (_ : d ((single₀ V).obj X) (ComplexShape.prev (ComplexShape.up ℕ) 0) 0 = 0) (_ : 0 = 0) ≪≫
              homologyZeroZero)
          X✝).hom ≫
      (𝟭 V).map f
[PROOFSTEP]
dsimp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0)
        (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (Hom.sqTo ((single₀ V).map f) 0)
        (Hom.sqFrom ((single₀ V).map f) 0)
        (_ : (Hom.sqTo ((single₀ V).map f) 0).right = (Hom.sqTo ((single₀ V).map f) 0).right) ≫
      homology.map (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (_ : 0 ≫ 0 = 0)
          (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj Y✝) 0)) (𝟙 Y✝))
          (CommaMorphism.mk (𝟙 Y✝) (𝟙 (xNext ((single₀ V).obj Y✝) 0)))
          (_ :
            (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
        homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
          (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0) =
    (homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) (_ : 0 ≫ 0 = 0)
          (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj X✝) 0)) (𝟙 X✝))
          (CommaMorphism.mk (𝟙 X✝) (𝟙 (xNext ((single₀ V).obj X✝) 0)))
          (_ :
            (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
        homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
          (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0)) ≫
      f
[PROOFSTEP]
ext
[GOAL]
case p
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
X✝ Y✝ : V
f : X✝ ⟶ Y✝
⊢ homology.π (dTo ((single₀ V).obj X✝) 0) (dFrom ((single₀ V).obj X✝) 0)
        (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) ≫
      homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0)
          (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (Hom.sqTo ((single₀ V).map f) 0)
          (Hom.sqFrom ((single₀ V).map f) 0)
          (_ : (Hom.sqTo ((single₀ V).map f) 0).right = (Hom.sqTo ((single₀ V).map f) 0).right) ≫
        homology.map (_ : dTo ((single₀ V).obj Y✝) 0 ≫ dFrom ((single₀ V).obj Y✝) 0 = 0) (_ : 0 ≫ 0 = 0)
            (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj Y✝) 0)) (𝟙 Y✝))
            (CommaMorphism.mk (𝟙 Y✝) (𝟙 (xNext ((single₀ V).obj Y✝) 0)))
            (_ :
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
                (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
          homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
            (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0) =
    homology.π (dTo ((single₀ V).obj X✝) 0) (dFrom ((single₀ V).obj X✝) 0)
        (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) ≫
      (homology.map (_ : dTo ((single₀ V).obj X✝) 0 ≫ dFrom ((single₀ V).obj X✝) 0 = 0) (_ : 0 ≫ 0 = 0)
            (CommaMorphism.mk (𝟙 (xPrev ((single₀ V).obj X✝) 0)) (𝟙 X✝))
            (CommaMorphism.mk (𝟙 X✝) (𝟙 (xNext ((single₀ V).obj X✝) 0)))
            (_ :
              (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right =
                (CommaMorphism.mk (𝟙 (Arrow.mk 0).left) (𝟙 (Arrow.mk 0).right)).right) ≫
          homology.desc 0 0 (_ : 0 ≫ 0 = 0) (Subobject.arrow (kernelSubobject 0))
            (_ : imageToKernel 0 0 (_ : 0 ≫ 0 = 0) ≫ Subobject.arrow (kernelSubobject 0) = 0)) ≫
        f
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
n : ℕ
X : V
⊢ dTo ((single₀ V).obj X) (n + 1) = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝⁶ : Category.{v, u} V
inst✝⁵ : HasZeroMorphisms V
inst✝⁴ : HasZeroObject V
inst✝³ : HasEqualizers V
inst✝² : HasCokernels V
inst✝¹ : HasImages V
inst✝ : HasImageMaps V
n : ℕ
X : V
⊢ dFrom ((single₀ V).obj X) (n + 1) = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ Hom.f f 0 ≫ d C 0 1 = 0
[PROOFSTEP]
rw [f.comm 0 1]
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ d ((single₀ V).obj X) 0 1 ≫ Hom.f f 1 = 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : { f // f ≫ d C 0 1 = 0 }
i j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) i j
⊢ (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        i ≫
      d C i j =
    d ((single₀ V).obj X) i j ≫
      (fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
        j
[PROOFSTEP]
rcases f with ⟨f, hf⟩
[GOAL]
case mk
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
i j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) i j
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        i ≫
      d C i j =
    d ((single₀ V).obj X) i j ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        j
[PROOFSTEP]
rcases j with (_ | _ | j)
[GOAL]
case mk.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
i : ℕ
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) i Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        i ≫
      d C i Nat.zero =
    d ((single₀ V).obj X) i Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
cases i
[GOAL]
case mk.succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
i : ℕ
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) i (Nat.succ Nat.zero)
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        i ≫
      d C i (Nat.succ Nat.zero) =
    d ((single₀ V).obj X) i (Nat.succ Nat.zero) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ Nat.zero)
[PROOFSTEP]
cases i
[GOAL]
case mk.succ.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
i : ℕ
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) i (Nat.succ (Nat.succ j))
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        i ≫
      d C i (Nat.succ (Nat.succ j)) =
    d ((single₀ V).obj X) i (Nat.succ (Nat.succ j)) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ j))
[PROOFSTEP]
cases i
[GOAL]
case mk.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero Nat.zero =
    d ((single₀ V).obj X) Nat.zero Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.zero.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) (Nat.succ n✝) Nat.zero
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ n✝) ≫
      d C (Nat.succ n✝) Nat.zero =
    d ((single₀ V).obj X) (Nat.succ n✝) Nat.zero ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.succ.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ Nat.zero)
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero (Nat.succ Nat.zero) =
    d ((single₀ V).obj X) Nat.zero (Nat.succ Nat.zero) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ Nat.zero)
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.succ.zero.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) (Nat.succ n✝) (Nat.succ Nat.zero)
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ n✝) ≫
      d C (Nat.succ n✝) (Nat.succ Nat.zero) =
    d ((single₀ V).obj X) (Nat.succ n✝) (Nat.succ Nat.zero) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ Nat.zero)
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.succ.succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j))
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        Nat.zero ≫
      d C Nat.zero (Nat.succ (Nat.succ j)) =
    d ((single₀ V).obj X) Nat.zero (Nat.succ (Nat.succ j)) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ j))
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.succ.succ.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j n✝ : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) (Nat.succ n✝) (Nat.succ (Nat.succ j))
⊢ (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ n✝) ≫
      d C (Nat.succ n✝) (Nat.succ (Nat.succ j)) =
    d ((single₀ V).obj X) (Nat.succ n✝) (Nat.succ (Nat.succ j)) ≫
      (fun i =>
          match i with
          | 0 => ↑{ val := f, property := hf }
          | Nat.succ n => 0)
        (Nat.succ (Nat.succ j))
[PROOFSTEP]
simp only [single₀_obj_X_d, zero_comp]
[GOAL]
case mk.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero Nat.zero
⊢ f ≫ d C Nat.zero Nat.zero = 0
[PROOFSTEP]
rw [C.shape, comp_zero]
[GOAL]
case mk.zero.zero.a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero Nat.zero
⊢ ¬ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero Nat.zero
[PROOFSTEP]
simp
[GOAL]
case mk.succ.zero.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ Nat.zero)
⊢ f ≫ d C Nat.zero (Nat.succ Nat.zero) = 0
[PROOFSTEP]
exact hf
[GOAL]
case mk.succ.succ.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j))
⊢ f ≫ d C Nat.zero (Nat.succ (Nat.succ j)) = 0
[PROOFSTEP]
rw [C.shape, comp_zero]
[GOAL]
case mk.succ.succ.zero.a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j))
⊢ ¬ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j))
[PROOFSTEP]
simp
[GOAL]
case mk.succ.succ.zero.a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ HomologicalComplex.X C 0
hf : f ≫ d C 0 1 = 0
j : ℕ
h : ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j))
⊢ ¬1 = Nat.succ (Nat.succ j)
[PROOFSTEP]
exact j.succ_succ_ne_one.symm
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ (fun f =>
        Hom.mk fun i =>
          match i with
          | 0 => ↑f
          | Nat.succ n => 0)
      ((fun f => { val := Hom.f f 0, property := (_ : Hom.f f 0 ≫ d C 0 1 = 0) }) f) =
    f
[PROOFSTEP]
ext i
[GOAL]
case h
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
i : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : Hom.f f 0 ≫ d C 0 1 = 0) }) f))
      i =
    Hom.f f i
[PROOFSTEP]
rcases i with ⟨⟩
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : Hom.f f 0 ≫ d C 0 1 = 0) }) f))
      Nat.zero =
    Hom.f f Nat.zero
[PROOFSTEP]
rfl
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
n✝ : ℕ
⊢ Hom.f
      ((fun f =>
          Hom.mk fun i =>
            match i with
            | 0 => ↑f
            | Nat.succ n => 0)
        ((fun f => { val := Hom.f f 0, property := (_ : Hom.f f 0 ≫ d C 0 1 = 0) }) f))
      (Nat.succ n✝) =
    Hom.f f (Nat.succ n✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : (single₀ V).obj X ⟶ C
n✝ : ℕ
⊢ 0 = Hom.f f (Nat.succ n✝)
[PROOFSTEP]
ext
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
⊢ Function.RightInverse
    (fun f =>
      Hom.mk fun i =>
        match i with
        | 0 => ↑f
        | Nat.succ n => 0)
    fun f => { val := Hom.f f 0, property := (_ : Hom.f f 0 ≫ d C 0 1 = 0) }
[PROOFSTEP]
aesop_cat
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f g : (single₀ V).obj X ⟶ C
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(fromSingle₀Equiv C X) f = ↑(fromSingle₀Equiv C X) g
[PROOFSTEP]
ext
[GOAL]
case a
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f g : (single₀ V).obj X ⟶ C
h : Hom.f f 0 = Hom.f g 0
⊢ ↑(↑(fromSingle₀Equiv C X) f) = ↑(↑(fromSingle₀Equiv C X) g)
[PROOFSTEP]
exact h
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ HomologicalComplex.X ((single₀ V).obj X) i ⟶ HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ HomologicalComplex.X ((single₀ V).obj X) Nat.zero ⟶
    HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero
[PROOFSTEP]
exact 𝟙 _
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n✝) ⟶
    HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n✝)
[PROOFSTEP]
exact 𝟙 _
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i ⟶ HomologicalComplex.X ((single₀ V).obj X) i
[PROOFSTEP]
cases i
[GOAL]
case zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero ⟶
    HomologicalComplex.X ((single₀ V).obj X) Nat.zero
[PROOFSTEP]
exact 𝟙 _
[GOAL]
case succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n✝) ⟶
    HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n✝)
[PROOFSTEP]
exact 𝟙 _
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i))
      0 =
    Hom.f (𝟙 ((single₀ V).obj X)) 0
[PROOFSTEP]
simp
[GOAL]
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ ((Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t →
            (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i ⟶
              HomologicalComplex.X ((single₀ V).obj X) i))
          i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero))
          (fun n h =>
            (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n)))
          (_ : i = i)) ≫
      Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t →
            (HomologicalComplex.X ((single₀ V).obj X) i ⟶
              HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i))
          i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
          (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i)) =
    𝟙 ((single V (ComplexShape.up ℕ) 0).obj X)
[PROOFSTEP]
ext (_ | _)
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i))
      Nat.zero =
    Hom.f (𝟙 ((single V (ComplexShape.up ℕ) 0).obj X)) Nat.zero
[PROOFSTEP]
dsimp
[GOAL]
case h.zero
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ 𝟙 (if 0 = 0 then X else 0) ≫ 𝟙 X = 𝟙 (if 0 = 0 then X else 0)
[PROOFSTEP]
simp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i ⟶
                HomologicalComplex.X ((single₀ V).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t →
              (HomologicalComplex.X ((single₀ V).obj X) i ⟶
                HomologicalComplex.X ((single V (ComplexShape.up ℕ) 0).obj X) i))
            i (fun h => (_ : Nat.zero = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) Nat.zero))
            (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (HomologicalComplex.X ((single₀ V).obj X) (Nat.succ n))) (_ : i = i))
      (Nat.succ n✝) =
    Hom.f (𝟙 ((single V (ComplexShape.up ℕ) 0).obj X)) (Nat.succ n✝)
[PROOFSTEP]
dsimp
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ 𝟙 (if Nat.succ n✝ = 0 then X else 0) ≫ 𝟙 0 = 𝟙 (if Nat.succ n✝ = 0 then X else 0)
[PROOFSTEP]
rw [Category.id_comp]
[GOAL]
case h.succ
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ 𝟙 0 = 𝟙 (if Nat.succ n✝ = 0 then X else 0)
[PROOFSTEP]
rfl
