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

tactic: by_cases 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

tactic: use θ ≫ σ (Fin.castPred 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)
⊢ ∃ θ', θ = θ' ≫ δ i

tactic: ext1
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)
⊢ θ = (θ ≫ σ (Fin.castPred i)) ≫ δ i

tactic: ext1
state_before: case pos.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 ((θ ≫ σ (Fin.castPred i)) ≫ δ i)

tactic: ext1 x
state_before: case pos.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 ((θ ≫ σ (Fin.castPred i)) ≫ δ i))

tactic: simp only [Hom.toOrderHom_mk, Function.comp_apply, OrderHom.comp_coe, Hom.comp,
  smallCategory_comp]
state_before: case pos.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 ((θ ≫ σ (Fin.castPred i)) ≫ δ i)) x

tactic: by_cases h' : θ.toOrderHom x ≤ i
state_before: case pos.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 (σ (Fin.castPred i))) (↑(Hom.toOrderHom θ) x))

tactic: simp only [σ, mkHom, Hom.toOrderHom_mk, OrderHom.coe_fun_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 (σ (Fin.castPred i))) (↑(Hom.toOrderHom θ) x))

tactic: rw [Fin.predAbove_below (Fin.castPred i) (θ.toOrderHom x)
    (by simpa [Fin.castSucc_castPred h] using h')]
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)) (Fin.predAbove (Fin.castPred i) (↑(Hom.toOrderHom θ) x))

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)) (Fin.castPred (↑(Hom.toOrderHom θ) x))

tactic: erw [Fin.succAbove_below 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 = ↑(Fin.succAbove i) (Fin.castPred (↑(Hom.toOrderHom θ) x))

tactic: swap
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 = ↑Fin.castSucc (Fin.castPred (↑(Hom.toOrderHom θ) x))

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
⊢ ↑Fin.castSucc (Fin.castPred (↑(Hom.toOrderHom θ) x)) < i

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 = ↑Fin.castSucc (Fin.castPred (↑(Hom.toOrderHom θ) x))

tactic: apply lt_of_le_of_lt h' h
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 < Fin.last (n + 1)

tactic: simpa [Fin.castSucc_castPred h] using h'
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 ≤ ↑Fin.castSucc (Fin.castPred i)

tactic: simp only [Fin.lt_iff_val_lt_val, Fin.coe_castSucc]
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
⊢ ↑Fin.castSucc (Fin.castPred (↑(Hom.toOrderHom θ) x)) < i

tactic: exact
  lt_of_le_of_lt (Fin.coe_castPred_le_self _)
    (Fin.lt_iff_val_lt_val.mp ((Ne.le_iff_lt (hi x)).mp 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
⊢ ↑(Fin.castPred (↑(Hom.toOrderHom θ) x)) < ↑i

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 (σ (Fin.castPred i))) (↑(Hom.toOrderHom θ) x))

tactic: simp only [σ, mkHom, Hom.toOrderHom_mk, OrderHom.coe_fun_mk,
  Fin.predAbove_above (Fin.castPred i) (θ.toOrderHom x)
    (by simpa only [Fin.castSucc_castPred h] using 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
⊢ ↑(Hom.toOrderHom θ) x = ↑(Hom.toOrderHom (δ i)) (↑(Hom.toOrderHom (σ (Fin.castPred i))) (↑(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)) (Fin.pred (↑(Hom.toOrderHom θ) x) (_ : ↑(Hom.toOrderHom θ) x ≠ 0))

tactic: erw [Fin.succAbove_above i _, 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 = ↑(Fin.succAbove i) (Fin.pred (↑(Hom.toOrderHom θ) x) (_ : ↑(Hom.toOrderHom θ) x ≠ 0))

tactic: simpa only [Fin.le_iff_val_le_val, Fin.coe_castSucc, Fin.coe_pred] using
  Nat.le_pred_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 ≤ ↑Fin.castSucc (Fin.pred (↑(Hom.toOrderHom θ) x) (_ : ↑(Hom.toOrderHom θ) x ≠ 0))

tactic: simpa only [Fin.castSucc_castPred h] using h'
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
⊢ ↑Fin.castSucc (Fin.castPred i) < ↑(Hom.toOrderHom θ) x

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

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))

tactic: ext x : 4
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)) ≫ δ (Fin.last (n + 1))

tactic: dsimp [δ, σ]
state_before: case neg.a.h.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 only [Fin.castPred]
state_before: case neg.a.h.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.succAbove (Fin.last (n + 1))) (Fin.castPred (↑(Hom.toOrderHom θ) x)))

tactic: rw [Fin.predAbove_last, Fin.succAbove_last, Fin.castSucc_castPred]
state_before: case neg.a.h.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.succAbove (Fin.last (n + 1))) (Fin.predAbove (Fin.last n) (↑(Hom.toOrderHom θ) x)))

tactic: exact (Ne.le_iff_lt (hi x)).mp (Fin.le_last _)
state_before: case neg.a.h.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)