Theorem: SimplexCategory.eq_comp_δ_of_not_surjective'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: by_cases h : i < Fin.last (n + 1)
state_before: n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
⊢ ∃ θ', θ = θ' ≫ δ i
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ i

case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : ¬i < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ i

tactic: use θ ≫ σ (Fin.castPred i h.ne)
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ i
state_after: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ θ = (θ ≫ σ (i.castPred ⋯)) ≫ δ i

tactic: ext1
state_before: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ θ = (θ ≫ σ (i.castPred ⋯)) ≫ δ i
state_after: case h.a
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ Hom.toOrderHom θ = Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i)

tactic: ext1
state_before: case h.a
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ Hom.toOrderHom θ = Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i)
state_after: case h.a.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ ⇑(Hom.toOrderHom θ) = ⇑(Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i))

tactic: ext1 x
state_before: case h.a.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
⊢ ⇑(Hom.toOrderHom θ) = ⇑(Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i))
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i)) x

tactic: simp only [len_mk, Category.assoc, comp_toOrderHom, OrderHom.comp_coe, Function.comp_apply]
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom ((θ ≫ σ (i.castPred ⋯)) ≫ δ i)) x
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))

tactic: by_cases h' : θ.toOrderHom x ≤ i
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))

case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : ¬(Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))

tactic: simp only [σ, mkHom, Hom.toOrderHom_mk, OrderHom.coe_mk]
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((i.castPred ⋯).predAbove ((Hom.toOrderHom θ) x))

tactic: erw [Fin.predAbove_of_le_castSucc _ _ (by rwa [Fin.castSucc_castPred])]
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((i.castPred ⋯).predAbove ((Hom.toOrderHom θ) x))
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) (((Hom.toOrderHom θ) x).castPred ⋯)

tactic: dsimp [δ]
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) (((Hom.toOrderHom θ) x).castPred ⋯)
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = i.succAbove (((Hom.toOrderHom θ) x).castPred ⋯)

tactic: erw [Fin.succAbove_of_castSucc_lt i]
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = i.succAbove (((Hom.toOrderHom θ) x).castPred ⋯)
state_after: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).castPred ⋯).castSucc

case pos.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (((Hom.toOrderHom θ) x).castPred ⋯).castSucc < i

tactic: rwa [Fin.castSucc_castPred]
state_before: n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x ≤ (i.castPred ⋯).castSucc
state_after: no goals

tactic: rw [Fin.castSucc_castPred]
state_before: case pos
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).castPred ⋯).castSucc
state_after: no goals

tactic: rw [(hi x).le_iff_lt] at h'
state_before: case pos.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : (Hom.toOrderHom θ) x ≤ i
⊢ (((Hom.toOrderHom θ) x).castPred ⋯).castSucc < i
state_after: case pos.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h'✝ : (Hom.toOrderHom θ) x ≤ i
h' : (Hom.toOrderHom θ) x < i
⊢ (((Hom.toOrderHom θ) x).castPred ⋯).castSucc < i

tactic: exact h'
state_before: case pos.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h'✝ : (Hom.toOrderHom θ) x ≤ i
h' : (Hom.toOrderHom θ) x < i
⊢ (((Hom.toOrderHom θ) x).castPred ⋯).castSucc < i
state_after: no goals

tactic: simp only [not_le] at h'
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : ¬(Hom.toOrderHom θ) x ≤ i
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))
state_after: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))

tactic: dsimp [σ, δ]
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (δ i)) ((Hom.toOrderHom (σ (i.castPred ⋯))) ((Hom.toOrderHom θ) x))
state_after: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = i.succAbove ((i.castPred ⋯).predAbove ((Hom.toOrderHom θ) x))

tactic: erw [Fin.predAbove_of_castSucc_lt _ _ (by rwa [Fin.castSucc_castPred])]
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = i.succAbove ((i.castPred ⋯).predAbove ((Hom.toOrderHom θ) x))
state_after: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = i.succAbove (((Hom.toOrderHom θ) x).pred ⋯)

tactic: rw [Fin.succAbove_of_le_castSucc i _]
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = i.succAbove (((Hom.toOrderHom θ) x).pred ⋯)
state_after: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).pred ⋯).succ

case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ i ≤ (((Hom.toOrderHom θ) x).pred ⋯).castSucc

tactic: rwa [Fin.castSucc_castPred]
state_before: n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (i.castPred ⋯).castSucc < (Hom.toOrderHom θ) x
state_after: no goals

tactic: erw [Fin.succ_pred]
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).pred ⋯).succ
state_after: no goals

tactic: exact Nat.le_sub_one_of_lt (Fin.lt_iff_val_lt_val.mp h')
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : i < Fin.last (n + 1)
x : Fin (Δ.len + 1)
h' : i < (Hom.toOrderHom θ) x
⊢ i ≤ (((Hom.toOrderHom θ) x).pred ⋯).castSucc
state_after: no goals

tactic: obtain rfl := le_antisymm (Fin.le_last i) (not_lt.mp h)
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
i : Fin (n + 2)
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ i
h : ¬i < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ i
state_after: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ (Fin.last (n + 1))

tactic: use θ ≫ σ (Fin.last _)
state_before: case neg
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
⊢ ∃ θ', θ = θ' ≫ δ (Fin.last (n + 1))
state_after: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
⊢ θ = (θ ≫ σ (Fin.last n)) ≫ δ (Fin.last (n + 1))

tactic: ext x : 3
state_before: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
⊢ θ = (θ ≫ σ (Fin.last n)) ≫ δ (Fin.last (n + 1))
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom ((θ ≫ σ (Fin.last n)) ≫ δ (Fin.last (n + 1)))) x

tactic: dsimp [δ, σ]
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom ((θ ≫ σ (Fin.last n)) ≫ δ (Fin.last (n + 1)))) x
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Fin.last (n + 1)).succAbove ((Fin.last n).predAbove ((Hom.toOrderHom θ) x))

tactic: simp_rw [Fin.succAbove_last, Fin.predAbove_last_apply]
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (Fin.last (n + 1)).succAbove ((Fin.last n).predAbove ((Hom.toOrderHom θ) x))
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x =
    (if hi : (Hom.toOrderHom θ) x = Fin.last (n + 1) then Fin.last n else ((Hom.toOrderHom θ) x).castPred hi).castSucc

tactic: erw [dif_neg (hi x)]
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x =
    (if hi : (Hom.toOrderHom θ) x = Fin.last (n + 1) then Fin.last n else ((Hom.toOrderHom θ) x).castPred hi).castSucc
state_after: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).castPred ⋯).castSucc

tactic: rw [Fin.castSucc_castPred]
state_before: case h.a.h.h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hi : ∀ (x : Fin (Δ.len + 1)), (Hom.toOrderHom θ) x ≠ Fin.last (n + 1)
h : ¬Fin.last (n + 1) < Fin.last (n + 1)
x : Fin (Δ.len + 1)
⊢ (Hom.toOrderHom θ) x = (((Hom.toOrderHom θ) x).castPred ⋯).castSucc
state_after: no goals