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

tactic: ext ⟨k, hk⟩
state_before: n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : ↑Fin.castSucc j < i
⊢ δ (Fin.succ i) ≫ σ (↑Fin.castSucc j) = σ j ≫ δ i

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

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

tactic: simp at H hk
state_before: case a.h.h.mk.h.mk.mk
n k : ℕ
hk : k < len [n + 1] + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : ↑Fin.castSucc { val := j, isLt := hj } < { val := i, isLt := hi }
⊢ ↑(↑(Hom.toOrderHom (δ (Fin.succ { val := i, isLt := hi }) ≫ σ (↑Fin.castSucc { 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 a.h.h.mk.h.mk.mk
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
⊢ ↑(↑(Hom.toOrderHom (δ (Fin.succ { val := i, isLt := hi }) ≫ σ (↑Fin.castSucc { 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 a.h.h.mk.h.mk.mk
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
⊢ ↑(if h :
          { val := j, isLt := (_ : j < Nat.succ (n + 1 + 1)) } <
            if
                { val := k, isLt := (_ : k < Nat.succ (n + 1 + 1)) } <
                  { val := i + 1, isLt := (_ : Nat.succ 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 + 1, isLt := (_ : Nat.succ 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 + 1, isLt := (_ : Nat.succ 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 + 1, isLt := (_ : Nat.succ 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 + 1, isLt := (_ : Nat.succ 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 a.h.h.mk.h.mk.mk
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
⊢ (if j < if k < i + 1 then k else k + 1 then (if k < i + 1 then k else k + 1) - 1
    else if k < i + 1 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 a.h.h.mk.h.mk.mk.inl.inl.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝² : k < i + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k - 1 = k - 1

case a.h.h.mk.h.mk.mk.inl.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝² : k < i + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k - 1 = k - 1 + 1

case a.h.h.mk.h.mk.mk.inl.inr.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝² : k < i + 1
h✝¹ : ¬j < k
h✝ : k < i
⊢ k = k

case a.h.h.mk.h.mk.mk.inl.inr.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝² : k < i + 1
h✝¹ : ¬j < k
h✝ : ¬k < i
⊢ k = k + 1

case a.h.h.mk.h.mk.mk.inr.inl.inl.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 - 1 = k - 1

case a.h.h.mk.h.mk.mk.inr.inl.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 - 1 = k - 1 + 1

case a.h.h.mk.h.mk.mk.inr.inl.inr.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : ¬j < k
h✝ : k < i
⊢ k + 1 - 1 = k

case a.h.h.mk.h.mk.mk.inr.inl.inr.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : ¬j < k
h✝ : ¬k < i
⊢ k + 1 - 1 = k + 1

case a.h.h.mk.h.mk.mk.inr.inr.inl.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 = k - 1

case a.h.h.mk.h.mk.mk.inr.inr.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 = k - 1 + 1

case a.h.h.mk.h.mk.mk.inr.inr.inr.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : ¬j < k
h✝ : k < i
⊢ k + 1 = k

case a.h.h.mk.h.mk.mk.inr.inr.inr.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : ¬j < k
h✝ : ¬k < i
⊢ k + 1 = k + 1

tactic: all_goals cases k <;> simp at * <;> linarith
state_before: case a.h.h.mk.h.mk.mk.inl.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝² : k < i + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k - 1 = k - 1 + 1

case a.h.h.mk.h.mk.mk.inr.inl.inl.inl
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 - 1 = k - 1

case a.h.h.mk.h.mk.mk.inr.inl.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 - 1 = k - 1 + 1

tactic: try simp <;> linarith
state_before: case a.h.h.mk.h.mk.mk.inr.inr.inr.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : ¬j < k
h✝ : ¬k < i
⊢ k + 1 = k + 1

tactic: simp <;> linarith
state_before: case a.h.h.mk.h.mk.mk.inr.inr.inr.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : ¬j < k + 1
h✝¹ : ¬j < k
h✝ : ¬k < i
⊢ k + 1 = k + 1

tactic: cases k <;> simp at * <;> linarith
state_before: case a.h.h.mk.h.mk.mk.inr.inl.inl.inr
n k : ℕ
hk : k < n + 1 + 1
i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : j < i
h✝³ : ¬k < i + 1
h✝² : j < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 - 1 = k - 1 + 1