File: Mathlib/AlgebraicTopology/SimplicialSet.lean

full_name: SSet
code: /-- The category of simplicial sets.
This is the category of contravariant functors from
`SimplexCategory` to `Type u`. -/
def SSet : Type (u + 1) 
goal: Type (u + 1)

full_name: SSet.largeCategory
code: instance largeCategory : LargeCategory SSet 
goal: CategoryTheory.LargeCategory SSet

full_name: SSet.hasLimits
code: instance hasLimits : HasLimits SSet 
goal: CategoryTheory.Limits.HasLimits SSet

full_name: SSet.hasColimits
code: instance hasColimits : HasColimits SSet 
goal: CategoryTheory.Limits.HasColimits SSet

full_name: SSet.hom_ext
code: @[ext]
lemma hom_ext {X Y : SSet} {f g : X ⟶ Y} (w : ∀ n, f.app n = g.app n) : f = g 
goal: f = g

full_name: SSet.uliftFunctor
code: /-- The ulift functor `SSet.{u} ⥤ SSet.{max u v}` on simplicial sets. -/
def uliftFunctor : SSet.{u} ⥤ SSet.{max u v} 
goal: SSet ⥤ SSet

full_name: SSet.standardSimplex
code: /-- The `n`-th standard simplex `Δ[n]` associated with a nonempty finite linear order `n`
is the Yoneda embedding of `n`. -/
def standardSimplex : SimplexCategory ⥤ SSet.{u} 
goal: SimplexCategory ⥤ SSet

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialSet___macroRules_Simplicial_termΔ[_]_1»
code: @[inherit_doc SSet.standardSimplex]
scoped[Simplicial] notation3 "Δ[" n "]" => SSet.standardSimplex.obj (SimplexCategory.mk n)
goal: Lean.Macro

full_name: SSet.instInhabited
code: instance : Inhabited SSet 
goal: Inhabited SSet

full_name: SSet.standardSimplex.map_id
code: @[simp]
lemma map_id (n : SimplexCategory) :
    (SSet.standardSimplex.map (SimplexCategory.Hom.mk OrderHom.id : n ⟶ n)) = 𝟙 _ 
goal: SSet.standardSimplex.map (SimplexCategory.Hom.mk OrderHom.id) = 𝟙 (SSet.standardSimplex.obj n)

full_name: SSet.standardSimplex.objEquiv
code: /-- Simplices of the standard simplex identify to morphisms in `SimplexCategory`. -/
def objEquiv (n : SimplexCategory) (m : SimplexCategoryᵒᵖ) :
    (standardSimplex.{u}.obj n).obj m ≃ (m.unop ⟶ n) 
goal: (SSet.standardSimplex.obj n).obj m ≃ (Opposite.unop m ⟶ n)

full_name: SSet.standardSimplex.objMk
code: /-- Constructor for simplices of the standard simplex which takes a `OrderHom` as an input. -/
abbrev objMk {n : SimplexCategory} {m : SimplexCategoryᵒᵖ}
    (f : Fin (len m.unop + 1) →o Fin (n.len + 1)) :
    (standardSimplex.{u}.obj n).obj m 
goal: (SSet.standardSimplex.obj n).obj m

full_name: SSet.standardSimplex.map_apply
code: lemma map_apply {m₁ m₂ : SimplexCategoryᵒᵖ} (f : m₁ ⟶ m₂) {n : SimplexCategory}
    (x : (standardSimplex.{u}.obj n).obj m₁) :
    (standardSimplex.{u}.obj n).map f x = (objEquiv _ _).symm (f.unop ≫ (objEquiv _ _) x) 
goal: (SSet.standardSimplex.obj n).map f x =
  (SSet.standardSimplex.objEquiv n m₂).symm (f.unop ≫ (SSet.standardSimplex.objEquiv n m₁) x)

full_name: SSet.yonedaEquiv
code: /-- The canonical bijection `(standardSimplex.obj n ⟶ X) ≃ X.obj (op n)`. -/
def _root_.SSet.yonedaEquiv (X : SSet.{u}) (n : SimplexCategory) :
    (standardSimplex.obj n ⟶ X) ≃ X.obj (op n) 
goal: (SSet.standardSimplex.obj n ⟶ X) ≃ X.obj (Opposite.op n)

full_name: SSet.standardSimplex.const
code: /-- The (degenerate) `m`-simplex in the standard simplex concentrated in vertex `k`. -/
def const (n : ℕ) (k : Fin (n+1)) (m : SimplexCategoryᵒᵖ) : Δ[n].obj m 
goal: Δ[n].obj m

full_name: SSet.standardSimplex.const_down_toOrderHom
code: @[simp]
lemma const_down_toOrderHom (n : ℕ) (k : Fin (n+1)) (m : SimplexCategoryᵒᵖ) :
    (const n k m).down.toOrderHom = OrderHom.const _ k 
goal: SimplexCategory.Hom.toOrderHom (SSet.standardSimplex.const n k m).down =
  (OrderHom.const (Fin ((Opposite.unop m).len + 1))) k

full_name: SSet.standardSimplex.edge
code: /-- The edge of the standard simplex with endpoints `a` and `b`. -/
def edge (n : ℕ) (a b : Fin (n+1)) (hab : a ≤ b) : Δ[n] _[1] 
goal: Δ[n] _[1]

full_name: SSet.standardSimplex.coe_edge_down_toOrderHom
code: lemma coe_edge_down_toOrderHom (n : ℕ) (a b : Fin (n+1)) (hab : a ≤ b) :
    ↑(edge n a b hab).down.toOrderHom = ![a, b] 
goal: ⇑(SimplexCategory.Hom.toOrderHom (SSet.standardSimplex.edge n a b hab).down) = ![a, b]

full_name: SSet.standardSimplex.triangle
code: /-- The triangle in the standard simplex with vertices `a`, `b`, and `c`. -/
def triangle {n : ℕ} (a b c : Fin (n+1)) (hab : a ≤ b) (hbc : b ≤ c) : Δ[n] _[2] 
goal: Δ[n] _[2]

full_name: SSet.standardSimplex.coe_triangle_down_toOrderHom
code: lemma coe_triangle_down_toOrderHom {n : ℕ} (a b c : Fin (n+1)) (hab : a ≤ b) (hbc : b ≤ c) :
    ↑(triangle a b c hab hbc).down.toOrderHom = ![a, b, c] 
goal: ⇑(SimplexCategory.Hom.toOrderHom (SSet.standardSimplex.triangle a b c hab hbc).down) = ![a, b, c]

full_name: SSet.asOrderHom
code: /-- The `m`-simplices of the `n`-th standard simplex are
the monotone maps from `Fin (m+1)` to `Fin (n+1)`. -/
def asOrderHom {n} {m} (α : Δ[n].obj m) : OrderHom (Fin (m.unop.len + 1)) (Fin (n + 1)) 
goal: Fin ((Opposite.unop m).len + 1) →o Fin (n + 1)

full_name: SSet.boundary
code: /-- The boundary `∂Δ[n]` of the `n`-th standard simplex consists of
all `m`-simplices of `standardSimplex n` that are not surjective
(when viewed as monotone function `m → n`). -/
def boundary (n : ℕ) : SSet.{u} 
goal: SSet

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialSet___macroRules_Simplicial_term∂Δ[_]_1»
code: /-- The boundary `∂Δ[n]` of the `n`-th standard simplex -/
scoped[Simplicial] notation3 "∂Δ[" n "]" => SSet.boundary n
goal: Lean.Macro

full_name: SSet.boundaryInclusion
code: /-- The inclusion of the boundary of the `n`-th standard simplex into that standard simplex. -/
def boundaryInclusion (n : ℕ) : ∂Δ[n] ⟶ Δ[n] 
goal: ∂Δ[n] ⟶ Δ[n]

full_name: SSet.horn
code: /-- `horn n i` (or `Λ[n, i]`) is the `i`-th horn of the `n`-th standard simplex, where `i : n`.
It consists of all `m`-simplices `α` of `Δ[n]`
for which the union of `{i}` and the range of `α` is not all of `n`
(when viewing `α` as monotone function `m → n`). -/
def horn (n : ℕ) (i : Fin (n + 1)) : SSet 
goal: SSet

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialSet___macroRules_Simplicial_termΛ[_,_]_1»
code: /-- The `i`-th horn `Λ[n, i]` of the standard `n`-simplex -/
scoped[Simplicial] notation3 "Λ[" n ", " i "]" => SSet.horn (n : ℕ) i
goal: Lean.Macro

full_name: SSet.hornInclusion
code: /-- The inclusion of the `i`-th horn of the `n`-th standard simplex into that standard simplex. -/
def hornInclusion (n : ℕ) (i : Fin (n + 1)) : Λ[n, i] ⟶ Δ[n] 
goal: Λ[n, i] ⟶ Δ[n]

full_name: SSet.horn.const
code: /-- The (degenerate) subsimplex of `Λ[n+2, i]` concentrated in vertex `k`. -/
@[simps]
def const (n : ℕ) (i k : Fin (n+3)) (m : SimplexCategoryᵒᵖ) : Λ[n+2, i].obj m 
goal: Λ[n + 2, i].obj m

full_name: SSet.horn.const_coe
code: /-- The (degenerate) subsimplex of `Λ[n+2, i]` concentrated in vertex `k`. -/
@[simps]
def const (n : ℕ) (i k : Fin (n+3)) (m : SimplexCategoryᵒᵖ) : Λ[n+2, i].obj m 
goal: ↑(SSet.horn.const n i k m) = SSet.standardSimplex.const (n + 2) k m

full_name: SSet.horn.edge_coe
code: /-- The edge of `Λ[n, i]` with endpoints `a` and `b`.

This edge only exists if `{i, a, b}` has cardinality less than `n`. -/
@[simps]
def edge (n : ℕ) (i a b : Fin (n+1)) (hab : a ≤ b) (H : Finset.card {i, a, b} ≤ n) :
    Λ[n, i] _[1] 
goal: ↑(SSet.horn.edge n i a b hab H) = SSet.standardSimplex.edge n a b hab

full_name: SSet.horn.edge
code: /-- The edge of `Λ[n, i]` with endpoints `a` and `b`.

This edge only exists if `{i, a, b}` has cardinality less than `n`. -/
@[simps]
def edge (n : ℕ) (i a b : Fin (n+1)) (hab : a ≤ b) (H : Finset.card {i, a, b} ≤ n) :
    Λ[n, i] _[1] 
goal: Λ[n, i] _[1]

full_name: SSet.horn.edge₃_coe_down
code: /-- Alternative constructor for the edge of `Λ[n, i]` with endpoints `a` and `b`,
assuming `3 ≤ n`. -/
@[simps!]
def edge₃ (n : ℕ) (i a b : Fin (n+1)) (hab : a ≤ b) (H : 3 ≤ n) :
    Λ[n, i] _[1] 
goal: (↑(SSet.horn.edge₃ n i a b hab H)).down = SimplexCategory.Hom.mk { toFun := ![a, b], monotone' := ⋯ }

full_name: SSet.horn.edge₃
code: /-- Alternative constructor for the edge of `Λ[n, i]` with endpoints `a` and `b`,
assuming `3 ≤ n`. -/
@[simps!]
def edge₃ (n : ℕ) (i a b : Fin (n+1)) (hab : a ≤ b) (H : 3 ≤ n) :
    Λ[n, i] _[1] 
goal: Λ[n, i] _[1]

full_name: SSet.horn.primitiveEdge
code: /-- The edge of `Λ[n, i]` with endpoints `j` and `j+1`.

This constructor assumes `0 < i < n`,
which is the type of horn that occurs in the horn-filling condition of quasicategories. -/
@[simps!]
def primitiveEdge {n : ℕ} {i : Fin (n+1)}
    (h₀ : 0 < i) (hₙ : i < Fin.last n) (j : Fin n) :
    Λ[n, i] _[1] 
goal: Λ[n, i] _[1]

full_name: SSet.horn.primitiveEdge_coe_down
code: /-- The edge of `Λ[n, i]` with endpoints `j` and `j+1`.

This constructor assumes `0 < i < n`,
which is the type of horn that occurs in the horn-filling condition of quasicategories. -/
@[simps!]
def primitiveEdge {n : ℕ} {i : Fin (n+1)}
    (h₀ : 0 < i) (hₙ : i < Fin.last n) (j : Fin n) :
    Λ[n, i] _[1] 
goal: (↑(SSet.horn.primitiveEdge h₀ hₙ j)).down = SimplexCategory.Hom.mk { toFun := ![j.castSucc, j.succ], monotone' := ⋯ }

full_name: SSet.horn.primitiveTriangle_coe
code: /-- The triangle in the standard simplex with vertices `k`, `k+1`, and `k+2`.

This constructor assumes `0 < i < n`,
which is the type of horn that occurs in the horn-filling condition of quasicategories. -/
@[simps]
def primitiveTriangle {n : ℕ} (i : Fin (n+4))
    (h₀ : 0 < i) (hₙ : i < Fin.last (n+3))
    (k : ℕ) (h : k < n+2) : Λ[n+3, i] _[2] 
goal: ↑(SSet.horn.primitiveTriangle i h₀ hₙ k h) = SSet.standardSimplex.triangle ⟨k, ⋯⟩ ⟨k + 1, ⋯⟩ ⟨k + 2, ⋯⟩ ⋯ ⋯

full_name: SSet.horn.primitiveTriangle
code: /-- The triangle in the standard simplex with vertices `k`, `k+1`, and `k+2`.

This constructor assumes `0 < i < n`,
which is the type of horn that occurs in the horn-filling condition of quasicategories. -/
@[simps]
def primitiveTriangle {n : ℕ} (i : Fin (n+4))
    (h₀ : 0 < i) (hₙ : i < Fin.last (n+3))
    (k : ℕ) (h : k < n+2) : Λ[n+3, i] _[2] 
goal: Λ[n + 3, i] _[2]

full_name: SSet.horn.face_coe
code: /-- The `j`th subface of the `i`-th horn. -/
@[simps]
def face {n : ℕ} (i j : Fin (n+2)) (h : j ≠ i) : Λ[n+1, i] _[n] 
goal: ↑(SSet.horn.face i j h) = (SSet.standardSimplex.objEquiv [n + 1] (Opposite.op [n])).symm (SimplexCategory.δ j)

full_name: SSet.horn.face
code: /-- The `j`th subface of the `i`-th horn. -/
@[simps]
def face {n : ℕ} (i j : Fin (n+2)) (h : j ≠ i) : Λ[n+1, i] _[n] 
goal: Λ[n + 1, i] _[n]

full_name: SSet.horn.hom_ext
code: /-- Two morphisms from a horn are equal if they are equal on all suitable faces. -/
protected
lemma hom_ext {n : ℕ} {i : Fin (n+2)} {S : SSet} (σ₁ σ₂ : Λ[n+1, i] ⟶ S)
    (h : ∀ (j) (h : j ≠ i), σ₁.app _ (face i j h) = σ₂.app _ (face i j h)) :
    σ₁ = σ₂ 
goal: σ₁ = σ₂

full_name: SSet.S1
code: /-- The simplicial circle. -/
noncomputable def S1 : SSet 
goal: SSet

full_name: SSet.Truncated
code: /-- Truncated simplicial sets. -/
def Truncated (n : ℕ) 
goal: Type (u + 1)

full_name: SSet.Truncated.largeCategory
code: instance Truncated.largeCategory (n : ℕ) : LargeCategory (Truncated n) 
goal: CategoryTheory.LargeCategory (SSet.Truncated n)

full_name: SSet.Truncated.hasLimits
code: instance Truncated.hasLimits {n : ℕ} : HasLimits (Truncated n) 
goal: CategoryTheory.Limits.HasLimits (SSet.Truncated n)

full_name: SSet.Truncated.hasColimits
code: instance Truncated.hasColimits {n : ℕ} : HasColimits (Truncated n) 
goal: CategoryTheory.Limits.HasColimits (SSet.Truncated n)

full_name: SSet.Truncated.hom_ext
code: @[ext]
lemma Truncated.hom_ext {n : ℕ} {X Y : Truncated n} {f g : X ⟶ Y} (w : ∀ n, f.app n = g.app n) :
    f = g 
goal: f = g

full_name: SSet.sk
code: /-- The skeleton functor on simplicial sets. -/
def sk (n : ℕ) : SSet ⥤ SSet.Truncated n 
goal: SSet ⥤ SSet.Truncated n

full_name: SSet.instInhabitedTruncated
code: instance {n} : Inhabited (SSet.Truncated n) 
goal: Inhabited (SSet.Truncated n)

full_name: SSet.Augmented
code: /-- The category of augmented simplicial sets, as a particular case of
augmented simplicial objects. -/
abbrev Augmented 
goal: Type (u + 1)

full_name: SSet.Augmented.standardSimplex_obj_hom_app
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: ∀ (a : ((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ'),
  (SSet.Augmented.standardSimplex.obj Δ).hom.app Δ' a =
    CategoryTheory.Limits.terminal.from
      (((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ') a

full_name: SSet.Augmented.standardSimplex_obj_left
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: (SSet.Augmented.standardSimplex.obj Δ).left = SSet.standardSimplex.obj Δ

full_name: SSet.Augmented.standardSimplex_map_right
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: ∀ {X Y : SimplexCategory} (θ : X ⟶ Y)
  (a :
    ((fun Δ =>
          { left := SSet.standardSimplex.obj Δ, right := ⊤_ Type u,
            hom :=
              {
                app := fun Δ' =>
                  CategoryTheory.Limits.terminal.from
                    (((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ'),
                naturality := ⋯ } })
        X).right),
  (SSet.Augmented.standardSimplex.map θ).right a =
    CategoryTheory.Limits.terminal.from
      ((fun Δ =>
            { left := SSet.standardSimplex.obj Δ, right := ⊤_ Type u,
              hom :=
                {
                  app := fun Δ' =>
                    CategoryTheory.Limits.terminal.from
                      (((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ'),
                  naturality := ⋯ } })
          X).right
      a

full_name: SSet.Augmented.standardSimplex
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: SimplexCategory ⥤ SSet.Augmented

full_name: SSet.Augmented.standardSimplex_obj_right
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: (SSet.Augmented.standardSimplex.obj Δ).right = ⊤_ Type u

full_name: SSet.Augmented.standardSimplex_map_left
code: /-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u} 
goal: ∀ {X Y : SimplexCategory} (θ : X ⟶ Y), (SSet.Augmented.standardSimplex.map θ).left = SSet.standardSimplex.map θ