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 θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
⊢ ∃ θ', θ = σ i ≫ θ'

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

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

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

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

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

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

tactic: have eq := Fin.castSucc_castPred (gt_of_gt_of_ge (Fin.castSucc_lt_last i) h')
state_before: case pos
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h' : x ≤ ↑Fin.castSucc i
⊢ ↑(Hom.toOrderHom θ) x = ↑(Hom.toOrderHom θ) (↑(Hom.toOrderHom (δ (Fin.succ i))) (Fin.castPred x))

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

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

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

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

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

tactic: rwa [eq, ← Fin.le_castSucc_iff]
state_before: n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h' : x ≤ ↑Fin.castSucc i
eq : ↑Fin.castSucc (Fin.castPred x) = x
⊢ ↑Fin.castSucc (Fin.castPred x) < Fin.succ i

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

tactic: let y := x.pred (by rintro rfl ; simp at h')
state_before: case neg
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h' : ↑Fin.castSucc i < x
⊢ ↑(Hom.toOrderHom θ) x = ↑(Hom.toOrderHom θ) (↑(Hom.toOrderHom (δ (Fin.succ i))) (Fin.predAbove i 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 θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h' : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
⊢ ↑(Hom.toOrderHom θ) x = ↑(Hom.toOrderHom θ) (↑(Hom.toOrderHom (δ (Fin.succ i))) (Fin.predAbove i x))

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

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

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

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

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

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

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

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

tactic: dsimp [δ]
state_before: case pos.e_a
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
h' : ↑Fin.castSucc i < Fin.succ y
hy : x = Fin.succ y
h'' : y = i
⊢ ↑Fin.castSucc i = ↑(Hom.toOrderHom (δ (Fin.succ i))) i

tactic: erw [Fin.succAbove_below i.succ]
state_before: case pos.e_a
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
h' : ↑Fin.castSucc i < Fin.succ y
hy : x = Fin.succ y
h'' : y = i
⊢ ↑Fin.castSucc i = ↑(Fin.succAbove (Fin.succ i)) i

tactic: exact Fin.lt_succ
state_before: case pos.e_a.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
h' : ↑Fin.castSucc i < Fin.succ y
hy : x = Fin.succ y
h'' : y = i
⊢ ↑Fin.castSucc i < Fin.succ i

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

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

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 θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
h' : ↑Fin.castSucc i < Fin.succ y
hy : x = Fin.succ y
h'' : ¬y = i
⊢ Fin.succ i ≤ ↑Fin.castSucc (Fin.pred x (_ : x = 0 → False))

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

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

tactic: exfalso
state_before: case neg.intro.zero
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
hy : x = Fin.succ y
h' : ↑i ≤ ↑(Fin.pred x (_ : x = 0 → False))
h'' : ¬↑(Fin.pred x (_ : x = 0 → False)) = ↑i
hc : ↑i + Nat.zero = ↑(Fin.pred x (_ : x = 0 → False))
⊢ ↑i + 1 ≤ ↑(Fin.pred x (_ : x = 0 → 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.h
n : ℕ
Δ' : SimplexCategory
θ : [n + 1] ⟶ Δ'
i : Fin (n + 1)
hi : ↑(Hom.toOrderHom θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
hy : x = Fin.succ y
h' : ↑i ≤ ↑(Fin.pred x (_ : x = 0 → False))
h'' : ¬↑(Fin.pred x (_ : x = 0 → False)) = ↑i
hc : ↑i + Nat.zero = ↑(Fin.pred x (_ : x = 0 → False))
⊢ False

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

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

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

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 θ) (↑Fin.castSucc i) = ↑(Hom.toOrderHom θ) (Fin.succ i)
x : Fin (len [n + 1] + 1)
h'✝ : ↑Fin.castSucc i < x
y : Fin (len [n + 1]) := Fin.pred x (_ : x = 0 → False)
hy : x = Fin.succ y
h' : ↑i ≤ ↑(Fin.pred x (_ : x = 0 → False))
h'' : ¬↑(Fin.pred x (_ : x = 0 → False)) = ↑i
n✝ : ℕ
hc : ↑i + Nat.succ n✝ = ↑(Fin.pred x (_ : x = 0 → False))
⊢ ↑i + 1 ≤ ↑i + Nat.succ n✝