Theorem: SimplexCategory.eq_σ_comp_of_not_injective'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: use δ i.succ ≫ θ
state_before: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ ∃ θ', θ = σ i ≫ θ'
state_after: case h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ θ = σ i ≫ δ i.succ ≫ θ

tactic: ext1
state_before: case h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ θ = σ i ≫ δ i.succ ≫ θ
state_after: case h.a
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ Hom.toOrderHom θ = Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ)

tactic: ext1
state_before: case h.a
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ Hom.toOrderHom θ = Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ)
state_after: case h.a.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ ⇑(Hom.toOrderHom θ) = ⇑(Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ))

tactic: ext1 x
state_before: case h.a.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
⊢ ⇑(Hom.toOrderHom θ) = ⇑(Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ))
state_after: case h.a.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ)) x

tactic: simp only [len_mk, σ, mkHom, comp_toOrderHom, Hom.toOrderHom_mk, OrderHom.comp_coe,
  OrderHom.coe_mk, Function.comp_apply]
state_before: case h.a.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom (σ i ≫ δ i.succ ≫ θ)) x
state_after: case h.a.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

tactic: by_cases h' : x ≤ Fin.castSucc i
state_before: case h.a.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : x ≤ i.castSucc
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : ¬x ≤ i.castSucc
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

tactic: rw [Fin.predAbove_of_le_castSucc i x h']
state_before: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : x ≤ i.castSucc
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : x ≤ i.castSucc
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (x.castPred ⋯))

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

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

n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : x ≤ i.castSucc
⊢ (x.castPred ⋯).castSucc < i.succ

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

tactic: exact (Fin.castSucc_lt_succ_iff.mpr h')
state_before: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : x ≤ i.castSucc
⊢ (x.castPred ⋯).castSucc < i.succ
state_after: no goals

tactic: simp only [not_le] at h'
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : ¬x ≤ i.castSucc
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

tactic: let y := x.pred <| by rintro (rfl : x = 0); simp at h'
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

tactic: have hy : x = y.succ := (Fin.succ_pred x _).symm
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))

tactic: rw [hy] at h' ⊢
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
⊢ (Hom.toOrderHom θ) x = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove x))
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove y.succ))

tactic: rw [Fin.predAbove_of_castSucc_lt i y.succ h', Fin.pred_succ]
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) (i.predAbove y.succ))
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)

tactic: by_cases h'' : y = i
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)
state_after: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)

case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)

tactic: rintro (rfl : x = 0)
state_before: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h' : i.castSucc < x
⊢ x ≠ 0
state_after: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
h' : i.castSucc < 0
⊢ False

tactic: simp at h'
state_before: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
h' : i.castSucc < 0
⊢ False
state_after: no goals

tactic: rw [h'']
state_before: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)
state_after: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) i.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) i)

tactic: refine hi.symm.trans ?_
state_before: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) i.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) i)
state_after: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) i)

tactic: congr 1
state_before: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) i)
state_after: case pos.h.e_6.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc = (Hom.toOrderHom (δ i.succ)) i

tactic: dsimp [δ]
state_before: case pos.h.e_6.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc = (Hom.toOrderHom (δ i.succ)) i
state_after: case pos.h.e_6.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc = i.succ.succAbove i

tactic: erw [Fin.succAbove_of_castSucc_lt i.succ]
state_before: case pos.h.e_6.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc = i.succ.succAbove i
state_after: case pos.h.e_6.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc < i.succ

tactic: exact Fin.lt_succ
state_before: case pos.h.e_6.h.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : y = i
⊢ i.castSucc < i.succ
state_after: no goals

tactic: dsimp [δ]
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) ((Hom.toOrderHom (δ i.succ)) y)
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) (i.succ.succAbove y)

tactic: erw [Fin.succAbove_of_le_castSucc i.succ _]
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ (Hom.toOrderHom θ) y.succ = (Hom.toOrderHom θ) (i.succ.succAbove y)
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ i.succ ≤ y.castSucc

tactic: simp only [Fin.lt_iff_val_lt_val, Fin.le_iff_val_le_val, Fin.val_succ, Fin.coe_castSucc,
  Nat.lt_succ_iff, Fin.ext_iff] at h' h'' ⊢
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
h' : i.castSucc < y.succ
hy : x = y.succ
h'' : ¬y = i
⊢ i.succ ≤ y.castSucc
state_after: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
⊢ ↑i + 1 ≤ ↑y

tactic: cases' Nat.le.dest h' with c hc
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
⊢ ↑i + 1 ≤ ↑y
state_after: case neg.intro
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
c : ℕ
hc : ↑i + c = ↑y
⊢ ↑i + 1 ≤ ↑y

tactic: cases c
state_before: case neg.intro
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
c : ℕ
hc : ↑i + c = ↑y
⊢ ↑i + 1 ≤ ↑y
state_after: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i + 0 = ↑y
⊢ ↑i + 1 ≤ ↑y

case neg.intro.succ
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
n✝ : ℕ
hc : ↑i + (n✝ + 1) = ↑y
⊢ ↑i + 1 ≤ ↑y

tactic: exfalso
state_before: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i + 0 = ↑y
⊢ ↑i + 1 ≤ ↑y
state_after: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i + 0 = ↑y
⊢ False

tactic: simp only [Nat.zero_eq, add_zero, len_mk, Fin.coe_pred, ge_iff_le] at hc
state_before: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i + 0 = ↑y
⊢ False
state_after: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i = ↑y
⊢ False

tactic: rw [hc] at h''
state_before: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
hc : ↑i = ↑y
⊢ False
state_after: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑y
hc : ↑i = ↑y
⊢ False

tactic: exact h'' rfl
state_before: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑y
hc : ↑i = ↑y
⊢ False
state_after: no goals

tactic: rw [← hc]
state_before: case neg.intro.succ
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
n✝ : ℕ
hc : ↑i + (n✝ + 1) = ↑y
⊢ ↑i + 1 ≤ ↑y
state_after: case neg.intro.succ
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
n✝ : ℕ
hc : ↑i + (n✝ + 1) = ↑y
⊢ ↑i + 1 ≤ ↑i + (n✝ + 1)

tactic: simp only [add_le_add_iff_left, Nat.succ_eq_add_one, le_add_iff_nonneg_left, zero_le]
state_before: case neg.intro.succ
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : (Hom.toOrderHom θ) i.castSucc = (Hom.toOrderHom θ) i.succ
x : Fin ([n + 1].len + 1)
h'✝ : i.castSucc < x
y : Fin [n + 1].len := x.pred ⋯
hy : x = y.succ
h' : ↑i ≤ ↑y
h'' : ¬↑y = ↑i
n✝ : ℕ
hc : ↑i + (n✝ + 1) = ↑y
⊢ ↑i + 1 ≤ ↑i + (n✝ + 1)
state_after: no goals