File: Mathlib/AlgebraicTopology/SimplicialObject.lean

full_name: CategoryTheory.SimplicialObject
code: /-- The category of simplicial objects valued in a category `C`.
This is the category of contravariant functors from `SimplexCategory` to `C`. -/
def SimplicialObject 
goal: Type (max v u)

full_name: CategoryTheory.instCategorySimplicialObject
code: @[simps!]
instance : Category (SimplicialObject C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.instCategorySimplicialObject_comp_app
code: @[simps!]
instance : Category (SimplicialObject C) 
goal: ∀ {X Y Z : SimplexCategoryᵒᵖ ⥤ C} (α : X ⟶ Y) (β : Y ⟶ Z) (X_1 : SimplexCategoryᵒᵖ),
  (α ≫ β).app X_1 = α.app X_1 ≫ β.app X_1

full_name: CategoryTheory.instCategorySimplicialObject_id_app
code: @[simps!]
instance : Category (SimplicialObject C) 
goal: (𝟙 F).app X = 𝟙 (F.obj X)

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialObject___macroRules_Simplicial_term__[_]_1»
code: /-- `X _[n]` denotes the `n`th-term of the simplicial object X -/
scoped[Simplicial]
  notation3:1000 X " _[" n "]" =>
    (X : CategoryTheory.SimplicialObject _).obj (Opposite.op (SimplexCategory.mk n))
goal: Lean.Macro

full_name: CategoryTheory.SimplicialObject.instHasLimitsOfShape
code: instance {J : Type v} [SmallCategory J] [HasLimitsOfShape J C] :
    HasLimitsOfShape J (SimplicialObject C) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.SimplicialObject.instHasLimits
code: instance [HasLimits C] : HasLimits (SimplicialObject C) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.SimplicialObject.instHasColimitsOfShape
code: instance {J : Type v} [SmallCategory J] [HasColimitsOfShape J C] :
    HasColimitsOfShape J (SimplicialObject C) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.SimplicialObject.instHasColimits
code: instance [HasColimits C] : HasColimits (SimplicialObject C) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.SimplicialObject.hom_ext
code: @[ext]
lemma hom_ext {X Y : SimplicialObject C} (f g : X ⟶ Y)
    (h : ∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n) : f = g 
goal: f = g

full_name: CategoryTheory.SimplicialObject.δ
code: /-- Face maps for a simplicial object. -/
def δ {n} (i : Fin (n + 2)) : X _[n + 1] ⟶ X _[n] 
goal: X.obj (Opposite.op (SimplexCategory.mk (n + 1))) ⟶ X.obj (Opposite.op (SimplexCategory.mk n))

full_name: CategoryTheory.SimplicialObject.σ
code: /-- Degeneracy maps for a simplicial object. -/
def σ {n} (i : Fin (n + 1)) : X _[n] ⟶ X _[n + 1] 
goal: X.obj (Opposite.op (SimplexCategory.mk n)) ⟶ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))

full_name: CategoryTheory.SimplicialObject.eqToIso
code: /-- Isomorphisms from identities in ℕ. -/
def eqToIso {n m : ℕ} (h : n = m) : X _[n] ≅ X _[m] 
goal: X.obj (Opposite.op (SimplexCategory.mk n)) ≅ X.obj (Opposite.op (SimplexCategory.mk m))

full_name: CategoryTheory.SimplicialObject.eqToIso_refl
code: @[simp]
theorem eqToIso_refl {n : ℕ} (h : n = n) : X.eqToIso h = Iso.refl _ 
goal: X.eqToIso h = CategoryTheory.Iso.refl (X.obj (Opposite.op (SimplexCategory.mk n)))

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

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

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

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

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

full_name: CategoryTheory.SimplicialObject.δ_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) :
    X.σ j.succ ≫ X.δ (Fin.castSucc i) = X.δ i ≫ X.σ j 
goal: X.σ j.succ ≫ X.δ i.castSucc = X.δ i ≫ X.σ j

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

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

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

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

full_name: CategoryTheory.SimplicialObject.δ_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) :
    X.σ (Fin.castSucc j) ≫ X.δ i.succ = X.δ i ≫ X.σ j 
goal: X.σ j.castSucc ≫ X.δ i.succ = X.δ i ≫ X.σ j

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

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

full_name: CategoryTheory.SimplicialObject.δ_naturality
code: @[reassoc (attr := simp)]
theorem δ_naturality {X' X : SimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 2)) :
    X.δ i ≫ f.app (op [n]) = f.app (op [n + 1]) ≫ X'.δ i 
goal: X.δ i ≫ f.app (Opposite.op (SimplexCategory.mk n)) = f.app (Opposite.op (SimplexCategory.mk (n + 1))) ≫ X'.δ i

full_name: CategoryTheory.SimplicialObject.σ_naturality
code: @[reassoc (attr := simp)]
theorem σ_naturality {X' X : SimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ f.app (op [n + 1]) = f.app (op [n]) ≫ X'.σ i 
goal: X.σ i ≫ f.app (Opposite.op (SimplexCategory.mk (n + 1))) = f.app (Opposite.op (SimplexCategory.mk n)) ≫ X'.σ i

full_name: CategoryTheory.SimplicialObject.whiskering_map_app_app
code: /-- Functor composition induces a functor on simplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ SimplicialObject C ⥤ SimplicialObject D 
goal: ∀ {X Y : C ⥤ D} (τ : X ⟶ Y) (F : SimplexCategoryᵒᵖ ⥤ C) (c : SimplexCategoryᵒᵖ),
  (((CategoryTheory.SimplicialObject.whiskering C D).map τ).app F).app c = τ.app (F.obj c)

full_name: CategoryTheory.SimplicialObject.whiskering_obj_obj_map
code: /-- Functor composition induces a functor on simplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ SimplicialObject C ⥤ SimplicialObject D 
goal: ∀ {X Y : SimplexCategoryᵒᵖ} (f : X ⟶ Y),
  (((CategoryTheory.SimplicialObject.whiskering C D).obj H).obj F).map f = H.map (F.map f)

full_name: CategoryTheory.SimplicialObject.whiskering
code: /-- Functor composition induces a functor on simplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ SimplicialObject C ⥤ SimplicialObject D 
goal: (C ⥤ D) ⥤ CategoryTheory.SimplicialObject C ⥤ CategoryTheory.SimplicialObject D

full_name: CategoryTheory.SimplicialObject.whiskering_obj_obj_obj
code: /-- Functor composition induces a functor on simplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ SimplicialObject C ⥤ SimplicialObject D 
goal: (((CategoryTheory.SimplicialObject.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)

full_name: CategoryTheory.SimplicialObject.whiskering_obj_map_app
code: /-- Functor composition induces a functor on simplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ SimplicialObject C ⥤ SimplicialObject D 
goal: ∀ {X Y : SimplexCategoryᵒᵖ ⥤ C} (α : X ⟶ Y) (X_1 : SimplexCategoryᵒᵖ),
  (((CategoryTheory.SimplicialObject.whiskering C D).obj H).map α).app X_1 = H.map (α.app X_1)

full_name: CategoryTheory.SimplicialObject.Truncated
code: /-- Truncated simplicial objects. -/
def Truncated (n : ℕ) 
goal: Type (max v u)

full_name: CategoryTheory.SimplicialObject.instCategoryTruncated
code: instance {n : ℕ} : Category (Truncated C n) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.SimplicialObject.Truncated C n)

full_name: CategoryTheory.SimplicialObject.Truncated.instHasLimitsOfShape
code: instance {n} {J : Type v} [SmallCategory J] [HasLimitsOfShape J C] :
    HasLimitsOfShape J (SimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.SimplicialObject.Truncated C n)

full_name: CategoryTheory.SimplicialObject.Truncated.instHasLimits
code: instance {n} [HasLimits C] : HasLimits (SimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.SimplicialObject.Truncated C n)

full_name: CategoryTheory.SimplicialObject.Truncated.instHasColimitsOfShape
code: instance {n} {J : Type v} [SmallCategory J] [HasColimitsOfShape J C] :
    HasColimitsOfShape J (SimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.SimplicialObject.Truncated C n)

full_name: CategoryTheory.SimplicialObject.Truncated.instHasColimits
code: instance {n} [HasColimits C] : HasColimits (SimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.SimplicialObject.Truncated C n)

full_name: CategoryTheory.SimplicialObject.Truncated.whiskering_obj_map_app
code: /-- Functor composition induces a functor on truncated simplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : (SimplexCategory.Truncated n)ᵒᵖ ⥤ C} (α : X ⟶ Y) (X_1 : (SimplexCategory.Truncated n)ᵒᵖ),
  (((CategoryTheory.SimplicialObject.Truncated.whiskering C D).obj H).map α).app X_1 = H.map (α.app X_1)

full_name: CategoryTheory.SimplicialObject.Truncated.whiskering_obj_obj_map
code: /-- Functor composition induces a functor on truncated simplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : (SimplexCategory.Truncated n)ᵒᵖ} (f : X ⟶ Y),
  (((CategoryTheory.SimplicialObject.Truncated.whiskering C D).obj H).obj F).map f = H.map (F.map f)

full_name: CategoryTheory.SimplicialObject.Truncated.whiskering
code: /-- Functor composition induces a functor on truncated simplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: (C ⥤ D) ⥤ CategoryTheory.SimplicialObject.Truncated C n ⥤ CategoryTheory.SimplicialObject.Truncated D n

full_name: CategoryTheory.SimplicialObject.Truncated.whiskering_obj_obj_obj
code: /-- Functor composition induces a functor on truncated simplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: (((CategoryTheory.SimplicialObject.Truncated.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)

full_name: CategoryTheory.SimplicialObject.Truncated.whiskering_map_app_app
code: /-- Functor composition induces a functor on truncated simplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : C ⥤ D} (τ : X ⟶ Y) (F : (SimplexCategory.Truncated n)ᵒᵖ ⥤ C) (c : (SimplexCategory.Truncated n)ᵒᵖ),
  (((CategoryTheory.SimplicialObject.Truncated.whiskering C D).map τ).app F).app c = τ.app (F.obj c)

full_name: CategoryTheory.SimplicialObject.sk
code: /-- The skeleton functor from simplicial objects to truncated simplicial objects. -/
def sk (n : ℕ) : SimplicialObject C ⥤ SimplicialObject.Truncated C n 
goal: CategoryTheory.SimplicialObject C ⥤ CategoryTheory.SimplicialObject.Truncated C n

full_name: CategoryTheory.SimplicialObject.const
code: /-- The constant simplicial object is the constant functor. -/
abbrev const : C ⥤ SimplicialObject C 
goal: C ⥤ CategoryTheory.SimplicialObject C

full_name: CategoryTheory.SimplicialObject.Augmented
code: /-- The category of augmented simplicial objects, defined as a comma category. -/
def Augmented 
goal: Type (max u v)

full_name: CategoryTheory.SimplicialObject.instCategoryAugmented_id_left_app
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ), (𝟙 X).left.app X_1 = 𝟙 (X.left.obj X_1)

full_name: CategoryTheory.SimplicialObject.instCategoryAugmented
code: @[simps!]
instance : Category (Augmented C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.SimplicialObject.Augmented C)

full_name: CategoryTheory.SimplicialObject.instCategoryAugmented_id_right
code: @[simps!]
instance : Category (Augmented C) 
goal: (𝟙 X).right = 𝟙 X.right

full_name: CategoryTheory.SimplicialObject.instCategoryAugmented_comp_left_app
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ {X Y Z : CategoryTheory.Comma (𝟭 (CategoryTheory.SimplicialObject C)) (CategoryTheory.SimplicialObject.const C)}
  (f : X ⟶ Y) (g : Y ⟶ Z) (X_1 : SimplexCategoryᵒᵖ), (f ≫ g).left.app X_1 = f.left.app X_1 ≫ g.left.app X_1

full_name: CategoryTheory.SimplicialObject.instCategoryAugmented_comp_right
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ {X Y Z : CategoryTheory.Comma (𝟭 (CategoryTheory.SimplicialObject C)) (CategoryTheory.SimplicialObject.const C)}
  (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).right = f.right ≫ g.right

full_name: CategoryTheory.SimplicialObject.Augmented.hom_ext
code: @[ext]
lemma hom_ext {X Y : Augmented C} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) :
    f = g 
goal: f = g

full_name: CategoryTheory.SimplicialObject.Augmented.drop
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ SimplicialObject C 
goal: CategoryTheory.SimplicialObject.Augmented C ⥤ CategoryTheory.SimplicialObject C

full_name: CategoryTheory.SimplicialObject.Augmented.drop_obj
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ SimplicialObject C 
goal: CategoryTheory.SimplicialObject.Augmented.drop.obj X = X.left

full_name: CategoryTheory.SimplicialObject.Augmented.drop_map
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ SimplicialObject C 
goal: ∀ {X Y : CategoryTheory.Comma (𝟭 (CategoryTheory.SimplicialObject C)) (CategoryTheory.SimplicialObject.const C)}
  (f : X ⟶ Y), CategoryTheory.SimplicialObject.Augmented.drop.map f = f.left

full_name: CategoryTheory.SimplicialObject.Augmented.point
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: CategoryTheory.SimplicialObject.Augmented C ⥤ C

full_name: CategoryTheory.SimplicialObject.Augmented.point_obj
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: CategoryTheory.SimplicialObject.Augmented.point.obj X = X.right

full_name: CategoryTheory.SimplicialObject.Augmented.point_map
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma (𝟭 (CategoryTheory.SimplicialObject C)) (CategoryTheory.SimplicialObject.const C)}
  (f : X ⟶ Y), CategoryTheory.SimplicialObject.Augmented.point.map f = f.right

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow_obj_right
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).right = CategoryTheory.SimplicialObject.Augmented.point.obj X

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: CategoryTheory.SimplicialObject.Augmented C ⥤ CategoryTheory.Arrow C

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow_obj_hom
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app (Opposite.op (SimplexCategory.mk 0))

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow_map_right
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: ∀ {X Y : CategoryTheory.SimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.SimplicialObject.Augmented.toArrow.map η).right =
    CategoryTheory.SimplicialObject.Augmented.point.map η

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow_obj_left
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).left =
  (CategoryTheory.SimplicialObject.Augmented.drop.obj X).obj (Opposite.op (SimplexCategory.mk 0))

full_name: CategoryTheory.SimplicialObject.Augmented.toArrow_map_left
code: /-- The functor from augmented objects to arrows. -/
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
goal: ∀ {X Y : CategoryTheory.SimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.SimplicialObject.Augmented.toArrow.map η).left =
    (CategoryTheory.SimplicialObject.Augmented.drop.map η).app (Opposite.op (SimplexCategory.mk 0))

full_name: CategoryTheory.SimplicialObject.Augmented.w₀
code: /-- The compatibility of a morphism with the augmentation, on 0-simplices -/
@[reassoc]
theorem w₀ {X Y : Augmented C} (f : X ⟶ Y) :
    (Augmented.drop.map f).app (op (SimplexCategory.mk 0)) ≫ Y.hom.app (op (SimplexCategory.mk 0)) =
      X.hom.app (op (SimplexCategory.mk 0)) ≫ Augmented.point.map f 
goal: (CategoryTheory.SimplicialObject.Augmented.drop.map f).app (Opposite.op (SimplexCategory.mk 0)) ≫
    Y.hom.app (Opposite.op (SimplexCategory.mk 0)) =
  X.hom.app (Opposite.op (SimplexCategory.mk 0)) ≫ CategoryTheory.SimplicialObject.Augmented.point.map f

full_name: CategoryTheory.SimplicialObject.Augmented.whiskeringObj
code: /-- Functor composition induces a functor on augmented simplicial objects. -/
@[simp]
def whiskeringObj (D : Type*) [Category D] (F : C ⥤ D) : Augmented C ⥤ Augmented D 
goal: CategoryTheory.SimplicialObject.Augmented C ⥤ CategoryTheory.SimplicialObject.Augmented D

full_name: CategoryTheory.SimplicialObject.Augmented.whiskering_obj
code: /-- Functor composition induces a functor on augmented simplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: (CategoryTheory.SimplicialObject.Augmented.whiskering C D).obj F =
  CategoryTheory.SimplicialObject.Augmented.whiskeringObj C D F

full_name: CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_left
code: /-- Functor composition induces a functor on augmented simplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: ∀ {X Y : C ⥤ D} (η : X ⟶ Y) (A : CategoryTheory.SimplicialObject.Augmented C),
  (((CategoryTheory.SimplicialObject.Augmented.whiskering C D).map η).app A).left =
    CategoryTheory.whiskerLeft (CategoryTheory.SimplicialObject.Augmented.drop.obj A) η

full_name: CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_right
code: /-- Functor composition induces a functor on augmented simplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: ∀ {X Y : 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)

full_name: CategoryTheory.SimplicialObject.Augmented.whiskering
code: /-- Functor composition induces a functor on augmented simplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: (C ⥤ D) ⥤ CategoryTheory.SimplicialObject.Augmented C ⥤ CategoryTheory.SimplicialObject.Augmented D

full_name: CategoryTheory.SimplicialObject.augment_hom_app
code: /-- Augment a simplicial object with an object. -/
@[simps]
def augment (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀)
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      X.map g₁.op ≫ f = X.map g₂.op ≫ f) :
    SimplicialObject.Augmented C 
goal: (X.augment X₀ f w).hom.app i = X.map ((SimplexCategory.mk 0).const (Opposite.unop i) 0).op ≫ f

full_name: CategoryTheory.SimplicialObject.augment
code: /-- Augment a simplicial object with an object. -/
@[simps]
def augment (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀)
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      X.map g₁.op ≫ f = X.map g₂.op ≫ f) :
    SimplicialObject.Augmented C 
goal: CategoryTheory.SimplicialObject.Augmented C

full_name: CategoryTheory.SimplicialObject.augment_left
code: /-- Augment a simplicial object with an object. -/
@[simps]
def augment (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀)
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      X.map g₁.op ≫ f = X.map g₂.op ≫ f) :
    SimplicialObject.Augmented C 
goal: (X.augment X₀ f w).left = X

full_name: CategoryTheory.SimplicialObject.augment_right
code: /-- Augment a simplicial object with an object. -/
@[simps]
def augment (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀)
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      X.map g₁.op ≫ f = X.map g₂.op ≫ f) :
    SimplicialObject.Augmented C 
goal: (X.augment X₀ f w).right = X₀

full_name: CategoryTheory.SimplicialObject.augment_hom_zero
code: theorem augment_hom_zero (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀) (w) :
    (X.augment X₀ f w).hom.app (op [0]) = f 
goal: (X.augment X₀ f w).hom.app (Opposite.op (SimplexCategory.mk 0)) = f

full_name: CategoryTheory.CosimplicialObject
code: /-- Cosimplicial objects. -/
def CosimplicialObject 
goal: Type (max v u)

full_name: CategoryTheory.instCategoryCosimplicialObject_id_app
code: @[simps!]
instance : Category (CosimplicialObject C) 
goal: (𝟙 F).app X = 𝟙 (F.obj X)

full_name: CategoryTheory.instCategoryCosimplicialObject
code: @[simps!]
instance : Category (CosimplicialObject C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.CosimplicialObject C)

full_name: CategoryTheory.instCategoryCosimplicialObject_comp_app
code: @[simps!]
instance : Category (CosimplicialObject C) 
goal: ∀ {X Y Z : SimplexCategory ⥤ C} (α : X ⟶ Y) (β : Y ⟶ Z) (X_1 : SimplexCategory), (α ≫ β).app X_1 = α.app X_1 ≫ β.app X_1

full_name: Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplicialObject___macroRules_Simplicial_term__[_]_1_1»
code: /-- `X _[n]` denotes the `n`th-term of the cosimplicial object X -/
scoped[Simplicial]
  notation:1000 X " _[" n "]" =>
    (X : CategoryTheory.CosimplicialObject _).obj (SimplexCategory.mk n)
goal: Lean.Macro

full_name: CategoryTheory.CosimplicialObject.instHasLimitsOfShape
code: instance {J : Type v} [SmallCategory J] [HasLimitsOfShape J C] :
    HasLimitsOfShape J (CosimplicialObject C) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.CosimplicialObject C)

full_name: CategoryTheory.CosimplicialObject.instHasLimits
code: instance [HasLimits C] : HasLimits (CosimplicialObject C) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.CosimplicialObject C)

full_name: CategoryTheory.CosimplicialObject.instHasColimitsOfShape
code: instance {J : Type v} [SmallCategory J] [HasColimitsOfShape J C] :
    HasColimitsOfShape J (CosimplicialObject C) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.CosimplicialObject C)

full_name: CategoryTheory.CosimplicialObject.instHasColimits
code: instance [HasColimits C] : HasColimits (CosimplicialObject C) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.CosimplicialObject C)

full_name: CategoryTheory.CosimplicialObject.hom_ext
code: @[ext]
lemma hom_ext {X Y : CosimplicialObject C} (f g : X ⟶ Y)
    (h : ∀ (n : SimplexCategory), f.app n = g.app n) : f = g 
goal: f = g

full_name: CategoryTheory.CosimplicialObject.δ
code: /-- Coface maps for a cosimplicial object. -/
def δ {n} (i : Fin (n + 2)) : X _[n] ⟶ X _[n + 1] 
goal: X.obj (SimplexCategory.mk n) ⟶ X.obj (SimplexCategory.mk (n + 1))

full_name: CategoryTheory.CosimplicialObject.σ
code: /-- Codegeneracy maps for a cosimplicial object. -/
def σ {n} (i : Fin (n + 1)) : X _[n + 1] ⟶ X _[n] 
goal: X.obj (SimplexCategory.mk (n + 1)) ⟶ X.obj (SimplexCategory.mk n)

full_name: CategoryTheory.CosimplicialObject.eqToIso
code: /-- Isomorphisms from identities in ℕ. -/
def eqToIso {n m : ℕ} (h : n = m) : X _[n] ≅ X _[m] 
goal: X.obj (SimplexCategory.mk n) ≅ X.obj (SimplexCategory.mk m)

full_name: CategoryTheory.CosimplicialObject.eqToIso_refl
code: @[simp]
theorem eqToIso_refl {n : ℕ} (h : n = n) : X.eqToIso h = Iso.refl _ 
goal: X.eqToIso h = CategoryTheory.Iso.refl (X.obj (SimplexCategory.mk n))

full_name: CategoryTheory.CosimplicialObject.δ_comp_δ
code: /-- The generic case of the first cosimplicial identity -/
@[reassoc]
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    X.δ i ≫ X.δ j.succ = X.δ j ≫ X.δ (Fin.castSucc i) 
goal: X.δ i ≫ X.δ j.succ = X.δ j ≫ X.δ i.castSucc

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

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

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

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

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

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

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

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

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

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

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

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

full_name: CategoryTheory.CosimplicialObject.δ_naturality
code: @[reassoc (attr := simp)]
theorem δ_naturality {X' X : CosimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 2)) :
    X.δ i ≫ f.app (SimplexCategory.mk (n + 1)) = f.app (SimplexCategory.mk n) ≫ X'.δ i 
goal: X.δ i ≫ f.app (SimplexCategory.mk (n + 1)) = f.app (SimplexCategory.mk n) ≫ X'.δ i

full_name: CategoryTheory.CosimplicialObject.σ_naturality
code: @[reassoc (attr := simp)]
theorem σ_naturality {X' X : CosimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ f.app (SimplexCategory.mk n) = f.app (SimplexCategory.mk (n + 1)) ≫ X'.σ i 
goal: X.σ i ≫ f.app (SimplexCategory.mk n) = f.app (SimplexCategory.mk (n + 1)) ≫ X'.σ i

full_name: CategoryTheory.CosimplicialObject.whiskering_map_app_app
code: /-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
goal: ∀ {X Y : C ⥤ D} (τ : X ⟶ Y) (F : SimplexCategory ⥤ C) (c : SimplexCategory),
  (((CategoryTheory.CosimplicialObject.whiskering C D).map τ).app F).app c = τ.app (F.obj c)

full_name: CategoryTheory.CosimplicialObject.whiskering_obj_obj_map
code: /-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y),
  (((CategoryTheory.CosimplicialObject.whiskering C D).obj H).obj F).map f = H.map (F.map f)

full_name: CategoryTheory.CosimplicialObject.whiskering_obj_obj_obj
code: /-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
goal: (((CategoryTheory.CosimplicialObject.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)

full_name: CategoryTheory.CosimplicialObject.whiskering_obj_map_app
code: /-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
goal: ∀ {X Y : SimplexCategory ⥤ C} (α : X ⟶ Y) (X_1 : SimplexCategory),
  (((CategoryTheory.CosimplicialObject.whiskering C D).obj H).map α).app X_1 = H.map (α.app X_1)

full_name: CategoryTheory.CosimplicialObject.whiskering
code: /-- Functor composition induces a functor on cosimplicial objects. -/
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
goal: (C ⥤ D) ⥤ CategoryTheory.CosimplicialObject C ⥤ CategoryTheory.CosimplicialObject D

full_name: CategoryTheory.CosimplicialObject.Truncated
code: /-- Truncated cosimplicial objects. -/
def Truncated (n : ℕ) 
goal: Type (max v u)

full_name: CategoryTheory.CosimplicialObject.instCategoryTruncated
code: instance {n : ℕ} : Category (Truncated C n) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.CosimplicialObject.Truncated C n)

full_name: CategoryTheory.CosimplicialObject.Truncated.instHasLimitsOfShape
code: instance {n} {J : Type v} [SmallCategory J] [HasLimitsOfShape J C] :
    HasLimitsOfShape J (CosimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.CosimplicialObject.Truncated C n)

full_name: CategoryTheory.CosimplicialObject.Truncated.instHasLimits
code: instance {n} [HasLimits C] : HasLimits (CosimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.CosimplicialObject.Truncated C n)

full_name: CategoryTheory.CosimplicialObject.Truncated.instHasColimitsOfShape
code: instance {n} {J : Type v} [SmallCategory J] [HasColimitsOfShape J C] :
    HasColimitsOfShape J (CosimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.CosimplicialObject.Truncated C n)

full_name: CategoryTheory.CosimplicialObject.Truncated.instHasColimits
code: instance {n} [HasColimits C] : HasColimits (CosimplicialObject.Truncated C n) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.CosimplicialObject.Truncated C n)

full_name: CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_map_app
code: /-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : SimplexCategory.Truncated n ⥤ C} (α : X ⟶ Y) (X_1 : SimplexCategory.Truncated n),
  (((CategoryTheory.CosimplicialObject.Truncated.whiskering C D).obj H).map α).app X_1 = H.map (α.app X_1)

full_name: CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_obj_map
code: /-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : SimplexCategory.Truncated n} (f : X ⟶ Y),
  (((CategoryTheory.CosimplicialObject.Truncated.whiskering C D).obj H).obj F).map f = H.map (F.map f)

full_name: CategoryTheory.CosimplicialObject.Truncated.whiskering_map_app_app
code: /-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: ∀ {X Y : C ⥤ D} (τ : X ⟶ Y) (F : SimplexCategory.Truncated n ⥤ C) (c : SimplexCategory.Truncated n),
  (((CategoryTheory.CosimplicialObject.Truncated.whiskering C D).map τ).app F).app c = τ.app (F.obj c)

full_name: CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_obj_obj
code: /-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: (((CategoryTheory.CosimplicialObject.Truncated.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)

full_name: CategoryTheory.CosimplicialObject.Truncated.whiskering
code: /-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
goal: (C ⥤ D) ⥤ CategoryTheory.CosimplicialObject.Truncated C n ⥤ CategoryTheory.CosimplicialObject.Truncated D n

full_name: CategoryTheory.CosimplicialObject.sk
code: /-- The skeleton functor from cosimplicial objects to truncated cosimplicial objects. -/
def sk (n : ℕ) : CosimplicialObject C ⥤ CosimplicialObject.Truncated C n 
goal: CategoryTheory.CosimplicialObject C ⥤ CategoryTheory.CosimplicialObject.Truncated C n

full_name: CategoryTheory.CosimplicialObject.const
code: /-- The constant cosimplicial object. -/
abbrev const : C ⥤ CosimplicialObject C 
goal: C ⥤ CategoryTheory.CosimplicialObject C

full_name: CategoryTheory.CosimplicialObject.Augmented
code: /-- Augmented cosimplicial objects. -/
def Augmented 
goal: Type (max u v)

full_name: CategoryTheory.CosimplicialObject.instCategoryAugmented_id_left
code: @[simps!]
instance : Category (Augmented C) 
goal: (𝟙 X).left = 𝟙 X.left

full_name: CategoryTheory.CosimplicialObject.instCategoryAugmented_comp_left
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ {X Y Z : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).left = f.left ≫ g.left

full_name: CategoryTheory.CosimplicialObject.instCategoryAugmented
code: @[simps!]
instance : Category (Augmented C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.CosimplicialObject.Augmented C)

full_name: CategoryTheory.CosimplicialObject.instCategoryAugmented_comp_right_app
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ {X Y Z : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y) (g : Y ⟶ Z) (X_1 : SimplexCategory), (f ≫ g).right.app X_1 = f.right.app X_1 ≫ g.right.app X_1

full_name: CategoryTheory.CosimplicialObject.instCategoryAugmented_id_right_app
code: @[simps!]
instance : Category (Augmented C) 
goal: ∀ (X_1 : SimplexCategory), (𝟙 X).right.app X_1 = 𝟙 (X.right.obj X_1)

full_name: CategoryTheory.CosimplicialObject.Augmented.hom_ext
code: @[ext]
lemma hom_ext {X Y : Augmented C} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) :
    f = g 
goal: f = g

full_name: CategoryTheory.CosimplicialObject.Augmented.drop_map
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ CosimplicialObject C 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y), CategoryTheory.CosimplicialObject.Augmented.drop.map f = f.right

full_name: CategoryTheory.CosimplicialObject.Augmented.drop_obj
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ CosimplicialObject C 
goal: CategoryTheory.CosimplicialObject.Augmented.drop.obj X = X.right

full_name: CategoryTheory.CosimplicialObject.Augmented.drop
code: /-- Drop the augmentation. -/
@[simps!]
def drop : Augmented C ⥤ CosimplicialObject C 
goal: CategoryTheory.CosimplicialObject.Augmented C ⥤ CategoryTheory.CosimplicialObject C

full_name: CategoryTheory.CosimplicialObject.Augmented.point
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: CategoryTheory.CosimplicialObject.Augmented C ⥤ C

full_name: CategoryTheory.CosimplicialObject.Augmented.point_obj
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: CategoryTheory.CosimplicialObject.Augmented.point.obj X = X.left

full_name: CategoryTheory.CosimplicialObject.Augmented.point_map
code: /-- The point of the augmentation. -/
@[simps!]
def point : Augmented C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y), CategoryTheory.CosimplicialObject.Augmented.point.map f = f.left

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: CategoryTheory.CosimplicialObject.Augmented C ⥤ CategoryTheory.Arrow C

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).right = X.right.obj (SimplexCategory.mk 0)

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow_map_right
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).right = η.right.app (SimplexCategory.mk 0)

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_left
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).left = X.left

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow_map_left
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).left = η.left

full_name: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_hom
code: /-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app (SimplexCategory.mk 0)

full_name: CategoryTheory.CosimplicialObject.Augmented.whiskeringObj
code: /-- Functor composition induces a functor on augmented cosimplicial objects. -/
@[simp]
def whiskeringObj (D : Type*) [Category D] (F : C ⥤ D) : Augmented C ⥤ Augmented D 
goal: CategoryTheory.CosimplicialObject.Augmented C ⥤ CategoryTheory.CosimplicialObject.Augmented D

full_name: CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_right
code: /-- Functor composition induces a functor on augmented cosimplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: ∀ {X Y : C ⥤ D} (η : X ⟶ Y) (A : CategoryTheory.CosimplicialObject.Augmented C),
  (((CategoryTheory.CosimplicialObject.Augmented.whiskering C D).map η).app A).right =
    CategoryTheory.whiskerLeft (CategoryTheory.CosimplicialObject.Augmented.drop.obj A) η

full_name: CategoryTheory.CosimplicialObject.Augmented.whiskering_obj
code: /-- Functor composition induces a functor on augmented cosimplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: (CategoryTheory.CosimplicialObject.Augmented.whiskering C D).obj F =
  CategoryTheory.CosimplicialObject.Augmented.whiskeringObj C D F

full_name: CategoryTheory.CosimplicialObject.Augmented.whiskering
code: /-- Functor composition induces a functor on augmented cosimplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: (C ⥤ D) ⥤ CategoryTheory.CosimplicialObject.Augmented C ⥤ CategoryTheory.CosimplicialObject.Augmented D

full_name: CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_left
code: /-- Functor composition induces a functor on augmented cosimplicial objects. -/
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
goal: ∀ {X Y : C ⥤ D} (η : X ⟶ Y) (A : CategoryTheory.CosimplicialObject.Augmented C),
  (((CategoryTheory.CosimplicialObject.Augmented.whiskering C D).map η).app A).left =
    η.app (CategoryTheory.CosimplicialObject.Augmented.point.obj A)

full_name: CategoryTheory.CosimplicialObject.augment
code: /-- Augment a cosimplicial object with an object. -/
@[simps]
def augment (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0])
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      f ≫ X.map g₁ = f ≫ X.map g₂) : CosimplicialObject.Augmented C 
goal: CategoryTheory.CosimplicialObject.Augmented C

full_name: CategoryTheory.CosimplicialObject.augment_right
code: /-- Augment a cosimplicial object with an object. -/
@[simps]
def augment (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0])
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      f ≫ X.map g₁ = f ≫ X.map g₂) : CosimplicialObject.Augmented C 
goal: (X.augment X₀ f w).right = X

full_name: CategoryTheory.CosimplicialObject.augment_left
code: /-- Augment a cosimplicial object with an object. -/
@[simps]
def augment (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0])
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      f ≫ X.map g₁ = f ≫ X.map g₂) : CosimplicialObject.Augmented C 
goal: (X.augment X₀ f w).left = X₀

full_name: CategoryTheory.CosimplicialObject.augment_hom_app
code: /-- Augment a cosimplicial object with an object. -/
@[simps]
def augment (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0])
    (w : ∀ (i : SimplexCategory) (g₁ g₂ : ([0] : SimplexCategory) ⟶ i),
      f ≫ X.map g₁ = f ≫ X.map g₂) : CosimplicialObject.Augmented C 
goal: (X.augment X₀ f w).hom.app i = f ≫ X.map ((SimplexCategory.mk 0).const i 0)

full_name: CategoryTheory.CosimplicialObject.augment_hom_zero
code: theorem augment_hom_zero (X : CosimplicialObject C) (X₀ : C) (f : X₀ ⟶ X.obj [0]) (w) :
    (X.augment X₀ f w).hom.app [0] = f 
goal: (X.augment X₀ f w).hom.app (SimplexCategory.mk 0) = f

full_name: CategoryTheory.simplicialCosimplicialEquiv_unitIso_inv_app
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: (CategoryTheory.simplicialCosimplicialEquiv C).unitIso.inv.app X = (Opposite.unop X).rightOpLeftOpIso.inv.op

full_name: CategoryTheory.simplicialCosimplicialEquiv_functor_obj_obj
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ((CategoryTheory.simplicialCosimplicialEquiv C).functor.obj F).obj X =
  Opposite.op ((Opposite.unop F).obj (Opposite.op X))

full_name: CategoryTheory.simplicialCosimplicialEquiv_counitIso_hom_app_app
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategory), ((CategoryTheory.simplicialCosimplicialEquiv C).counitIso.hom.app X).app X_1 = 𝟙 (X.obj X_1)

full_name: CategoryTheory.simplicialCosimplicialEquiv_inverse_obj
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: (CategoryTheory.simplicialCosimplicialEquiv C).inverse.obj F = Opposite.op F.leftOp

full_name: CategoryTheory.simplicialCosimplicialEquiv
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: (CategoryTheory.SimplicialObject C)ᵒᵖ ≌ CategoryTheory.CosimplicialObject Cᵒᵖ

full_name: CategoryTheory.simplicialCosimplicialEquiv_inverse_map
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ∀ {X Y : SimplexCategory ⥤ Cᵒᵖ} (η : X ⟶ Y),
  (CategoryTheory.simplicialCosimplicialEquiv C).inverse.map η = (CategoryTheory.NatTrans.leftOp η).op

full_name: CategoryTheory.simplicialCosimplicialEquiv_unitIso_hom_app
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: (CategoryTheory.simplicialCosimplicialEquiv C).unitIso.hom.app X = (Opposite.unop X).rightOpLeftOpIso.hom.op

full_name: CategoryTheory.simplicialCosimplicialEquiv_functor_obj_map
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y),
  ((CategoryTheory.simplicialCosimplicialEquiv C).functor.obj F).map f = ((Opposite.unop F).map f.op).op

full_name: CategoryTheory.simplicialCosimplicialEquiv_counitIso_inv_app_app
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategory), ((CategoryTheory.simplicialCosimplicialEquiv C).counitIso.inv.app X).app X_1 = 𝟙 (X.obj X_1)

full_name: CategoryTheory.simplicialCosimplicialEquiv_functor_map_app
code: /-- The anti-equivalence between simplicial objects and cosimplicial objects. -/
@[simps!]
def simplicialCosimplicialEquiv : (SimplicialObject C)ᵒᵖ ≌ CosimplicialObject Cᵒᵖ 
goal: ∀ {X Y : (SimplexCategoryᵒᵖ ⥤ C)ᵒᵖ} (η : X ⟶ Y) (X_1 : SimplexCategory),
  ((CategoryTheory.simplicialCosimplicialEquiv C).functor.map η).app X_1 = (η.unop.app (Opposite.op X_1)).op

full_name: CategoryTheory.cosimplicialSimplicialEquiv_unitIso_inv_app
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: (CategoryTheory.cosimplicialSimplicialEquiv C).unitIso.inv.app X = (Opposite.unop X).opUnopIso.inv.op

full_name: CategoryTheory.cosimplicialSimplicialEquiv_counitIso_hom_app_app
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ),
  ((CategoryTheory.cosimplicialSimplicialEquiv C).counitIso.hom.app X).app X_1 = 𝟙 (X.obj X_1)

full_name: CategoryTheory.cosimplicialSimplicialEquiv_functor_obj_obj
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ((CategoryTheory.cosimplicialSimplicialEquiv C).functor.obj F).obj X =
  Opposite.op ((Opposite.unop F).obj (Opposite.unop X))

full_name: CategoryTheory.cosimplicialSimplicialEquiv_functor_map_app
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ∀ {X Y : (SimplexCategory ⥤ C)ᵒᵖ} (α : X ⟶ Y) (X_1 : SimplexCategoryᵒᵖ),
  ((CategoryTheory.cosimplicialSimplicialEquiv C).functor.map α).app X_1 = (α.unop.app (Opposite.unop X_1)).op

full_name: CategoryTheory.cosimplicialSimplicialEquiv_inverse_map
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ∀ {X Y : SimplexCategoryᵒᵖ ⥤ Cᵒᵖ} (α : X ⟶ Y),
  (CategoryTheory.cosimplicialSimplicialEquiv C).inverse.map α =
    Quiver.Hom.op { app := fun X_1 => (α.app (Opposite.op X_1)).unop, naturality := ⋯ }

full_name: CategoryTheory.cosimplicialSimplicialEquiv_functor_obj_map
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ∀ {X Y : SimplexCategoryᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.cosimplicialSimplicialEquiv C).functor.obj F).map f = ((Opposite.unop F).map f.unop).op

full_name: CategoryTheory.cosimplicialSimplicialEquiv_inverse_obj
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: (CategoryTheory.cosimplicialSimplicialEquiv C).inverse.obj F = Opposite.op F.unop

full_name: CategoryTheory.cosimplicialSimplicialEquiv_unitIso_hom_app
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: (CategoryTheory.cosimplicialSimplicialEquiv C).unitIso.hom.app X = (Opposite.unop X).opUnopIso.hom.op

full_name: CategoryTheory.cosimplicialSimplicialEquiv_counitIso_inv_app_app
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ),
  ((CategoryTheory.cosimplicialSimplicialEquiv C).counitIso.inv.app X).app X_1 = 𝟙 (X.obj X_1)

full_name: CategoryTheory.cosimplicialSimplicialEquiv
code: /-- The anti-equivalence between cosimplicial objects and simplicial objects. -/
@[simps!]
def cosimplicialSimplicialEquiv : (CosimplicialObject C)ᵒᵖ ≌ SimplicialObject Cᵒᵖ 
goal: (CategoryTheory.CosimplicialObject C)ᵒᵖ ≌ CategoryTheory.SimplicialObject Cᵒᵖ

full_name: CategoryTheory.SimplicialObject.Augmented.rightOp_right_map
code: /-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ 
goal: ∀ {X_1 Y : SimplexCategory} (f : X_1 ⟶ Y), X.rightOp.right.map f = (X.left.map f.op).op

full_name: CategoryTheory.SimplicialObject.Augmented.rightOp_left
code: /-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ 
goal: X.rightOp.left = Opposite.op X.right

full_name: CategoryTheory.SimplicialObject.Augmented.rightOp_hom_app
code: /-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategory), X.rightOp.hom.app X_1 = (X.hom.app (Opposite.op X_1)).op

full_name: CategoryTheory.SimplicialObject.Augmented.rightOp
code: /-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ 
goal: CategoryTheory.CosimplicialObject.Augmented Cᵒᵖ

full_name: CategoryTheory.SimplicialObject.Augmented.rightOp_right_obj
code: /-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ 
goal: ∀ (X_1 : SimplexCategory), X.rightOp.right.obj X_1 = Opposite.op (X.left.obj (Opposite.op X_1))

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOp_left_map
code: /-- Construct an augmented simplicial object from an augmented cosimplicial
object in the opposite category. -/
@[simps!]
def CosimplicialObject.Augmented.leftOp (X : CosimplicialObject.Augmented Cᵒᵖ) :
    SimplicialObject.Augmented C 
goal: ∀ {X_1 Y : SimplexCategoryᵒᵖ} (f : X_1 ⟶ Y), X.leftOp.left.map f = (X.right.map f.unop).unop

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOp_hom_app
code: /-- Construct an augmented simplicial object from an augmented cosimplicial
object in the opposite category. -/
@[simps!]
def CosimplicialObject.Augmented.leftOp (X : CosimplicialObject.Augmented Cᵒᵖ) :
    SimplicialObject.Augmented C 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ), X.leftOp.hom.app X_1 = (X.hom.app (Opposite.unop X_1)).unop

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOp
code: /-- Construct an augmented simplicial object from an augmented cosimplicial
object in the opposite category. -/
@[simps!]
def CosimplicialObject.Augmented.leftOp (X : CosimplicialObject.Augmented Cᵒᵖ) :
    SimplicialObject.Augmented C 
goal: CategoryTheory.SimplicialObject.Augmented C

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOp_right
code: /-- Construct an augmented simplicial object from an augmented cosimplicial
object in the opposite category. -/
@[simps!]
def CosimplicialObject.Augmented.leftOp (X : CosimplicialObject.Augmented Cᵒᵖ) :
    SimplicialObject.Augmented C 
goal: X.leftOp.right = Opposite.unop X.left

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOp_left_obj
code: /-- Construct an augmented simplicial object from an augmented cosimplicial
object in the opposite category. -/
@[simps!]
def CosimplicialObject.Augmented.leftOp (X : CosimplicialObject.Augmented Cᵒᵖ) :
    SimplicialObject.Augmented C 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ), X.leftOp.left.obj X_1 = Opposite.unop (X.right.obj (Opposite.unop X_1))

full_name: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_inv_right
code: /-- Converting an augmented simplicial object to an augmented cosimplicial
object and back is isomorphic to the given object. -/
@[simps!]
def SimplicialObject.Augmented.rightOpLeftOpIso (X : SimplicialObject.Augmented C) :
    X.rightOp.leftOp ≅ X 
goal: X.rightOpLeftOpIso.inv.right = 𝟙 X.right

full_name: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_hom_left_app
code: /-- Converting an augmented simplicial object to an augmented cosimplicial
object and back is isomorphic to the given object. -/
@[simps!]
def SimplicialObject.Augmented.rightOpLeftOpIso (X : SimplicialObject.Augmented C) :
    X.rightOp.leftOp ≅ X 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ), X.rightOpLeftOpIso.hom.left.app X_1 = 𝟙 (X.left.obj X_1)

full_name: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_inv_left_app
code: /-- Converting an augmented simplicial object to an augmented cosimplicial
object and back is isomorphic to the given object. -/
@[simps!]
def SimplicialObject.Augmented.rightOpLeftOpIso (X : SimplicialObject.Augmented C) :
    X.rightOp.leftOp ≅ X 
goal: ∀ (X_1 : SimplexCategoryᵒᵖ), X.rightOpLeftOpIso.inv.left.app X_1 = 𝟙 (X.left.obj X_1)

full_name: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_hom_right
code: /-- Converting an augmented simplicial object to an augmented cosimplicial
object and back is isomorphic to the given object. -/
@[simps!]
def SimplicialObject.Augmented.rightOpLeftOpIso (X : SimplicialObject.Augmented C) :
    X.rightOp.leftOp ≅ X 
goal: X.rightOpLeftOpIso.hom.right = 𝟙 X.right

full_name: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso
code: /-- Converting an augmented simplicial object to an augmented cosimplicial
object and back is isomorphic to the given object. -/
@[simps!]
def SimplicialObject.Augmented.rightOpLeftOpIso (X : SimplicialObject.Augmented C) :
    X.rightOp.leftOp ≅ X 
goal: X.rightOp.leftOp ≅ X

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso
code: /-- Converting an augmented cosimplicial object to an augmented simplicial
object and back is isomorphic to the given object. -/
@[simps!]
def CosimplicialObject.Augmented.leftOpRightOpIso (X : CosimplicialObject.Augmented Cᵒᵖ) :
    X.leftOp.rightOp ≅ X 
goal: X.leftOp.rightOp ≅ X

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_hom_left
code: /-- Converting an augmented cosimplicial object to an augmented simplicial
object and back is isomorphic to the given object. -/
@[simps!]
def CosimplicialObject.Augmented.leftOpRightOpIso (X : CosimplicialObject.Augmented Cᵒᵖ) :
    X.leftOp.rightOp ≅ X 
goal: X.leftOpRightOpIso.hom.left = 𝟙 X.left

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_inv_left
code: /-- Converting an augmented cosimplicial object to an augmented simplicial
object and back is isomorphic to the given object. -/
@[simps!]
def CosimplicialObject.Augmented.leftOpRightOpIso (X : CosimplicialObject.Augmented Cᵒᵖ) :
    X.leftOp.rightOp ≅ X 
goal: X.leftOpRightOpIso.inv.left = 𝟙 X.left

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_hom_right_app
code: /-- Converting an augmented cosimplicial object to an augmented simplicial
object and back is isomorphic to the given object. -/
@[simps!]
def CosimplicialObject.Augmented.leftOpRightOpIso (X : CosimplicialObject.Augmented Cᵒᵖ) :
    X.leftOp.rightOp ≅ X 
goal: ∀ (X_1 : SimplexCategory), X.leftOpRightOpIso.hom.right.app X_1 = 𝟙 (X.right.obj X_1)

full_name: CategoryTheory.CosimplicialObject.Augmented.leftOpRightOpIso_inv_right_app
code: /-- Converting an augmented cosimplicial object to an augmented simplicial
object and back is isomorphic to the given object. -/
@[simps!]
def CosimplicialObject.Augmented.leftOpRightOpIso (X : CosimplicialObject.Augmented Cᵒᵖ) :
    X.leftOp.rightOp ≅ X 
goal: ∀ (X_1 : SimplexCategory), X.leftOpRightOpIso.inv.right.app X_1 = 𝟙 (X.right.obj X_1)

full_name: CategoryTheory.simplicialToCosimplicialAugmented
code: /-- A functorial version of `SimplicialObject.Augmented.rightOp`. -/
@[simps]
def simplicialToCosimplicialAugmented :
    (SimplicialObject.Augmented C)ᵒᵖ ⥤ CosimplicialObject.Augmented Cᵒᵖ 
goal: (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ ⥤ CategoryTheory.CosimplicialObject.Augmented Cᵒᵖ

full_name: CategoryTheory.simplicialToCosimplicialAugmented_obj
code: /-- A functorial version of `SimplicialObject.Augmented.rightOp`. -/
@[simps]
def simplicialToCosimplicialAugmented :
    (SimplicialObject.Augmented C)ᵒᵖ ⥤ CosimplicialObject.Augmented Cᵒᵖ 
goal: (CategoryTheory.simplicialToCosimplicialAugmented C).obj X = (Opposite.unop X).rightOp

full_name: CategoryTheory.simplicialToCosimplicialAugmented_map_right
code: /-- A functorial version of `SimplicialObject.Augmented.rightOp`. -/
@[simps]
def simplicialToCosimplicialAugmented :
    (SimplicialObject.Augmented C)ᵒᵖ ⥤ CosimplicialObject.Augmented Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.simplicialToCosimplicialAugmented C).map f).right = CategoryTheory.NatTrans.rightOp f.unop.left

full_name: CategoryTheory.simplicialToCosimplicialAugmented_map_left
code: /-- A functorial version of `SimplicialObject.Augmented.rightOp`. -/
@[simps]
def simplicialToCosimplicialAugmented :
    (SimplicialObject.Augmented C)ᵒᵖ ⥤ CosimplicialObject.Augmented Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.simplicialToCosimplicialAugmented C).map f).left = f.unop.right.op

full_name: CategoryTheory.cosimplicialToSimplicialAugmented_obj
code: /-- A functorial version of `Cosimplicial_object.Augmented.leftOp`. -/
@[simps]
def cosimplicialToSimplicialAugmented :
    CosimplicialObject.Augmented Cᵒᵖ ⥤ (SimplicialObject.Augmented C)ᵒᵖ 
goal: (CategoryTheory.cosimplicialToSimplicialAugmented C).obj X = Opposite.op X.leftOp

full_name: CategoryTheory.cosimplicialToSimplicialAugmented
code: /-- A functorial version of `Cosimplicial_object.Augmented.leftOp`. -/
@[simps]
def cosimplicialToSimplicialAugmented :
    CosimplicialObject.Augmented Cᵒᵖ ⥤ (SimplicialObject.Augmented C)ᵒᵖ 
goal: CategoryTheory.CosimplicialObject.Augmented Cᵒᵖ ⥤ (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ

full_name: CategoryTheory.cosimplicialToSimplicialAugmented_map
code: /-- A functorial version of `Cosimplicial_object.Augmented.leftOp`. -/
@[simps]
def cosimplicialToSimplicialAugmented :
    CosimplicialObject.Augmented Cᵒᵖ ⥤ (SimplicialObject.Augmented C)ᵒᵖ 
goal: ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented Cᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.cosimplicialToSimplicialAugmented C).map f =
    Quiver.Hom.op { left := CategoryTheory.NatTrans.leftOp f.right, right := f.left.unop, w := ⋯ }

full_name: CategoryTheory.simplicialCosimplicialAugmentedEquiv_functor
code: /-- The contravariant categorical equivalence between augmented simplicial
objects and augmented cosimplicial objects in the opposite category. -/
@[simps! functor inverse]
def simplicialCosimplicialAugmentedEquiv :
    (SimplicialObject.Augmented C)ᵒᵖ ≌ CosimplicialObject.Augmented Cᵒᵖ 
goal: (CategoryTheory.simplicialCosimplicialAugmentedEquiv C).functor = CategoryTheory.simplicialToCosimplicialAugmented C

full_name: CategoryTheory.simplicialCosimplicialAugmentedEquiv_inverse
code: /-- The contravariant categorical equivalence between augmented simplicial
objects and augmented cosimplicial objects in the opposite category. -/
@[simps! functor inverse]
def simplicialCosimplicialAugmentedEquiv :
    (SimplicialObject.Augmented C)ᵒᵖ ≌ CosimplicialObject.Augmented Cᵒᵖ 
goal: (CategoryTheory.simplicialCosimplicialAugmentedEquiv C).inverse = CategoryTheory.cosimplicialToSimplicialAugmented C

full_name: CategoryTheory.simplicialCosimplicialAugmentedEquiv
code: /-- The contravariant categorical equivalence between augmented simplicial
objects and augmented cosimplicial objects in the opposite category. -/
@[simps! functor inverse]
def simplicialCosimplicialAugmentedEquiv :
    (SimplicialObject.Augmented C)ᵒᵖ ≌ CosimplicialObject.Augmented Cᵒᵖ 
goal: (CategoryTheory.SimplicialObject.Augmented C)ᵒᵖ ≌ CategoryTheory.CosimplicialObject.Augmented Cᵒᵖ