Theorem: SimplexCategory.δ_comp_σ_succ
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: ext j
state_before: n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.succ i) ≫ σ i = 𝟙 [n]

tactic: rcases i with ⟨i, _⟩
state_before: case a.h.h.h
n : ℕ
i : Fin (n + 1)
j : Fin (len [n] + 1)
⊢ ↑(↑(Hom.toOrderHom (δ (Fin.succ i) ≫ σ i)) j) = ↑(↑(Hom.toOrderHom (𝟙 [n])) j)

tactic: rcases j with ⟨j, _⟩
state_before: case a.h.h.h.mk
n : ℕ
j : Fin (len [n] + 1)
i : ℕ
isLt✝ : i < n + 1
⊢ ↑(↑(Hom.toOrderHom (δ (Fin.succ { val := i, isLt := isLt✝ }) ≫ σ { val := i, isLt := isLt✝ })) j) =
    ↑(↑(Hom.toOrderHom (𝟙 [n])) j)

tactic: dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
state_before: case a.h.h.h.mk.mk
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
⊢ ↑(↑(Hom.toOrderHom (δ (Fin.succ { val := i, isLt := isLt✝¹ }) ≫ σ { val := i, isLt := isLt✝¹ }))
        { val := j, isLt := isLt✝ }) =
    ↑(↑(Hom.toOrderHom (𝟙 [n])) { val := j, isLt := isLt✝ })

tactic: simp only [Fin.mk_lt_mk]
state_before: case a.h.h.h.mk.mk
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
⊢ ↑(if h :
          { val := i, isLt := (_ : i < Nat.succ (n + 1)) } <
            if
                { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
                  { val := i + 1, isLt := (_ : Nat.succ i < Nat.succ (n + 1)) } then
              { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
            else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } then
        Fin.pred
          (if
              { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
                { val := i + 1, isLt := (_ : Nat.succ i < Nat.succ (n + 1)) } then
            { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            (if
                  { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
                    { val := i + 1, isLt := (_ : Nat.succ i < Nat.succ (n + 1)) } then
                { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
              else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) ≠
              0)
      else
        Fin.castLT
          (if
              { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
                { val := i + 1, isLt := (_ : Nat.succ i < Nat.succ (n + 1)) } then
            { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            ↑(if
                    { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
                      { val := i + 1, isLt := (_ : Nat.succ i < Nat.succ (n + 1)) } then
                  { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
                else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) <
              n + 1)) =
    j

tactic: split_ifs <;> simp <;> simp at * <;> linarith
state_before: case a.h.h.h.mk.mk
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
⊢ ↑(if h :
          { val := i, isLt := (_ : i < Nat.succ (n + 1)) } <
            if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
            else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } then
        Fin.pred
          (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
              else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) ≠
              0)
      else
        Fin.castLT
          (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            ↑(if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
                else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) <
              n + 1)) =
    j