Theorem: SSet.horn.hom_ext
File: Mathlib/AlgebraicTopology/SimplicialSet.lean

tactic: apply NatTrans.ext
state_before: n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ σ₁ = σ₂
state_after: case app
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ σ₁.app = σ₂.app

tactic: apply funext
state_before: case app
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ σ₁.app = σ₂.app
state_after: case app.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (x : SimplexCategoryᵒᵖ), σ₁.app x = σ₂.app x

tactic: apply Opposite.rec
state_before: case app.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (x : SimplexCategoryᵒᵖ), σ₁.app x = σ₂.app x
state_after: case app.h.op
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (unop : SimplexCategory), σ₁.app { unop := unop } = σ₂.app { unop := unop }

tactic: apply SimplexCategory.rec
state_before: case app.h.op
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (unop : SimplexCategory), σ₁.app { unop := unop } = σ₂.app { unop := unop }
state_after: case app.h.op.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (n_1 : ℕ), σ₁.app { unop := [n_1] } = σ₂.app { unop := [n_1] }

tactic: intro m
state_before: case app.h.op.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
⊢ ∀ (n_1 : ℕ), σ₁.app { unop := [n_1] } = σ₂.app { unop := [n_1] }
state_after: case app.h.op.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
⊢ σ₁.app { unop := [m] } = σ₂.app { unop := [m] }

tactic: ext f
state_before: case app.h.op.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
⊢ σ₁.app { unop := [m] } = σ₂.app { unop := [m] }
state_after: case app.h.op.h.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: obtain ⟨f', hf⟩ := (standardSimplex.objEquiv _ _).symm.surjective f.1
state_before: case app.h.op.h.h
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: obtain ⟨j, hji, hfj⟩ : ∃ j, ¬j = i ∧ ∀ k, f'.toOrderHom k ≠ j := by
  obtain ⟨f, hf'⟩ := f
  subst hf
  simpa [← Set.univ_subset_iff, Set.subset_def, asOrderHom, not_or] using hf'
state_before: case app.h.op.h.h.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: have H : f = (Λ[n+1, i].map (factor_δ f' j).op) (face i j hji) := by
  apply Subtype.ext
  apply (standardSimplex.objEquiv _ _).injective
  rw [← hf]
  exact (factor_δ_spec f' j hfj).symm
state_before: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: have H₁ := congrFun (σ₁.naturality (factor_δ f' j).op) (face i j hji)
state_before: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₁.app { unop := [m] }) (face i j hji) =
    (σ₁.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: have H₂ := congrFun (σ₂.naturality (factor_δ f' j).op) (face i j hji)
state_before: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₁.app { unop := [m] }) (face i j hji) =
    (σ₁.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₁.app { unop := [m] }) (face i j hji) =
    (σ₁.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
H₂ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₂.app { unop := [m] }) (face i j hji) =
    (σ₂.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: dsimp at H₁ H₂
state_before: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₁.app { unop := [m] }) (face i j hji) =
    (σ₁.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
H₂ :
  (Λ[n + 1, i].map (factor_δ f' j).op ≫ σ₂.app { unop := [m] }) (face i j hji) =
    (σ₂.app { unop := [n] } ≫ S.map (factor_δ f' j).op) (face i j hji)
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  σ₁.app { unop := [m] } (Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)) =
    S.map (factor_δ f' j).op (σ₁.app { unop := [n] } (face i j hji))
H₂ :
  σ₂.app { unop := [m] } (Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)) =
    S.map (factor_δ f' j).op (σ₂.app { unop := [n] } (face i j hji))
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f

tactic: erw [H, H₁, H₂, h _ hji]
state_before: case app.h.op.h.h.intro.intro.intro
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
H : f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
H₁ :
  σ₁.app { unop := [m] } (Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)) =
    S.map (factor_δ f' j).op (σ₁.app { unop := [n] } (face i j hji))
H₂ :
  σ₂.app { unop := [m] } (Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)) =
    S.map (factor_δ f' j).op (σ₂.app { unop := [n] } (face i j hji))
⊢ σ₁.app { unop := [m] } f = σ₂.app { unop := [m] } f
state_after: no goals

tactic: obtain ⟨f, hf'⟩ := f
state_before: n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
state_after: case mk
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f' : { unop := [m] }.unop ⟶ [n + 1]
f : Δ[n + 1] _[m]
hf' : Set.range ⇑(asOrderHom f) ∪ {i} ≠ Set.univ
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑⟨f, hf'⟩
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j

tactic: subst hf
state_before: case mk
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f' : { unop := [m] }.unop ⟶ [n + 1]
f : Δ[n + 1] _[m]
hf' : Set.range ⇑(asOrderHom f) ∪ {i} ≠ Set.univ
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑⟨f, hf'⟩
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
state_after: case mk
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f' : { unop := [m] }.unop ⟶ [n + 1]
hf' : Set.range ⇑(asOrderHom ((standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f')) ∪ {i} ≠ Set.univ
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j

tactic: simpa [← Set.univ_subset_iff, Set.subset_def, asOrderHom, not_or] using hf'
state_before: case mk
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f' : { unop := [m] }.unop ⟶ [n + 1]
hf' : Set.range ⇑(asOrderHom ((standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f')) ∪ {i} ≠ Set.univ
⊢ ∃ j, ¬j = i ∧ ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
state_after: no goals

tactic: apply Subtype.ext
state_before: n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ f = Λ[n + 1, i].map (factor_δ f' j).op (face i j hji)
state_after: case a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ ↑f = ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))

tactic: apply (standardSimplex.objEquiv _ _).injective
state_before: case a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ ↑f = ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))
state_after: case a.a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑f =
    (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))

tactic: rw [← hf]
state_before: case a.a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑f =
    (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))
state_after: case a.a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ (standardSimplex.objEquiv [n + 1] { unop := [m] }) ((standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f') =
    (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))

tactic: exact (factor_δ_spec f' j hfj).symm
state_before: case a.a
n : ℕ
i : Fin (n + 2)
S : SSet
σ₁ σ₂ : Λ[n + 1, i] ⟶ S
h : ∀ (j : Fin (n + 2)) (h : j ≠ i), σ₁.app { unop := [n] } (face i j h) = σ₂.app { unop := [n] } (face i j h)
m : ℕ
f : Λ[n + 1, i] _[m]
f' : { unop := [m] }.unop ⟶ [n + 1]
hf : (standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f' = ↑f
j : Fin (n + 2)
hji : ¬j = i
hfj : ∀ (k : Fin ({ unop := [m] }.unop.len + 1)), (Hom.toOrderHom f') k ≠ j
⊢ (standardSimplex.objEquiv [n + 1] { unop := [m] }) ((standardSimplex.objEquiv [n + 1] { unop := [m] }).symm f') =
    (standardSimplex.objEquiv [n + 1] { unop := [m] }) ↑(Λ[n + 1, i].map (factor_δ f' j).op (face i j hji))
state_after: no goals