Theorem: SimplexCategory.factor_δ_spec
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: ext k : 3
state_before: m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
⊢ factor_δ f j ≫ δ j = f
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
k : Fin ([m].len + 1)
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k

tactic: specialize hj k
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
k : Fin ([m].len + 1)
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k

tactic: dsimp [factor_δ, δ, σ]
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ j.succAbove ((predAbove 0 j).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

tactic: cases' j using cases with j
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ j.succAbove ((predAbove 0 j).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.zero
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ 0
⊢ succAbove 0 ((predAbove 0 0).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

case a.h.h.succ
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj : (Hom.toOrderHom f) k ≠ j.succ
⊢ j.succ.succAbove ((predAbove 0 j.succ).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

tactic: rw [predAbove_of_le_castSucc _ _ (zero_le _), castPred_zero, predAbove_of_castSucc_lt 0 _
(castSucc_zero ▸ pos_of_ne_zero hj),
zero_succAbove, succ_pred]
state_before: case a.h.h.zero
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ 0
⊢ succAbove 0 ((predAbove 0 0).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: no goals

tactic: rw [predAbove_of_castSucc_lt 0 _ (castSucc_zero ▸ succ_pos _), pred_succ]
state_before: case a.h.h.succ
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj : (Hom.toOrderHom f) k ≠ j.succ
⊢ j.succ.succAbove ((predAbove 0 j.succ).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj : (Hom.toOrderHom f) k ≠ j.succ
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

tactic: rcases hj.lt_or_lt with (hj | hj)
state_before: case a.h.h.succ
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj : (Hom.toOrderHom f) k ≠ j.succ
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

tactic: rw [predAbove_of_le_castSucc j _]
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).castPred ⋯) = (Hom.toOrderHom f) k

case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (Hom.toOrderHom f) k ≤ j.castSucc

tactic: swap
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).castPred ⋯) = (Hom.toOrderHom f) k

case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (Hom.toOrderHom f) k ≤ j.castSucc
state_after: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (Hom.toOrderHom f) k ≤ j.castSucc

case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).castPred ⋯) = (Hom.toOrderHom f) k

tactic: exact (le_castSucc_iff.mpr hj)
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (Hom.toOrderHom f) k ≤ j.castSucc
state_after: no goals

tactic: rw [succAbove_of_castSucc_lt]
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).castPred ⋯) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc = (Hom.toOrderHom f) k

case a.h.h.succ.inl.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc < j.succ

tactic: swap
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc = (Hom.toOrderHom f) k

case a.h.h.succ.inl.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc < j.succ
state_after: case a.h.h.succ.inl.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc < j.succ

case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc = (Hom.toOrderHom f) k

tactic: rw [castSucc_castPred]
state_before: case a.h.h.succ.inl
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc = (Hom.toOrderHom f) k
state_after: no goals

tactic: rwa [castSucc_lt_succ_iff, castPred_le_iff, le_castSucc_iff]
state_before: case a.h.h.succ.inl.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : (Hom.toOrderHom f) k < j.succ
⊢ (((Hom.toOrderHom f) k).castPred ⋯).castSucc < j.succ
state_after: no goals

tactic: rw [predAbove_of_castSucc_lt]
state_before: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (j.predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).pred ⋯) = (Hom.toOrderHom f) k

case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.castSucc < (Hom.toOrderHom f) k

tactic: swap
state_before: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).pred ⋯) = (Hom.toOrderHom f) k

case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.castSucc < (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.castSucc < (Hom.toOrderHom f) k

case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).pred ⋯) = (Hom.toOrderHom f) k

tactic: rw [succAbove_of_le_castSucc]
state_before: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ.succAbove (((Hom.toOrderHom f) k).pred ⋯) = (Hom.toOrderHom f) k
state_after: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ (((Hom.toOrderHom f) k).pred ⋯).succ = (Hom.toOrderHom f) k

case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ ≤ (((Hom.toOrderHom f) k).pred ⋯).castSucc

tactic: swap
state_before: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ (((Hom.toOrderHom f) k).pred ⋯).succ = (Hom.toOrderHom f) k

case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ ≤ (((Hom.toOrderHom f) k).pred ⋯).castSucc
state_after: case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ ≤ (((Hom.toOrderHom f) k).pred ⋯).castSucc

case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ (((Hom.toOrderHom f) k).pred ⋯).succ = (Hom.toOrderHom f) k

tactic: rw [succ_pred]
state_before: case a.h.h.succ.inr
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ (((Hom.toOrderHom f) k).pred ⋯).succ = (Hom.toOrderHom f) k
state_after: no goals

tactic: exact (castSucc_lt_succ _).trans hj
state_before: case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.castSucc < (Hom.toOrderHom f) k
state_after: no goals

tactic: rwa [succ_le_castSucc_iff, lt_pred_iff]
state_before: case a.h.h.succ.inr.h
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj✝ : (Hom.toOrderHom f) k ≠ j.succ
hj : j.succ < (Hom.toOrderHom f) k
⊢ j.succ ≤ (((Hom.toOrderHom f) k).pred ⋯).castSucc
state_after: no goals