ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.SimplicialObject.Augmented.toArrow_obj_right
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C)
Goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).right = CategoryTheory.SimplicialObject.Augmented.point.obj X
-- CategoryTheory.SimplicialObject.Augmented.toArrow_obj_hom
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C)
Goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app (Opposite.op (SimplexCategory.mk 0))
-- CategoryTheory.SimplicialObject.Augmented.toArrow_map_right
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.SimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.SimplicialObject.Augmented.toArrow.map η).right =
    CategoryTheory.SimplicialObject.Augmented.point.map η
-- CategoryTheory.SimplicialObject.Augmented.toArrow_obj_left
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C)
Goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X).left =
  (CategoryTheory.SimplicialObject.Augmented.drop.obj X).obj (Opposite.op (SimplexCategory.mk 0))
-- CategoryTheory.SimplicialObject.Augmented.toArrow_map_left
@[simps]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} 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))
-- CategoryTheory.SimplicialObject.Augmented.w₀
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject.Augmented C} (f : X ⟶ Y)
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
-- CategoryTheory.SimplicialObject.Augmented.whiskering_obj
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} D] (F : C ⥤ D)
Goal: (CategoryTheory.SimplicialObject.Augmented.whiskering C D).obj F =
  CategoryTheory.SimplicialObject.Augmented.whiskeringObj C D F
-- CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_left
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} 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) η
-- CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_right
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} 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)
-- CategoryTheory.SimplicialObject.augment_hom_app
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj (Opposite.op (SimplexCategory.mk 0)) ⟶ X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f) (i : SimplexCategoryᵒᵖ)
Goal: (X.augment X₀ f w).hom.app i = X.map ((SimplexCategory.mk 0).const (Opposite.unop i) 0).op ≫ f
-- CategoryTheory.SimplicialObject.augment_left
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj (Opposite.op (SimplexCategory.mk 0)) ⟶ X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f)
Goal: (X.augment X₀ f w).left = X
-- CategoryTheory.SimplicialObject.augment_right
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj (Opposite.op (SimplexCategory.mk 0)) ⟶ X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f)
Goal: (X.augment X₀ f w).right = X₀
-- CategoryTheory.SimplicialObject.augment_hom_zero
theorem augment_hom_zero (X : SimplicialObject C) (X₀ : C) (f : X _[0] ⟶ X₀) (w) :
    (X.augment X₀ f w).hom.app (op [0]) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) (X₀ : C) (f : X.obj (Opposite.op (SimplexCategory.mk 0)) ⟶ X₀) (w : ∀ (i : SimplexCategory) (g₁ g₂ : SimplexCategory.mk 0 ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f)
Goal: (X.augment X₀ f w).hom.app (Opposite.op (SimplexCategory.mk 0)) = f
-- CategoryTheory.instCategoryCosimplicialObject_id_app
@[simps!]
instance : Category (CosimplicialObject C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (F : SimplexCategory ⥤ C) (X : SimplexCategory)
Goal: (𝟙 F).app X = 𝟙 (F.obj X)
-- CategoryTheory.instCategoryCosimplicialObject_comp_app
@[simps!]
instance : Category (CosimplicialObject C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y Z : SimplexCategory ⥤ C} (α : X ⟶ Y) (β : Y ⟶ Z) (X_1 : SimplexCategory), (α ≫ β).app X_1 = α.app X_1 ≫ β.app X_1
-- CategoryTheory.CosimplicialObject.hom_ext
@[ext]
lemma hom_ext {X Y : CosimplicialObject C} (f g : X ⟶ Y)
    (h : ∀ (n : SimplexCategory), f.app n = g.app n) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.CosimplicialObject C} (f g : X ⟶ Y) (h : ∀ (n : SimplexCategory), f.app n = g.app n)
Goal: f = g
-- CategoryTheory.CosimplicialObject.eqToIso_refl
@[simp]
theorem eqToIso_refl {n : ℕ} (h : n = n) : X.eqToIso h = Iso.refl _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} (h : n = n)
Goal: X.eqToIso h = CategoryTheory.Iso.refl (X.obj (SimplexCategory.mk n))
-- CategoryTheory.CosimplicialObject.δ_comp_δ
@[reassoc]
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    X.δ i ≫ X.δ j.succ = X.δ j ≫ X.δ (Fin.castSucc i) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j)
Goal: X.δ i ≫ X.δ j.succ = X.δ j ≫ X.δ i.castSucc
-- CategoryTheory.CosimplicialObject.δ_comp_δ'
@[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) 
Arguments: {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)
Goal: X.δ i ≫ X.δ j = X.δ (j.pred ⋯) ≫ X.δ i.castSucc
-- CategoryTheory.CosimplicialObject.δ_comp_δ''
@[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 
Arguments: {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)
Goal: X.δ (i.castLT ⋯) ≫ X.δ j.succ = X.δ j ≫ X.δ i
-- CategoryTheory.CosimplicialObject.δ_comp_δ_self
@[reassoc]
theorem δ_comp_δ_self {n} {i : Fin (n + 2)} :
    X.δ i ≫ X.δ (Fin.castSucc i) = X.δ i ≫ X.δ i.succ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i : Fin (n + 2)}
Goal: X.δ i ≫ X.δ i.castSucc = X.δ i ≫ X.δ i.succ
-- CategoryTheory.CosimplicialObject.δ_comp_δ_self'
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = i.castSucc)
Goal: X.δ i ≫ X.δ j = X.δ i ≫ X.δ i.succ
-- CategoryTheory.CosimplicialObject.δ_comp_σ_of_le
@[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 
Arguments: {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)
Goal: X.δ i.castSucc ≫ X.σ j.succ = X.σ j ≫ X.δ i
-- CategoryTheory.CosimplicialObject.δ_comp_σ_self
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} : X.δ (Fin.castSucc i) ≫ X.σ i = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i : Fin (n + 1)}
Goal: X.δ i.castSucc ≫ X.σ i = 𝟙 (X.obj (SimplexCategory.mk n))
-- CategoryTheory.CosimplicialObject.δ_comp_σ_self'
@[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    X.δ j ≫ X.σ i = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = i.castSucc)
Goal: X.δ j ≫ X.σ i = 𝟙 (X.obj (SimplexCategory.mk n))
-- CategoryTheory.CosimplicialObject.δ_comp_σ_succ
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : X.δ i.succ ≫ X.σ i = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i : Fin (n + 1)}
Goal: X.δ i.succ ≫ X.σ i = 𝟙 (X.obj (SimplexCategory.mk n))
-- CategoryTheory.CosimplicialObject.δ_comp_σ_succ'
@[reassoc]
theorem δ_comp_σ_succ' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = i.succ) :
    X.δ j ≫ X.σ i = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = i.succ)
Goal: X.δ j ≫ X.σ i = 𝟙 (X.obj (SimplexCategory.mk n))
-- CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt
@[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 
Arguments: {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)
Goal: X.δ i.succ ≫ X.σ j.castSucc = X.σ j ≫ X.δ i
-- CategoryTheory.CosimplicialObject.δ_comp_σ_of_gt'
@[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) 
Arguments: {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)
Goal: X.δ i ≫ X.σ j = X.σ (j.castLT ⋯) ≫ X.δ (i.pred ⋯)
-- CategoryTheory.CosimplicialObject.σ_comp_σ
@[reassoc]
theorem σ_comp_σ {n} {i j : Fin (n + 1)} (H : i ≤ j) :
    X.σ (Fin.castSucc i) ≫ X.σ j = X.σ j.succ ≫ X.σ i 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j)
Goal: X.σ i.castSucc ≫ X.σ j = X.σ j.succ ≫ X.σ i
-- CategoryTheory.CosimplicialObject.δ_naturality
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X' X : CategoryTheory.CosimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 2))
Goal: X.δ i ≫ f.app (SimplexCategory.mk (n + 1)) = f.app (SimplexCategory.mk n) ≫ X'.δ i
-- CategoryTheory.CosimplicialObject.σ_naturality
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X' X : CategoryTheory.CosimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 1))
Goal: X.σ i ≫ f.app (SimplexCategory.mk n) = f.app (SimplexCategory.mk (n + 1)) ≫ X'.σ i
-- CategoryTheory.CosimplicialObject.whiskering_map_app_app
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} 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)
-- CategoryTheory.CosimplicialObject.whiskering_obj_obj_map
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ D) (F : SimplexCategory ⥤ C)
Goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y),
  (((CategoryTheory.CosimplicialObject.whiskering C D).obj H).obj F).map f = H.map (F.map f)
-- CategoryTheory.CosimplicialObject.whiskering_obj_obj_obj
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ D) (F : SimplexCategory ⥤ C) (X : SimplexCategory)
Goal: (((CategoryTheory.CosimplicialObject.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)
-- CategoryTheory.CosimplicialObject.whiskering_obj_map_app
@[simps!]
def whiskering (D : Type*) [Category D] : (C ⥤ D) ⥤ CosimplicialObject C ⥤ CosimplicialObject D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ 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)
-- CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_map_app
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {n : ℕ} (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ D)
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)
-- CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_obj_map
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {n : ℕ} (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ D) (F : SimplexCategory.Truncated n ⥤ C)
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)
-- CategoryTheory.CosimplicialObject.Truncated.whiskering_map_app_app
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {n : ℕ} (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D]
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)
-- CategoryTheory.CosimplicialObject.Truncated.whiskering_obj_obj_obj
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {n : ℕ} (D : Type u_1) [CategoryTheory.Category.{u_2, u_1} D] (H : C ⥤ D) (F : SimplexCategory.Truncated n ⥤ C) (X : SimplexCategory.Truncated n)
Goal: (((CategoryTheory.CosimplicialObject.Truncated.whiskering C D).obj H).obj F).obj X = H.obj (F.obj X)
-- CategoryTheory.CosimplicialObject.instCategoryAugmented_id_left
@[simps!]
instance : Category (Augmented C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C)))
Goal: (𝟙 X).left = 𝟙 X.left
-- CategoryTheory.CosimplicialObject.instCategoryAugmented_comp_left
@[simps!]
instance : Category (Augmented C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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
-- CategoryTheory.CosimplicialObject.instCategoryAugmented_comp_right_app
@[simps!]
instance : Category (Augmented C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} 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
-- CategoryTheory.CosimplicialObject.instCategoryAugmented_id_right_app
@[simps!]
instance : Category (Augmented C) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C)))
Goal: ∀ (X_1 : SimplexCategory), (𝟙 X).right.app X_1 = 𝟙 (X.right.obj X_1)
-- CategoryTheory.CosimplicialObject.Augmented.hom_ext
@[ext]
lemma hom_ext {X Y : Augmented C} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.CosimplicialObject.Augmented C} (f g : X ⟶ Y) (h₁ : f.left = g.left) (h₂ : f.right = g.right)
Goal: f = g
-- CategoryTheory.CosimplicialObject.Augmented.drop_map
@[simps!]
def drop : Augmented C ⥤ CosimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y), CategoryTheory.CosimplicialObject.Augmented.drop.map f = f.right
-- CategoryTheory.CosimplicialObject.Augmented.drop_obj
@[simps!]
def drop : Augmented C ⥤ CosimplicialObject C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C)))
Goal: CategoryTheory.CosimplicialObject.Augmented.drop.obj X = X.right
-- CategoryTheory.CosimplicialObject.Augmented.point_obj
@[simps!]
def point : Augmented C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C)))
Goal: CategoryTheory.CosimplicialObject.Augmented.point.obj X = X.left
-- CategoryTheory.CosimplicialObject.Augmented.point_map
@[simps!]
def point : Augmented C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Comma (CategoryTheory.CosimplicialObject.const C) (𝟭 (CategoryTheory.CosimplicialObject C))}
  (f : X ⟶ Y), CategoryTheory.CosimplicialObject.Augmented.point.map f = f.left
-- CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C)
Goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).right = X.right.obj (SimplexCategory.mk 0)
-- CategoryTheory.CosimplicialObject.Augmented.toArrow_map_right
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).right = η.right.app (SimplexCategory.mk 0)
-- CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_left
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C)
Goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).left = X.left
-- CategoryTheory.CosimplicialObject.Augmented.toArrow_map_left
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.CosimplicialObject.Augmented C} (η : X ⟶ Y),
  (CategoryTheory.CosimplicialObject.Augmented.toArrow.map η).left = η.left
-- CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_hom
@[simps!]
def toArrow : Augmented C ⥤ Arrow C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C)
Goal: (CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).hom = X.hom.app (SimplexCategory.mk 0)
-- CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_right
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} 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) η
-- CategoryTheory.CosimplicialObject.Augmented.whiskering_obj
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} D] (F : C ⥤ D)
Goal: (CategoryTheory.CosimplicialObject.Augmented.whiskering C D).obj F =
  CategoryTheory.CosimplicialObject.Augmented.whiskeringObj C D F
-- CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_left
@[simps]
def whiskering (D : Type u') [Category.{v'} D] : (C ⥤ D) ⥤ Augmented C ⥤ Augmented D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u') [CategoryTheory.Category.{v', u'} 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)
-- CategoryTheory.CosimplicialObject.augment_right
@[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 
Arguments: {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), f ≫ X.map g₁ = f ≫ X.map g₂)
Goal: (X.augment X₀ f w).right = X