l3lab/ntp-mathlib huggingface dataset:
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ e.hom.app { val := k, isLt := (_ : k < n + 1) } ≫ e.inv.app { val := k, isLt := (_ : k < n + 1) } =
    𝟙 (S₁.obj { val := k, isLt := (_ : k < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ sc'Map e.inv h₂ h₁ i j k ≫ sc'Map e.hom h₁ h₂ i j k = 𝟙 (sc' S₂ h₂ i j k)

Next tactic:
ext
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ (sc'Map e.inv h₂ h₁ i j k ≫ sc'Map e.hom h₁ h₂ i j k).τ₁ = (𝟙 (sc' S₂ h₂ i j k)).τ₁

Next tactic:
dsimp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ (sc'Map e.inv h₂ h₁ i j k ≫ sc'Map e.hom h₁ h₂ i j k).τ₂ = (𝟙 (sc' S₂ h₂ i j k)).τ₂

Next tactic:
dsimp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ (sc'Map e.inv h₂ h₁ i j k ≫ sc'Map e.hom h₁ h₂ i j k).τ₃ = (𝟙 (sc' S₂ h₂ i j k)).τ₃

Next tactic:
dsimp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ e.inv.app { val := i, isLt := (_ : i < n + 1) } ≫ e.hom.app { val := i, isLt := (_ : i < n + 1) } =
    𝟙 (S₂.obj { val := i, isLt := (_ : i < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ e.inv.app { val := j, isLt := (_ : j < n + 1) } ≫ e.hom.app { val := j, isLt := (_ : j < n + 1) } =
    𝟙 (S₂.obj { val := j, isLt := (_ : j < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc' _ i j k ≅ S₂.sc' _ i j k` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def sc'MapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by linarith)
    (hjk : j + 1 = k := by linarith) (hk : k ≤ n := by linarith) :
    S₁.sc' h₁ i j k ≅ S₂.sc' h₂ i j k where
  hom := sc'Map e.hom h₁ h₂ i j k
  inv := sc'Map e.inv h₂ h₁ i j k
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.438443, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ e.inv.app { val := k, isLt := (_ : k < n + 1) } ≫ e.hom.app { val := k, isLt := (_ : k < n + 1) } =
    𝟙 (S₂.obj { val := k, isLt := (_ : k < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ scMap e.hom h₁ h₂ i ≫ scMap e.inv h₂ h₁ i = 𝟙 (sc S₁ h₁ i)

Next tactic:
ext
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.hom h₁ h₂ i ≫ scMap e.inv h₂ h₁ i).τ₁ = (𝟙 (sc S₁ h₁ i)).τ₁

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.hom h₁ h₂ i ≫ scMap e.inv h₂ h₁ i).τ₂ = (𝟙 (sc S₁ h₁ i)).τ₂

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.hom h₁ h₂ i ≫ scMap e.inv h₂ h₁ i).τ₃ = (𝟙 (sc S₁ h₁ i)).τ₃

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.hom.app { val := i, isLt := (_ : i < n + 1) } ≫ e.inv.app { val := i, isLt := (_ : i < n + 1) } =
    𝟙 (S₁.obj { val := i, isLt := (_ : i < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.hom.app { val := i + 1, isLt := (_ : i + 1 < n + 1) } ≫ e.inv.app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
    𝟙 (S₁.obj { val := i + 1, isLt := (_ : i + 1 < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.hom.app { val := i + 2, isLt := (_ : i + 2 < n + 1) } ≫ e.inv.app { val := i + 2, isLt := (_ : i + 2 < n + 1) } =
    𝟙 (S₁.obj { val := i + 2, isLt := (_ : i + 2 < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ scMap e.inv h₂ h₁ i ≫ scMap e.hom h₁ h₂ i = 𝟙 (sc S₂ h₂ i)

Next tactic:
ext
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.inv h₂ h₁ i ≫ scMap e.hom h₁ h₂ i).τ₁ = (𝟙 (sc S₂ h₂ i)).τ₁

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.inv h₂ h₁ i ≫ scMap e.hom h₁ h₂ i).τ₂ = (𝟙 (sc S₂ h₂ i)).τ₂

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ (scMap e.inv h₂ h₁ i ≫ scMap e.hom h₁ h₂ i).τ₃ = (𝟙 (sc S₂ h₂ i)).τ₃

Next tactic:
dsimp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₁
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.inv.app { val := i, isLt := (_ : i < n + 1) } ≫ e.hom.app { val := i, isLt := (_ : i < n + 1) } =
    𝟙 (S₂.obj { val := i, isLt := (_ : i < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₂
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.inv.app { val := i + 1, isLt := (_ : i + 1 < n + 1) } ≫ e.hom.app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
    𝟙 (S₂.obj { val := i + 1, isLt := (_ : i + 1 < n + 1) })

Next tactic:
simp
/-- The isomorphism `S₁.sc _ i ≅ S₂.sc _ i` induced by an isomorphism `S₁ ≅ S₂`
in `ComposableArrows C n`. -/
@[simps]
def scMapIso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂)
    (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
    (i : ℕ) (hi : i + 2 ≤ n := by linarith) :
    S₁.sc h₁ i ≅ S₂.sc h₂ i where
  hom := scMap e.hom h₁ h₂ i
  inv := scMap e.inv h₂ h₁ i
  hom_inv_id := by ext <;> dsimp <;> simp
  inv_hom_id := by ext <;> dsimp <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{?u.620934, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : IsComplex S₁
h₂ : IsComplex S₂
i : ℕ
hi : autoParam (i + 2 ≤ n) _auto✝
⊢ e.inv.app { val := i + 2, isLt := (_ : i + 2 < n + 1) } ≫ e.hom.app { val := i + 2, isLt := (_ : i + 2 < n + 1) } =
    𝟙 (S₂.obj { val := i + 2, isLt := (_ : i + 2 < n + 1) })

Next tactic:
simp
lemma exact₀ (S : ComposableArrows C 0) : S.Exact where
  toIsComplex := S.isComplex₀
  -- See https://github.com/leanprover/lean4/issues/2862
  exact i hi := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 0
i : ℕ
hi : autoParam (i + 2 ≤ 0) _auto✝
⊢ ShortComplex.Exact (sc S (_ : IsComplex S) i)

Next tactic:
simp [autoParam] at hi
lemma exact₁ (S : ComposableArrows C 1) : S.Exact where
  toIsComplex := S.isComplex₁
  exact i hi := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 1
i : ℕ
hi : autoParam (i + 2 ≤ 1) _auto✝
⊢ ShortComplex.Exact (sc S (_ : IsComplex S) i)

Next tactic:
exfalso
lemma exact₁ (S : ComposableArrows C 1) : S.Exact where
  toIsComplex := S.isComplex₁
  exact i hi := by exfalso; 

Proof state:
case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 1
i : ℕ
hi : autoParam (i + 2 ≤ 1) _auto✝
⊢ False

Next tactic:
linarith
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
⊢ IsComplex S ↔ map' S 0 1 ≫ map' S 1 2 = 0

Next tactic:
constructor
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · 

Proof state:
case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
⊢ IsComplex S → map' S 0 1 ≫ map' S 1 2 = 0

Next tactic:
intro h
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    

Proof state:
case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : IsComplex S
⊢ map' S 0 1 ≫ map' S 1 2 = 0

Next tactic:
exact h.zero 0 (by linarith)
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : IsComplex S
⊢ 0 + 2 ≤ 2

Next tactic:
linarith
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by linarith)
  · 

Proof state:
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
⊢ map' S 0 1 ≫ map' S 1 2 = 0 → IsComplex S

Next tactic:
intro h
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by linarith)
  · intro h
    

Proof state:
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : map' S 0 1 ≫ map' S 1 2 = 0
⊢ IsComplex S

Next tactic:
refine' IsComplex.mk (fun i hi => _)
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by linarith)
  · intro h
    refine' IsComplex.mk (fun i hi => _)
    

Proof state:
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : map' S 0 1 ≫ map' S 1 2 = 0
i : ℕ
hi : autoParam (i + 2 ≤ 2) _auto✝
⊢ map' S i (i + 1) ≫ map' S (i + 1) (i + 2) = 0

Next tactic:
obtain rfl : i = 0 := by linarith
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by linarith)
  · intro h
    refine' IsComplex.mk (fun i hi => _)
    obtain rfl : i = 0 := by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : map' S 0 1 ≫ map' S 1 2 = 0
i : ℕ
hi : autoParam (i + 2 ≤ 2) _auto✝
⊢ i = 0

Next tactic:
linarith
lemma isComplex₂_iff (S : ComposableArrows C 2) :
    S.IsComplex ↔ S.map' 0 1 ≫ S.map' 1 2 = 0 := by
  constructor
  · intro h
    exact h.zero 0 (by linarith)
  · intro h
    refine' IsComplex.mk (fun i hi => _)
    obtain rfl : i = 0 := by linarith
    

Proof state:
case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
h : map' S 0 1 ≫ map' S 1 2 = 0
hi : autoParam (0 + 2 ≤ 2) _auto✝
⊢ map' S 0 (0 + 1) ≫ map' S (0 + 1) (0 + 2) = 0

Next tactic:
exact h
lemma _root_.CategoryTheory.ShortComplex.isComplex_toComposableArrows (S : ShortComplex C) :
    S.toComposableArrows.IsComplex :=
  isComplex₂_mk _ (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ShortComplex C
⊢ map' (ShortComplex.toComposableArrows S) 0 1 ≫ map' (ShortComplex.toComposableArrows S) 1 2 = 0

Next tactic:
simp
lemma exact₂_iff (S : ComposableArrows C 2) (hS : S.IsComplex) :
    S.Exact ↔ (S.sc' hS 0 1 2).Exact := by
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
hS : IsComplex S
⊢ Exact S ↔ ShortComplex.Exact (sc' S hS 0 1 2)

Next tactic:
constructor
lemma exact₂_iff (S : ComposableArrows C 2) (hS : S.IsComplex) :
    S.Exact ↔ (S.sc' hS 0 1 2).Exact := by
  constructor
  · 

Proof state:
case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S✝ : ComposableArrows C n
S : ComposableArrows C 2
hS : IsComplex S
⊢ Exact S → ShortComplex.Exact (sc' S hS 0 1 2)

Next tactic:
intro h