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

tactic: ext k : 3
state_before: n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ σ i.castSucc ≫ σ j = σ j.succ ≫ σ i
state_after: case a.h.h
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin ([n + 1 + 1].len + 1)
⊢ (Hom.toOrderHom (σ i.castSucc ≫ σ j)) k = (Hom.toOrderHom (σ j.succ ≫ σ i)) k

tactic: dsimp [σ]
state_before: case a.h.h
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin ([n + 1 + 1].len + 1)
⊢ (Hom.toOrderHom (σ i.castSucc ≫ σ j)) k = (Hom.toOrderHom (σ j.succ ≫ σ i)) k
state_after: case a.h.h
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin ([n + 1 + 1].len + 1)
⊢ j.predAbove (i.castSucc.predAbove k) = i.predAbove (j.succ.predAbove k)

tactic: cases' k using Fin.lastCases with k
state_before: case a.h.h
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin ([n + 1 + 1].len + 1)
⊢ j.predAbove (i.castSucc.predAbove k) = i.predAbove (j.succ.predAbove k)
state_after: case a.h.h.last
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ j.predAbove (i.castSucc.predAbove (Fin.last [n + 1 + 1].len)) =
    i.predAbove (j.succ.predAbove (Fin.last [n + 1 + 1].len))

case a.h.h.cast
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin [n + 1 + 1].len
⊢ j.predAbove (i.castSucc.predAbove k.castSucc) = i.predAbove (j.succ.predAbove k.castSucc)

tactic: simp only [len_mk, Fin.predAbove_right_last]
state_before: case a.h.h.last
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ j.predAbove (i.castSucc.predAbove (Fin.last [n + 1 + 1].len)) =
    i.predAbove (j.succ.predAbove (Fin.last [n + 1 + 1].len))
state_after: no goals

tactic: cases' k using Fin.cases with k
state_before: case a.h.h.cast
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin [n + 1 + 1].len
⊢ j.predAbove (i.castSucc.predAbove k.castSucc) = i.predAbove (j.succ.predAbove k.castSucc)
state_after: case a.h.h.cast.zero
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ j.predAbove (i.castSucc.predAbove (Fin.castSucc 0)) = i.predAbove (j.succ.predAbove (Fin.castSucc 0))

case a.h.h.cast.succ
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)

tactic: rw [Fin.castSucc_zero, Fin.predAbove_of_le_castSucc _ 0 (Fin.zero_le _),
Fin.predAbove_of_le_castSucc _ _ (Fin.zero_le _), Fin.castPred_zero,
Fin.predAbove_of_le_castSucc _ 0 (Fin.zero_le _),
Fin.predAbove_of_le_castSucc _ _ (Fin.zero_le _)]
state_before: case a.h.h.cast.zero
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ j.predAbove (i.castSucc.predAbove (Fin.castSucc 0)) = i.predAbove (j.succ.predAbove (Fin.castSucc 0))
state_after: no goals

tactic: rcases le_or_lt i k with (h | h)
state_before: case a.h.h.cast.succ
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)
state_after: case a.h.h.cast.succ.inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)

case a.h.h.cast.succ.inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : k < i
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)

tactic: simp_rw [Fin.predAbove_of_castSucc_lt i.castSucc _ (Fin.castSucc_lt_castSucc_iff.mpr
(Fin.castSucc_lt_succ_iff.mpr h)), ← Fin.succ_castSucc, Fin.pred_succ,
Fin.succ_predAbove_succ]
state_before: case a.h.h.cast.succ.inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)
state_after: case a.h.h.cast.succ.inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ j.predAbove k.castSucc = i.predAbove (j.predAbove k.castSucc).succ

tactic: rw [Fin.predAbove_of_castSucc_lt i _ (Fin.castSucc_lt_succ_iff.mpr _), Fin.pred_succ]
state_before: case a.h.h.cast.succ.inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ j.predAbove k.castSucc = i.predAbove (j.predAbove k.castSucc).succ
state_after: n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ i ≤ j.predAbove k.castSucc

tactic: rcases le_or_lt k j with (hkj | hkj)
state_before: n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
⊢ i ≤ j.predAbove k.castSucc
state_after: case inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : k ≤ j
⊢ i ≤ j.predAbove k.castSucc

case inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : j < k
⊢ i ≤ j.predAbove k.castSucc

tactic: rwa [Fin.predAbove_of_le_castSucc _ _ (Fin.castSucc_le_castSucc_iff.mpr hkj),
Fin.castPred_castSucc]
state_before: case inl
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : k ≤ j
⊢ i ≤ j.predAbove k.castSucc
state_after: no goals

tactic: rw [Fin.predAbove_of_castSucc_lt _ _ (Fin.castSucc_lt_castSucc_iff.mpr hkj),
Fin.le_pred_iff,
Fin.succ_le_castSucc_iff]
state_before: case inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : j < k
⊢ i ≤ j.predAbove k.castSucc
state_after: case inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : j < k
⊢ i < k

tactic: exact H.trans_lt hkj
state_before: case inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : i ≤ k
hkj : j < k
⊢ i < k
state_after: no goals

tactic: simp_rw [Fin.predAbove_of_le_castSucc i.castSucc _ (Fin.castSucc_le_castSucc_iff.mpr
(Fin.succ_le_castSucc_iff.mpr h)), Fin.castPred_castSucc, ← Fin.succ_castSucc,
Fin.succ_predAbove_succ]
state_before: case a.h.h.cast.succ.inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : k < i
⊢ j.predAbove (i.castSucc.predAbove k.succ.castSucc) = i.predAbove (j.succ.predAbove k.succ.castSucc)
state_after: case a.h.h.cast.succ.inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : k < i
⊢ j.predAbove k.succ = i.predAbove (j.predAbove k.castSucc).succ

tactic: rw [Fin.predAbove_of_le_castSucc _ k.castSucc
(Fin.castSucc_le_castSucc_iff.mpr (h.le.trans H)),
Fin.castPred_castSucc, Fin.predAbove_of_le_castSucc _ k.succ
(Fin.succ_le_castSucc_iff.mpr (H.trans_lt' h)), Fin.predAbove_of_le_castSucc _ k.succ
(Fin.succ_le_castSucc_iff.mpr h)]
state_before: case a.h.h.cast.succ.inr
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
k : Fin (n + 1)
h : k < i
⊢ j.predAbove k.succ = i.predAbove (j.predAbove k.castSucc).succ
state_after: no goals