File: Mathlib/AlgebraicTopology/SimplexCategory.lean

full_name: SimplexCategory
code: /-- The simplex category:
* objects are natural numbers `n : ℕ`
* morphisms from `n` to `m` are monotone functions `Fin (n+1) → Fin (m+1)`
-/
def SimplexCategory 
goal: Type

full_name: SimplexCategory.mk
code: /-- Interpret a natural number as an object of the simplex category. -/
def mk (n : ℕ) : SimplexCategory 
goal: SimplexCategory

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplexCategory___macroRules_Simplicial_term[_]_1»
code: /-- the `n`-dimensional simplex can be denoted `[n]` -/
scoped[Simplicial] notation "[" n "]" => SimplexCategory.mk n
goal: Lean.Macro

full_name: Simplicial._aux_Mathlib_AlgebraicTopology_SimplexCategory___unexpand_SimplexCategory_mk_1
code: /-- the `n`-dimensional simplex can be denoted `[n]` -/
scoped[Simplicial] notation "[" n "]" => SimplexCategory.mk n
goal: Lean.PrettyPrinter.Unexpander

full_name: SimplexCategory.len
code: /-- The length of an object of `SimplexCategory`. -/
def len (n : SimplexCategory) : ℕ 
goal: ℕ

full_name: SimplexCategory.ext
code: @[ext]
theorem ext (a b : SimplexCategory) : a.len = b.len → a = b 
goal: a.len = b.len → a = b

full_name: SimplexCategory.len_mk
code: @[simp]
theorem len_mk (n : ℕ) : [n].len = n 
goal: (SimplexCategory.mk n).len = n

full_name: SimplexCategory.mk_len
code: @[simp]
theorem mk_len (n : SimplexCategory) : ([n.len] : SimplexCategory) = n 
goal: SimplexCategory.mk n.len = n

full_name: SimplexCategory.rec
code: /-- A recursor for `SimplexCategory`. Use it as `induction Δ using SimplexCategory.rec`. -/
protected def rec {F : SimplexCategory → Sort*} (h : ∀ n : ℕ, F [n]) : ∀ X, F X 
goal: F X

full_name: SimplexCategory.Hom
code: /-- Morphisms in the `SimplexCategory`. -/
protected def Hom (a b : SimplexCategory) 
goal: Type

full_name: SimplexCategory.Hom.mk
code: /-- Make a morphism in `SimplexCategory` from a monotone map of `Fin`'s. -/
def mk {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1)) : SimplexCategory.Hom a b 
goal: a.Hom b

full_name: SimplexCategory.Hom.toOrderHom
code: /-- Recover the monotone map from a morphism in the simplex category. -/
def toOrderHom {a b : SimplexCategory} (f : SimplexCategory.Hom a b) :
    Fin (a.len + 1) →o Fin (b.len + 1) 
goal: Fin (a.len + 1) →o Fin (b.len + 1)

full_name: SimplexCategory.Hom.ext'
code: theorem ext' {a b : SimplexCategory} (f g : SimplexCategory.Hom a b) :
    f.toOrderHom = g.toOrderHom → f = g 
goal: f.toOrderHom = g.toOrderHom → f = g

full_name: SimplexCategory.Hom.mk_toOrderHom
code: @[simp]
theorem mk_toOrderHom {a b : SimplexCategory} (f : SimplexCategory.Hom a b) : mk f.toOrderHom = f 
goal: SimplexCategory.Hom.mk f.toOrderHom = f

full_name: SimplexCategory.Hom.toOrderHom_mk
code: @[simp]
theorem toOrderHom_mk {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1)) :
    (mk f).toOrderHom = f 
goal: (SimplexCategory.Hom.mk f).toOrderHom = f

full_name: SimplexCategory.Hom.mk_toOrderHom_apply
code: theorem mk_toOrderHom_apply {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1))
    (i : Fin (a.len + 1)) : (mk f).toOrderHom i = f i 
goal: (SimplexCategory.Hom.mk f).toOrderHom i = f i

full_name: SimplexCategory.Hom.id
code: /-- Identity morphisms of `SimplexCategory`. -/
@[simp]
def id (a : SimplexCategory) : SimplexCategory.Hom a a 
goal: a.Hom a

full_name: SimplexCategory.Hom.comp
code: /-- Composition of morphisms of `SimplexCategory`. -/
@[simp]
def comp {a b c : SimplexCategory} (f : SimplexCategory.Hom b c) (g : SimplexCategory.Hom a b) :
    SimplexCategory.Hom a c 
goal: a.Hom c

full_name: SimplexCategory.smallCategory
code: instance smallCategory : SmallCategory.{0} SimplexCategory 
goal: CategoryTheory.SmallCategory SimplexCategory

full_name: SimplexCategory.id_toOrderHom
code: @[simp]
lemma id_toOrderHom (a : SimplexCategory) :
    Hom.toOrderHom (𝟙 a) = OrderHom.id 
goal: SimplexCategory.Hom.toOrderHom (𝟙 a) = OrderHom.id

full_name: SimplexCategory.comp_toOrderHom
code: @[simp]
lemma comp_toOrderHom {a b c : SimplexCategory} (f : a ⟶ b) (g : b ⟶ c) :
    (f ≫ g).toOrderHom = g.toOrderHom.comp f.toOrderHom 
goal: SimplexCategory.Hom.toOrderHom (f ≫ g) = (SimplexCategory.Hom.toOrderHom g).comp (SimplexCategory.Hom.toOrderHom f)

full_name: SimplexCategory.Hom.ext
code: @[ext]
theorem Hom.ext {a b : SimplexCategory} (f g : a ⟶ b) :
    f.toOrderHom = g.toOrderHom → f = g 
goal: SimplexCategory.Hom.toOrderHom f = SimplexCategory.Hom.toOrderHom g → f = g

full_name: SimplexCategory.const
code: /-- The constant morphism from [0]. -/
def const (x y : SimplexCategory) (i : Fin (y.len + 1)) : x ⟶ y 
goal: x ⟶ y

full_name: SimplexCategory.const_eq_id
code: @[simp]
lemma const_eq_id : const [0] [0] 0 = 𝟙 _ 
goal: (SimplexCategory.mk 0).const (SimplexCategory.mk 0) 0 = 𝟙 (SimplexCategory.mk 0)

full_name: SimplexCategory.const_apply
code: @[simp]
lemma const_apply (x y : SimplexCategory) (i : Fin (y.len + 1)) (a : Fin (x.len + 1)) :
    (const x y i).toOrderHom a = i 
goal: (SimplexCategory.Hom.toOrderHom (x.const y i)) a = i

full_name: SimplexCategory.const_comp
code: @[simp]
theorem const_comp (x : SimplexCategory) {y z : SimplexCategory}
    (f : y ⟶ z) (i : Fin (y.len + 1)) :
    const x y i ≫ f = const x z (f.toOrderHom i) 
goal: x.const y i ≫ f = x.const z ((SimplexCategory.Hom.toOrderHom f) i)

full_name: SimplexCategory.mkHom
code: /-- Make a morphism `[n] ⟶ [m]` from a monotone map between fin's.
This is useful for constructing morphisms between `[n]` directly
without identifying `n` with `[n].len`.
-/
@[simp]
def mkHom {n m : ℕ} (f : Fin (n + 1) →o Fin (m + 1)) : ([n] : SimplexCategory) ⟶ [m] 
goal: SimplexCategory.mk n ⟶ SimplexCategory.mk m

full_name: SimplexCategory.hom_zero_zero
code: theorem hom_zero_zero (f : ([0] : SimplexCategory) ⟶ [0]) : f = 𝟙 _ 
goal: f = 𝟙 (SimplexCategory.mk 0)

full_name: SimplexCategory.δ
code: /-- The `i`-th face map from `[n]` to `[n+1]` -/
def δ {n} (i : Fin (n + 2)) : ([n] : SimplexCategory) ⟶ [n + 1] 
goal: SimplexCategory.mk n ⟶ SimplexCategory.mk (n + 1)

full_name: SimplexCategory.σ
code: /-- The `i`-th degeneracy map from `[n+1]` to `[n]` -/
def σ {n} (i : Fin (n + 1)) : ([n + 1] : SimplexCategory) ⟶ [n] 
goal: SimplexCategory.mk (n + 1) ⟶ SimplexCategory.mk n

full_name: SimplexCategory.δ_comp_δ
code: /-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) 
goal: SimplexCategory.δ i ≫ SimplexCategory.δ j.succ = SimplexCategory.δ j ≫ SimplexCategory.δ i.castSucc

full_name: SimplexCategory.δ_comp_δ'
code: theorem δ_comp_δ' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : Fin.castSucc i < j) :
    δ i ≫ δ j =
      δ (j.pred fun (hj : j = 0) => by simp [hj, Fin.not_lt_zero] at H) ≫
        δ (Fin.castSucc i) 
goal: SimplexCategory.δ i ≫ SimplexCategory.δ j = SimplexCategory.δ (j.pred ⋯) ≫ SimplexCategory.δ i.castSucc

full_name: SimplexCategory.δ_comp_δ''
code: theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) ≫ δ j.succ =
      δ j ≫ δ i 
goal: SimplexCategory.δ (i.castLT ⋯) ≫ SimplexCategory.δ j.succ = SimplexCategory.δ j ≫ SimplexCategory.δ i

full_name: SimplexCategory.δ_comp_δ_self
code: /-- The special case of the first simplicial identity -/
@[reassoc]
theorem δ_comp_δ_self {n} {i : Fin (n + 2)} : δ i ≫ δ (Fin.castSucc i) = δ i ≫ δ i.succ 
goal: SimplexCategory.δ i ≫ SimplexCategory.δ i.castSucc = SimplexCategory.δ i ≫ SimplexCategory.δ i.succ

full_name: SimplexCategory.δ_comp_δ_self'
code: @[reassoc]
theorem δ_comp_δ_self' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = Fin.castSucc i) :
    δ i ≫ δ j = δ i ≫ δ i.succ 
goal: SimplexCategory.δ i ≫ SimplexCategory.δ j = SimplexCategory.δ i ≫ SimplexCategory.δ i.succ

full_name: SimplexCategory.δ_comp_σ_of_le
code: /-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i 
goal: SimplexCategory.δ i.castSucc ≫ SimplexCategory.σ j.succ = SimplexCategory.σ j ≫ SimplexCategory.δ i

full_name: SimplexCategory.δ_comp_σ_self
code: /-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) 
goal: SimplexCategory.δ i.castSucc ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)

full_name: SimplexCategory.δ_comp_σ_self'
code: @[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) 
goal: SimplexCategory.δ j ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)

full_name: SimplexCategory.δ_comp_σ_succ
code: /-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) 
goal: SimplexCategory.δ i.succ ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)

full_name: SimplexCategory.δ_comp_σ_succ'
code: @[reassoc]
theorem δ_comp_σ_succ' {n} (j : Fin (n + 2)) (i : Fin (n + 1)) (H : j = i.succ) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) 
goal: SimplexCategory.δ j ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)

full_name: SimplexCategory.δ_comp_σ_of_gt
code: /-- The fourth simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_gt {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : Fin.castSucc j < i) :
    δ i.succ ≫ σ (Fin.castSucc j) = σ j ≫ δ i 
goal: SimplexCategory.δ i.succ ≫ SimplexCategory.σ j.castSucc = SimplexCategory.σ j ≫ SimplexCategory.δ i

full_name: SimplexCategory.δ_comp_σ_of_gt'
code: @[reassoc]
theorem δ_comp_σ_of_gt' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) :
    δ i ≫ σ j = σ (j.castLT ((add_lt_add_iff_right 1).mp (lt_of_lt_of_le H i.is_le))) ≫
      δ (i.pred fun (hi : i = 0) => by simp only [Fin.not_lt_zero, hi] at H) 
goal: SimplexCategory.δ i ≫ SimplexCategory.σ j = SimplexCategory.σ (j.castLT ⋯) ≫ SimplexCategory.δ (i.pred ⋯)

full_name: SimplexCategory.σ_comp_σ
code: /-- The fifth simplicial identity -/
@[reassoc]
theorem σ_comp_σ {n} {i j : Fin (n + 1)} (H : i ≤ j) :
    σ (Fin.castSucc i) ≫ σ j = σ j.succ ≫ σ i 
goal: SimplexCategory.σ i.castSucc ≫ SimplexCategory.σ j = SimplexCategory.σ j.succ ≫ SimplexCategory.σ i

full_name: SimplexCategory.factor_δ
code: /--
If `f : [m] ⟶ [n+1]` is a morphism and `j` is not in the range of `f`,
then `factor_δ f j` is a morphism `[m] ⟶ [n]` such that
`factor_δ f j ≫ δ j = f` (as witnessed by `factor_δ_spec`).
-/
def factor_δ {m n : ℕ} (f : ([m] : SimplexCategory) ⟶ [n+1]) (j : Fin (n+2)) :
    ([m] : SimplexCategory) ⟶ [n] 
goal: SimplexCategory.mk m ⟶ SimplexCategory.mk n

full_name: SimplexCategory.factor_δ_spec
code: lemma factor_δ_spec {m n : ℕ} (f : ([m] : SimplexCategory) ⟶ [n+1]) (j : Fin (n+2))
    (hj : ∀ (k : Fin (m+1)), f.toOrderHom k ≠ j) :
    factor_δ f j ≫ δ j = f 
goal: SimplexCategory.factor_δ f j ≫ SimplexCategory.δ j = f

full_name: SimplexCategory.skeletalFunctor_obj
code: /-- The functor that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` -/
@[simps obj map]
def skeletalFunctor : SimplexCategory ⥤ NonemptyFinLinOrd 
goal: SimplexCategory.skeletalFunctor.obj a = NonemptyFinLinOrd.of (Fin (a.len + 1))

full_name: SimplexCategory.skeletalFunctor
code: /-- The functor that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` -/
@[simps obj map]
def skeletalFunctor : SimplexCategory ⥤ NonemptyFinLinOrd 
goal: SimplexCategory ⥤ NonemptyFinLinOrd

full_name: SimplexCategory.skeletalFunctor_map
code: /-- The functor that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` -/
@[simps obj map]
def skeletalFunctor : SimplexCategory ⥤ NonemptyFinLinOrd 
goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y), SimplexCategory.skeletalFunctor.map f = SimplexCategory.Hom.toOrderHom f

full_name: SimplexCategory.skeletalFunctor.coe_map
code: theorem skeletalFunctor.coe_map {Δ₁ Δ₂ : SimplexCategory} (f : Δ₁ ⟶ Δ₂) :
    ↑(skeletalFunctor.map f) = f.toOrderHom 
goal: SimplexCategory.skeletalFunctor.map f = SimplexCategory.Hom.toOrderHom f

full_name: SimplexCategory.skeletal
code: theorem skeletal : Skeletal SimplexCategory 
goal: CategoryTheory.Skeletal SimplexCategory

full_name: SimplexCategory.SkeletalFunctor.instFullNonemptyFinLinOrdSkeletalFunctor
code: instance : skeletalFunctor.Full 
goal: SimplexCategory.skeletalFunctor.Full

full_name: SimplexCategory.SkeletalFunctor.instFaithfulNonemptyFinLinOrdSkeletalFunctor
code: instance : skeletalFunctor.Faithful 
goal: SimplexCategory.skeletalFunctor.Faithful

full_name: SimplexCategory.SkeletalFunctor.instEssSurjNonemptyFinLinOrdSkeletalFunctor
code: instance : skeletalFunctor.EssSurj 
goal: SimplexCategory.skeletalFunctor.EssSurj

full_name: SimplexCategory.SkeletalFunctor.isEquivalence
code: noncomputable instance isEquivalence : skeletalFunctor.IsEquivalence 
goal: SimplexCategory.skeletalFunctor.IsEquivalence

full_name: SimplexCategory.skeletalEquivalence
code: /-- The equivalence that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` -/
noncomputable def skeletalEquivalence : SimplexCategory ≌ NonemptyFinLinOrd 
goal: SimplexCategory ≌ NonemptyFinLinOrd

full_name: SimplexCategory.isSkeletonOf
code: /-- `SimplexCategory` is a skeleton of `NonemptyFinLinOrd`.
-/
lemma isSkeletonOf :
    IsSkeletonOf NonemptyFinLinOrd SimplexCategory skeletalFunctor 
goal: CategoryTheory.IsSkeletonOf NonemptyFinLinOrd SimplexCategory SimplexCategory.skeletalFunctor

full_name: SimplexCategory.Truncated
code: /-- The truncated simplex category. -/
def Truncated (n : ℕ) 
goal: Type

full_name: SimplexCategory.instSmallCategoryTruncated
code: instance (n : ℕ) : SmallCategory.{0} (Truncated n) 
goal: CategoryTheory.SmallCategory (SimplexCategory.Truncated n)

full_name: SimplexCategory.Truncated.instInhabited
code: instance {n} : Inhabited (Truncated n) 
goal: Inhabited (SimplexCategory.Truncated n)

full_name: SimplexCategory.Truncated.inclusion
code: /-- The fully faithful inclusion of the truncated simplex category into the usual
simplex category.
-/
def inclusion {n : ℕ} : SimplexCategory.Truncated n ⥤ SimplexCategory 
goal: SimplexCategory.Truncated n ⥤ SimplexCategory

full_name: SimplexCategory.Truncated.instFullInclusion
code: instance (n : ℕ) : (inclusion : Truncated n ⥤ _).Full 
goal: SimplexCategory.Truncated.inclusion.Full

full_name: SimplexCategory.Truncated.instFaithfulInclusion
code: instance (n : ℕ) : (inclusion : Truncated n ⥤ _).Faithful 
goal: SimplexCategory.Truncated.inclusion.Faithful

full_name: SimplexCategory.instConcreteCategory
code: instance : ConcreteCategory.{0} SimplexCategory 
goal: CategoryTheory.ConcreteCategory SimplexCategory

full_name: SimplexCategory.mono_iff_injective
code: /-- A morphism in `SimplexCategory` is a monomorphism precisely when it is an injective function
-/
theorem mono_iff_injective {n m : SimplexCategory} {f : n ⟶ m} :
    Mono f ↔ Function.Injective f.toOrderHom 
goal: CategoryTheory.Mono f ↔ Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f)

full_name: SimplexCategory.epi_iff_surjective
code: /-- A morphism in `SimplexCategory` is an epimorphism if and only if it is a surjective function
-/
theorem epi_iff_surjective {n m : SimplexCategory} {f : n ⟶ m} :
    Epi f ↔ Function.Surjective f.toOrderHom 
goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑(SimplexCategory.Hom.toOrderHom f)

full_name: SimplexCategory.len_le_of_mono
code: /-- A monomorphism in `SimplexCategory` must increase lengths-/
theorem len_le_of_mono {x y : SimplexCategory} {f : x ⟶ y} : Mono f → x.len ≤ y.len 
goal: CategoryTheory.Mono f → x.len ≤ y.len

full_name: SimplexCategory.le_of_mono
code: theorem le_of_mono {n m : ℕ} {f : ([n] : SimplexCategory) ⟶ [m]} : CategoryTheory.Mono f → n ≤ m 
goal: CategoryTheory.Mono f → n ≤ m

full_name: SimplexCategory.len_le_of_epi
code: /-- An epimorphism in `SimplexCategory` must decrease lengths-/
theorem len_le_of_epi {x y : SimplexCategory} {f : x ⟶ y} : Epi f → y.len ≤ x.len 
goal: CategoryTheory.Epi f → y.len ≤ x.len

full_name: SimplexCategory.le_of_epi
code: theorem le_of_epi {n m : ℕ} {f : ([n] : SimplexCategory) ⟶ [m]} : Epi f → m ≤ n 
goal: CategoryTheory.Epi f → m ≤ n

full_name: SimplexCategory.instMonoδ
code: instance {n : ℕ} {i : Fin (n + 2)} : Mono (δ i) 
goal: CategoryTheory.Mono (SimplexCategory.δ i)

full_name: SimplexCategory.instEpiσ
code: instance {n : ℕ} {i : Fin (n + 1)} : Epi (σ i) 
goal: CategoryTheory.Epi (SimplexCategory.σ i)

full_name: SimplexCategory.instReflectsIsomorphismsForget
code: instance : (forget SimplexCategory).ReflectsIsomorphisms 
goal: (CategoryTheory.forget SimplexCategory).ReflectsIsomorphisms

full_name: SimplexCategory.isIso_of_bijective
code: theorem isIso_of_bijective {x y : SimplexCategory} {f : x ⟶ y}
    (hf : Function.Bijective f.toOrderHom.toFun) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: SimplexCategory.orderIsoOfIso
code: /-- An isomorphism in `SimplexCategory` induces an `OrderIso`. -/
@[simp]
def orderIsoOfIso {x y : SimplexCategory} (e : x ≅ y) : Fin (x.len + 1) ≃o Fin (y.len + 1) 
goal: Fin (x.len + 1) ≃o Fin (y.len + 1)

full_name: SimplexCategory.iso_eq_iso_refl
code: theorem iso_eq_iso_refl {x : SimplexCategory} (e : x ≅ x) : e = Iso.refl x 
goal: e = CategoryTheory.Iso.refl x

full_name: SimplexCategory.eq_id_of_isIso
code: theorem eq_id_of_isIso {x : SimplexCategory} (f : x ⟶ x) [IsIso f] : f = 𝟙 _ 
goal: f = 𝟙 x

full_name: SimplexCategory.eq_σ_comp_of_not_injective'
code: theorem eq_σ_comp_of_not_injective' {n : ℕ} {Δ' : SimplexCategory} (θ : mk (n + 1) ⟶ Δ')
    (i : Fin (n + 1)) (hi : θ.toOrderHom (Fin.castSucc i) = θ.toOrderHom i.succ) :
    ∃ θ' : mk n ⟶ Δ', θ = σ i ≫ θ' 
goal: ∃ θ', θ = SimplexCategory.σ i ≫ θ'

full_name: SimplexCategory.eq_σ_comp_of_not_injective
code: theorem eq_σ_comp_of_not_injective {n : ℕ} {Δ' : SimplexCategory} (θ : mk (n + 1) ⟶ Δ')
    (hθ : ¬Function.Injective θ.toOrderHom) :
    ∃ (i : Fin (n + 1)) (θ' : mk n ⟶ Δ'), θ = σ i ≫ θ' 
goal: ∃ i θ', θ = SimplexCategory.σ i ≫ θ'

full_name: SimplexCategory.eq_comp_δ_of_not_surjective'
code: theorem eq_comp_δ_of_not_surjective' {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
    (i : Fin (n + 2)) (hi : ∀ x, θ.toOrderHom x ≠ i) : ∃ θ' : Δ ⟶ mk n, θ = θ' ≫ δ i 
goal: ∃ θ', θ = θ' ≫ SimplexCategory.δ i

full_name: SimplexCategory.eq_comp_δ_of_not_surjective
code: theorem eq_comp_δ_of_not_surjective {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
    (hθ : ¬Function.Surjective θ.toOrderHom) :
    ∃ (i : Fin (n + 2)) (θ' : Δ ⟶ mk n), θ = θ' ≫ δ i 
goal: ∃ i θ', θ = θ' ≫ SimplexCategory.δ i

full_name: SimplexCategory.eq_id_of_mono
code: theorem eq_id_of_mono {x : SimplexCategory} (i : x ⟶ x) [Mono i] : i = 𝟙 _ 
goal: i = 𝟙 x

full_name: SimplexCategory.eq_id_of_epi
code: theorem eq_id_of_epi {x : SimplexCategory} (i : x ⟶ x) [Epi i] : i = 𝟙 _ 
goal: i = 𝟙 x

full_name: SimplexCategory.eq_σ_of_epi
code: theorem eq_σ_of_epi {n : ℕ} (θ : mk (n + 1) ⟶ mk n) [Epi θ] : ∃ i : Fin (n + 1), θ = σ i 
goal: ∃ i, θ = SimplexCategory.σ i

full_name: SimplexCategory.eq_δ_of_mono
code: theorem eq_δ_of_mono {n : ℕ} (θ : mk n ⟶ mk (n + 1)) [Mono θ] : ∃ i : Fin (n + 2), θ = δ i 
goal: ∃ i, θ = SimplexCategory.δ i

full_name: SimplexCategory.len_lt_of_mono
code: theorem len_lt_of_mono {Δ' Δ : SimplexCategory} (i : Δ' ⟶ Δ) [hi : Mono i] (hi' : Δ ≠ Δ') :
    Δ'.len < Δ.len 
goal: Δ'.len < Δ.len

full_name: SimplexCategory.instSplitEpiCategory
code: noncomputable instance : SplitEpiCategory SimplexCategory 
goal: CategoryTheory.SplitEpiCategory SimplexCategory

full_name: SimplexCategory.instHasStrongEpiMonoFactorisations
code: instance : HasStrongEpiMonoFactorisations SimplexCategory 
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations SimplexCategory

full_name: SimplexCategory.instHasStrongEpiImages
code: instance : HasStrongEpiImages SimplexCategory 
goal: CategoryTheory.Limits.HasStrongEpiImages SimplexCategory

full_name: SimplexCategory.instEpiFactorThruImage
code: instance (Δ Δ' : SimplexCategory) (θ : Δ ⟶ Δ') : Epi (factorThruImage θ) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.factorThruImage θ)

full_name: SimplexCategory.image_eq
code: theorem image_eq {Δ Δ' Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ Δ'} [Epi e] {i : Δ' ⟶ Δ''}
    [Mono i] (fac : e ≫ i = φ) : image φ = Δ' 
goal: CategoryTheory.Limits.image φ = Δ'

full_name: SimplexCategory.image_ι_eq
code: theorem image_ι_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : image.ι φ = i 
goal: CategoryTheory.Limits.image.ι φ = i

full_name: SimplexCategory.factorThruImage_eq
code: theorem factorThruImage_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : factorThruImage φ = e 
goal: CategoryTheory.Limits.factorThruImage φ = e

full_name: SimplexCategory.toCat_obj
code: /-- This functor `SimplexCategory ⥤ Cat` sends `[n]` (for `n : ℕ`)
to the category attached to the ordered set `{0, 1, ..., n}` -/
@[simps! obj map]
def toCat : SimplexCategory ⥤ Cat.{0} 
goal: SimplexCategory.toCat.obj X =
  CategoryTheory.Cat.of
    ↑((CategoryTheory.forget₂ PartOrd Preord).obj
        ((CategoryTheory.forget₂ Lat PartOrd).obj
          ((CategoryTheory.forget₂ LinOrd Lat).obj
            ((CategoryTheory.forget₂ NonemptyFinLinOrd LinOrd).obj (NonemptyFinLinOrd.of (Fin (X.len + 1)))))))

full_name: SimplexCategory.toCat_map
code: /-- This functor `SimplexCategory ⥤ Cat` sends `[n]` (for `n : ℕ`)
to the category attached to the ordered set `{0, 1, ..., n}` -/
@[simps! obj map]
def toCat : SimplexCategory ⥤ Cat.{0} 
goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y), SimplexCategory.toCat.map f = ⋯.functor

full_name: SimplexCategory.toCat
code: /-- This functor `SimplexCategory ⥤ Cat` sends `[n]` (for `n : ℕ`)
to the category attached to the ordered set `{0, 1, ..., n}` -/
@[simps! obj map]
def toCat : SimplexCategory ⥤ Cat.{0} 
goal: SimplexCategory ⥤ CategoryTheory.Cat