l3lab/ntp-mathlib huggingface dataset:
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · 

Proof state:
case succ.succ.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
j : ℕ
⊢ ComplexShape.Rel (ComplexShape.up ℕ) Nat.zero (Nat.succ (Nat.succ j)) →
    (fun i =>
            Nat.casesOn (motive := fun t =>
              i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
              (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
              (_ : i = i))
          Nat.zero ≫
        d (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero (Nat.succ (Nat.succ j)) =
      d C Nat.zero (Nat.succ (Nat.succ j)) ≫
        (fun i =>
            Nat.casesOn (motive := fun t =>
              i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
              (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
              (_ : i = i))
          (Nat.succ (Nat.succ j))

Next tactic:
dsimp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            

Proof state:
case succ.succ.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
j : ℕ
⊢ 0 + 1 = Nat.succ (Nat.succ j) →
    𝟙 (X C 0) ≫ d (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) 0 (Nat.succ (Nat.succ j)) =
      d C 0 (Nat.succ (Nat.succ j)) ≫ 𝟙 (X C (Nat.succ (Nat.succ j)))

Next tactic:
aesop
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · 

Proof state:
case succ.succ.succ
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
j i : ℕ
⊢ ComplexShape.Rel (ComplexShape.up ℕ) (Nat.succ i) (Nat.succ (Nat.succ j)) →
    (fun i =>
            Nat.casesOn (motive := fun t =>
              i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
              (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
              (_ : i = i))
          (Nat.succ i) ≫
        d (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ i) (Nat.succ (Nat.succ j)) =
      d C (Nat.succ i) (Nat.succ (Nat.succ j)) ≫
        (fun i =>
            Nat.casesOn (motive := fun t =>
              i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
              (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
              (_ : i = i))
          (Nat.succ (Nat.succ j))

Next tactic:
dsimp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            

Proof state:
case succ.succ.succ
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
j i : ℕ
⊢ Nat.succ i + 1 = Nat.succ (Nat.succ j) →
    𝟙 (X C (Nat.succ i)) ≫ d C (i + 1) (j + 1 + 1) =
      d C (Nat.succ i) (Nat.succ (Nat.succ j)) ≫ 𝟙 (X C (Nat.succ (Nat.succ j)))

Next tactic:
aesop
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    

Proof state:
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ ((Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
          (fun h =>
            (_ : Nat.zero = i) ▸ 𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
          (fun n h =>
            (_ : Nat.succ n = i) ▸
              𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
          (_ : i = i)) ≫
      Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
          (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
          (_ : i = i)) =
    𝟙 (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0))

Next tactic:
ext i
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    

Proof state:
case h
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
i : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i))
      i =
    Hom.f (𝟙 (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0))) i

Next tactic:
cases i
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · 

Proof state:
case h.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i))
      Nat.zero =
    Hom.f (𝟙 (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0))) Nat.zero

Next tactic:
dsimp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        

Proof state:
case h.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ 𝟙 (X C 0) ≫ 𝟙 (X C 0) = 𝟙 (X C 0)

Next tactic:
simp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · 

Proof state:
case h.succ
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
n✝ : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i))
      (Nat.succ n✝) =
    Hom.f (𝟙 (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0))) (Nat.succ n✝)

Next tactic:
dsimp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        

Proof state:
case h.succ
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
n✝ : ℕ
⊢ 𝟙 (X C (n✝ + 1)) ≫ 𝟙 (X C (Nat.succ n✝)) = 𝟙 (X C (n✝ + 1))

Next tactic:
simp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        simp
  inv_hom_id := by
    

Proof state:
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ ((Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
          (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
          (_ : i = i)) ≫
      Hom.mk fun i =>
        Nat.casesOn (motive := fun t =>
          i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
          (fun h =>
            (_ : Nat.zero = i) ▸ 𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
          (fun n h =>
            (_ : Nat.succ n = i) ▸
              𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
          (_ : i = i)) =
    𝟙 C

Next tactic:
ext i
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        simp
  inv_hom_id := by
    ext i
    

Proof state:
case h
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
i : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i))
      i =
    Hom.f (𝟙 C) i

Next tactic:
cases i
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        simp
  inv_hom_id := by
    ext i
    cases i <;>
      · 

Proof state:
case h.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i))
      Nat.zero =
    Hom.f (𝟙 C) Nat.zero

Next tactic:
dsimp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        simp
  inv_hom_id := by
    ext i
    cases i <;>
      · dsimp
        

Proof state:
case h.zero
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
⊢ 𝟙 (X C 0) ≫ 𝟙 (X C 0) = 𝟙 (X C 0)

Next tactic:
simp
/-- Augmenting a truncated complex with the original object and morphism is isomorphic
(with components the identity) to the original complex.
-/
def augmentTruncate (C : CochainComplex V ℕ) :
    augment (truncate.obj C) (C.d 0 1) (C.d_comp_d _ _ _) ≅ C where
  hom :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  inv :=
    { f := fun i => by cases i <;> exact 𝟙 _
      comm' := fun i j => by
        rcases j with (_ | _ | j) <;> cases' i with i <;>
          · dsimp
            -- Porting note: simp can't handle this now but aesop does
            aesop }
  hom_inv_id := by
    ext i
    cases i <;>
      · dsimp
        simp
  inv_hom_id := by
    ext i
    cases i <;>
      · 

Proof state:
case h.succ
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : CochainComplex V ℕ
n✝ : ℕ
⊢ Hom.f
      ((Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X C i ⟶ X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i)) i
            (fun h => (_ : Nat.zero = i) ▸ 𝟙 (X C Nat.zero)) (fun n h => (_ : Nat.succ n = i) ▸ 𝟙 (X C (Nat.succ n)))
            (_ : i = i)) ≫
        Hom.mk fun i =>
          Nat.casesOn (motive := fun t =>
            i = t → (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) i ⟶ X C i)) i
            (fun h =>
              (_ : Nat.zero = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) Nat.zero))
            (fun n h =>
              (_ : Nat.succ n = i) ▸
                𝟙 (X (augment (truncate.obj C) (d C 0 1) (_ : d C 0 1 ≫ d C 1 (1 + 1) = 0)) (Nat.succ n)))
            (_ : i = i))
      (Nat.succ n✝) =
    Hom.f (𝟙 C) (Nat.succ n✝)

Next tactic:
dsimp