Theorem: AlgebraicTopology.AlternatingFaceMapComplex.d_squared
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

tactic: dsimp
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
⊢ objD X (n + 1) ≫ objD X n = 0

tactic: simp only [comp_sum, sum_comp, ← Finset.sum_product']
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
⊢ (∑ i : Fin (n + 1 + 2), (-1) ^ ↑i • SimplicialObject.δ X i) ≫ ∑ i : Fin (n + 2), (-1) ^ ↑i • SimplicialObject.δ X i =
    0

tactic: let P := Fin (n + 2) × Fin (n + 3)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
⊢ ∑ x in Finset.univ ×ˢ Finset.univ,
      ((-1) ^ ↑x.snd • SimplicialObject.δ X x.snd) ≫ ((-1) ^ ↑x.fst • SimplicialObject.δ X x.fst) =
    0

tactic: let S := Finset.univ.filter fun ij : P => (ij.2 : ℕ) ≤ (ij.1 : ℕ)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
⊢ ∑ x in Finset.univ ×ˢ Finset.univ,
      ((-1) ^ ↑x.snd • SimplicialObject.δ X x.snd) ≫ ((-1) ^ ↑x.fst • SimplicialObject.δ X x.fst) =
    0

tactic: erw [← Finset.sum_add_sum_compl S, ← eq_neg_iff_add_eq_zero, ← Finset.sum_neg_distrib]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
⊢ ∑ x in Finset.univ ×ˢ Finset.univ,
      ((-1) ^ ↑x.snd • SimplicialObject.δ X x.snd) ≫ ((-1) ^ ↑x.fst • SimplicialObject.δ X x.fst) =
    0

tactic: let φ : ∀ ij : P, ij ∈ S → P := fun ij hij =>
  (Fin.castLT ij.2 (lt_of_le_of_lt (Finset.mem_filter.mp hij).right (Fin.is_lt ij.1)), ij.1.succ)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
⊢ ∑ i in S, ((-1) ^ ↑i.snd • SimplicialObject.δ X i.snd) ≫ ((-1) ^ ↑i.fst • SimplicialObject.δ X i.fst) =
    ∑ x in Sᶜ, -((-1) ^ ↑x.snd • SimplicialObject.δ X x.snd) ≫ ((-1) ^ ↑x.fst • SimplicialObject.δ X x.fst)

tactic: apply Finset.sum_bij φ
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
⊢ ∑ i in S, ((-1) ^ ↑i.snd • SimplicialObject.δ X i.snd) ≫ ((-1) ^ ↑i.fst • SimplicialObject.δ X i.fst) =
    ∑ x in Sᶜ, -((-1) ^ ↑x.snd • SimplicialObject.δ X x.snd) ≫ ((-1) ^ ↑x.fst • SimplicialObject.δ X x.fst)

tactic: intro ij hij
state_before: case hi
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
⊢ ∀ (a : P) (ha : a ∈ S), φ a ha ∈ Sᶜ

tactic: simp only [Finset.mem_univ, Finset.compl_filter, Finset.mem_filter, true_and_iff, Fin.val_succ,
  Fin.coe_castLT] at hij ⊢
state_before: case hi
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
ij : P
hij : ij ∈ S
⊢ φ ij hij ∈ Sᶜ

tactic: linarith
state_before: case hi
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
ij : P
hij : ↑ij.snd ≤ ↑ij.fst
⊢ ¬↑ij.fst + 1 ≤ ↑ij.snd

tactic: rintro ⟨i, j⟩ hij
state_before: case h
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
⊢ ∀ (a : P) (ha : a ∈ S),
    ((-1) ^ ↑a.snd • SimplicialObject.δ X a.snd) ≫ ((-1) ^ ↑a.fst • SimplicialObject.δ X a.fst) =
      -((-1) ^ ↑(φ a ha).snd • SimplicialObject.δ X (φ a ha).snd) ≫
          ((-1) ^ ↑(φ a ha).fst • SimplicialObject.δ X (φ a ha).fst)

tactic: dsimp
state_before: case h.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ ((-1) ^ ↑(i, j).snd • SimplicialObject.δ X (i, j).snd) ≫ ((-1) ^ ↑(i, j).fst • SimplicialObject.δ X (i, j).fst) =
    -((-1) ^ ↑(φ (i, j) hij).snd • SimplicialObject.δ X (φ (i, j) hij).snd) ≫
        ((-1) ^ ↑(φ (i, j) hij).fst • SimplicialObject.δ X (φ (i, j) hij).fst)

tactic: simp only [zsmul_comp, comp_zsmul, smul_smul, ← neg_smul]
state_before: case h.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ ((-1) ^ ↑j • SimplicialObject.δ X j) ≫ ((-1) ^ ↑i • SimplicialObject.δ X i) =
    -((-1) ^ ↑(Fin.succ i) • SimplicialObject.δ X (Fin.succ i)) ≫
        ((-1) ^ ↑j • SimplicialObject.δ X (Fin.castLT j (_ : ↑j < n + 2)))

tactic: congr 1
state_before: case h.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ ((-1) ^ ↑i * (-1) ^ ↑j) • SimplicialObject.δ X j ≫ SimplicialObject.δ X i =
    -((-1) ^ ↑j * (-1) ^ ↑(Fin.succ i)) •
      SimplicialObject.δ X (Fin.succ i) ≫ SimplicialObject.δ X (Fin.castLT j (_ : ↑j < n + 2))

tactic: . simp only [Fin.val_succ, pow_add, pow_one, mul_neg, neg_neg, mul_one]
  apply mul_comm
state_before: case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ (-1) ^ ↑i * (-1) ^ ↑j = -((-1) ^ ↑j * (-1) ^ ↑(Fin.succ i))

case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ SimplicialObject.δ X j ≫ SimplicialObject.δ X i =
    SimplicialObject.δ X (Fin.succ i) ≫ SimplicialObject.δ X (Fin.castLT j (_ : ↑j < n + 2))

tactic: . rw [CategoryTheory.SimplicialObject.δ_comp_δ'']
  simpa using hij
state_before: case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ SimplicialObject.δ X j ≫ SimplicialObject.δ X i =
    SimplicialObject.δ X (Fin.succ i) ≫ SimplicialObject.δ X (Fin.castLT j (_ : ↑j < n + 2))

tactic: simp only [Fin.val_succ, pow_add, pow_one, mul_neg, neg_neg, mul_one]
state_before: case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ (-1) ^ ↑i * (-1) ^ ↑j = -((-1) ^ ↑j * (-1) ^ ↑(Fin.succ i))

tactic: apply mul_comm
state_before: case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ (-1) ^ ↑i * (-1) ^ ↑j = (-1) ^ ↑j * (-1) ^ ↑i

tactic: rw [CategoryTheory.SimplicialObject.δ_comp_δ'']
state_before: case h.mk.e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ SimplicialObject.δ X j ≫ SimplicialObject.δ X i =
    SimplicialObject.δ X (Fin.succ i) ≫ SimplicialObject.δ X (Fin.castLT j (_ : ↑j < n + 2))

tactic: simpa using hij
state_before: case h.mk.e_a.H
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
hij : (i, j) ∈ S
⊢ j ≤ ↑Fin.castSucc i

tactic: rintro ⟨i, j⟩ ⟨i', j'⟩ hij hij' h
state_before: case i_inj
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
⊢ ∀ (a₁ a₂ : P) (ha₁ : a₁ ∈ S) (ha₂ : a₂ ∈ S), φ a₁ ha₁ = φ a₂ ha₂ → a₁ = a₂

tactic: rw [Prod.mk.inj_iff]
state_before: case i_inj.mk.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij : (i, j) ∈ S
hij' : (i', j') ∈ S
h : φ (i, j) hij = φ (i', j') hij'
⊢ (i, j) = (i', j')

tactic: exact ⟨by simpa using congr_arg Prod.snd h,
  by simpa [Fin.castSucc_castLT] using congr_arg Fin.castSucc (congr_arg Prod.fst h)⟩
state_before: case i_inj.mk.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij : (i, j) ∈ S
hij' : (i', j') ∈ S
h : φ (i, j) hij = φ (i', j') hij'
⊢ i = i' ∧ j = j'

tactic: simpa using congr_arg Prod.snd h
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij : (i, j) ∈ S
hij' : (i', j') ∈ S
h : φ (i, j) hij = φ (i', j') hij'
⊢ i = i'

tactic: simpa [Fin.castSucc_castLT] using congr_arg Fin.castSucc (congr_arg Prod.fst h)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i : Fin (n + 2)
j : Fin (n + 3)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij : (i, j) ∈ S
hij' : (i', j') ∈ S
h : φ (i, j) hij = φ (i', j') hij'
⊢ j = j'

tactic: rintro ⟨i', j'⟩ hij'
state_before: case i_surj
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
⊢ ∀ (b : P), b ∈ Sᶜ → ∃ a ha, b = φ a ha

tactic: simp only [Finset.mem_univ, forall_true_left, Prod.forall, ge_iff_le, Finset.compl_filter,
  not_le, Finset.mem_filter, true_and] at hij'
state_before: case i_surj.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : (i', j') ∈ Sᶜ
⊢ ∃ a ha, (i', j') = φ a ha

tactic: refine' ⟨(j'.pred _, Fin.castSucc i'), _, _⟩
state_before: case i_surj.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ ∃ a ha, (i', j') = φ a ha

tactic: . rintro rfl
  simp only [Fin.val_zero, not_lt_zero'] at hij'
state_before: case i_surj.mk.refine'_1
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ j' ≠ 0

case i_surj.mk.refine'_2
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (Fin.pred j' ?i_surj.mk.refine'_1, ↑Fin.castSucc i') ∈ S

case i_surj.mk.refine'_3
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (i', j') = φ (Fin.pred j' ?i_surj.mk.refine'_1, ↑Fin.castSucc i') ?i_surj.mk.refine'_2

tactic: . simpa only [Finset.mem_univ, forall_true_left, Prod.forall, ge_iff_le, Finset.mem_filter,
    Fin.coe_castSucc, Fin.coe_pred, true_and] using Nat.le_pred_of_lt hij'
state_before: case i_surj.mk.refine'_2
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i') ∈ S

case i_surj.mk.refine'_3
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (i', j') = φ (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i') ?i_surj.mk.refine'_2

tactic: . simp only [Fin.castLT_castSucc, Fin.succ_pred]
state_before: case i_surj.mk.refine'_3
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (i', j') =
    φ (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i')
      (_ : (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i') ∈ S)

tactic: rintro rfl
state_before: case i_surj.mk.refine'_1
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ j' ≠ 0

tactic: simp only [Fin.val_zero, not_lt_zero'] at hij'
state_before: case i_surj.mk.refine'_1
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
hij' : ↑i' < ↑0
⊢ False

tactic: simpa only [Finset.mem_univ, forall_true_left, Prod.forall, ge_iff_le, Finset.mem_filter,
  Fin.coe_castSucc, Fin.coe_pred, true_and] using Nat.le_pred_of_lt hij'
state_before: case i_surj.mk.refine'_2
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i') ∈ S

tactic: simp only [Fin.castLT_castSucc, Fin.succ_pred]
state_before: case i_surj.mk.refine'_3
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X Y : SimplicialObject C
n : ℕ
P : Type := Fin (n + 2) × Fin (n + 3)
S : Finset P := Finset.filter (fun ij => ↑ij.snd ≤ ↑ij.fst) Finset.univ
φ : (ij : P) → ij ∈ S → P := fun ij hij => (Fin.castLT ij.snd (_ : ↑ij.snd < n + 2), Fin.succ ij.fst)
i' : Fin (n + 2)
j' : Fin (n + 3)
hij' : ↑i' < ↑j'
⊢ (i', j') =
    φ (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i')
      (_ : (Fin.pred j' (_ : j' = 0 → False), ↑Fin.castSucc i') ∈ S)