l3lab/ntp-mathlib huggingface dataset:
theorem δ_comp_δ' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : Fin.castSucc i < j) :
    δ i ≫ δ j =
      δ (j.pred <| fun (hj : j = 0) => by simp [hj, Fin.not_lt_zero] at H) ≫
        δ (Fin.castSucc i) := by
  rw [← δ_comp_δ]
  · rw [Fin.succ_pred]
  · 

Proof state:
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
⊢ i ≤ Fin.pred j (_ : j = 0 → False)

Next tactic:
simpa only [Fin.le_iff_val_le_val, ← Nat.lt_succ_iff, Nat.succ_eq_add_one, ← Fin.val_succ,
      j.succ_pred, Fin.lt_iff_val_lt_val] using H
theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) ≫ δ j.succ =
      δ j ≫ δ i := by
  

Proof state:
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ δ (Fin.castLT i (_ : ↑i < n + 2)) ≫ δ (Fin.succ j) = δ j ≫ δ i

Next tactic:
rw [δ_comp_δ]
theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) ≫ δ j.succ =
      δ j ≫ δ i := by
  rw [δ_comp_δ]
  · 

Proof state:
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ δ j ≫ δ (Fin.castSucc (Fin.castLT i (_ : ↑i < n + 2))) = δ j ≫ δ i

Next tactic:
rfl
theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) ≫ δ j.succ =
      δ j ≫ δ i := by
  rw [δ_comp_δ]
  · rfl
  · 

Proof state:
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ Fin.castLT i (_ : ↑i < n + 2) ≤ j

Next tactic:
exact H
@[reassoc]
theorem δ_comp_δ_self' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = Fin.castSucc i) :
    δ i ≫ δ j = δ i ≫ δ i.succ := by
  

Proof state:
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : j = Fin.castSucc i
⊢ δ i ≫ δ j = δ i ≫ δ (Fin.succ i)

Next tactic:
subst H
@[reassoc]
theorem δ_comp_δ_self' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = Fin.castSucc i) :
    δ i ≫ δ j = δ i ≫ δ i.succ := by
  subst H
  

Proof state:
n : ℕ
i : Fin (n + 2)
⊢ δ i ≫ δ (Fin.castSucc i) = δ i ≫ δ (Fin.succ i)

Next tactic:
rw [δ_comp_δ_self]
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  

Proof state:
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ Fin.castSucc j
⊢ δ (Fin.castSucc i) ≫ σ (Fin.succ j) = σ j ≫ δ i

Next tactic:
rcases i with ⟨i, hi⟩
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  

Proof state:
case mk
n : ℕ
j : Fin (n + 1)
i : ℕ
hi : i < n + 2
H : { val := i, isLt := hi } ≤ Fin.castSucc j
⊢ δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ (Fin.succ j) = σ j ≫ δ { val := i, isLt := hi }

Next tactic:
rcases j with ⟨j, hj⟩
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  

Proof state:
case mk.mk
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : { val := i, isLt := hi } ≤ Fin.castSucc { val := j, isLt := hj }
⊢ δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ (Fin.succ { val := j, isLt := hj }) =
    σ { val := j, isLt := hj } ≫ δ { val := i, isLt := hi }

Next tactic:
ext ⟨k, hk⟩
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  

Proof state:
case mk.mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : { val := i, isLt := hi } ≤ Fin.castSucc { val := j, isLt := hj }
k : ℕ
hk : k < len [n + 1] + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ (Fin.succ { val := j, isLt := hj })))
        { val := k, isLt := hk }) =
    ↑((Hom.toOrderHom (σ { val := j, isLt := hj } ≫ δ { val := i, isLt := hi })) { val := k, isLt := hk })

Next tactic:
simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says 

Proof state:
case mk.mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : { val := i, isLt := hi } ≤ Fin.castSucc { val := j, isLt := hj }
k : ℕ
hk : k < len [n + 1] + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ (Fin.succ { val := j, isLt := hj })))
        { val := k, isLt := hk }) =
    ↑((Hom.toOrderHom (σ { val := j, isLt := hj } ≫ δ { val := i, isLt := hi })) { val := k, isLt := hk })

Next tactic:
simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  

Proof state:
case mk.mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ (Fin.succ { val := j, isLt := hj })))
        { val := k, isLt := hk }) =
    ↑((Hom.toOrderHom (σ { val := j, isLt := hj } ≫ δ { val := i, isLt := hi })) { val := k, isLt := hk })

Next tactic:
dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  

Proof state:
case mk.mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
⊢ ↑(if h :
          { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 1)) } <
            if k < i then { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
            else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) } then
        Fin.pred
          (if k < i then { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
          else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) })
          (_ :
            (if k < i then { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
              else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) }) ≠
              0)
      else
        Fin.castLT
          (if k < i then { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
          else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) })
          (_ :
            ↑(if k < i then { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
                else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) }) <
              n + 1 + 1)) =
    ↑(if
          ↑(if h : { val := j, isLt := (_ : j < Nat.succ (n + 1)) } < { val := k, isLt := hk } then
                Fin.pred { val := k, isLt := hk } (_ : { val := k, isLt := hk } ≠ 0)
              else { val := k, isLt := (_ : ↑{ val := k, isLt := hk } < n + 1) }) <
            i then
        Fin.castSucc
          (if h : { val := j, isLt := (_ : j < Nat.succ (n + 1)) } < { val := k, isLt := hk } then
            Fin.pred { val := k, isLt := hk } (_ : { val := k, isLt := hk } ≠ 0)
          else { val := k, isLt := (_ : ↑{ val := k, isLt := hk } < n + 1) })
      else
        Fin.succ
          (if h : { val := j, isLt := (_ : j < Nat.succ (n + 1)) } < { val := k, isLt := hk } then
            Fin.pred { val := k, isLt := hk } (_ : { val := k, isLt := hk } ≠ 0)
          else { val := k, isLt := (_ : ↑{ val := k, isLt := hk } < n + 1) }))

Next tactic:
simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  

Proof state:
case mk.mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
⊢ (if j + 1 < if k < i then k else k + 1 then (if k < i then k else k + 1) - 1 else if k < i then k else k + 1) =
    if (if j < k then k - 1 else k) < i then if j < k then k - 1 else k else (if j < k then k - 1 else k) + 1

Next tactic:
split_ifs
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k - 1 = k - 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k - 1 = k - 1 + 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : j + 1 < k
h✝ : ¬j < k
⊢ k - 1 = k
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k = k - 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k = k - 1 + 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : ¬j + 1 < k
h✝ : ¬j < k
⊢ k = k
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 - 1 = k - 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 - 1 = k - 1 + 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : ¬k < i
h✝¹ : j + 1 < k + 1
h✝ : ¬j < k
⊢ k + 1 - 1 = k + 1
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : ¬j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 = k - 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : ¬j + 1 < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 = k - 1 + 1
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : ¬k < i
h✝¹ : ¬j + 1 < k + 1
h✝ : ¬j < k
⊢ k + 1 = k + 1

Next tactic:
all_goals try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k - 1 = k - 1

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k - 1 = k - 1

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k - 1 = k - 1 + 1

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k - 1 = k - 1 + 1

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ False

Next tactic:
linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : j + 1 < k
h✝ : ¬j < k
⊢ k - 1 = k

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : j + 1 < k
h✝ : ¬j < k
⊢ k - 1 = k

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k = k - 1

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k = k - 1

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k = k - 1 + 1

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : k < i
h✝² : ¬j + 1 < k
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k = k - 1 + 1

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : ¬j + 1 < k
h✝ : ¬j < k
⊢ k = k

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝² : k < i
h✝¹ : ¬j + 1 < k
h✝ : ¬j < k
⊢ k = k

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 - 1 = k - 1

Next tactic:
try simp <;> linarith
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 - 1 = k - 1

Next tactic:
simp
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k = k - 1

Next tactic:
linarith