l3lab/ntp-mathlib huggingface dataset:
theorem map_chain_complex_of (F : V ⥤ W) [F.Additive] (X : α → V) (d : ∀ n, X (n + 1) ⟶ X n)
    (sq : ∀ n, d (n + 1) ≫ d n = 0) :
    (F.mapHomologicalComplex _).obj (ChainComplex.of X d sq) =
      ChainComplex.of (fun n => F.obj (X n)) (fun n => F.map (d n)) fun n => by
        rw [← F.map_comp, sq n, Functor.map_zero] := by
  refine' HomologicalComplex.ext rfl _
  

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_2
inst✝⁵ : Category.{u_4, u_2} W
inst✝⁴ : Preadditive W
α : Type u_3
inst✝³ : AddRightCancelSemigroup α
inst✝² : One α
inst✝¹ : DecidableEq α
F : V ⥤ W
inst✝ : Functor.Additive F
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
⊢ ∀ (i j : α),
    ComplexShape.Rel (ComplexShape.down α) i j →
      HomologicalComplex.d ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) i j ≫
          eqToHom
            (_ :
              HomologicalComplex.X ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) j =
                HomologicalComplex.X
                  (of (fun n => F.obj (X n)) (fun n => F.map (d n))
                    (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
                  j) =
        eqToHom
            (_ :
              HomologicalComplex.X ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) i =
                HomologicalComplex.X
                  (of (fun n => F.obj (X n)) (fun n => F.map (d n))
                    (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
                  i) ≫
          HomologicalComplex.d
            (of (fun n => F.obj (X n)) (fun n => F.map (d n))
              (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
            i j

Next tactic:
rintro i j (rfl : j + 1 = i)
theorem map_chain_complex_of (F : V ⥤ W) [F.Additive] (X : α → V) (d : ∀ n, X (n + 1) ⟶ X n)
    (sq : ∀ n, d (n + 1) ≫ d n = 0) :
    (F.mapHomologicalComplex _).obj (ChainComplex.of X d sq) =
      ChainComplex.of (fun n => F.obj (X n)) (fun n => F.map (d n)) fun n => by
        rw [← F.map_comp, sq n, Functor.map_zero] := by
  refine' HomologicalComplex.ext rfl _
  rintro i j (rfl : j + 1 = i)
  

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_2
inst✝⁵ : Category.{u_4, u_2} W
inst✝⁴ : Preadditive W
α : Type u_3
inst✝³ : AddRightCancelSemigroup α
inst✝² : One α
inst✝¹ : DecidableEq α
F : V ⥤ W
inst✝ : Functor.Additive F
X : α → V
d : (n : α) → X (n + 1) ⟶ X n
sq : ∀ (n : α), d (n + 1) ≫ d n = 0
j : α
⊢ HomologicalComplex.d ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) (j + 1) j ≫
      eqToHom
        (_ :
          HomologicalComplex.X ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) j =
            HomologicalComplex.X
              (of (fun n => F.obj (X n)) (fun n => F.map (d n))
                (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
              j) =
    eqToHom
        (_ :
          HomologicalComplex.X ((Functor.mapHomologicalComplex F (ComplexShape.down α)).obj (of X d sq)) (j + 1) =
            HomologicalComplex.X
              (of (fun n => F.obj (X n)) (fun n => F.map (d n))
                (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
              (j + 1)) ≫
      HomologicalComplex.d
        (of (fun n => F.obj (X n)) (fun n => F.map (d n))
          (_ : ∀ (n : α), (fun n => F.map (d n)) (n + 1) ≫ (fun n => F.map (d n)) n = 0))
        (j + 1) j

Next tactic:
simp only [CategoryTheory.Functor.mapHomologicalComplex_obj_d, of_d, eqToHom_refl, comp_id,
    id_comp]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by 

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : i = j
⊢ HomologicalComplex.X ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X) i =
    HomologicalComplex.X ((F ⋙ single W c j).obj X) i

Next tactic:
simp [h]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by 

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : i = j
⊢ HomologicalComplex.X ((F ⋙ single W c j).obj X) i =
    HomologicalComplex.X ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X) i

Next tactic:
simp [h]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
⊢ ((Hom.mk fun i =>
        if h : i = j then
          eqToHom
            (_ :
              HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i =
                HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
        else 0) ≫
      Hom.mk fun i =>
        if h : i = j then
          eqToHom
            (_ :
              HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
                HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i)
        else 0) =
    𝟙 ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X)

Next tactic:
ext i
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          

Proof state:
case h
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
⊢ Hom.f
      ((Hom.mk fun i =>
          if h : i = j then
            eqToHom
              (_ :
                HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i =
                  HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
          else 0) ≫
        Hom.mk fun i =>
          if h : i = j then
            eqToHom
              (_ :
                HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
                  HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i)
          else 0)
      i =
    Hom.f (𝟙 ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X)) i

Next tactic:
dsimp
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          

Proof state:
case h
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
⊢ ((if h : i = j then
        eqToHom
          (_ :
            F.obj (HomologicalComplex.X ((single V c j).obj X) i) =
              HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
      else 0) ≫
      if h : i = j then
        eqToHom
          (_ :
            HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
              F.obj (HomologicalComplex.X ((single V c j).obj X) i))
      else 0) =
    𝟙 (F.obj (HomologicalComplex.X ((single V c j).obj X) i))

Next tactic:
split_ifs with h
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · 

Proof state:
case pos
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : i = j
⊢ eqToHom
        (_ :
          F.obj (HomologicalComplex.X ((single V c j).obj X) i) =
            HomologicalComplex.X ((single W c j).obj (F.obj X)) i) ≫
      eqToHom
        (_ :
          HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
            F.obj (HomologicalComplex.X ((single V c j).obj X) i)) =
    𝟙 (F.obj (HomologicalComplex.X ((single V c j).obj X) i))

Next tactic:
simp [h]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · 

Proof state:
case neg
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : ¬i = j
⊢ 0 ≫ 0 = 𝟙 (F.obj (HomologicalComplex.X ((single V c j).obj X) i))

Next tactic:
rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
        inv_hom_id := by
          

Proof state:
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
⊢ ((Hom.mk fun i =>
        if h : i = j then
          eqToHom
            (_ :
              HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
                HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i)
        else 0) ≫
      Hom.mk fun i =>
        if h : i = j then
          eqToHom
            (_ :
              HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i =
                HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
        else 0) =
    𝟙 ((F ⋙ single W c j).obj X)

Next tactic:
ext i
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
        inv_hom_id := by
          ext i
          

Proof state:
case h
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
⊢ Hom.f
      ((Hom.mk fun i =>
          if h : i = j then
            eqToHom
              (_ :
                HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
                  HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i)
          else 0) ≫
        Hom.mk fun i =>
          if h : i = j then
            eqToHom
              (_ :
                HomologicalComplex.X ((Functor.mapHomologicalComplex F c).obj ((single V c j).obj X)) i =
                  HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
          else 0)
      i =
    Hom.f (𝟙 ((F ⋙ single W c j).obj X)) i

Next tactic:
dsimp
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
        inv_hom_id := by
          ext i
          dsimp
          

Proof state:
case h
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
⊢ ((if h : i = j then
        eqToHom
          (_ :
            HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
              F.obj (HomologicalComplex.X ((single V c j).obj X) i))
      else 0) ≫
      if h : i = j then
        eqToHom
          (_ :
            F.obj (HomologicalComplex.X ((single V c j).obj X) i) =
              HomologicalComplex.X ((single W c j).obj (F.obj X)) i)
      else 0) =
    𝟙 (HomologicalComplex.X ((single W c j).obj (F.obj X)) i)

Next tactic:
split_ifs with h
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
        inv_hom_id := by
          ext i
          dsimp
          split_ifs with h
          · 

Proof state:
case pos
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : i = j
⊢ eqToHom
        (_ :
          HomologicalComplex.X ((single W c j).obj (F.obj X)) i =
            F.obj (HomologicalComplex.X ((single V c j).obj X) i)) ≫
      eqToHom
        (_ :
          F.obj (HomologicalComplex.X ((single V c j).obj X) i) =
            HomologicalComplex.X ((single W c j).obj (F.obj X)) i) =
    𝟙 (HomologicalComplex.X ((single W c j).obj (F.obj X)) i)

Next tactic:
simp [h]
/-- Turning an object into a complex supported at `j` then applying a functor is
the same as applying the functor then forming the complex.
-/
noncomputable def singleMapHomologicalComplex (F : V ⥤ W) [F.Additive] (c : ComplexShape ι)
    [DecidableEq ι] (j : ι) :
    single V c j ⋙ F.mapHomologicalComplex _ ≅ F ⋙ single W c j :=
  NatIso.ofComponents
    (fun X =>
      { hom := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        inv := { f := fun i => if h : i = j then eqToHom (by simp [h]) else 0 }
        hom_inv_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · rw [zero_comp, ← F.map_id,
              (isZero_single_obj_X c j X _ h).eq_of_src (𝟙 _) 0, F.map_zero]
        inv_hom_id := by
          ext i
          dsimp
          split_ifs with h
          · simp [h]
          · 

Proof state:
case neg
ι : Type u_1
V : Type u
inst✝⁷ : Category.{v, u} V
inst✝⁶ : Preadditive V
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝⁵ : HasZeroObject V
W : Type u_2
inst✝⁴ : Category.{?u.124701, u_2} W
inst✝³ : Preadditive W
inst✝² : HasZeroObject W
F : V ⥤ W
inst✝¹ : Functor.Additive F
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : V
i : ι
h : ¬i = j
⊢ 0 ≫ 0 = 𝟙 (HomologicalComplex.X ((single W c j).obj (F.obj X)) i)

Next tactic:
apply (isZero_single_obj_X c j _ _ h).eq_of_src