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

tactic: rcases i with ⟨i, hi⟩
state_before: n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ ↑Fin.castSucc j
⊢ δ (↑Fin.castSucc i) ≫ σ (Fin.succ j) = σ j ≫ δ i

tactic: rcases j with ⟨j, hj⟩
state_before: 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 }

tactic: ext ⟨k, hk⟩
state_before: 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 }

tactic: simp at H hk
state_before: 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 })

tactic: dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
state_before: 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 })

tactic: simp [Fin.lt_iff_val_lt_val, Fin.ite_val, Fin.dite_val]
state_before: 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
                { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                  { val := i, isLt := (_ : i < Nat.succ (n + 2)) } 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
              { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                { val := i, isLt := (_ : i < Nat.succ (n + 2)) } then
            { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
          else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) })
          (_ :
            (if
                  { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                    { val := i, isLt := (_ : i < Nat.succ (n + 2)) } 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
              { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                { val := i, isLt := (_ : i < Nat.succ (n + 2)) } then
            { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) }
          else { val := k + 1, isLt := (_ : Nat.succ k < Nat.succ (n + 1 + 1)) })
          (_ :
            ↑(if
                    { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                      { val := i, isLt := (_ : i < Nat.succ (n + 2)) } 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
          ↑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) }) <
            { val := i, isLt := hi } 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) }))

tactic: split_ifs
state_before: 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

tactic: all_goals try simp <;> linarith
state_before: case mk.mk.a.h.h.mk.h.inl.inl.inl.inl
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 mk.mk.a.h.h.mk.h.inl.inl.inl.inr
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 mk.mk.a.h.h.mk.h.inl.inl.inr
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 mk.mk.a.h.h.mk.h.inl.inr.inl.inl
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 mk.mk.a.h.h.mk.h.inl.inr.inl.inr
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 mk.mk.a.h.h.mk.h.inl.inr.inr
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 mk.mk.a.h.h.mk.h.inr.inl.inl.inl
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 mk.mk.a.h.h.mk.h.inr.inl.inl.inr
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 mk.mk.a.h.h.mk.h.inr.inl.inr
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 mk.mk.a.h.h.mk.h.inr.inr.inl.inl
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 mk.mk.a.h.h.mk.h.inr.inr.inl.inr
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 mk.mk.a.h.h.mk.h.inr.inr.inr
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

tactic: all_goals cases k <;> simp at * <;> linarith
state_before: case mk.mk.a.h.h.mk.h.inr.inl.inl.inl
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 mk.mk.a.h.h.mk.h.inr.inl.inl.inr
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

tactic: try simp <;> linarith
state_before: case mk.mk.a.h.h.mk.h.inr.inr.inr
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

tactic: simp <;> linarith
state_before: case mk.mk.a.h.h.mk.h.inr.inr.inr
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

tactic: cases k <;> simp at * <;> linarith
state_before: case mk.mk.a.h.h.mk.h.inr.inl.inl.inr
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