Documentation

Mathlib.AlgebraicTopology.SimplicialObject

Simplicial objects in a category. #

A simplicial object in a category C is a C-valued presheaf on SimplexCategory. (Similarly a cosimplicial object is functor SimplexCategory ⥤ C.)

Use the notation X _[n] in the Simplicial locale to obtain the n-th term of a (co)simplicial object X, where n is a natural number.

The category of simplicial objects valued in a category C. This is the category of contravariant functors from SimplexCategory to C.

Equations
Instances For

    Pretty printer defined by notation3 command.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      X _[n] denotes the nth-term of the simplicial object X

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For

        Face maps for a simplicial object.

        Equations
        Instances For

          Degeneracy maps for a simplicial object.

          Equations
          Instances For

            Isomorphisms from identities in ℕ.

            Equations
            Instances For
              theorem CategoryTheory.SimplicialObject.δ_comp_δ {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 2)} (H : i j) :
              CategoryTheory.CategoryStruct.comp (X j.succ) (X i) = CategoryTheory.CategoryStruct.comp (X i.castSucc) (X j)

              The generic case of the first simplicial identity

              theorem CategoryTheory.SimplicialObject.δ_comp_δ'_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 3)} (H : i.castSucc < j) {Z : C} (h : X.obj { unop := SimplexCategory.mk n } Z) :
              theorem CategoryTheory.SimplicialObject.δ_comp_δ' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 3)} (H : i.castSucc < j) :
              CategoryTheory.CategoryStruct.comp (X j) (X i) = CategoryTheory.CategoryStruct.comp (X i.castSucc) (X (j.pred ))
              theorem CategoryTheory.SimplicialObject.δ_comp_δ'' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i j.castSucc) :
              CategoryTheory.CategoryStruct.comp (X j.succ) (X (i.castLT )) = CategoryTheory.CategoryStruct.comp (X i) (X j)

              The special case of the first simplicial identity

              theorem CategoryTheory.SimplicialObject.δ_comp_σ_of_le {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i j.castSucc) :
              CategoryTheory.CategoryStruct.comp (X j.succ) (X i.castSucc) = CategoryTheory.CategoryStruct.comp (X i) (X j)

              The second simplicial identity

              The first part of the third simplicial identity

              theorem CategoryTheory.SimplicialObject.δ_comp_σ_self'_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = i.castSucc) {Z : C} (h : X.obj { unop := SimplexCategory.mk n } Z) :

              The second part of the third simplicial identity

              theorem CategoryTheory.SimplicialObject.δ_comp_σ_of_gt {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i) :
              CategoryTheory.CategoryStruct.comp (X j.castSucc) (X i.succ) = CategoryTheory.CategoryStruct.comp (X i) (X j)

              The fourth simplicial identity

              theorem CategoryTheory.SimplicialObject.δ_comp_σ_of_gt'_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) {Z : C} (h : X.obj { unop := SimplexCategory.mk (n + 1) } Z) :
              theorem CategoryTheory.SimplicialObject.δ_comp_σ_of_gt' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) :
              CategoryTheory.CategoryStruct.comp (X j) (X i) = CategoryTheory.CategoryStruct.comp (X (i.pred )) (X (j.castLT ))
              theorem CategoryTheory.SimplicialObject.σ_comp_σ {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : } {i : Fin (n + 1)} {j : Fin (n + 1)} (H : i j) :
              CategoryTheory.CategoryStruct.comp (X j) (X i.castSucc) = CategoryTheory.CategoryStruct.comp (X i) (X j.succ)

              The fifth simplicial identity

              The skeleton functor from simplicial objects to truncated simplicial objects.

              Equations
              Instances For
                @[simp]
                theorem CategoryTheory.SimplicialObject.Augmented.toArrow_map_right {C : Type u} [CategoryTheory.Category.{v, u} C] :
                ∀ {X Y : CategoryTheory.SimplicialObject.Augmented C} (η : X Y), (CategoryTheory.SimplicialObject.Augmented.toArrow.map η).right = CategoryTheory.SimplicialObject.Augmented.point.map η
                @[simp]
                theorem CategoryTheory.SimplicialObject.Augmented.toArrow_obj_right {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C) :
                (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).right = CategoryTheory.SimplicialObject.Augmented.point.obj X
                @[simp]
                theorem CategoryTheory.SimplicialObject.Augmented.toArrow_obj_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C) :
                (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app { unop := SimplexCategory.mk 0 }
                @[simp]
                theorem CategoryTheory.SimplicialObject.Augmented.toArrow_map_left {C : Type u} [CategoryTheory.Category.{v, u} C] :
                ∀ {X Y : CategoryTheory.SimplicialObject.Augmented C} (η : X Y), (CategoryTheory.SimplicialObject.Augmented.toArrow.map η).left = (CategoryTheory.SimplicialObject.Augmented.drop.map η).app { unop := SimplexCategory.mk 0 }
                @[simp]
                theorem CategoryTheory.SimplicialObject.Augmented.toArrow_obj_left {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C) :
                (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).left = (CategoryTheory.SimplicialObject.Augmented.drop.obj X).obj { unop := SimplexCategory.mk 0 }

                The functor from augmented objects to arrows.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem CategoryTheory.SimplicialObject.Augmented.w₀_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : CategoryTheory.SimplicialObject.Augmented C} {Y : CategoryTheory.SimplicialObject.Augmented C} (f : X Y) {Z : C} (h : ((CategoryTheory.SimplicialObject.const C).obj Y.right).obj { unop := SimplexCategory.mk 0 } Z) :
                  CategoryTheory.CategoryStruct.comp ((CategoryTheory.SimplicialObject.Augmented.drop.map f).app { unop := SimplexCategory.mk 0 }) (CategoryTheory.CategoryStruct.comp (Y.hom.app { unop := SimplexCategory.mk 0 }) h) = CategoryTheory.CategoryStruct.comp (X.hom.app { unop := SimplexCategory.mk 0 }) (CategoryTheory.CategoryStruct.comp (CategoryTheory.SimplicialObject.Augmented.point.map f) h)
                  theorem CategoryTheory.SimplicialObject.Augmented.w₀ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : CategoryTheory.SimplicialObject.Augmented C} {Y : CategoryTheory.SimplicialObject.Augmented C} (f : X Y) :
                  CategoryTheory.CategoryStruct.comp ((CategoryTheory.SimplicialObject.Augmented.drop.map f).app { unop := SimplexCategory.mk 0 }) (Y.hom.app { unop := SimplexCategory.mk 0 }) = CategoryTheory.CategoryStruct.comp (X.hom.app { unop := SimplexCategory.mk 0 }) (CategoryTheory.SimplicialObject.Augmented.point.map f)

                  The compatibility of a morphism with the augmentation, on 0-simplices

                  Functor composition induces a functor on augmented simplicial objects.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    @[simp]
                    theorem CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_right (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} D] :
                    ∀ {X Y : CategoryTheory.Functor C D} (η : X Y) (A : CategoryTheory.SimplicialObject.Augmented C), (((CategoryTheory.SimplicialObject.Augmented.whiskering C D).map η).app A).right = η.app (CategoryTheory.SimplicialObject.Augmented.point.obj A)

                    Functor composition induces a functor on augmented simplicial objects.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      @[simp]
                      theorem CategoryTheory.SimplicialObject.augment_right {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj { unop := SimplexCategory.mk 0 } X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp (X.map g₁.op) f = CategoryTheory.CategoryStruct.comp (X.map g₂.op) f) :
                      (X.augment X₀ f w).right = X₀
                      @[simp]
                      theorem CategoryTheory.SimplicialObject.augment_left {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj { unop := SimplexCategory.mk 0 } X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp (X.map g₁.op) f = CategoryTheory.CategoryStruct.comp (X.map g₂.op) f) :
                      (X.augment X₀ f w).left = X
                      @[simp]
                      theorem CategoryTheory.SimplicialObject.augment_hom_app {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj { unop := SimplexCategory.mk 0 } X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp (X.map g₁.op) f = CategoryTheory.CategoryStruct.comp (X.map g₂.op) f) (i : SimplexCategoryᵒᵖ) :
                      (X.augment X₀ f w).hom.app i = CategoryTheory.CategoryStruct.comp (X.map ((SimplexCategory.mk 0).const i.unop 0).op) f

                      Augment a simplicial object with an object.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem CategoryTheory.SimplicialObject.augment_hom_zero {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj { unop := SimplexCategory.mk 0 } X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp (X.map g₁.op) f = CategoryTheory.CategoryStruct.comp (X.map g₂.op) f) :
                        (X.augment X₀ f w).hom.app { unop := SimplexCategory.mk 0 } = f

                        X _[n] denotes the nth-term of the cosimplicial object X

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For

                          Coface maps for a cosimplicial object.

                          Equations
                          Instances For

                            Codegeneracy maps for a cosimplicial object.

                            Equations
                            Instances For

                              Isomorphisms from identities in ℕ.

                              Equations
                              Instances For
                                theorem CategoryTheory.CosimplicialObject.δ_comp_δ {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 2)} (H : i j) :
                                CategoryTheory.CategoryStruct.comp (X i) (X j.succ) = CategoryTheory.CategoryStruct.comp (X j) (X i.castSucc)

                                The generic case of the first cosimplicial identity

                                theorem CategoryTheory.CosimplicialObject.δ_comp_δ' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 3)} (H : i.castSucc < j) :
                                CategoryTheory.CategoryStruct.comp (X i) (X j) = CategoryTheory.CategoryStruct.comp (X (j.pred )) (X i.castSucc)
                                theorem CategoryTheory.CosimplicialObject.δ_comp_δ'' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i j.castSucc) :
                                CategoryTheory.CategoryStruct.comp (X (i.castLT )) (X j.succ) = CategoryTheory.CategoryStruct.comp (X j) (X i)

                                The special case of the first cosimplicial identity

                                theorem CategoryTheory.CosimplicialObject.δ_comp_σ_of_le {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i j.castSucc) :
                                CategoryTheory.CategoryStruct.comp (X i.castSucc) (X j.succ) = CategoryTheory.CategoryStruct.comp (X j) (X i)

                                The second cosimplicial identity

                                The first part of the third cosimplicial identity

                                theorem CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i) :
                                CategoryTheory.CategoryStruct.comp (X i.succ) (X j.castSucc) = CategoryTheory.CategoryStruct.comp (X j) (X i)

                                The fourth cosimplicial identity

                                theorem CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt' {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) :
                                CategoryTheory.CategoryStruct.comp (X i) (X j) = CategoryTheory.CategoryStruct.comp (X (j.castLT )) (X (i.pred ))
                                theorem CategoryTheory.CosimplicialObject.σ_comp_σ {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : } {i : Fin (n + 1)} {j : Fin (n + 1)} (H : i j) :
                                CategoryTheory.CategoryStruct.comp (X i.castSucc) (X j) = CategoryTheory.CategoryStruct.comp (X j.succ) (X i)

                                The fifth cosimplicial identity

                                The skeleton functor from cosimplicial objects to truncated cosimplicial objects.

                                Equations
                                Instances For
                                  @[simp]
                                  theorem CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C) :
                                  (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app (SimplexCategory.mk 0)
                                  @[simp]
                                  theorem CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_left {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C) :
                                  (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).left = X.left
                                  @[simp]
                                  theorem CategoryTheory.CosimplicialObject.Augmented.toArrow_map_right {C : Type u} [CategoryTheory.Category.{v, u} C] :
                                  ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X Y), (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).right = η.right.app (SimplexCategory.mk 0)
                                  @[simp]
                                  theorem CategoryTheory.CosimplicialObject.Augmented.toArrow_map_left {C : Type u} [CategoryTheory.Category.{v, u} C] :
                                  ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X Y), (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).left = η.left
                                  @[simp]
                                  theorem CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C) :
                                  (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).right = X.right.obj (SimplexCategory.mk 0)

                                  The functor from augmented objects to arrows.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For

                                    Functor composition induces a functor on augmented cosimplicial objects.

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      @[simp]

                                      Functor composition induces a functor on augmented cosimplicial objects.

                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        @[simp]
                                        theorem CategoryTheory.CosimplicialObject.augment_right {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) (X₀ : C) (f : X₀ X.obj (SimplexCategory.mk 0)) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp f (X.map g₁) = CategoryTheory.CategoryStruct.comp f (X.map g₂)) :
                                        (X.augment X₀ f w).right = X
                                        @[simp]
                                        @[simp]
                                        theorem CategoryTheory.CosimplicialObject.augment_left {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) (X₀ : C) (f : X₀ X.obj (SimplexCategory.mk 0)) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 i), CategoryTheory.CategoryStruct.comp f (X.map g₁) = CategoryTheory.CategoryStruct.comp f (X.map g₂)) :
                                        (X.augment X₀ f w).left = X₀

                                        Augment a cosimplicial object with an object.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          @[simp]
                                          theorem CategoryTheory.cosimplicialSimplicialEquiv_inverse_map (C : Type u) [CategoryTheory.Category.{v, u} C] :
                                          ∀ {X Y : CategoryTheory.Functor SimplexCategoryᵒᵖ Cᵒᵖ} (α : X Y), (CategoryTheory.cosimplicialSimplicialEquiv C).inverse.map α = Quiver.Hom.op { app := fun (X_1 : SimplexCategory) => (α.app { unop := X_1 }).unop, naturality := }
                                          @[simp]
                                          @[simp]
                                          theorem CategoryTheory.SimplicialObject.Augmented.rightOp_right_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C) (X : SimplexCategory) :
                                          X✝.rightOp.right.obj X = { unop := X✝.left.obj { unop := X } }
                                          @[simp]
                                          theorem CategoryTheory.SimplicialObject.Augmented.rightOp_right_map {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C) :
                                          ∀ {X_1 Y : SimplexCategory} (f : X_1 Y), X.rightOp.right.map f = (X.left.map f.op).op

                                          Construct an augmented cosimplicial object in the opposite category from an augmented simplicial object.

                                          Equations
                                          Instances For
                                            @[simp]

                                            Construct an augmented simplicial object from an augmented cosimplicial object in the opposite category.

                                            Equations
                                            Instances For

                                              Converting an augmented simplicial object to an augmented cosimplicial object and back is isomorphic to the given object.

                                              Equations
                                              Instances For

                                                Converting an augmented cosimplicial object to an augmented simplicial object and back is isomorphic to the given object.

                                                Equations
                                                Instances For

                                                  A functorial version of Cosimplicial_object.Augmented.leftOp.

                                                  Equations
                                                  • One or more equations did not get rendered due to their size.
                                                  Instances For

                                                    The contravariant categorical equivalence between augmented simplicial objects and augmented cosimplicial objects in the opposite category.

                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For