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

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

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

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

tactic: simp [Fin.lt_iff_val_lt_val, Fin.ite_val]
state_before: case a.h.h.mk.h.mk.mk
n k : ℕ
hk : k < n + 1 + 1 + 1
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
H : i ≤ j
⊢ ↑(if h :
          { val := j, isLt := (_ : j < Nat.succ (n + 1)) } <
            if h : { val := i, isLt := (_ : i < Nat.succ (n + 1 + 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 + 1) } then
        Fin.pred
          (if h : { val := i, isLt := (_ : i < Nat.succ (n + 1 + 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 + 1) })
          (_ :
            (if h : { val := i, isLt := (_ : i < Nat.succ (n + 1 + 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 + 1) }) ≠
              0)
      else
        Fin.castLT
          (if h : { val := i, isLt := (_ : i < Nat.succ (n + 1 + 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 + 1) })
          (_ :
            ↑(if h : { val := i, isLt := (_ : i < Nat.succ (n + 1 + 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 + 1) }) <
              n + 1)) =
    ↑(if h :
          { val := i, isLt := (_ : i < Nat.succ (n + 1)) } <
            if h : { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 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 + 1) } then
        Fin.pred
          (if h : { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 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 + 1) })
          (_ :
            (if h : { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 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 + 1) }) ≠
              0)
      else
        Fin.castLT
          (if h : { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 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 + 1) })
          (_ :
            ↑(if h : { val := j + 1, isLt := (_ : j + 1 < Nat.succ (n + 1 + 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 + 1) }) <
              n + 1))

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

tactic: all_goals try linarith
state_before: case a.h.h.mk.h.mk.mk.inl.inl.inl.inl
n k : ℕ
hk : k < n + 1 + 1 + 1
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
H : i ≤ j
h✝³ : i < k
h✝² : j < k - 1
h✝¹ : j + 1 < k
h✝ : i < k - 1
⊢ k - 1 - 1 = k - 1 - 1

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

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

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

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

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

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

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

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

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

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

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

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 + 1
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
H : i ≤ j
h✝² : i < k
h✝¹ : j < k - 1
h✝ : ¬j + 1 < k
⊢ k - 1 - 1 = k - 1

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

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

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

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

tactic: linarith
state_before: case a.h.h.mk.h.mk.mk.inl.inr.inl.inl.succ
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
H : i ≤ j
n✝ : ℕ
hk : Nat.succ n✝ < n + 1 + 1 + 1
h✝³ : i < Nat.succ n✝
h✝² : j + 1 < Nat.succ n✝
h✝¹ : n✝ ≤ j
h✝ : i < n✝
⊢ n✝ = n✝ - 1