l3lab/ntp-mathlib huggingface dataset:
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  

Proof state:
case a.h.h.h.mk
n : ℕ
j : Fin (n + 2)
k : Fin (len [n] + 1)
i : ℕ
isLt✝ : i < n + 2
H : { val := i, isLt := isLt✝ } ≤ j
⊢ ↑(if ↑(if ↑k < ↑{ val := i, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k) < ↑j + 1 then
        Fin.castSucc (if ↑k < ↑{ val := i, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k)
      else Fin.succ (if ↑k < ↑{ val := i, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k)) =
    ↑(if ↑(if ↑k < ↑j then Fin.castSucc k else Fin.succ k) < ↑{ val := i, isLt := isLt✝ } then
        Fin.castSucc (if ↑k < ↑j then Fin.castSucc k else Fin.succ k)
      else Fin.succ (if ↑k < ↑j then Fin.castSucc k else Fin.succ k))

Next tactic:
rcases j with ⟨j, _⟩
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  

Proof state:
case a.h.h.h.mk.mk
n : ℕ
k : Fin (len [n] + 1)
i : ℕ
isLt✝¹ : i < n + 2
j : ℕ
isLt✝ : j < n + 2
H : { val := i, isLt := isLt✝¹ } ≤ { val := j, isLt := isLt✝ }
⊢ ↑(if
          ↑(if ↑k < ↑{ val := i, isLt := isLt✝¹ } then Fin.castSucc k else Fin.succ k) <
            ↑{ val := j, isLt := isLt✝ } + 1 then
        Fin.castSucc (if ↑k < ↑{ val := i, isLt := isLt✝¹ } then Fin.castSucc k else Fin.succ k)
      else Fin.succ (if ↑k < ↑{ val := i, isLt := isLt✝¹ } then Fin.castSucc k else Fin.succ k)) =
    ↑(if
          ↑(if ↑k < ↑{ val := j, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k) <
            ↑{ val := i, isLt := isLt✝¹ } then
        Fin.castSucc (if ↑k < ↑{ val := j, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k)
      else Fin.succ (if ↑k < ↑{ val := j, isLt := isLt✝ } then Fin.castSucc k else Fin.succ k))

Next tactic:
rcases k with ⟨k, _⟩
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  

Proof state:
case a.h.h.h.mk.mk.mk
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
⊢ ↑(if
          ↑(if ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² } then
                Fin.castSucc { val := k, isLt := isLt✝ }
              else Fin.succ { val := k, isLt := isLt✝ }) <
            ↑{ val := j, isLt := isLt✝¹ } + 1 then
        Fin.castSucc
          (if ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² } then Fin.castSucc { val := k, isLt := isLt✝ }
          else Fin.succ { val := k, isLt := isLt✝ })
      else
        Fin.succ
          (if ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² } then Fin.castSucc { val := k, isLt := isLt✝ }
          else Fin.succ { val := k, isLt := isLt✝ })) =
    ↑(if
          ↑(if ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ } then
                Fin.castSucc { val := k, isLt := isLt✝ }
              else Fin.succ { val := k, isLt := isLt✝ }) <
            ↑{ val := i, isLt := isLt✝² } then
        Fin.castSucc
          (if ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ } then Fin.castSucc { val := k, isLt := isLt✝ }
          else Fin.succ { val := k, isLt := isLt✝ })
      else
        Fin.succ
          (if ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ } then Fin.castSucc { val := k, isLt := isLt✝ }
          else Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
split_ifs
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ })) =
    ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < i
h✝² : k < j + 1
h✝¹ : k < j
H : i ≤ j
h✝ : i ≤ k
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < i
h✝² : k < j + 1
h✝¹ : k + 1 < i
H : i ≤ j
h✝ : j ≤ k
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < i
h✝² : k < j + 1
H : i ≤ j
h✝¹ : j ≤ k
h✝ : i ≤ k + 1
⊢ k = k + 1 + 1

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < i
h✝² : k < j
h✝¹ : k < i
H : i ≤ j
h✝ : j + 1 ≤ k
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < i
H : i ≤ j
h✝² : j + 1 ≤ k
h✝¹ : j ≤ k
h✝ : i ≤ k + 1
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < j
h✝² : k < i
H : i ≤ j
h✝¹ : i ≤ k
h✝ : k < j
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
H : i ≤ j
h✝³ : i ≤ k
h✝² : k < j
h✝¹ : j ≤ k
h✝ : i ≤ k + 1
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < j
h✝² : k < i
H : i ≤ j
h✝¹ : i ≤ k
h✝ : j ≤ k
⊢ k + 1 + 1 = k

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.castSucc { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.castSucc { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k < j
H : i ≤ j
h✝² : i ≤ k
h✝¹ : j ≤ k
h✝ : i ≤ k
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.castSucc (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : k + 1 < i
H : i ≤ j
h✝² : i ≤ k
h✝¹ h✝ : j ≤ k
⊢ False

Next tactic:
linarith
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) := by
  ext k
  dsimp [δ, Fin.succAbove]
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  rcases k with ⟨k, _⟩
  split_ifs <;> · 

Proof state:
case neg
n i : ℕ
isLt✝² : i < n + 2
j : ℕ
isLt✝¹ : j < n + 2
H : { val := i, isLt := isLt✝² } ≤ { val := j, isLt := isLt✝¹ }
k : ℕ
isLt✝ : k < len [n] + 1
h✝³ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := i, isLt := isLt✝² }
h✝² : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := j, isLt := isLt✝¹ } + 1
h✝¹ : ¬↑{ val := k, isLt := isLt✝ } < ↑{ val := j, isLt := isLt✝¹ }
h✝ : ¬↑(Fin.succ { val := k, isLt := isLt✝ }) < ↑{ val := i, isLt := isLt✝² }
⊢ ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ })) = ↑(Fin.succ (Fin.succ { val := k, isLt := isLt✝ }))

Next tactic:
simp at *
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 

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

Next tactic:
simp [hj, Fin.not_lt_zero] at H
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
  

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

Next tactic:
rw [← δ_comp_δ]
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_δ]
  · 

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

Next tactic:
rw [Fin.succ_pred]