ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.OverPresheafAux.YonedaCollection.mk_fst
@[simp]
lemma mk_fst (s : yoneda.obj X ⟶ A) (x : F.obj (op (CostructuredArrow.mk s))) : (mk s x).fst = s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} (s : CategoryTheory.yoneda.obj X ⟶ A) (x : F.obj (Opposite.op (CategoryTheory.CostructuredArrow.mk s)))
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.mk s x).fst = s
-- CategoryTheory.OverPresheafAux.YonedaCollection.mk_snd
@[simp]
lemma mk_snd (s : yoneda.obj X ⟶ A) (x : F.obj (op (CostructuredArrow.mk s))) :
    (mk s x).snd = F.map (eqToHom <| by rw [YonedaCollection.mk_fst]) x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} (s : CategoryTheory.yoneda.obj X ⟶ A) (x : F.obj (Opposite.op (CategoryTheory.CostructuredArrow.mk s)))
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.mk s x).snd = F.map (CategoryTheory.eqToHom ⋯) x
-- CategoryTheory.OverPresheafAux.YonedaCollection.ext
@[ext]
lemma ext {p q : YonedaCollection F X} (h : p.fst = q.fst)
    (h' : F.map (eqToHom <| by rw [h]) q.snd = p.snd) : p = q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {p q : CategoryTheory.OverPresheafAux.YonedaCollection F X} (h : p.fst = q.fst) (h' : F.map (CategoryTheory.eqToHom ⋯) q.snd = p.snd)
Goal: p = q
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_fst
@[simp]
lemma map₁_fst {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (p : YonedaCollection F X) : (YonedaCollection.map₁ η p).fst = p.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (p : CategoryTheory.OverPresheafAux.YonedaCollection F X)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η p).fst = p.fst
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_yonedaEquivFst
@[simp]
lemma map₁_yonedaEquivFst {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (p : YonedaCollection F X) :
    (YonedaCollection.map₁ η p).yonedaEquivFst = p.yonedaEquivFst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (p : CategoryTheory.OverPresheafAux.YonedaCollection F X)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η p).yonedaEquivFst = p.yonedaEquivFst
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_snd
@[simp]
lemma map₁_snd {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (p : YonedaCollection F X) : (YonedaCollection.map₁ η p).snd =
      G.map (eqToHom (by rw [YonedaCollection.map₁_fst])) (η.app _ p.snd) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (p : CategoryTheory.OverPresheafAux.YonedaCollection F X)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η p).snd =
  G.map (CategoryTheory.eqToHom ⋯) (η.app (Opposite.op (CategoryTheory.CostructuredArrow.mk p.fst)) p.snd)
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₂_fst
@[simp]
lemma map₂_fst {Y : C} (f : X ⟶ Y) (p : YonedaCollection F Y) :
    (YonedaCollection.map₂ F f p).fst = yoneda.map f ≫ p.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X Y : C} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F Y)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f p).fst =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) p.fst
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₂_yonedaEquivFst
@[simp]
lemma map₂_yonedaEquivFst {Y : C} (f : X ⟶ Y) (p : YonedaCollection F Y) :
    (YonedaCollection.map₂ F f p).yonedaEquivFst = A.map f.op p.yonedaEquivFst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X Y : C} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F Y)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f p).yonedaEquivFst = A.map f.op p.yonedaEquivFst
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₂_snd
@[simp]
lemma map₂_snd {Y : C} (f : X ⟶ Y) (p : YonedaCollection F Y) :
    (YonedaCollection.map₂ F f p).snd = F.map ((CostructuredArrow.mkPrecomp p.fst f).op ≫
      eqToHom (by rw [YonedaCollection.map₂_fst f])) p.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X Y : C} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F Y)
Goal: (CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f p).snd =
  F.map
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.CostructuredArrow.mkPrecomp p.fst f).op
      (CategoryTheory.eqToHom ⋯))
    p.snd
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_id
@[simp]
lemma map₁_id : YonedaCollection.map₁ (𝟙 F) (X := X) = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C}
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.map₁ (CategoryTheory.CategoryStruct.id F) = id
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_comp
@[simp]
lemma map₁_comp {G H : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G) (μ : G ⟶ H) :
    YonedaCollection.map₁ (η ≫ μ) (X := X) =
      YonedaCollection.map₁ μ (X := X) ∘ YonedaCollection.map₁ η (X := X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {G H : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (μ : G ⟶ H)
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.map₁ (CategoryTheory.CategoryStruct.comp η μ) =
  CategoryTheory.OverPresheafAux.YonedaCollection.map₁ μ ∘ CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₂_id
@[simp]
lemma map₂_id : YonedaCollection.map₂ F (𝟙 X) = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C}
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F (CategoryTheory.CategoryStruct.id X) = id
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₂_comp
@[simp]
lemma map₂_comp {Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    YonedaCollection.map₂ F (f ≫ g) = YonedaCollection.map₂ F f ∘ YonedaCollection.map₂ F g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f ∘ CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F g
-- CategoryTheory.OverPresheafAux.YonedaCollection.map₁_map₂
@[simp]
lemma map₁_map₂ {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G) {Y : C} (f : X ⟶ Y)
    (p : YonedaCollection F Y) :
    YonedaCollection.map₂ G f (YonedaCollection.map₁ η p) =
      YonedaCollection.map₁ η (YonedaCollection.map₂ F f p) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} {G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) {Y : C} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F Y)
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.map₂ G f (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η p) =
  CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η (CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f p)
-- CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf_obj
@[simps]
def yonedaCollectionPresheaf (A : Cᵒᵖ ⥤ Type v) (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    Cᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (X : Cᵒᵖ)
Goal: (CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A F).obj X =
  CategoryTheory.OverPresheafAux.YonedaCollection F (Opposite.unop X)
-- CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf_map
@[simps]
def yonedaCollectionPresheaf (A : Cᵒᵖ ⥤ Type v) (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    Cᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v))
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F (Opposite.unop X)),
  (CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A F).map f p =
    CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f.unop p
-- CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁_app
@[simps]
def yonedaCollectionPresheafMap₁ {F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G) :
    yonedaCollectionPresheaf A F ⟶ yonedaCollectionPresheaf A G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (X : Cᵒᵖ)
Goal: ∀ (a : CategoryTheory.OverPresheafAux.YonedaCollection F (Opposite.unop X)),
  (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁ η).app X a =
    CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η a
-- CategoryTheory.OverPresheafAux.yonedaCollectionFunctor_obj
@[simps]
def yonedaCollectionFunctor (A : Cᵒᵖ ⥤ Type v) :
    ((CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) ⥤ Cᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v))
Goal: (CategoryTheory.OverPresheafAux.yonedaCollectionFunctor A).obj F =
  CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A F
-- CategoryTheory.OverPresheafAux.yonedaCollectionFunctor_map
@[simps]
def yonedaCollectionFunctor (A : Cᵒᵖ ⥤ Type v) :
    ((CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) ⥤ Cᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : X ⟶ Y),
  (CategoryTheory.OverPresheafAux.yonedaCollectionFunctor A).map η =
    CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁ η
-- CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA_app
@[simps]
def yonedaCollectionPresheafToA (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    yonedaCollectionPresheaf A F ⟶ A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (X : Cᵒᵖ) (p : CategoryTheory.OverPresheafAux.YonedaCollection F (Opposite.unop X))
Goal: (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA F).app X p = p.yonedaEquivFst
-- CategoryTheory.OverPresheafAux.costructuredArrowPresheafToOver_map
@[simps! obj map]
def costructuredArrowPresheafToOver (A : Cᵒᵖ ⥤ Type v) :
    ((CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) ⥤ Over A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (g : X ⟶ Y),
  (CategoryTheory.OverPresheafAux.costructuredArrowPresheafToOver A).map g =
    CategoryTheory.CostructuredArrow.homMk (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁ g) ⋯
-- CategoryTheory.OverPresheafAux.costructuredArrowPresheafToOver_obj
@[simps! obj map]
def costructuredArrowPresheafToOver (A : Cᵒᵖ ⥤ Type v) :
    ((CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) ⥤ Over A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) (Y : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v))
Goal: (CategoryTheory.OverPresheafAux.costructuredArrowPresheafToOver A).obj Y =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA Y)
-- CategoryTheory.OverPresheafAux.unitForward_naturality₁
@[simp]
lemma unitForward_naturality₁ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G)
    (hε : ε ≫ μ = η) (X : C) (p : YonedaCollection (restrictedYonedaObj η) X) :
    unitForward μ X (p.map₁ (restrictedYonedaObjMap₁ ε hε)) = ε.app _ (unitForward η X p) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F G : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G) (hε : CategoryTheory.CategoryStruct.comp ε μ = η) (X : C) (p : CategoryTheory.OverPresheafAux.YonedaCollection (CategoryTheory.OverPresheafAux.restrictedYonedaObj η) X)
Goal: CategoryTheory.OverPresheafAux.unitForward μ X
    (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ (CategoryTheory.OverPresheafAux.restrictedYonedaObjMap₁ ε hε)
      p) =
  ε.app (Opposite.op X) (CategoryTheory.OverPresheafAux.unitForward η X p)
-- CategoryTheory.OverPresheafAux.unitForward_naturality₂
@[simp]
lemma unitForward_naturality₂ {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X Y : C) (f : X ⟶ Y)
    (p : YonedaCollection (restrictedYonedaObj η) Y) :
    unitForward η X (YonedaCollection.map₂ (restrictedYonedaObj η) f p) =
      F.map f.op (unitForward η Y p) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X Y : C) (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection (CategoryTheory.OverPresheafAux.restrictedYonedaObj η) Y)
Goal: CategoryTheory.OverPresheafAux.unitForward η X
    (CategoryTheory.OverPresheafAux.YonedaCollection.map₂ (CategoryTheory.OverPresheafAux.restrictedYonedaObj η) f p) =
  F.map f.op (CategoryTheory.OverPresheafAux.unitForward η Y p)
-- CategoryTheory.OverPresheafAux.app_unitForward
@[simp]
lemma app_unitForward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : Cᵒᵖ)
    (p : YonedaCollection (restrictedYonedaObj η) X.unop) :
    η.app X (unitForward η X.unop p) = p.yonedaEquivFst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : Cᵒᵖ) (p :
  CategoryTheory.OverPresheafAux.YonedaCollection (CategoryTheory.OverPresheafAux.restrictedYonedaObj η)
    (Opposite.unop X))
Goal: η.app X (CategoryTheory.OverPresheafAux.unitForward η (Opposite.unop X) p) = p.yonedaEquivFst
-- CategoryTheory.OverPresheafAux.unitForward_unitBackward
lemma unitForward_unitBackward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) :
    unitForward η X ∘ unitBackward η X = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : C)
Goal: CategoryTheory.OverPresheafAux.unitForward η X ∘ CategoryTheory.OverPresheafAux.unitBackward η X = id
-- CategoryTheory.OverPresheafAux.unitBackward_unitForward
lemma unitBackward_unitForward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) :
    unitBackward η X ∘ unitForward η X = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : C)
Goal: CategoryTheory.OverPresheafAux.unitBackward η X ∘ CategoryTheory.OverPresheafAux.unitForward η X = id
-- CategoryTheory.OverPresheafAux.unitAuxAuxAux_inv
@[simps]
def unitAuxAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) :
    YonedaCollection (restrictedYonedaObj η) X ≅ F.obj (op X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : C)
Goal: ∀ (a : F.obj (Opposite.op X)),
  (CategoryTheory.OverPresheafAux.unitAuxAuxAux η X).inv a = CategoryTheory.OverPresheafAux.unitBackward η X a
-- CategoryTheory.OverPresheafAux.unitAuxAuxAux_hom
@[simps]
def unitAuxAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) :
    YonedaCollection (restrictedYonedaObj η) X ≅ F.obj (op X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : C)
Goal: ∀ (a : CategoryTheory.OverPresheafAux.YonedaCollection (CategoryTheory.OverPresheafAux.restrictedYonedaObj η) X),
  (CategoryTheory.OverPresheafAux.unitAuxAuxAux η X).hom a = CategoryTheory.OverPresheafAux.unitForward η X a
-- CategoryTheory.OverPresheafAux.unitAuxAux_inv_app_fst
@[simps!]
def unitAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) :
    yonedaCollectionPresheaf A (restrictedYonedaObj η) ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : Cᵒᵖ)
Goal: ∀ (a : F.obj X), ((CategoryTheory.OverPresheafAux.unitAuxAux η).inv.app X a).fst = η.app X a
-- CategoryTheory.OverPresheafAux.unitAuxAux_inv_app_snd_coe
@[simps!]
def unitAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) :
    yonedaCollectionPresheaf A (restrictedYonedaObj η) ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : Cᵒᵖ)
Goal: ∀ (a : F.obj X),
  ↑((CategoryTheory.OverPresheafAux.unitAuxAux η).inv.app X a).snd =
    CategoryTheory.OverPresheafAux.OverArrows.val ⟨a, ⋯⟩
-- CategoryTheory.OverPresheafAux.unitAuxAux_hom_app
@[simps!]
def unitAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) :
    yonedaCollectionPresheaf A (restrictedYonedaObj η) ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (X : Cᵒᵖ)
Goal: ∀
  (a :
    (CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A
          (CategoryTheory.OverPresheafAux.restrictedYonedaObj η)).obj
      X),
  (CategoryTheory.OverPresheafAux.unitAuxAux η).hom.app X a =
    CategoryTheory.OverPresheafAux.unitForward η (Opposite.unop X) a
-- CategoryTheory.OverPresheafAux.unitAux_hom
@[simps! hom]
def unitAux (η : Over A) : (restrictedYoneda A ⋙ costructuredArrowPresheafToOver A).obj η ≅ η 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : CategoryTheory.Over A)
Goal: (CategoryTheory.OverPresheafAux.unitAux η).hom =
  { left := (CategoryTheory.OverPresheafAux.unitAuxAux η.hom).hom,
    right := CategoryTheory.CategoryStruct.id { as := PUnit.unit }, w := ⋯ }
-- CategoryTheory.OverPresheafAux.OverArrows.yonedaCollectionPresheafToA_val_fst
@[simp]
lemma OverArrows.yonedaCollectionPresheafToA_val_fst (s : yoneda.obj X ⟶ A)
    (p : OverArrows (yonedaCollectionPresheafToA F) s) : p.val.fst = s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C} (s : CategoryTheory.yoneda.obj X ⟶ A) (p : CategoryTheory.OverPresheafAux.OverArrows (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafToA F) s)
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.fst p.val = s
-- CategoryTheory.OverPresheafAux.counitForward_val_fst
lemma counitForward_val_fst (s : CostructuredArrow yoneda A) (x : F.obj (op s)) :
    (counitForward F s x).val.fst = s.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) (x : F.obj (Opposite.op s))
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.fst (CategoryTheory.OverPresheafAux.counitForward F s x).val = s.hom
-- CategoryTheory.OverPresheafAux.counitForward_val_snd
@[simp]
lemma counitForward_val_snd (s : CostructuredArrow yoneda A) (x : F.obj (op s)) :
    (counitForward F s x).val.snd = F.map (eqToHom (by simp [← CostructuredArrow.eq_mk])) x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A) (x : F.obj (Opposite.op s))
Goal: CategoryTheory.OverPresheafAux.YonedaCollection.snd (CategoryTheory.OverPresheafAux.counitForward F s x).val =
  F.map (CategoryTheory.eqToHom ⋯) x
-- CategoryTheory.OverPresheafAux.counitForward_naturality₁
@[simp]
lemma counitForward_naturality₁ {G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} (η : F ⟶ G)
    (s : (CostructuredArrow yoneda A)ᵒᵖ) (x : F.obj s) : counitForward G s.unop (η.app s x) =
      OverArrows.map₁ (counitForward F s.unop x) (yonedaCollectionPresheafMap₁ η) (by aesop_cat) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G) (s : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ) (x : F.obj s)
Goal: CategoryTheory.OverPresheafAux.counitForward G (Opposite.unop s) (η.app s x) =
  (CategoryTheory.OverPresheafAux.counitForward F (Opposite.unop s) x).map₁
    (CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁ η) ⋯
-- CategoryTheory.OverPresheafAux.counitForward_naturality₂
@[simp]
lemma counitForward_naturality₂ (s t : (CostructuredArrow yoneda A)ᵒᵖ) (f : t ⟶ s) (x : F.obj t) :
    counitForward F s.unop (F.map f x) =
      OverArrows.map₂ (counitForward F t.unop x) f.unop.left (by simp) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (s t : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ) (f : t ⟶ s) (x : F.obj t)
Goal: CategoryTheory.OverPresheafAux.counitForward F (Opposite.unop s) (F.map f x) =
  (CategoryTheory.OverPresheafAux.counitForward F (Opposite.unop t) x).map₂ f.unop.left ⋯
-- CategoryTheory.OverPresheafAux.counitForward_counitBackward
lemma counitForward_counitBackward (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v)
    (s : CostructuredArrow yoneda A) : counitForward F s ∘ counitBackward F s = id 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} (F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)) (s : CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)
Goal: CategoryTheory.OverPresheafAux.counitForward F s ∘ CategoryTheory.OverPresheafAux.counitBackward F s = id