The Yoneda embedding

Let C : Type u₁ be a category (with Category.{v₁} C). We define the Yoneda embedding as a fully faithful functor yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁, In addition to yoneda, we also define uliftYoneda : C ⥤ Cᵒᵖ ⥤ Type (max w v₁) with the additional universe parameter w. When C is locally w-small, one may also use shrinkYoneda.{w} : C ⥤ Cᵒᵖ ⥤ Type w from the file Mathlib/CategoryTheory/ShrinkYoneda.lean.

The naturality of the bijection yonedaEquiv involved in the Yoneda lemma is also expressed as a natural isomorphism yonedaLemma : yonedaPairing C ≅ yonedaEvaluation C.

References

• Stacks: Opposite Categories and the Yoneda Lemma

def CategoryTheory.yoneda {C : Type u₁} [Category.{v₁, u₁} C] : Functor C (Functor Cᵒᵖ (Type v₁))

The Yoneda embedding, as a functor from C into presheaves on C.

@[simp]

theorem CategoryTheory.yoneda_obj_map {C : Type u₁} [Category.{v₁, u₁} C] (X : C) {X✝ Y✝ : Cᵒᵖ} (f : X✝ ⟶ Y✝) (g : Opposite.unop X✝ ⟶ X) : (yoneda.obj X).map f g = CategoryStruct.comp f.unop g

@[simp]

theorem CategoryTheory.yoneda_obj_obj {C : Type u₁} [Category.{v₁, u₁} C] (X : C) (Y : Cᵒᵖ) : (yoneda.obj X).obj Y = (Opposite.unop Y ⟶ X)

@[simp]

theorem CategoryTheory.yoneda_map_app {C : Type u₁} [Category.{v₁, u₁} C] {X✝ Y✝ : C} (f : X✝ ⟶ Y✝) (x✝ : Cᵒᵖ) (g : { obj := fun (Y : Cᵒᵖ) => Opposite.unop Y ⟶ X✝, map := fun {X Y : Cᵒᵖ} (f : X ⟶ Y) (g : Opposite.unop X ⟶ X✝) => CategoryStruct.comp f.unop g, map_id := ⋯, map_comp := ⋯ }.obj x✝) : (yoneda.map f).app x✝ g = CategoryStruct.comp g f

def CategoryTheory.uliftYoneda {C : Type u₁} [Category.{v₁, u₁} C] : Functor C (Functor Cᵒᵖ (Type (max w v₁)))

Variant of the Yoneda embedding which allows a raise in the universe level for the category of types.

@[simp]

theorem CategoryTheory.uliftYoneda_obj_obj {C : Type u₁} [Category.{v₁, u₁} C] (X : C) (X✝ : Cᵒᵖ) : (uliftYoneda.{w, v₁, u₁}.obj X).obj X✝ = ULift.{w, v₁} (Opposite.unop X✝ ⟶ X)

@[simp]

theorem CategoryTheory.uliftYoneda_map_app {C : Type u₁} [Category.{v₁, u₁} C] {X✝ Y✝ : C} (f : X✝ ⟶ Y✝) (X : Cᵒᵖ) (a✝ : uliftFunctor.{w, v₁}.obj ((yoneda.obj X✝).obj X)) : (uliftYoneda.{w, v₁, u₁}.map f).app X a✝ = { down := CategoryStruct.comp a✝.down f }

@[simp]

theorem CategoryTheory.uliftYoneda_obj_map {C : Type u₁} [Category.{v₁, u₁} C] (X : C) {X✝ Y✝ : Cᵒᵖ} (f : X✝ ⟶ Y✝) (a✝ : uliftFunctor.{w, v₁}.obj ((yoneda.obj X).obj X✝)) : (uliftYoneda.{w, v₁, u₁}.obj X).map f a✝ = { down := CategoryStruct.comp f.unop a✝.down }

@[deprecated CategoryTheory.uliftYoneda_obj_map (since := "2026-02-13")]

theorem CategoryTheory.uliftYoneda_obj_map_down {C : Type u₁} [Category.{v₁, u₁} C] (X : C) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) (a : (uliftYoneda.{w, v₁, u₁}.obj X).obj Y) : ((uliftYoneda.{w, v₁, u₁}.obj X).map f a).down = CategoryStruct.comp f.unop a.down

@[deprecated CategoryTheory.uliftYoneda_map_app (since := "2026-02-13")]

theorem CategoryTheory.uliftYoneda_map_app_down {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (Z : Cᵒᵖ) (a : (uliftYoneda.{w, v₁, u₁}.obj X).obj Z) : ((uliftYoneda.{w, v₁, u₁}.map f).app Z a).down = CategoryStruct.comp a.down f

def CategoryTheory.uliftYonedaIsoYoneda {C : Type u₁} [Category.{max w v₁, u₁} C] : uliftYoneda.{w, max v₁ w, u₁} ≅ yoneda

If C is a category with [Category.{max w v₁} C], this is the isomorphism uliftYoneda.{w} (C := C) ≅ yoneda.

@[simp]

theorem CategoryTheory.uliftYonedaIsoYoneda_inv_app_app_down {C : Type u₁} [Category.{max w v₁, u₁} C] (X : C) (X✝ : Cᵒᵖ) (a✝ : (yoneda.obj X).obj X✝) : ((uliftYonedaIsoYoneda.inv.app X).app X✝ a✝).down = a✝

@[simp]

theorem CategoryTheory.uliftYonedaIsoYoneda_hom_app_app {C : Type u₁} [Category.{max w v₁, u₁} C] (X : C) (X✝ : Cᵒᵖ) (a✝ : (uliftYoneda.{w, max v₁ w, u₁}.obj X).obj X✝) : (uliftYonedaIsoYoneda.hom.app X).app X✝ a✝ = a✝.down

@[reducible, inline]

abbrev CategoryTheory.coyoneda {C : Type u₁} [Category.{v₁, u₁} C] : Functor Cᵒᵖ (Functor C (Type v₁))

The co-Yoneda embedding, as a functor from Cᵒᵖ into co-presheaves on C.

@[reducible, inline]

abbrev CategoryTheory.uliftCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] : Functor Cᵒᵖ (Functor C (Type (max w v₁)))

Variant of the Coyoneda embedding which allows a raise in the universe level for the category of types.

def CategoryTheory.uliftCoyonedaIsoCoyoneda {C : Type u₁} [Category.{max w v₁, u₁} C] : uliftCoyoneda.{w, max v₁ w, u₁} ≅ coyoneda

If C is a category with [Category.{max w v₁} C], this is the isomorphism uliftCoyoneda.{w} (C := C) ≅ coyoneda.

@[simp]

theorem CategoryTheory.uliftCoyonedaIsoCoyoneda_hom_app_app {C : Type u₁} [Category.{max w v₁, u₁} C] (X : Cᵒᵖ) (X✝ : C) (a✝ : (uliftCoyoneda.{w, max v₁ w, u₁}.obj X).obj X✝) : (uliftCoyonedaIsoCoyoneda.hom.app X).app X✝ a✝ = a✝.down

@[simp]

theorem CategoryTheory.uliftCoyonedaIsoCoyoneda_inv_app_app_down {C : Type u₁} [Category.{max w v₁, u₁} C] (X : Cᵒᵖ) (X✝ : C) (a✝ : (coyoneda.obj X).obj X✝) : ((uliftCoyonedaIsoCoyoneda.inv.app X).app X✝ a✝).down = a✝

theorem CategoryTheory.Yoneda.obj_map_id {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : Opposite.op X ⟶ Opposite.op Y) : (yoneda.obj X).map f (CategoryStruct.id X) = (yoneda.map f.unop).app (Opposite.op Y) (CategoryStruct.id Y)

@[simp]

theorem CategoryTheory.Yoneda.naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (α : yoneda.obj X ⟶ yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z') (h : Z' ⟶ X) : CategoryStruct.comp f (α.app (Opposite.op Z') h) = α.app (Opposite.op Z) (CategoryStruct.comp f h)

def CategoryTheory.Yoneda.fullyFaithful {C : Type u₁} [Category.{v₁, u₁} C] : yoneda.FullyFaithful

The Yoneda embedding is fully faithful.

theorem CategoryTheory.Yoneda.fullyFaithful_preimage {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : yoneda.obj X ⟶ yoneda.obj Y) : fullyFaithful.preimage f = f.app (Opposite.op X) (CategoryStruct.id X)

instance CategoryTheory.Yoneda.yoneda_full {C : Type u₁} [Category.{v₁, u₁} C] : yoneda.Full

The Yoneda embedding is full.

instance CategoryTheory.Yoneda.yoneda_faithful {C : Type u₁} [Category.{v₁, u₁} C] : yoneda.Faithful

The Yoneda embedding is faithful.

def CategoryTheory.Yoneda.ext {C : Type u₁} [Category.{v₁, u₁} C] (X Y : C) (p : {Z : C} → (Z ⟶ X) → (Z ⟶ Y)) (q : {Z : C} → (Z ⟶ Y) → (Z ⟶ X)) (h₁ : ∀ {Z : C} (f : Z ⟶ X), q (p f) = f) (h₂ : ∀ {Z : C} (f : Z ⟶ Y), p (q f) = f) (n : ∀ {Z Z' : C} (f : Z' ⟶ Z) (g : Z ⟶ X), p (CategoryStruct.comp f g) = CategoryStruct.comp f (p g)) : X ≅ Y

Extensionality via Yoneda. The typical usage would be

-- Goal is `X ≅ Y`
apply Yoneda.ext
-- Goals are now functions `(Z ⟶ X) → (Z ⟶ Y)`, `(Z ⟶ Y) → (Z ⟶ X)`, and the fact that these
-- functions are inverses and natural in `Z`.

theorem CategoryTheory.Yoneda.isIso {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [IsIso (yoneda.map f)] : IsIso f

If yoneda.map f is an isomorphism, so was f.

def CategoryTheory.ULiftYoneda.fullyFaithful (C : Type u₁) [Category.{v₁, u₁} C] : uliftYoneda.{w, v₁, u₁}.FullyFaithful

When C is a category such that Category.{v₁} C, then the functor uliftYoneda.{w} : C ⥤ Cᵒᵖ ⥤ Type max w v₁ is fully faithful.

instance CategoryTheory.ULiftYoneda.instFullFunctorOppositeTypeUliftYoneda (C : Type u₁) [Category.{v₁, u₁} C] : uliftYoneda.{w, v₁, u₁}.Full

instance CategoryTheory.ULiftYoneda.instFaithfulFunctorOppositeTypeUliftYoneda (C : Type u₁) [Category.{v₁, u₁} C] : uliftYoneda.{w, v₁, u₁}.Faithful

@[simp]

theorem CategoryTheory.Coyoneda.naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (α : coyoneda.obj X ⟶ coyoneda.obj Y) {Z Z' : C} (f : Z' ⟶ Z) (h : Opposite.unop X ⟶ Z') : CategoryStruct.comp (α.app Z' h) f = α.app Z (CategoryStruct.comp h f)

def CategoryTheory.Coyoneda.fullyFaithful {C : Type u₁} [Category.{v₁, u₁} C] : coyoneda.FullyFaithful

The co-Yoneda embedding is fully faithful.

theorem CategoryTheory.Coyoneda.fullyFaithful_preimage {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) : fullyFaithful.preimage f = Quiver.Hom.op (f.app (Opposite.unop X) (CategoryStruct.id (Opposite.unop X)))

def CategoryTheory.Coyoneda.preimage {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) : X ⟶ Y

The morphism X ⟶ Y corresponding to a natural transformation coyoneda.obj X ⟶ coyoneda.obj Y.

instance CategoryTheory.Coyoneda.coyoneda_full {C : Type u₁} [Category.{v₁, u₁} C] : coyoneda.Full

instance CategoryTheory.Coyoneda.coyoneda_faithful {C : Type u₁} [Category.{v₁, u₁} C] : coyoneda.Faithful

def CategoryTheory.Coyoneda.ext {C : Type u₁} [Category.{v₁, u₁} C] (X Y : C) (p : {Z : C} → (X ⟶ Z) → (Y ⟶ Z)) (q : {Z : C} → (Y ⟶ Z) → (X ⟶ Z)) (h₁ : ∀ {Z : C} (f : X ⟶ Z), q (p f) = f) (h₂ : ∀ {Z : C} (f : Y ⟶ Z), p (q f) = f) (n : ∀ {Z Z' : C} (f : Y ⟶ Z) (g : Z ⟶ Z'), q (CategoryStruct.comp f g) = CategoryStruct.comp (q f) g) : X ≅ Y

Extensionality via Coyoneda. The typical usage would be

-- Goal is `X ≅ Y`
apply Coyoneda.ext
-- Goals are now functions `(X ⟶ Z) → (Y ⟶ Z)`, `(Y ⟶ Z) → (X ⟶ Z)`, and the fact that these
-- functions are inverses and natural in `Z`.

theorem CategoryTheory.Coyoneda.isIso {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso (coyoneda.map f)] : IsIso f

If coyoneda.map f is an isomorphism, so was f.

def CategoryTheory.Coyoneda.punitIso : coyoneda.obj (Opposite.op PUnit.{v₁ + 1}) ≅ Functor.id (Type v₁)

The identity functor on Type is isomorphic to the coyoneda functor coming from PUnit.

def CategoryTheory.Coyoneda.objOpOp {C : Type u₁} [Category.{v₁, u₁} C] (X : C) : coyoneda.obj (Opposite.op (Opposite.op X)) ≅ yoneda.obj X

Taking the unop of morphisms is a natural isomorphism.

@[simp]

theorem CategoryTheory.Coyoneda.objOpOp_inv_app {C : Type u₁} [Category.{v₁, u₁} C] (X : C) (X✝ : Cᵒᵖ) (a✝ : (yoneda.obj X).obj X✝) : (objOpOp X).inv.app X✝ a✝ = (opEquiv (Opposite.op X) X✝).symm a✝

@[simp]

theorem CategoryTheory.Coyoneda.objOpOp_hom_app {C : Type u₁} [Category.{v₁, u₁} C] (X : C) (X✝ : Cᵒᵖ) (a✝ : (coyoneda.obj (Opposite.op (Opposite.op X))).obj X✝) : (objOpOp X).hom.app X✝ a✝ = (opEquiv (Opposite.op X) X✝) a✝

def CategoryTheory.Coyoneda.opIso {C : Type u₁} [Category.{v₁, u₁} C] : yoneda.comp ((Functor.whiskeringLeft C Cᵒᵖᵒᵖ (Type v₁)).obj (opOp C)) ≅ coyoneda

Taking the unop of morphisms is a natural isomorphism.

def CategoryTheory.Coyoneda.ULiftCoyoneda.fullyFaithful (C : Type u₁) [Category.{v₁, u₁} C] : uliftCoyoneda.{w, v₁, u₁}.FullyFaithful

When C is a category such that Category.{v₁} C, then the functor uliftCoyoneda.{w} : C ⥤ Cᵒᵖ ⥤ Type max w v₁ is fully faithful.

instance CategoryTheory.Coyoneda.ULiftCoyoneda.instFullOppositeFunctorTypeUliftCoyoneda (C : Type u₁) [Category.{v₁, u₁} C] : uliftCoyoneda.{w, v₁, u₁}.Full

instance CategoryTheory.Coyoneda.ULiftCoyoneda.instFaithfulOppositeFunctorTypeUliftCoyoneda (C : Type u₁) [Category.{v₁, u₁} C] : uliftCoyoneda.{w, v₁, u₁}.Faithful

structure CategoryTheory.Functor.RepresentableBy {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) (Y : C) : Type (max (max u₁ v) v₁)

The data which expresses that a functor F : Cᵒᵖ ⥤ Type v is representable by Y : C.

• homEquiv {X : C} : (X ⟶ Y) ≃ F.obj (Opposite.op X)

  the natural bijection (X ⟶ Y) ≃ F.obj (op X).

• homEquiv_comp {X X' : C} (f : X ⟶ X') (g : X' ⟶ Y) : self.homEquiv (CategoryStruct.comp f g) = F.map f.op (self.homEquiv g)

theorem CategoryTheory.Functor.RepresentableBy.comp_homEquiv_symm {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y : C} (e : F.RepresentableBy Y) {X X' : C} (x : F.obj (Opposite.op X')) (f : X ⟶ X') : CategoryStruct.comp f (e.homEquiv.symm x) = e.homEquiv.symm (F.map f.op x)

theorem CategoryTheory.Functor.RepresentableBy.homEquiv_unop_comp {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type u_1)} {Y : C} (h : F.RepresentableBy Y) {X : Cᵒᵖ} {X' : C} (f : Opposite.op X' ⟶ X) (g : X' ⟶ Y) : h.homEquiv (CategoryStruct.comp f.unop g) = F.map f (h.homEquiv g)

def CategoryTheory.Functor.RepresentableBy.ofIso {C : Type u₁} [Category.{v₁, u₁} C] {F F' : Functor Cᵒᵖ (Type v)} {Y : C} (e : F.RepresentableBy Y) (e' : F ≅ F') : F'.RepresentableBy Y

If F ≅ F', and F is representable, then F' is representable.

structure CategoryTheory.Functor.CorepresentableBy {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) (X : C) : Type (max (max u₁ v) v₁)

The data which expresses that a functor F : C ⥤ Type v is corepresentable by X : C.

• homEquiv {Y : C} : (X ⟶ Y) ≃ F.obj Y

  the natural bijection (X ⟶ Y) ≃ F.obj Y.

• homEquiv_comp {Y Y' : C} (g : Y ⟶ Y') (f : X ⟶ Y) : self.homEquiv (CategoryStruct.comp f g) = F.map g (self.homEquiv f)

theorem CategoryTheory.Functor.CorepresentableBy.homEquiv_symm_comp {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} (e : F.CorepresentableBy X) {Y Y' : C} (y : F.obj Y) (g : Y ⟶ Y') : CategoryStruct.comp (e.homEquiv.symm y) g = e.homEquiv.symm (F.map g y)

def CategoryTheory.Functor.CorepresentableBy.ofIso {C : Type u₁} [Category.{v₁, u₁} C] {F F' : Functor C (Type v)} {X : C} (e : F.CorepresentableBy X) (e' : F ≅ F') : F'.CorepresentableBy X

If F ≅ F', and F is corepresentable, then F' is corepresentable.

theorem CategoryTheory.Functor.RepresentableBy.homEquiv_eq {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y : C} (e : F.RepresentableBy Y) {X : C} (f : X ⟶ Y) : e.homEquiv f = F.map f.op (e.homEquiv (CategoryStruct.id Y))

theorem CategoryTheory.Functor.CorepresentableBy.homEquiv_eq {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} (e : F.CorepresentableBy X) {Y : C} (f : X ⟶ Y) : e.homEquiv f = F.map f (e.homEquiv (CategoryStruct.id X))

def CategoryTheory.Functor.RepresentableBy.uniqueUpToIso {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y Y' : C} (e : F.RepresentableBy Y) (e' : F.RepresentableBy Y') : Y ≅ Y'

Representing objects are unique up to isomorphism.

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.uniqueUpToIso_inv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y Y' : C} (e : F.RepresentableBy Y) (e' : F.RepresentableBy Y') : (e.uniqueUpToIso e').inv = Yoneda.fullyFaithful.preimage (NatIso.ofComponents (fun (Z : Cᵒᵖ) => { hom := ⇑e'.homEquiv.symm ∘ ⇑e.homEquiv, inv := ⇑(e.homEquiv.trans e'.homEquiv.symm).symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯).inv

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.uniqueUpToIso_hom {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y Y' : C} (e : F.RepresentableBy Y) (e' : F.RepresentableBy Y') : (e.uniqueUpToIso e').hom = Yoneda.fullyFaithful.preimage (NatIso.ofComponents (fun (Z : Cᵒᵖ) => { hom := ⇑e'.homEquiv.symm ∘ ⇑e.homEquiv, inv := ⇑(e.homEquiv.trans e'.homEquiv.symm).symm, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯).hom

def CategoryTheory.Functor.CorepresentableBy.uniqueUpToIso {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X X' : C} (e : F.CorepresentableBy X) (e' : F.CorepresentableBy X') : X ≅ X'

Corepresenting objects are unique up to isomorphism.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.uniqueUpToIso_inv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X X' : C} (e : F.CorepresentableBy X) (e' : F.CorepresentableBy X') : (e.uniqueUpToIso e').inv = (Coyoneda.fullyFaithful.preimage (NatIso.ofComponents (fun (Z : C) => { hom := ⇑(e.homEquiv.trans e'.homEquiv.symm).symm, inv := ⇑e'.homEquiv.symm ∘ ⇑e.homEquiv, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯).inv).unop

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.uniqueUpToIso_hom {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X X' : C} (e : F.CorepresentableBy X) (e' : F.CorepresentableBy X') : (e.uniqueUpToIso e').hom = (Coyoneda.fullyFaithful.preimage (NatIso.ofComponents (fun (Z : C) => { hom := ⇑(e.homEquiv.trans e'.homEquiv.symm).symm, inv := ⇑e'.homEquiv.symm ∘ ⇑e.homEquiv, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯).hom).unop

theorem CategoryTheory.Functor.RepresentableBy.ext {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y : C} {e e' : F.RepresentableBy Y} (h : e.homEquiv (CategoryStruct.id Y) = e'.homEquiv (CategoryStruct.id Y)) : e = e'

theorem CategoryTheory.Functor.RepresentableBy.ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y : C} {e e' : F.RepresentableBy Y} : e = e' ↔ e.homEquiv (CategoryStruct.id Y) = e'.homEquiv (CategoryStruct.id Y)

theorem CategoryTheory.Functor.CorepresentableBy.ext {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} {e e' : F.CorepresentableBy X} (h : e.homEquiv (CategoryStruct.id X) = e'.homEquiv (CategoryStruct.id X)) : e = e'

theorem CategoryTheory.Functor.CorepresentableBy.ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} {e e' : F.CorepresentableBy X} : e = e' ↔ e.homEquiv (CategoryStruct.id X) = e'.homEquiv (CategoryStruct.id X)

def CategoryTheory.Functor.representableByEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v₁)} {Y : C} : F.RepresentableBy Y ≃ (yoneda.obj Y ≅ F)

The obvious bijection F.RepresentableBy Y ≃ (yoneda.obj Y ≅ F) when F : Cᵒᵖ ⥤ Type v₁ and [Category.{v₁} C].

def CategoryTheory.Functor.RepresentableBy.yoneda {C : Type u₁} [Category.{v₁, u₁} C] (X : C) : (yoneda.obj X).RepresentableBy X

yoneda.obj X is represented by X.

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.coyoneda_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] (X Y : C) : (RepresentableBy.yoneda X).homEquiv = Equiv.refl (Y ⟶ X)

def CategoryTheory.Functor.RepresentableBy.toIso {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v₁)} {Y : C} (e : F.RepresentableBy Y) : yoneda.obj Y ≅ F

The isomorphism yoneda.obj Y ≅ F induced by e : F.RepresentableBy Y.

def CategoryTheory.Functor.corepresentableByEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v₁)} {X : C} : F.CorepresentableBy X ≃ (coyoneda.obj (Opposite.op X) ≅ F)

The obvious bijection F.CorepresentableBy X ≃ (yoneda.obj Y ≅ F) when F : C ⥤ Type v₁ and [Category.{v₁} C].

def CategoryTheory.Functor.CorepresentableBy.coyoneda {C : Type u₁} [Category.{v₁, u₁} C] (X : Cᵒᵖ) : (coyoneda.obj X).CorepresentableBy (Opposite.unop X)

coyoneda.obj X is represented by X.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.coyoneda_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] (X : Cᵒᵖ) (Y : C) : (CorepresentableBy.coyoneda X).homEquiv = Equiv.refl (Opposite.unop X ⟶ Y)

def CategoryTheory.Functor.CorepresentableBy.toIso {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v₁)} {X : C} (e : F.CorepresentableBy X) : coyoneda.obj (Opposite.op X) ≅ F

The isomorphism coyoneda.obj (op X) ≅ F induced by e : F.CorepresentableBy X.

def CategoryTheory.Functor.RepresentableBy.ofIsoObj {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type w)} {X Y : C} (R : F.RepresentableBy X) (e : Y ≅ X) : F.RepresentableBy Y

Transport RepresentableBy along an isomorphism of the object.

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.ofIsoObj_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type w)} {X Y : C} (R : F.RepresentableBy X) (e : Y ≅ X) {Z : C} : (R.ofIsoObj e).homEquiv = e.homToEquiv.trans R.homEquiv

def CategoryTheory.Functor.CorepresentableBy.ofIsoObj {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type w)} {X Y : C} (R : F.CorepresentableBy X) (e : Y ≅ X) : F.CorepresentableBy Y

Transport RepresentableBy along an isomorphism of the object.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.ofIsoObj_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type w)} {X Y : C} (R : F.CorepresentableBy X) (e : Y ≅ X) {Z : C} : (R.ofIsoObj e).homEquiv = e.homFromEquiv.trans R.homEquiv

def CategoryTheory.Functor.RepresentableBy.equivOfIsoObj {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type w)} {X Y : C} (e : Y ≅ X) : F.RepresentableBy X ≃ F.RepresentableBy Y

If Y is isomorphic to X, representations of F by X are equivalent to representations of F by Y.

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.equivOfIsoObj_symm_apply {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type w)} {X Y : C} (e : Y ≅ X) (R : F.RepresentableBy Y) : (equivOfIsoObj e).symm R = R.ofIsoObj e.symm

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.equivOfIsoObj_apply {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type w)} {X Y : C} (e : Y ≅ X) (R : F.RepresentableBy X) : (equivOfIsoObj e) R = R.ofIsoObj e

def CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type w)} {X Y : C} (e : Y ≅ X) : F.CorepresentableBy X ≃ F.CorepresentableBy Y

If Y is isomorphic to X, corepresentations of F by X are equivalent to corepresentations of F by Y.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj_symm_apply {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type w)} {X Y : C} (e : Y ≅ X) (R : F.CorepresentableBy Y) : (equivOfIsoObj e).symm R = R.ofIsoObj e.symm

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj_apply {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type w)} {X Y : C} (e : Y ≅ X) (R : F.CorepresentableBy X) : (equivOfIsoObj e) R = R.ofIsoObj e

def CategoryTheory.Functor.representableByUliftFunctorEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {X : C} : (F.comp uliftFunctor.{w, v}).RepresentableBy X ≃ F.RepresentableBy X

Representing F composed with universe lifting is the same as representing F.

@[simp]

theorem CategoryTheory.Functor.representableByUliftFunctorEquiv_symm_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {X : C} (R : F.RepresentableBy X) {Y : C} : (representableByUliftFunctorEquiv.symm R).homEquiv = R.homEquiv.trans Equiv.ulift.symm

@[simp]

theorem CategoryTheory.Functor.representableByUliftFunctorEquiv_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {X : C} (R : (F.comp uliftFunctor.{w, v}).RepresentableBy X) {Y : C} : (representableByUliftFunctorEquiv R).homEquiv = R.homEquiv.trans Equiv.ulift

def CategoryTheory.Functor.corepresentableByUliftFunctorEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} : (F.comp uliftFunctor.{w, v}).CorepresentableBy X ≃ F.CorepresentableBy X

Corepresenting F composed with universe lifting is the same as corepresenting F.

@[simp]

theorem CategoryTheory.Functor.corepresentableByUliftFunctorEquiv_symm_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} (R : F.CorepresentableBy X) {Y : C} : (corepresentableByUliftFunctorEquiv.symm R).homEquiv = R.homEquiv.trans Equiv.ulift.symm

@[simp]

theorem CategoryTheory.Functor.corepresentableByUliftFunctorEquiv_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} (R : (F.comp uliftFunctor.{w, v}).CorepresentableBy X) {Y : C} : (corepresentableByUliftFunctorEquiv R).homEquiv = R.homEquiv.trans Equiv.ulift

def CategoryTheory.Functor.RepresentableBy.equivUliftYonedaIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type (max w v₁))) (X : C) : F.RepresentableBy X ≃ (uliftYoneda.{w, v₁, u₁}.obj X ≅ F)

Version of representableByEquiv with more general universe assumptions.

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.equivUliftYonedaIso_apply {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type (max w v₁))) (X : C) (R : F.RepresentableBy X) : (equivUliftYonedaIso F X) R = NatIso.ofComponents (fun (X_1 : Cᵒᵖ) => equivEquivIso (Equiv.ulift.trans R.homEquiv)) ⋯

@[simp]

theorem CategoryTheory.Functor.RepresentableBy.equivUliftYonedaIso_symm_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type (max w v₁))) (X : C) (e : uliftYoneda.{w, v₁, u₁}.obj X ≅ F) {X✝ : C} : ((equivUliftYonedaIso F X).symm e).homEquiv = Equiv.ulift.symm.trans (equivEquivIso.symm (e.app (Opposite.op X✝)))

def CategoryTheory.Functor.CorepresentableBy.equivUliftCoyonedaIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type (max w v₁))) (X : C) : F.CorepresentableBy X ≃ (uliftCoyoneda.{w, v₁, u₁}.obj (Opposite.op X) ≅ F)

Version of corepresentableByEquiv with more general universe assumptions.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.equivUliftCoyonedaIso_symm_apply_homEquiv {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type (max w v₁))) (X : C) (e : uliftCoyoneda.{w, v₁, u₁}.obj (Opposite.op X) ≅ F) {X✝ : C} : ((equivUliftCoyonedaIso F X).symm e).homEquiv = Equiv.ulift.symm.trans (equivEquivIso.symm (e.app X✝))

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.equivUliftCoyonedaIso_apply {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type (max w v₁))) (X : C) (R : F.CorepresentableBy X) : (equivUliftCoyonedaIso F X) R = NatIso.ofComponents (fun (X_1 : C) => equivEquivIso (Equiv.ulift.trans R.homEquiv)) ⋯

class CategoryTheory.Functor.IsRepresentable {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) : Prop

A functor F : Cᵒᵖ ⥤ Type v is representable if there is an object Y with a structure F.RepresentableBy Y, i.e. there is a natural bijection (X ⟶ Y) ≃ F.obj (op X), which may also be rephrased as a natural isomorphism yoneda.obj X ≅ F when Category.{v} C.

• has_representation : ∃ (Y : C), Nonempty (F.RepresentableBy Y)

theorem CategoryTheory.Functor.RepresentableBy.isRepresentable {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} {Y : C} (e : F.RepresentableBy Y) : F.IsRepresentable

theorem CategoryTheory.Functor.IsRepresentable.mk' {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v₁)} {X : C} (e : yoneda.obj X ≅ F) : F.IsRepresentable

Alternative constructor for F.IsRepresentable, which takes as an input an isomorphism yoneda.obj X ≅ F.

instance CategoryTheory.Functor.instIsRepresentableObjOppositeTypeYoneda {C : Type u₁} [Category.{v₁, u₁} C] {X : C} : (yoneda.obj X).IsRepresentable

instance CategoryTheory.Functor.instIsRepresentableObjOppositeTypeUliftYoneda {C : Type u₁} [Category.{v₁, u₁} C] {X : C} : (uliftYoneda.{w, v₁, u₁}.obj X).IsRepresentable

class CategoryTheory.Functor.IsCorepresentable {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) : Prop

A functor F : C ⥤ Type v₁ is corepresentable if there is object X so F ≅ coyoneda.obj X.

• has_corepresentation : ∃ (X : C), Nonempty (F.CorepresentableBy X)

theorem CategoryTheory.Functor.CorepresentableBy.isCorepresentable {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} {X : C} (e : F.CorepresentableBy X) : F.IsCorepresentable

theorem CategoryTheory.Functor.IsCorepresentable.mk' {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v₁)} {X : C} (e : coyoneda.obj (Opposite.op X) ≅ F) : F.IsCorepresentable

Alternative constructor for F.IsCorepresentable, which takes as an input an isomorphism coyoneda.obj (op X) ≅ F.

instance CategoryTheory.Functor.instIsCorepresentableObjOppositeTypeCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} : (coyoneda.obj X).IsCorepresentable

instance CategoryTheory.Functor.instIsCorepresentableObjOppositeTypeUliftCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} : (uliftCoyoneda.{w, v₁, u₁}.obj X).IsCorepresentable

noncomputable def CategoryTheory.Functor.reprX {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) [hF : F.IsRepresentable] : C

The representing object for the representable functor F.

noncomputable def CategoryTheory.Functor.representableBy {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) [hF : F.IsRepresentable] : F.RepresentableBy F.reprX

A chosen term in F.RepresentableBy (reprX F) when F.IsRepresentable holds.

noncomputable def CategoryTheory.Functor.RepresentableBy.isoReprX {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) [hF : F.IsRepresentable] {Y : C} (e : F.RepresentableBy Y) : Y ≅ F.reprX

Any representing object for a representable functor F is isomorphic to reprX F.

noncomputable def CategoryTheory.Functor.reprx {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) [hF : F.IsRepresentable] : F.obj (Opposite.op F.reprX)

The representing element for the representable functor F, sometimes called the universal element of the functor.

noncomputable def CategoryTheory.Functor.reprW {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v₁)) [F.IsRepresentable] : yoneda.obj F.reprX ≅ F

An isomorphism between a representable F and a functor of the form C(-, F.reprX). Note the components F.reprW.app X definitionally have type (X.unop ⟶ F.reprX) ≅ F.obj X.

theorem CategoryTheory.Functor.reprW_hom_app {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v₁)) [F.IsRepresentable] (X : Cᵒᵖ) (f : Opposite.unop X ⟶ F.reprX) : F.reprW.hom.app X f = F.map f.op F.reprx

noncomputable def CategoryTheory.Functor.uliftYonedaReprXIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type (max v v₁))) [F.IsRepresentable] : uliftYoneda.{v, v₁, u₁}.obj F.reprX ≅ F

If F is representable, it is, modulo universe lifting, isomorphic to Hom(-, X) for the representing object X.

theorem CategoryTheory.Functor.uliftYonedaReprXIso_hom_app {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type (max v v₁))) [F.IsRepresentable] (X : Cᵒᵖ) (f : ULift.{v, v₁} (Opposite.unop X ⟶ F.reprX)) : F.uliftYonedaReprXIso.hom.app X f = F.map f.down.op F.reprx

noncomputable def CategoryTheory.Functor.coreprX {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) [hF : F.IsCorepresentable] : C

The representing object for the corepresentable functor F.

noncomputable def CategoryTheory.Functor.corepresentableBy {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) [hF : F.IsCorepresentable] : F.CorepresentableBy F.coreprX

A chosen term in F.CorepresentableBy (coreprX F) when F.IsCorepresentable holds.

noncomputable def CategoryTheory.Functor.CorepresentableBy.isoCoreprX {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} [hF : F.IsCorepresentable] {Y : C} (e : F.CorepresentableBy Y) : Y ≅ F.coreprX

Any corepresenting object for a corepresentable functor F is isomorphic to coreprX F.

noncomputable def CategoryTheory.Functor.coreprx {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) [hF : F.IsCorepresentable] : F.obj F.coreprX

The representing element for the corepresentable functor F, sometimes called the universal element of the functor.

noncomputable def CategoryTheory.Functor.coreprW {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v₁)) [F.IsCorepresentable] : coyoneda.obj (Opposite.op F.coreprX) ≅ F

An isomorphism between a corepresentable F and a functor of the form C(F.corepr X, -). Note the components F.coreprW.app X definitionally have type F.corepr_X ⟶ X ≅ F.obj X.

theorem CategoryTheory.Functor.coreprW_hom_app {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v₁)) [F.IsCorepresentable] (X : C) (f : F.coreprX ⟶ X) : F.coreprW.hom.app X f = F.map f F.coreprx

noncomputable def CategoryTheory.Functor.uliftCoyonedaCoreprXIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type (max v v₁))) [F.IsCorepresentable] : uliftCoyoneda.{v, v₁, u₁}.obj (Opposite.op F.coreprX) ≅ F

If F is corepresentable, it is, modulo universe lifting, isomorphic to Hom(X, -) for the corepresenting object X.

theorem CategoryTheory.Functor.uliftCoyonedaCoreprXIso_hom_app {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type (max v v₁))) [F.IsCorepresentable] (X : C) (f : ULift.{v, v₁} (F.coreprX ⟶ X)) : F.uliftCoyonedaCoreprXIso.hom.app X f = F.map f.down F.coreprx

theorem CategoryTheory.Functor.isRepresentable_comp_uliftFunctor_iff {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor Cᵒᵖ (Type v)} : (F.comp uliftFunctor.{w, v}).IsRepresentable ↔ F.IsRepresentable

theorem CategoryTheory.Functor.isCorepresentable_comp_uliftFunctor_iff {C : Type u₁} [Category.{v₁, u₁} C] {F : Functor C (Type v)} : (F.comp uliftFunctor.{w, v}).IsCorepresentable ↔ F.IsCorepresentable

instance CategoryTheory.Functor.instIsRepresentableCompOppositeUliftFunctor {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) [F.IsRepresentable] : (F.comp uliftFunctor.{w, v}).IsRepresentable

instance CategoryTheory.Functor.instIsCorepresentableCompUliftFunctor {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) [F.IsCorepresentable] : (F.comp uliftFunctor.{w, v}).IsCorepresentable

theorem CategoryTheory.isRepresentable_of_natIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor Cᵒᵖ (Type v)) {G : Functor Cᵒᵖ (Type v)} (i : F ≅ G) [F.IsRepresentable] : G.IsRepresentable

theorem CategoryTheory.corepresentable_of_natIso {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type v)) {G : Functor C (Type v)} (i : F ≅ G) [F.IsCorepresentable] : G.IsCorepresentable

def CategoryTheory.Functor.CorepresentableBy.id : (Functor.id (Type v)).CorepresentableBy PUnit.{v + 1}

The identity functor on Type v is corepresented by PUnit.

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.id_homEquiv_apply (X : Type v) (a : PUnit.{v + 1} ⟶ X) : id.homEquiv a = a PUnit.unit

@[simp]

theorem CategoryTheory.Functor.CorepresentableBy.id_homEquiv_symm_apply (X : Type v) (x : X) (a : PUnit.{v + 1}) : id.homEquiv.symm x a = x

instance CategoryTheory.instIsCorepresentableIdType : (Functor.id (Type v)).IsCorepresentable

@[implicit_reducible]

instance CategoryTheory.prodCategoryInstance1 (C : Type u₁) [Category.{v₁, u₁} C] : Category.{max u₁ v₁, max u₁ (max (v₁ + 1) u₁) v₁} (Functor Cᵒᵖ (Type v₁) × Cᵒᵖ)

@[implicit_reducible]

instance CategoryTheory.prodCategoryInstance2 (C : Type u₁) [Category.{v₁, u₁} C] : Category.{max u₁ v₁, max (max (max (v₁ + 1) u₁) v₁) u₁} (Cᵒᵖ × Functor Cᵒᵖ (Type v₁))

def CategoryTheory.yonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type v₁)} : (yoneda.obj X ⟶ F) ≃ F.obj (Opposite.op X)

We have a type-level equivalence between natural transformations from the yoneda embedding and elements of F.obj X, without any universe switching.

theorem CategoryTheory.yonedaEquiv_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type v₁)} (f : yoneda.obj X ⟶ F) : yonedaEquiv f = f.app (Opposite.op X) (CategoryStruct.id X)

@[simp]

theorem CategoryTheory.yonedaEquiv_symm_app_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type v₁)} (x : F.obj (Opposite.op X)) (Y : Cᵒᵖ) (f : Opposite.unop Y ⟶ X) : (yonedaEquiv.symm x).app Y f = F.map f.op x

theorem CategoryTheory.yonedaEquiv_naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} {F : Functor Cᵒᵖ (Type v₁)} (f : yoneda.obj X ⟶ F) (g : Y ⟶ X) : F.map g.op (yonedaEquiv f) = yonedaEquiv (CategoryStruct.comp (yoneda.map g) f)

See also yonedaEquiv_naturality' for a more general version.

theorem CategoryTheory.yonedaEquiv_naturality' {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {F : Functor Cᵒᵖ (Type v₁)} (f : yoneda.obj (Opposite.unop X) ⟶ F) (g : X ⟶ Y) : F.map g (yonedaEquiv f) = yonedaEquiv (CategoryStruct.comp (yoneda.map g.unop) f)

Variant of yonedaEquiv_naturality with general g. This is technically strictly more general than yonedaEquiv_naturality, but yonedaEquiv_naturality is sometimes preferable because it can avoid the "motive is not type correct" error.

theorem CategoryTheory.yonedaEquiv_comp {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F G : Functor Cᵒᵖ (Type v₁)} (α : yoneda.obj X ⟶ F) (β : F ⟶ G) : yonedaEquiv (CategoryStruct.comp α β) = β.app (Opposite.op X) (yonedaEquiv α)

theorem CategoryTheory.yonedaEquiv_yoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : yonedaEquiv (yoneda.map f) = f

theorem CategoryTheory.yonedaEquiv_symm_naturality_left {C : Type u₁} [Category.{v₁, u₁} C] {X X' : C} (f : X' ⟶ X) (F : Functor Cᵒᵖ (Type v₁)) (x : F.obj (Opposite.op X)) : CategoryStruct.comp (yoneda.map f) (yonedaEquiv.symm x) = yonedaEquiv.symm (F.map f.op x)

theorem CategoryTheory.yonedaEquiv_symm_naturality_right {C : Type u₁} [Category.{v₁, u₁} C] (X : C) {F F' : Functor Cᵒᵖ (Type v₁)} (f : F ⟶ F') (x : F.obj (Opposite.op X)) : CategoryStruct.comp (yonedaEquiv.symm x) f = yonedaEquiv.symm (f.app (Opposite.op X) x)

theorem CategoryTheory.map_yonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} {F : Functor Cᵒᵖ (Type v₁)} (f : yoneda.obj X ⟶ F) (g : Y ⟶ X) : F.map g.op (yonedaEquiv f) = f.app (Opposite.op Y) g

See also map_yonedaEquiv' for a more general version.

theorem CategoryTheory.map_yonedaEquiv' {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {F : Functor Cᵒᵖ (Type v₁)} (f : yoneda.obj (Opposite.unop X) ⟶ F) (g : X ⟶ Y) : F.map g (yonedaEquiv f) = f.app Y g.unop

Variant of map_yonedaEquiv with general g. This is technically strictly more general than map_yonedaEquiv, but map_yonedaEquiv is sometimes preferable because it can avoid the "motive is not type correct" error.

theorem CategoryTheory.yonedaEquiv_symm_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Functor Cᵒᵖ (Type v₁)} (t : F.obj X) : yonedaEquiv.symm (F.map f t) = CategoryStruct.comp (yoneda.map f.unop) (yonedaEquiv.symm t)

theorem CategoryTheory.hom_ext_yoneda {C : Type u₁} [Category.{v₁, u₁} C] {P Q : Functor Cᵒᵖ (Type v₁)} {f g : P ⟶ Q} (h : ∀ (X : C) (p : yoneda.obj X ⟶ P), CategoryStruct.comp p f = CategoryStruct.comp p g) : f = g

Two morphisms of presheaves of types P ⟶ Q coincide if the precompositions with morphisms yoneda.obj X ⟶ P agree.

def CategoryTheory.yonedaEvaluation (C : Type u₁) [Category.{v₁, u₁} C] : Functor (Cᵒᵖ × Functor Cᵒᵖ (Type v₁)) (Type (max u₁ v₁))

The "Yoneda evaluation" functor, which sends X : Cᵒᵖ and F : Cᵒᵖ ⥤ Type to F.obj X, functorially in both X and F.

@[simp]

theorem CategoryTheory.yonedaEvaluation_map_down (C : Type u₁) [Category.{v₁, u₁} C] (P Q : Cᵒᵖ × Functor Cᵒᵖ (Type v₁)) (α : P ⟶ Q) (x : (yonedaEvaluation C).obj P) : ((yonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down)

def CategoryTheory.yonedaPairing (C : Type u₁) [Category.{v₁, u₁} C] : Functor (Cᵒᵖ × Functor Cᵒᵖ (Type v₁)) (Type (max u₁ v₁))

The "Yoneda pairing" functor, which sends X : Cᵒᵖ and F : Cᵒᵖ ⥤ Type to yoneda.op.obj X ⟶ F, functorially in both X and F.

theorem CategoryTheory.yonedaPairingExt (C : Type u₁) [Category.{v₁, u₁} C] {X : Cᵒᵖ × Functor Cᵒᵖ (Type v₁)} {x y : (yonedaPairing C).obj X} (w : ∀ (Y : Cᵒᵖ), x.app Y = y.app Y) : x = y

theorem CategoryTheory.yonedaPairingExt_iff {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ × Functor Cᵒᵖ (Type v₁)} {x y : (yonedaPairing C).obj X} : x = y ↔ ∀ (Y : Cᵒᵖ), x.app Y = y.app Y

@[simp]

theorem CategoryTheory.yonedaPairing_map (C : Type u₁) [Category.{v₁, u₁} C] (P Q : Cᵒᵖ × Functor Cᵒᵖ (Type v₁)) (α : P ⟶ Q) (β : (yonedaPairing C).obj P) : (yonedaPairing C).map α β = CategoryStruct.comp (yoneda.map α.1.unop) (CategoryStruct.comp β α.2)

def CategoryTheory.yonedaLemma (C : Type u₁) [Category.{v₁, u₁} C] : yonedaPairing C ≅ yonedaEvaluation C

The Yoneda lemma asserts that the Yoneda pairing (X : Cᵒᵖ, F : Cᵒᵖ ⥤ Type) ↦ (yoneda.obj (unop X) ⟶ F) is naturally isomorphic to the evaluation (X, F) ↦ F.obj X.

def CategoryTheory.curriedYonedaLemma {C : Type u₁} [SmallCategory C] : yoneda.op.comp coyoneda ≅ evaluation Cᵒᵖ (Type u₁)

The curried version of yoneda lemma when C is small.

def CategoryTheory.largeCurriedYonedaLemma {C : Type u₁} [Category.{v₁, u₁} C] : yoneda.op.comp coyoneda ≅ (evaluation Cᵒᵖ (Type v₁)).comp ((Functor.whiskeringRight (Functor Cᵒᵖ (Type v₁)) (Type v₁) (Type (max u₁ v₁))).obj uliftFunctor.{u₁, v₁})

The curried version of the Yoneda lemma.

def CategoryTheory.yonedaOpCompYonedaObj {C : Type u₁} [Category.{v₁, u₁} C] (P : Functor Cᵒᵖ (Type v₁)) : yoneda.op.comp (yoneda.obj P) ≅ P.comp uliftFunctor.{u₁, v₁}

Version of the Yoneda lemma where the presheaf is fixed but the argument varies.

def CategoryTheory.curriedYonedaLemma' {C : Type u₁} [SmallCategory C] : yoneda.comp ((Functor.whiskeringLeft Cᵒᵖ (Functor Cᵒᵖ (Type u₁))ᵒᵖ (Type u₁)).obj yoneda.op) ≅ Functor.id (Functor Cᵒᵖ (Type u₁))

The curried version of yoneda lemma when C is small.

theorem CategoryTheory.isIso_of_yoneda_map_bijective {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (T : C), Function.Bijective fun (x : T ⟶ X) => CategoryStruct.comp x f) : IsIso f

theorem CategoryTheory.isIso_iff_yoneda_map_bijective {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ ∀ (T : C), Function.Bijective fun (x : T ⟶ X) => CategoryStruct.comp x f

theorem CategoryTheory.isIso_iff_isIso_yoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ ∀ (c : C), IsIso ((yoneda.map f).app (Opposite.op c))

def CategoryTheory.uliftYonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type (max w v₁))} : (uliftYoneda.{w, v₁, u₁}.obj X ⟶ F) ≃ F.obj (Opposite.op X)

Yoneda's lemma as a bijection (uliftYoneda.{w}.obj X ⟶ F) ≃ F.obj (op X) for any presheaf of type F : Cᵒᵖ ⥤ Type (max w v₁) for some auxiliary universe w.

theorem CategoryTheory.uliftYonedaEquiv_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type (max w v₁))} (τ : uliftYoneda.{w, v₁, u₁}.obj X ⟶ F) : uliftYonedaEquiv τ = τ.app (Opposite.op X) { down := CategoryStruct.id X }

@[simp]

theorem CategoryTheory.uliftYonedaEquiv_symm_apply_app {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor Cᵒᵖ (Type (max w v₁))} (x : F.obj (Opposite.op X)) (Y : Cᵒᵖ) (y : (uliftYoneda.{w, v₁, u₁}.obj X).obj Y) : (uliftYonedaEquiv.symm x).app Y y = F.map y.down.op x

theorem CategoryTheory.uliftYonedaEquiv_naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {F : Functor Cᵒᵖ (Type (max w v₁))} (f : uliftYoneda.{w, v₁, u₁}.obj (Opposite.unop X) ⟶ F) (g : X ⟶ Y) : F.map g (uliftYonedaEquiv f) = uliftYonedaEquiv (CategoryStruct.comp (uliftYoneda.{w, v₁, u₁}.map g.unop) f)

theorem CategoryTheory.uliftYonedaEquiv_comp {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F G : Functor Cᵒᵖ (Type (max w v₁))} (α : uliftYoneda.{w, v₁, u₁}.obj X ⟶ F) (β : F ⟶ G) : uliftYonedaEquiv (CategoryStruct.comp α β) = β.app (Opposite.op X) (uliftYonedaEquiv α)

theorem CategoryTheory.uliftYonedaEquiv_symm_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Functor Cᵒᵖ (Type (max w v₁))} (t : F.obj X) : uliftYonedaEquiv.symm (F.map f t) = CategoryStruct.comp (uliftYoneda.{w, v₁, u₁}.map f.unop) (uliftYonedaEquiv.symm t)

theorem CategoryTheory.uliftYonedaEquiv_symm_map_assoc {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Functor Cᵒᵖ (Type (max w v₁))} (t : F.obj X) {Z : Functor Cᵒᵖ (Type (max w v₁))} (h : F ⟶ Z) : CategoryStruct.comp (uliftYonedaEquiv.symm (F.map f t)) h = CategoryStruct.comp (uliftYoneda.{w, v₁, u₁}.map f.unop) (CategoryStruct.comp (uliftYonedaEquiv.symm t) h)

theorem CategoryTheory.uliftYonedaEquiv_symm_comp {C : Type u₁} [Category.{v₁, u₁} C] {F G : Functor Cᵒᵖ (Type (max w v₁))} {X : Cᵒᵖ} (x : F.obj X) (f : F ⟶ G) : CategoryStruct.comp (uliftYonedaEquiv.symm x) f = uliftYonedaEquiv.symm (f.app (Opposite.op (Opposite.unop X)) x)

theorem CategoryTheory.uliftYonedaEquiv_symm_comp_assoc {C : Type u₁} [Category.{v₁, u₁} C] {F G : Functor Cᵒᵖ (Type (max w v₁))} {X : Cᵒᵖ} (x : F.obj X) (f : F ⟶ G) {Z : Functor Cᵒᵖ (Type (max w v₁))} (h : G ⟶ Z) : CategoryStruct.comp (uliftYonedaEquiv.symm x) (CategoryStruct.comp f h) = CategoryStruct.comp (uliftYonedaEquiv.symm (f.app (Opposite.op (Opposite.unop X)) x)) h

@[simp]

theorem CategoryTheory.uliftYonedaEquiv_uliftYoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : uliftYonedaEquiv (uliftYoneda.{w, v₁, u₁}.map f) = { down := f }

theorem CategoryTheory.hom_ext_uliftYoneda {C : Type u₁} [Category.{v₁, u₁} C] {P Q : Functor Cᵒᵖ (Type (max w v₁))} {f g : P ⟶ Q} (h : ∀ (X : C) (p : uliftYoneda.{w, v₁, u₁}.obj X ⟶ P), CategoryStruct.comp p f = CategoryStruct.comp p g) : f = g

Two morphisms of presheaves of types P ⟶ Q coincide if the precompositions with morphisms uliftYoneda.obj X ⟶ P agree.

def CategoryTheory.uliftYonedaOpCompCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] : uliftYoneda.{w, v₁, u₁}.op.comp coyoneda ≅ (evaluation Cᵒᵖ (Type (max v₁ w))).comp ((Functor.whiskeringRight (Functor Cᵒᵖ (Type (max v₁ w))) (Type (max v₁ w)) (Type (max (max w u₁) v₁))).obj uliftFunctor.{u₁, max v₁ w})

A variant of the curried version of the Yoneda lemma with a raise in the universe level.

def CategoryTheory.coyonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor C (Type v₁)} : (coyoneda.obj (Opposite.op X) ⟶ F) ≃ F.obj X

We have a type-level equivalence between natural transformations from the coyoneda embedding and elements of F.obj X.unop, without any universe switching.

theorem CategoryTheory.coyonedaEquiv_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor C (Type v₁)} (f : coyoneda.obj (Opposite.op X) ⟶ F) : coyonedaEquiv f = f.app X (CategoryStruct.id X)

@[simp]

theorem CategoryTheory.coyonedaEquiv_symm_app_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F : Functor C (Type v₁)} (x : F.obj X) (Y : C) (f : X ⟶ Y) : (coyonedaEquiv.symm x).app Y f = F.map f x

theorem CategoryTheory.coyonedaEquiv_naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} {F : Functor C (Type v₁)} (f : coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y) : F.map g (coyonedaEquiv f) = coyonedaEquiv (CategoryStruct.comp (coyoneda.map g.op) f)

theorem CategoryTheory.coyonedaEquiv_comp {C : Type u₁} [Category.{v₁, u₁} C] {X : C} {F G : Functor C (Type v₁)} (α : coyoneda.obj (Opposite.op X) ⟶ F) (β : F ⟶ G) : coyonedaEquiv (CategoryStruct.comp α β) = β.app X (coyonedaEquiv α)

theorem CategoryTheory.coyonedaEquiv_coyoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : coyonedaEquiv (coyoneda.map f.op) = f

theorem CategoryTheory.map_coyonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} {F : Functor C (Type v₁)} (f : coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y) : F.map g (coyonedaEquiv f) = f.app Y g

theorem CategoryTheory.coyonedaEquiv_symm_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) {F : Functor C (Type v₁)} (t : F.obj X) : coyonedaEquiv.symm (F.map f t) = CategoryStruct.comp (coyoneda.map f.op) (coyonedaEquiv.symm t)

def CategoryTheory.coyonedaEvaluation (C : Type u₁) [Category.{v₁, u₁} C] : Functor (C × Functor C (Type v₁)) (Type (max u₁ v₁))

The "Coyoneda evaluation" functor, which sends X : C and F : C ⥤ Type to F.obj X, functorially in both X and F.

@[simp]

theorem CategoryTheory.coyonedaEvaluation_map_down (C : Type u₁) [Category.{v₁, u₁} C] (P Q : C × Functor C (Type v₁)) (α : P ⟶ Q) (x : (coyonedaEvaluation C).obj P) : ((coyonedaEvaluation C).map α x).down = α.2.app Q.1 (P.2.map α.1 x.down)

def CategoryTheory.coyonedaPairing (C : Type u₁) [Category.{v₁, u₁} C] : Functor (C × Functor C (Type v₁)) (Type (max u₁ v₁))

The "Coyoneda pairing" functor, which sends X : C and F : C ⥤ Type to coyoneda.rightOp.obj X ⟶ F, functorially in both X and F.

theorem CategoryTheory.coyonedaPairingExt (C : Type u₁) [Category.{v₁, u₁} C] {X : C × Functor C (Type v₁)} {x y : (coyonedaPairing C).obj X} (w : ∀ (Y : C), x.app Y = y.app Y) : x = y

theorem CategoryTheory.coyonedaPairingExt_iff {C : Type u₁} [Category.{v₁, u₁} C] {X : C × Functor C (Type v₁)} {x y : (coyonedaPairing C).obj X} : x = y ↔ ∀ (Y : C), x.app Y = y.app Y

@[simp]

theorem CategoryTheory.coyonedaPairing_map (C : Type u₁) [Category.{v₁, u₁} C] (P Q : C × Functor C (Type v₁)) (α : P ⟶ Q) (β : (coyonedaPairing C).obj P) : (coyonedaPairing C).map α β = CategoryStruct.comp (coyoneda.map α.1.op) (CategoryStruct.comp β α.2)

def CategoryTheory.coyonedaLemma (C : Type u₁) [Category.{v₁, u₁} C] : coyonedaPairing C ≅ coyonedaEvaluation C

The Coyoneda lemma asserts that the Coyoneda pairing (X : C, F : C ⥤ Type) ↦ (coyoneda.obj X ⟶ F) is naturally isomorphic to the evaluation (X, F) ↦ F.obj X.

def CategoryTheory.curriedCoyonedaLemma {C : Type u₁} [SmallCategory C] : coyoneda.rightOp.comp coyoneda ≅ evaluation C (Type u₁)

The curried version of coyoneda lemma when C is small.

def CategoryTheory.largeCurriedCoyonedaLemma {C : Type u₁} [Category.{v₁, u₁} C] : coyoneda.rightOp.comp coyoneda ≅ (evaluation C (Type v₁)).comp ((Functor.whiskeringRight (Functor C (Type v₁)) (Type v₁) (Type (max u₁ v₁))).obj uliftFunctor.{u₁, v₁})

The curried version of the Coyoneda lemma.

def CategoryTheory.coyonedaCompYonedaObj {C : Type u₁} [Category.{v₁, u₁} C] (P : Functor C (Type v₁)) : coyoneda.rightOp.comp (yoneda.obj P) ≅ P.comp uliftFunctor.{u₁, v₁}

Version of the Coyoneda lemma where the presheaf is fixed but the argument varies.

def CategoryTheory.curriedCoyonedaLemma' {C : Type u₁} [SmallCategory C] : yoneda.comp ((Functor.whiskeringLeft C (Functor C (Type u₁))ᵒᵖ (Type u₁)).obj coyoneda.rightOp) ≅ Functor.id (Functor C (Type u₁))

The curried version of coyoneda lemma when C is small.

theorem CategoryTheory.isIso_of_coyoneda_map_bijective {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (T : C), Function.Bijective fun (x : Y ⟶ T) => CategoryStruct.comp f x) : IsIso f

theorem CategoryTheory.isIso_iff_coyoneda_map_bijective {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ ∀ (T : C), Function.Bijective fun (x : Y ⟶ T) => CategoryStruct.comp f x

theorem CategoryTheory.isIso_iff_isIso_coyoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ ∀ (c : C), IsIso ((coyoneda.map f.op).app c)

def CategoryTheory.uliftCoyonedaEquiv {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} {F : Functor C (Type (max w v₁))} : (uliftCoyoneda.{w, v₁, u₁}.obj X ⟶ F) ≃ F.obj (Opposite.unop X)

Coyoneda's lemma as a bijection (uliftCoyoneda.{w}.obj X ⟶ F) ≃ F.obj (op X) for any presheaf of type F : Cᵒᵖ ⥤ Type (max w v₁) for some auxiliary universe w.

@[simp]

theorem CategoryTheory.uliftCoyonedaEquiv_symm_apply_app {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} {F : Functor C (Type (max w v₁))} (x : F.obj (Opposite.unop X)) (Y : C) (y : (uliftCoyoneda.{w, v₁, u₁}.obj X).obj Y) : (uliftCoyonedaEquiv.symm x).app Y y = F.map y.down x

theorem CategoryTheory.uliftCoyonedaEquiv_apply {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} {F : Functor C (Type (max w v₁))} (τ : uliftCoyoneda.{w, v₁, u₁}.obj X ⟶ F) : uliftCoyonedaEquiv τ = τ.app (Opposite.unop X) { down := CategoryStruct.id (Opposite.unop X) }

theorem CategoryTheory.uliftCoyonedaEquiv_naturality {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} {F : Functor C (Type (max w v₁))} (f : uliftCoyoneda.{w, v₁, u₁}.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y) : F.map g (uliftCoyonedaEquiv f) = uliftCoyonedaEquiv (CategoryStruct.comp (uliftCoyoneda.{w, v₁, u₁}.map g.op) f)

theorem CategoryTheory.uliftCoyonedaEquiv_comp {C : Type u₁} [Category.{v₁, u₁} C] {X : Cᵒᵖ} {F G : Functor C (Type (max w v₁))} (α : uliftCoyoneda.{w, v₁, u₁}.obj X ⟶ F) (β : F ⟶ G) : uliftCoyonedaEquiv (CategoryStruct.comp α β) = β.app (Opposite.unop X) (uliftCoyonedaEquiv α)

theorem CategoryTheory.uliftCoyonedaEquiv_symm_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) {F : Functor C (Type (max w v₁))} (t : F.obj X) : uliftCoyonedaEquiv.symm (F.map f t) = CategoryStruct.comp (uliftCoyoneda.{w, v₁, u₁}.map f.op) (uliftCoyonedaEquiv.symm t)

theorem CategoryTheory.uliftCoyonedaEquiv_symm_map_assoc {C : Type u₁} [Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) {F : Functor C (Type (max w v₁))} (t : F.obj X) {Z : Functor C (Type (max w v₁))} (h : F ⟶ Z) : CategoryStruct.comp (uliftCoyonedaEquiv.symm (F.map f t)) h = CategoryStruct.comp (uliftCoyoneda.{w, v₁, u₁}.map f.op) (CategoryStruct.comp (uliftCoyonedaEquiv.symm t) h)

@[simp]

theorem CategoryTheory.uliftCoyonedaEquiv_uliftCoyoneda_map {C : Type u₁} [Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y) : uliftCoyonedaEquiv (uliftCoyoneda.{w, v₁, u₁}.map f) = { down := f.unop }

theorem CategoryTheory.hom_ext_uliftCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] {P Q : Functor C (Type (max w v₁))} {f g : P ⟶ Q} (h : ∀ (X : Cᵒᵖ) (p : uliftCoyoneda.{w, v₁, u₁}.obj X ⟶ P), CategoryStruct.comp p f = CategoryStruct.comp p g) : f = g

Two morphisms of presheaves of types P ⟶ Q coincide if the precompositions with morphisms uliftCoyoneda.obj X ⟶ P agree.

def CategoryTheory.uliftCoyonedaRightOpCompCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] : uliftCoyoneda.{w, v₁, u₁}.rightOp.comp coyoneda ≅ (evaluation C (Type (max v₁ w))).comp ((Functor.whiskeringRight (Functor C (Type (max v₁ w))) (Type (max v₁ w)) (Type (max (max w u₁) v₁))).obj uliftFunctor.{u₁, max v₁ w})

A variant of the curried version of the Coyoneda lemma with a raise in the universe level.

def CategoryTheory.yonedaMap {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u_1} [Category.{v₁, u_1} D] (F : Functor C D) (X : C) : yoneda.obj X ⟶ F.op.comp (yoneda.obj (F.obj X))

The natural transformation yoneda.obj X ⟶ F.op ⋙ yoneda.obj (F.obj X) when F : C ⥤ D and X : C.

@[simp]

theorem CategoryTheory.yonedaMap_app_apply {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u_1} [Category.{v₁, u_1} D] (F : Functor C D) {Y : C} {X : Cᵒᵖ} (f : Opposite.unop X ⟶ Y) : (yonedaMap F Y).app X f = F.map f

def CategoryTheory.uliftYonedaMap {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (X : C) : uliftYoneda.{max w v₂, v₁, u₁}.obj X ⟶ F.op.comp (uliftYoneda.{max w v₁, v₂, u₂}.obj (F.obj X))

The natural transformation uliftYoneda.obj X ⟶ F.op ⋙ uliftYoneda.obj (F.obj X) when F : C ⥤ D and X : C.

@[simp]

theorem CategoryTheory.uliftYonedaMap_app_apply {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) {Y : C} {X : Cᵒᵖ} (f : Opposite.unop X ⟶ Y) : (uliftYonedaMap F Y).app X { down := f } = { down := F.map f }

def CategoryTheory.Functor.sectionsEquivHom {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type u₂)) (X : Type u₂) [Unique X] : ↑F.sections ≃ ((const C).obj X ⟶ F)

A type-level equivalence between sections of a functor and morphisms from a terminal functor to it. We use the constant functor on a given singleton type here as a specific choice of terminal functor.

@[simp]

theorem CategoryTheory.Functor.sectionsEquivHom_apply_app {C : Type u₁} [Category.{v₁, u₁} C] (F : Functor C (Type u₂)) (X : Type u₂) [Unique X] (s : ↑F.sections) (j : C) (x : ((const C).obj X).obj j) : ((F.sectionsEquivHom X) s).app j x = ↑s j

theorem CategoryTheory.Functor.sectionsEquivHom_naturality {C : Type u₁} [Category.{v₁, u₁} C] {F G : Functor C (Type u₂)} (f : F ⟶ G) (X : Type u₂) [Unique X] (x : ↑F.sections) : (G.sectionsEquivHom X) ((sectionsFunctor C).map f x) = CategoryStruct.comp ((F.sectionsEquivHom X) x) f

theorem CategoryTheory.Functor.sectionsEquivHom_naturality_symm {C : Type u₁} [Category.{v₁, u₁} C] {F G : Functor C (Type u₂)} (f : F ⟶ G) (X : Type u₂) [Unique X] (τ : (const C).obj X ⟶ F) : (G.sectionsEquivHom X).symm (CategoryStruct.comp τ f) = (sectionsFunctor C).map f ((F.sectionsEquivHom X).symm τ)

noncomputable def CategoryTheory.sectionsFunctorNatIsoCoyoneda {C : Type u₁} [Category.{v₁, u₁} C] (X : Type (max u₁ u₂)) [Unique X] : Functor.sectionsFunctor C ≅ coyoneda.obj (Opposite.op ((Functor.const C).obj X))

A natural isomorphism between the sections functor (C ⥤ Type _) ⥤ Type _ and the co-Yoneda embedding of a terminal functor, specifically a constant functor on a given singleton type X.

@[simp]

theorem CategoryTheory.sectionsFunctorNatIsoCoyoneda_hom_app_app {C : Type u₁} [Category.{v₁, u₁} C] (X : Type (max u₁ u₂)) [Unique X] (X✝ : Functor C (Type (max u₁ u₂))) (a✝ : (Functor.sectionsFunctor C).obj X✝) (j : C) (x : ((Functor.const C).obj X).obj j) : ((sectionsFunctorNatIsoCoyoneda X).hom.app X✝ a✝).app j x = ↑a✝ j

@[simp]

theorem CategoryTheory.sectionsFunctorNatIsoCoyoneda_inv_app_coe {C : Type u₁} [Category.{v₁, u₁} C] (X : Type (max u₁ u₂)) [Unique X] (X✝ : Functor C (Type (max u₁ u₂))) (a✝ : (coyoneda.obj (Opposite.op ((Functor.const C).obj X))).obj X✝) (j : C) : ↑((sectionsFunctorNatIsoCoyoneda X).inv.app X✝ a✝) j = a✝.app j default

def CategoryTheory.Functor.FullyFaithful.homNatIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) : F.op.comp (uliftYoneda.{v₁, v₂, u₂}.obj (F.obj X)) ≅ uliftYoneda.{v₂, v₁, u₁}.obj X

FullyFaithful.homEquiv as a natural isomorphism.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIso_hom_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (F.op.comp (uliftYoneda.{v₁, v₂, u₂}.obj (F.obj X))).obj X✝) : ((hF.homNatIso X).hom.app X✝ a✝).down = hF.preimage (Equiv.ulift a✝)

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIso_inv_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (uliftYoneda.{v₂, v₁, u₁}.obj X).obj X✝) : ((hF.homNatIso X).inv.app X✝ a✝).down = (hF.homEquiv.symm.trans Equiv.ulift.symm).symm a✝

@[deprecated CategoryTheory.Functor.FullyFaithful.homNatIso (since := "2025-10-28")]

def CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) : F.op.comp (yoneda.obj (F.obj X)) ≅ uliftYoneda.{v₂, v₁, u₁}.obj X

FullyFaithful.homEquiv as a natural isomorphism.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight_hom_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (F.op.comp (yoneda.obj (F.obj X))).obj X✝) : ((hF.homNatIsoMaxRight X).hom.app X✝ a✝).down = Equiv.ulift ((hF.homNatIso X).hom.app X✝ ((uliftYonedaIsoYoneda.inv.app (F.obj X)).app (Opposite.op (F.obj (Opposite.unop X✝))) a✝))

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight_inv_app {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (uliftYoneda.{v₂, v₁, u₁}.obj X).obj X✝) : (hF.homNatIsoMaxRight X).inv.app X✝ a✝ = (hF.homEquiv.symm.trans Equiv.ulift.symm).symm { down := a✝.down }

def CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) : F.comp (uliftYoneda.{v₁, v₂, u₂}.comp ((whiskeringLeft Cᵒᵖ Dᵒᵖ (Type (max v₁ v₂))).obj F.op)) ≅ uliftYoneda.{v₂, v₁, u₁}

FullyFaithful.homEquiv as a natural isomorphism.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft_hom_app_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (F.op.comp (uliftYoneda.{v₁, v₂, u₂}.obj (F.obj X))).obj X✝) : ((hF.compUliftYonedaCompWhiskeringLeft.hom.app X).app X✝ a✝).down = hF.preimage a✝.down

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft_inv_app_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (uliftYoneda.{v₂, v₁, u₁}.obj X).obj X✝) : ((hF.compUliftYonedaCompWhiskeringLeft.inv.app X).app X✝ a✝).down = F.map a✝.down

@[deprecated CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft (since := "2025-10-20")]

def CategoryTheory.Functor.FullyFaithful.compYonedaCompWhiskeringLeft {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) : F.comp (uliftYoneda.{v₁, v₂, u₂}.comp ((whiskeringLeft Cᵒᵖ Dᵒᵖ (Type (max v₁ v₂))).obj F.op)) ≅ uliftYoneda.{v₂, v₁, u₁}

Alias of CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft.

---

FullyFaithful.homEquiv as a natural isomorphism.

@[deprecated CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft (since := "2025-10-28")]

def CategoryTheory.Functor.FullyFaithful.compYonedaCompWhiskeringLeftMaxRight {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) : F.comp (yoneda.comp ((whiskeringLeft Cᵒᵖ Dᵒᵖ (Type (max v₁ v₂))).obj F.op)) ≅ uliftYoneda.{v₂, v₁, u₁}

FullyFaithful.homEquiv as a natural isomorphism.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compYonedaCompWhiskeringLeftMaxRight_hom_app_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : ((F.comp (yoneda.comp ((whiskeringLeft Cᵒᵖ Dᵒᵖ (Type (max v₁ v₂))).obj F.op))).obj X).obj X✝) : ((hF.compYonedaCompWhiskeringLeftMaxRight.hom.app X).app X✝ a✝).down = Equiv.ulift ((hF.compUliftYonedaCompWhiskeringLeft.hom.app X).app X✝ ((uliftYonedaIsoYoneda.inv.app (F.obj X)).app (Opposite.op (F.obj (Opposite.unop X✝))) a✝))

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compYonedaCompWhiskeringLeftMaxRight_inv_app_app {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{max v₁ v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) (X✝ : Cᵒᵖ) (a✝ : (uliftYoneda.{v₂, v₁, u₁}.obj X).obj X✝) : (hF.compYonedaCompWhiskeringLeftMaxRight.inv.app X).app X✝ a✝ = F.map a✝.down

def CategoryTheory.Functor.FullyFaithful.homNatIso' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : C) : F.comp (uliftCoyoneda.{v₁, v₂, u₂}.obj (Opposite.op (F.obj X))) ≅ uliftCoyoneda.{v₂, v₁, u₁}.obj (Opposite.op X)

FullyFaithful.homEquiv as a natural isomorphism, using coyoneda.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIso'_inv_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X X✝ : C) (a✝ : (uliftCoyoneda.{v₂, v₁, u₁}.obj (Opposite.op X)).obj X✝) : ((hF.homNatIso' X).inv.app X✝ a✝).down = (hF.homEquiv.symm.trans Equiv.ulift.symm).symm a✝

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.homNatIso'_hom_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X X✝ : C) (a✝ : (F.comp (uliftCoyoneda.{v₁, v₂, u₂}.obj (Opposite.op (F.obj X)))).obj X✝) : ((hF.homNatIso' X).hom.app X✝ a✝).down = hF.preimage (Equiv.ulift a✝)

def CategoryTheory.Functor.FullyFaithful.compUliftCoyonedaCompWhiskeringLeft {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) : F.op.comp (uliftCoyoneda.{v₁, v₂, u₂}.comp ((whiskeringLeft C D (Type (max v₁ v₂))).obj F)) ≅ uliftCoyoneda.{v₂, v₁, u₁}

FullyFaithful.homEquiv as a natural isomorphism, using coyoneda.

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compUliftCoyonedaCompWhiskeringLeft_inv_app_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : Cᵒᵖ) (X✝ : C) (a✝ : (uliftCoyoneda.{v₂, v₁, u₁}.obj (Opposite.op (Opposite.unop X))).obj X✝) : ((hF.compUliftCoyonedaCompWhiskeringLeft.inv.app X).app X✝ a✝).down = F.map a✝.down

@[simp]

theorem CategoryTheory.Functor.FullyFaithful.compUliftCoyonedaCompWhiskeringLeft_hom_app_app_down {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} (hF : F.FullyFaithful) (X : Cᵒᵖ) (X✝ : C) (a✝ : (F.comp (uliftCoyoneda.{v₁, v₂, u₂}.obj (Opposite.op (F.obj (Opposite.unop X))))).obj X✝) : ((hF.compUliftCoyonedaCompWhiskeringLeft.hom.app X).app X✝ a✝).down = hF.preimage a✝.down