ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.conjugateEquiv_counit
theorem conjugateEquiv_counit (α : L₂ ⟶ L₁) (d : D) :
    L₂.map ((conjugateEquiv adj₁ adj₂ α).app _) ≫ adj₂.counit.app d =
      α.app _ ≫ adj₁.counit.app d 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : L₂ ⟶ L₁) (d : D)
Goal: CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.conjugateEquiv adj₁ adj₂) α).app d)) (adj₂.counit.app d) =
  CategoryTheory.CategoryStruct.comp (α.app (R₁.obj d)) (adj₁.counit.app d)
-- CategoryTheory.conjugateEquiv_counit_symm
theorem conjugateEquiv_counit_symm (α : R₁ ⟶ R₂) (d : D) :
    L₂.map (α.app _) ≫ adj₂.counit.app d =
      ((conjugateEquiv adj₁ adj₂).symm α).app _ ≫ adj₁.counit.app d 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : R₁ ⟶ R₂) (d : D)
Goal: CategoryTheory.CategoryStruct.comp (L₂.map (α.app d)) (adj₂.counit.app d) =
  CategoryTheory.CategoryStruct.comp (((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α).app (R₁.obj d))
    (adj₁.counit.app d)
-- CategoryTheory.unit_conjugateEquiv
theorem unit_conjugateEquiv (α : L₂ ⟶ L₁) (c : C) :
    adj₁.unit.app _ ≫ (conjugateEquiv adj₁ adj₂ α).app _ =
      adj₂.unit.app c ≫ R₂.map (α.app _) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : L₂ ⟶ L₁) (c : C)
Goal: CategoryTheory.CategoryStruct.comp (adj₁.unit.app c) (((CategoryTheory.conjugateEquiv adj₁ adj₂) α).app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app c) (R₂.map (α.app c))
-- CategoryTheory.unit_conjugateEquiv_symm
theorem unit_conjugateEquiv_symm (α : R₁ ⟶ R₂) (c : C) :
    adj₁.unit.app _ ≫ α.app _ =
      adj₂.unit.app c ≫ R₂.map (((conjugateEquiv adj₁ adj₂).symm α).app _) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : R₁ ⟶ R₂) (c : C)
Goal: CategoryTheory.CategoryStruct.comp (adj₁.unit.app c) (α.app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app c)
    (R₂.map (((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α).app c))
-- CategoryTheory.conjugateEquiv_id
@[simp]
theorem conjugateEquiv_id : conjugateEquiv adj₁ adj₁ (𝟙 _) = 𝟙 _ 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁)
Goal: (CategoryTheory.conjugateEquiv adj₁ adj₁) (CategoryTheory.CategoryStruct.id L₁) = CategoryTheory.CategoryStruct.id R₁
-- CategoryTheory.conjugateEquiv_symm_id
@[simp]
theorem conjugateEquiv_symm_id : (conjugateEquiv adj₁ adj₁).symm (𝟙 _) = 𝟙 _ 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ : CategoryTheory.Functor C D} {R₁ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁)
Goal: (CategoryTheory.conjugateEquiv adj₁ adj₁).symm (CategoryTheory.CategoryStruct.id R₁) =
  CategoryTheory.CategoryStruct.id L₁
-- CategoryTheory.conjugateEquiv_adjunction_id
theorem conjugateEquiv_adjunction_id {L R : C ⥤ C} (adj : L ⊣ R) (α : 𝟭 C ⟶ L) (c : C) :
    (conjugateEquiv adj Adjunction.id α).app c = α.app (R.obj c) ≫ adj.counit.app c 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {L R : CategoryTheory.Functor C C} (adj : L ⊣ R) (α : CategoryTheory.Functor.id C ⟶ L) (c : C)
Goal: ((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id) α).app c =
  CategoryTheory.CategoryStruct.comp (α.app (R.obj c)) (adj.counit.app c)
-- CategoryTheory.conjugateEquiv_adjunction_id_symm
theorem conjugateEquiv_adjunction_id_symm {L R : C ⥤ C} (adj : L ⊣ R) (α : R ⟶ 𝟭 C) (c : C) :
    ((conjugateEquiv adj Adjunction.id).symm α).app c = adj.unit.app c ≫ α.app (L.obj c) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {L R : CategoryTheory.Functor C C} (adj : L ⊣ R) (α : R ⟶ CategoryTheory.Functor.id C) (c : C)
Goal: ((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id).symm α).app c =
  CategoryTheory.CategoryStruct.comp (adj.unit.app c) (α.app (L.obj c))
-- CategoryTheory.conjugateEquiv_comp
theorem conjugateEquiv_comp (α : L₂ ⟶ L₁) (β : L₃ ⟶ L₂) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₃ β =
      conjugateEquiv adj₁ adj₃ (β ≫ α) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ L₃ : CategoryTheory.Functor C D} {R₁ R₂ R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : L₂ ⟶ L₁) (β : L₃ ⟶ L₂)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₃) β) =
  (CategoryTheory.conjugateEquiv adj₁ adj₃) (CategoryTheory.CategoryStruct.comp β α)
-- CategoryTheory.conjugateEquiv_symm_comp
theorem conjugateEquiv_symm_comp (α : R₁ ⟶ R₂) (β : R₂ ⟶ R₃) :
    (conjugateEquiv adj₂ adj₃).symm β ≫ (conjugateEquiv adj₁ adj₂).symm α =
      (conjugateEquiv adj₁ adj₃).symm (α ≫ β) 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ L₃ : CategoryTheory.Functor C D} {R₁ R₂ R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : R₁ ⟶ R₂) (β : R₂ ⟶ R₃)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₂ adj₃).symm β)
    ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α) =
  (CategoryTheory.conjugateEquiv adj₁ adj₃).symm (CategoryTheory.CategoryStruct.comp α β)
-- CategoryTheory.conjugateEquiv_comm
theorem conjugateEquiv_comm {α : L₂ ⟶ L₁} {β : L₁ ⟶ L₂} (βα : β ≫ α = 𝟙 _) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₁ β = 𝟙 _ 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) {α : L₂ ⟶ L₁} {β : L₁ ⟶ L₂} (βα : CategoryTheory.CategoryStruct.comp β α = CategoryTheory.CategoryStruct.id L₁)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₁) β) =
  CategoryTheory.CategoryStruct.id R₁
-- CategoryTheory.conjugateEquiv_symm_comm
theorem conjugateEquiv_symm_comm {α : R₁ ⟶ R₂}{β : R₂ ⟶ R₁} (αβ : α ≫ β = 𝟙 _) :
    (conjugateEquiv adj₂ adj₁).symm β ≫ (conjugateEquiv adj₁ adj₂).symm α = 𝟙 _ 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) {α : R₁ ⟶ R₂} {β : R₂ ⟶ R₁} (αβ : CategoryTheory.CategoryStruct.comp α β = CategoryTheory.CategoryStruct.id R₁)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₂ adj₁).symm β)
    ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α) =
  CategoryTheory.CategoryStruct.id L₁
-- CategoryTheory.conjugateEquiv_of_iso
theorem conjugateEquiv_of_iso (α : L₂ ⟶ L₁) [IsIso (conjugateEquiv adj₁ adj₂ α)] :
    IsIso α 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : L₂ ⟶ L₁) [CategoryTheory.IsIso ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)]
Goal: CategoryTheory.IsIso α
-- CategoryTheory.conjugateEquiv_symm_of_iso
theorem conjugateEquiv_symm_of_iso (α : R₁ ⟶ R₂)
    [IsIso ((conjugateEquiv adj₁ adj₂).symm α)] : IsIso α 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L₁ L₂ : CategoryTheory.Functor C D} {R₁ R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (α : R₁ ⟶ R₂) [CategoryTheory.IsIso ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α)]
Goal: CategoryTheory.IsIso α
-- CategoryTheory.iterated_mateEquiv_conjugateEquiv
theorem iterated_mateEquiv_conjugateEquiv (α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂) :
    mateEquiv adj₄ adj₃ (mateEquiv adj₁ adj₂ α) =
      conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂) α 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] {F₁ : CategoryTheory.Functor A C} {U₁ : CategoryTheory.Functor C A} {F₂ : CategoryTheory.Functor B D} {U₂ : CategoryTheory.Functor D B} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor C D} {R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : F₁ ⊣ U₁) (adj₄ : F₂ ⊣ U₂) (α : F₁.comp L₂ ⟶ L₁.comp F₂)
Goal: (CategoryTheory.mateEquiv adj₄ adj₃) ((CategoryTheory.mateEquiv adj₁ adj₂) α) =
  (CategoryTheory.conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)) α
-- CategoryTheory.iterated_mateEquiv_conjugateEquiv_symm
theorem iterated_mateEquiv_conjugateEquiv_symm (α : U₂ ⋙ R₁ ⟶ R₂ ⋙ U₁) :
    (mateEquiv adj₁ adj₂).symm ((mateEquiv adj₄ adj₃).symm α) =
      (conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] {F₁ : CategoryTheory.Functor A C} {U₁ : CategoryTheory.Functor C A} {F₂ : CategoryTheory.Functor B D} {U₂ : CategoryTheory.Functor D B} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor C D} {R₂ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : F₁ ⊣ U₁) (adj₄ : F₂ ⊣ U₂) (α : U₂.comp R₁ ⟶ R₂.comp U₁)
Goal: (CategoryTheory.mateEquiv adj₁ adj₂).symm ((CategoryTheory.mateEquiv adj₄ adj₃).symm α) =
  (CategoryTheory.conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α
-- CategoryTheory.mateEquiv_conjugateEquiv_vcomp
theorem mateEquiv_conjugateEquiv_vcomp
    (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (β : L₃ ⟶ L₂) :
    (mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β) =
      rightAdjointSquareConjugate.vcomp (mateEquiv adj₁ adj₂ α) (conjugateEquiv adj₂ adj₃ β) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor C D} {R₂ : CategoryTheory.Functor D C} {L₃ : CategoryTheory.Functor C D} {R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : G.comp L₂ ⟶ L₁.comp H) (β : L₃ ⟶ L₂)
Goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointSquareConjugate.vcomp α β) =
  CategoryTheory.rightAdjointSquareConjugate.vcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₃) β)
-- CategoryTheory.conjugateEquiv_mateEquiv_vcomp
theorem conjugateEquiv_mateEquiv_vcomp
    (α : L₂ ⟶ L₁) (β : G ⋙ L₃ ⟶ L₂ ⋙ H) :
    (mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β) =
      rightAdjointConjugateSquare.vcomp (conjugateEquiv adj₁ adj₂ α) (mateEquiv adj₂ adj₃ β) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] [CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D} {L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor A B} {R₂ : CategoryTheory.Functor B A} {L₃ : CategoryTheory.Functor C D} {R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : L₂ ⟶ L₁) (β : G.comp L₃ ⟶ L₂.comp H)
Goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointConjugateSquare.vcomp α β) =
  CategoryTheory.rightAdjointConjugateSquare.vcomp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₂ adj₃) β)
-- CategoryTheory.OverPresheafAux.MakesOverArrow.app
structure MakesOverArrow {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) {X : C} (s : yoneda.obj X ⟶ A)
    (u : F.obj (op X)) : Prop where
  app : η.app (op X) u = yonedaEquiv s
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {u : F.obj (Opposite.op X)} (self : CategoryTheory.OverPresheafAux.MakesOverArrow η s u)
Goal: η.app (Opposite.op X) u = CategoryTheory.yonedaEquiv s
-- CategoryTheory.OverPresheafAux.MakesOverArrow.map₁
lemma map₁ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} {ε : F ⟶ G}
    (hε : ε ≫ μ = η) {X : C} {s : yoneda.obj X ⟶ A} {u : F.obj (op X)}
    (h : MakesOverArrow η s u) : MakesOverArrow μ s (ε.app _ u) 
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} {s : CategoryTheory.yoneda.obj X ⟶ A} {u : F.obj (Opposite.op X)} (h : CategoryTheory.OverPresheafAux.MakesOverArrow η s u)
Goal: CategoryTheory.OverPresheafAux.MakesOverArrow μ s (ε.app (Opposite.op X) u)
-- CategoryTheory.OverPresheafAux.MakesOverArrow.map₂
lemma map₂ {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y)
    {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (hst : yoneda.map f ≫ t = s)
    {u : F.obj (op Y)} (h : MakesOverArrow η t u) : MakesOverArrow η s (F.map f.op u) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y) {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A} (hst : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) t = s) {u : F.obj (Opposite.op Y)} (h : CategoryTheory.OverPresheafAux.MakesOverArrow η t u)
Goal: CategoryTheory.OverPresheafAux.MakesOverArrow η s (F.map f.op u)
-- CategoryTheory.OverPresheafAux.MakesOverArrow.of_arrow
lemma of_arrow {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    {f : yoneda.obj X ⟶ F} (hf : f ≫ η = s) : MakesOverArrow η s (yonedaEquiv f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : CategoryTheory.yoneda.obj X ⟶ F} (hf : CategoryTheory.CategoryStruct.comp f η = s)
Goal: CategoryTheory.OverPresheafAux.MakesOverArrow η s (CategoryTheory.yonedaEquiv f)
-- CategoryTheory.OverPresheafAux.MakesOverArrow.of_yoneda_arrow
lemma of_yoneda_arrow {Y : C} {η : yoneda.obj Y ⟶ A} {X : C} {s : yoneda.obj X ⟶ A} {f : X ⟶ Y}
    (hf : yoneda.map f ≫ η = s) : MakesOverArrow η s f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C} {η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : X ⟶ Y} (hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) η = s)
Goal: CategoryTheory.OverPresheafAux.MakesOverArrow η s f
-- CategoryTheory.OverPresheafAux.OverArrows.val_mk
@[simp]
lemma val_mk {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) {X : C} (s : yoneda.obj X ⟶ A) (u : F.obj (op X))
    (h : MakesOverArrow η s u) : val ⟨u, h⟩ = u 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) {X : C} (s : CategoryTheory.yoneda.obj X ⟶ A) (u : F.obj (Opposite.op X)) (h : CategoryTheory.OverPresheafAux.MakesOverArrow η s u)
Goal: CategoryTheory.OverPresheafAux.OverArrows.val ⟨u, h⟩ = u
-- CategoryTheory.OverPresheafAux.OverArrows.ext
@[ext]
lemma ext {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    {u v : OverArrows η s} : u.val = v.val → u = v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {u v : CategoryTheory.OverPresheafAux.OverArrows η s}
Goal: u.val = v.val → u = v
-- CategoryTheory.OverPresheafAux.OverArrows.app_val
lemma app_val {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    (p : OverArrows η s) : η.app (op X) p.val = yonedaEquiv s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} (p : CategoryTheory.OverPresheafAux.OverArrows η s)
Goal: η.app (Opposite.op X) p.val = CategoryTheory.yonedaEquiv s
-- CategoryTheory.OverPresheafAux.OverArrows.map_val
@[simp]
lemma map_val {Y : C} {η : yoneda.obj Y ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    (p : OverArrows η s) : yoneda.map p.val ≫ η = s 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C} {η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} (p : CategoryTheory.OverPresheafAux.OverArrows η s)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map p.val) η = s
-- CategoryTheory.OverPresheafAux.OverArrows.map₁_val
@[simp]
lemma map₁_val {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} {X : C}
    (s : yoneda.obj X ⟶ A) (u : OverArrows η s) (ε : F ⟶ G) (hε : ε ≫ μ = η) :
    (u.map₁ ε hε).val = ε.app _ u.val 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F G : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {μ : G ⟶ A} {X : C} (s : CategoryTheory.yoneda.obj X ⟶ A) (u : CategoryTheory.OverPresheafAux.OverArrows η s) (ε : F ⟶ G) (hε : CategoryTheory.CategoryStruct.comp ε μ = η)
Goal: (u.map₁ ε hε).val = ε.app (Opposite.op X) u.val
-- CategoryTheory.OverPresheafAux.OverArrows.map₂_val
@[simp]
lemma map₂_val {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y)
    {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (hst : yoneda.map f ≫ t = s)
    (u : OverArrows η t) : (u.map₂ f hst).val = F.map f.op u.val 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y) {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A} (hst : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) t = s) (u : CategoryTheory.OverPresheafAux.OverArrows η t)
Goal: (u.map₂ f hst).val = F.map f.op u.val
-- CategoryTheory.OverPresheafAux.OverArrows.map₁_map₂
@[simp]
lemma map₁_map₂ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G)
    (hε : ε ≫ μ = η) {X Y : C} {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (f : X ⟶ Y)
    (hf : yoneda.map f ≫ t = s) (u : OverArrows η t) :
    (u.map₁ ε hε).map₂ f hf = (u.map₂ f hf).map₁ ε hε 
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 Y : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A} (f : X ⟶ Y) (hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) t = s) (u : CategoryTheory.OverPresheafAux.OverArrows η t)
Goal: (u.map₁ ε hε).map₂ f hf = (u.map₂ f hf).map₁ ε hε
-- CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow_val
@[simp]
lemma yonedaArrow_val {Y : C} {η : yoneda.obj Y ⟶ A} {X : C} {s : yoneda.obj X ⟶ A} {f : X ⟶ Y}
    (hf : yoneda.map f ≫ η = s) : (yonedaArrow f hf).val = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C} {η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : X ⟶ Y} (hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) η = s)
Goal: (CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow f hf).val = f
-- CategoryTheory.OverPresheafAux.restrictedYonedaObj_obj
@[simps]
def restrictedYonedaObj {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) :
    (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A) (s : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ)
Goal: (CategoryTheory.OverPresheafAux.restrictedYonedaObj η).obj s =
  CategoryTheory.OverPresheafAux.OverArrows η (Opposite.unop s).hom
-- CategoryTheory.OverPresheafAux.restrictedYonedaObj_map
@[simps]
def restrictedYonedaObj {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) :
    (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} (η : F ⟶ A)
Goal: ∀ {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ} (f : X ⟶ Y)
  (u : CategoryTheory.OverPresheafAux.OverArrows η (Opposite.unop X).hom),
  (CategoryTheory.OverPresheafAux.restrictedYonedaObj η).map f u = u.map₂ f.unop.left ⋯
-- CategoryTheory.OverPresheafAux.restrictedYonedaObjMap₁_app
@[simps]
def restrictedYonedaObjMap₁ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G)
    (hε : ε ≫ μ = η) : restrictedYonedaObj η ⟶ restrictedYonedaObj μ 
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 ε μ = η) (s : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ) (u : (CategoryTheory.OverPresheafAux.restrictedYonedaObj η).obj s)
Goal: (CategoryTheory.OverPresheafAux.restrictedYonedaObjMap₁ ε hε).app s u =
  CategoryTheory.OverPresheafAux.OverArrows.map₁ u ε hε
-- CategoryTheory.OverPresheafAux.restrictedYoneda_obj
@[simps]
def restrictedYoneda (A : Cᵒᵖ ⥤ Type v) : Over A ⥤ (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v)) (η : CategoryTheory.Over A)
Goal: (CategoryTheory.OverPresheafAux.restrictedYoneda A).obj η = CategoryTheory.OverPresheafAux.restrictedYonedaObj η.hom
-- CategoryTheory.OverPresheafAux.restrictedYoneda_map
@[simps]
def restrictedYoneda (A : Cᵒᵖ ⥤ Type v) : Over A ⥤ (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
  (CategoryTheory.OverPresheafAux.restrictedYoneda A).map ε =
    CategoryTheory.OverPresheafAux.restrictedYonedaObjMap₁ ε.left ⋯
-- CategoryTheory.OverPresheafAux.map_mkPrecomp_eqToHom
lemma map_mkPrecomp_eqToHom {F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} {X Y : C} {f : X ⟶ Y}
    {g g' : yoneda.obj Y ⟶ A} (h : g = g') {x : F.obj (op (CostructuredArrow.mk g'))} :
    F.map (CostructuredArrow.mkPrecomp g f).op (F.map (eqToHom (by rw [h])) x) =
      F.map (eqToHom (by rw [h])) (F.map (CostructuredArrow.mkPrecomp g' f).op 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 Y : C} {f : X ⟶ Y} {g g' : CategoryTheory.yoneda.obj Y ⟶ A} (h : g = g') {x : F.obj (Opposite.op (CategoryTheory.CostructuredArrow.mk g'))}
Goal: F.map (CategoryTheory.CostructuredArrow.mkPrecomp g f).op (F.map (CategoryTheory.eqToHom ⋯) x) =
  F.map (CategoryTheory.eqToHom ⋯) (F.map (CategoryTheory.CostructuredArrow.mkPrecomp g' f).op x)
-- CategoryTheory.OverPresheafAux.YonedaCollection.yonedaEquivFst_eq
lemma yonedaEquivFst_eq (p : YonedaCollection F X) : p.yonedaEquivFst = yonedaEquiv 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} (p : CategoryTheory.OverPresheafAux.YonedaCollection F X)
Goal: p.yonedaEquivFst = CategoryTheory.yonedaEquiv p.fst