fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
isIso {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso (coyoneda.map f)] : IsIso f :=
isIso_of_fully_faithful coyoneda f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso | If `coyoneda.map f` is an isomorphism, so was `f`. |
punitIso : coyoneda.obj (Opposite.op PUnit) ≅ 𝟭 (Type v₁) :=
NatIso.ofComponents fun X =>
{ hom := fun f => f ⟨⟩
inv := fun x _ => x } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | punitIso | The identity functor on `Type` is isomorphic to the coyoneda functor coming from `PUnit`. |
@[simps!]
objOpOp (X : C) : coyoneda.obj (op (op X)) ≅ yoneda.obj X :=
NatIso.ofComponents fun _ => (opEquiv _ _).toIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | objOpOp | Taking the `unop` of morphisms is a natural isomorphism. |
opIso : yoneda ⋙ (whiskeringLeft _ _ _).obj (opOp C) ≅ coyoneda :=
NatIso.ofComponents (fun X ↦ NatIso.ofComponents (fun Y ↦ (opEquiv (op Y) X).toIso)
(fun _ ↦ rfl)) (fun _ ↦ rfl) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | opIso | Taking the `unop` of morphisms is a natural isomorphism. |
RepresentableBy (F : Cᵒᵖ ⥤ Type v) (Y : C) where
/-- the natural bijection `(X ⟶ Y) ≃ F.obj (op X)`. -/
homEquiv {X : C} : (X ⟶ Y) ≃ F.obj (op X)
homEquiv_comp {X X' : C} (f : X ⟶ X') (g : X' ⟶ Y) :
homEquiv (f ≫ g) = F.map f.op (homEquiv g) | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy | The data which expresses that a functor `F : Cᵒᵖ ⥤ Type v` is representable by `Y : C`. |
RepresentableBy.comp_homEquiv_symm {F : Cᵒᵖ ⥤ Type v} {Y : C}
(e : F.RepresentableBy Y) {X X' : C} (x : F.obj (op X')) (f : X ⟶ X') :
f ≫ e.homEquiv.symm x = e.homEquiv.symm (F.map f.op x) :=
e.homEquiv.injective (by simp [homEquiv_comp]) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.comp_homEquiv_symm | null |
RepresentableBy.ofIso {F F' : Cᵒᵖ ⥤ Type v} {Y : C} (e : F.RepresentableBy Y) (e' : F ≅ F') :
F'.RepresentableBy Y where
homEquiv {X} := e.homEquiv.trans (e'.app _).toEquiv
homEquiv_comp {X X'} f g := by
dsimp
rw [e.homEquiv_comp]
apply congr_fun (e'.hom.naturality f.op) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.ofIso | If `F ≅ F'`, and `F` is representable, then `F'` is representable. |
CorepresentableBy (F : C ⥤ Type v) (X : C) where
/-- the natural bijection `(X ⟶ Y) ≃ F.obj Y`. -/
homEquiv {Y : C} : (X ⟶ Y) ≃ F.obj Y
homEquiv_comp {Y Y' : C} (g : Y ⟶ Y') (f : X ⟶ Y) :
homEquiv (f ≫ g) = F.map g (homEquiv f) | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy | The data which expresses that a functor `F : C ⥤ Type v` is corepresentable by `X : C`. |
CorepresentableBy.homEquiv_symm_comp {F : C ⥤ Type v} {X : C}
(e : F.CorepresentableBy X) {Y Y' : C} (y : F.obj Y) (g : Y ⟶ Y') :
e.homEquiv.symm y ≫ g = e.homEquiv.symm (F.map g y) :=
e.homEquiv.injective (by simp [homEquiv_comp]) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.homEquiv_symm_comp | null |
CorepresentableBy.ofIso {F F' : C ⥤ Type v} {X : C} (e : F.CorepresentableBy X)
(e' : F ≅ F') :
F'.CorepresentableBy X where
homEquiv {X} := e.homEquiv.trans (e'.app _).toEquiv
homEquiv_comp {Y Y'} g f := by
dsimp
rw [e.homEquiv_comp]
apply congr_fun (e'.hom.naturality g) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.ofIso | If `F ≅ F'`, and `F` is corepresentable, then `F'` is corepresentable. |
RepresentableBy.homEquiv_eq {F : Cᵒᵖ ⥤ Type v} {Y : C} (e : F.RepresentableBy Y)
{X : C} (f : X ⟶ Y) :
e.homEquiv f = F.map f.op (e.homEquiv (𝟙 Y)) := by
conv_lhs => rw [← Category.comp_id f, e.homEquiv_comp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.homEquiv_eq | null |
CorepresentableBy.homEquiv_eq {F : C ⥤ Type v} {X : C} (e : F.CorepresentableBy X)
{Y : C} (f : X ⟶ Y) :
e.homEquiv f = F.map f (e.homEquiv (𝟙 X)) := by
conv_lhs => rw [← Category.id_comp f, e.homEquiv_comp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.homEquiv_eq | null |
@[simps!]
RepresentableBy.uniqueUpToIso {F : Cᵒᵖ ⥤ Type v} {Y Y' : C} (e : F.RepresentableBy Y)
(e' : F.RepresentableBy Y') : Y ≅ Y' :=
let ε {X} := (@e.homEquiv X).trans e'.homEquiv.symm
Yoneda.ext _ _ ε ε.symm (by simp) (by simp)
(by simp [ε, comp_homEquiv_symm, homEquiv_comp]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.uniqueUpToIso | Representing objects are unique up to isomorphism. |
@[simps!]
CorepresentableBy.uniqueUpToIso {F : C ⥤ Type v} {X X' : C} (e : F.CorepresentableBy X)
(e' : F.CorepresentableBy X') : X ≅ X' :=
let ε {Y} := (@e.homEquiv Y).trans e'.homEquiv.symm
Coyoneda.ext _ _ ε ε.symm (by simp) (by simp)
(by simp [ε, homEquiv_symm_comp, homEquiv_comp])
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.uniqueUpToIso | Corepresenting objects are unique up to isomorphism. |
RepresentableBy.ext {F : Cᵒᵖ ⥤ Type v} {Y : C} {e e' : F.RepresentableBy Y}
(h : e.homEquiv (𝟙 Y) = e'.homEquiv (𝟙 Y)) : e = e' := by
have : ∀ {X : C} (f : X ⟶ Y), e.homEquiv f = e'.homEquiv f := fun {X} f ↦ by
rw [e.homEquiv_eq, e'.homEquiv_eq, h]
obtain ⟨e, he⟩ := e
obtain ⟨e', he'⟩ := e'
obtain rfl : @e = @e' := by ext; apply this
rfl
@[ext] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.ext | null |
CorepresentableBy.ext {F : C ⥤ Type v} {X : C} {e e' : F.CorepresentableBy X}
(h : e.homEquiv (𝟙 X) = e'.homEquiv (𝟙 X)) : e = e' := by
have : ∀ {Y : C} (f : X ⟶ Y), e.homEquiv f = e'.homEquiv f := fun {X} f ↦ by
rw [e.homEquiv_eq, e'.homEquiv_eq, h]
obtain ⟨e, he⟩ := e
obtain ⟨e', he'⟩ := e'
obtain rfl : @e = @e' := by ext; apply this
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.ext | null |
representableByEquiv {F : Cᵒᵖ ⥤ Type v₁} {Y : C} :
F.RepresentableBy Y ≃ (yoneda.obj Y ≅ F) where
toFun r := NatIso.ofComponents (fun _ ↦ r.homEquiv.toIso) (fun {X X'} f ↦ by
ext g
simp [r.homEquiv_comp])
invFun e :=
{ homEquiv := (e.app _).toEquiv
homEquiv_comp := fun {X X'} f g ↦ congr_fun (e.hom.naturality f.op) g } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | representableByEquiv | The obvious bijection `F.RepresentableBy Y ≃ (yoneda.obj Y ≅ F)`
when `F : Cᵒᵖ ⥤ Type v₁` and `[Category.{v₁} C]`. |
RepresentableBy.toIso {F : Cᵒᵖ ⥤ Type v₁} {Y : C} (e : F.RepresentableBy Y) :
yoneda.obj Y ≅ F :=
representableByEquiv e | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.toIso | The isomorphism `yoneda.obj Y ≅ F` induced by `e : F.RepresentableBy Y`. |
corepresentableByEquiv {F : C ⥤ Type v₁} {X : C} :
F.CorepresentableBy X ≃ (coyoneda.obj (op X) ≅ F) where
toFun r := NatIso.ofComponents (fun _ ↦ r.homEquiv.toIso) (fun {X X'} f ↦ by
ext g
simp [r.homEquiv_comp])
invFun e :=
{ homEquiv := (e.app _).toEquiv
homEquiv_comp := fun {X X'} f g ↦ congr_fun (e.hom.naturality f) g } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | corepresentableByEquiv | The obvious bijection `F.CorepresentableBy X ≃ (yoneda.obj Y ≅ F)`
when `F : C ⥤ Type v₁` and `[Category.{v₁} C]`. |
CorepresentableBy.toIso {F : C ⥤ Type v₁} {X : C} (e : F.CorepresentableBy X) :
coyoneda.obj (op X) ≅ F :=
corepresentableByEquiv e | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.toIso | The isomorphism `coyoneda.obj (op X) ≅ F` induced by `e : F.CorepresentableBy X`. |
@[stacks 001Q]
IsRepresentable (F : Cᵒᵖ ⥤ Type v) : Prop where
has_representation : ∃ (Y : C), Nonempty (F.RepresentableBy Y) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | IsRepresentable | 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`. |
RepresentableBy.isRepresentable {F : Cᵒᵖ ⥤ Type v} {Y : C} (e : F.RepresentableBy Y) :
F.IsRepresentable where
has_representation := ⟨Y, ⟨e⟩⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.isRepresentable | null |
IsRepresentable.mk' {F : Cᵒᵖ ⥤ Type v₁} {X : C} (e : yoneda.obj X ≅ F) :
F.IsRepresentable :=
(representableByEquiv.symm e).isRepresentable | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | IsRepresentable.mk' | Alternative constructor for `F.IsRepresentable`, which takes as an input an
isomorphism `yoneda.obj X ≅ F`. |
@[stacks 001Q]
IsCorepresentable (F : C ⥤ Type v) : Prop where
has_corepresentation : ∃ (X : C), Nonempty (F.CorepresentableBy X) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | IsCorepresentable | A functor `F : C ⥤ Type v₁` is corepresentable if there is object `X` so `F ≅ coyoneda.obj X`. |
CorepresentableBy.isCorepresentable {F : C ⥤ Type v} {X : C} (e : F.CorepresentableBy X) :
F.IsCorepresentable where
has_corepresentation := ⟨X, ⟨e⟩⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.isCorepresentable | null |
IsCorepresentable.mk' {F : C ⥤ Type v₁} {X : C} (e : coyoneda.obj (op X) ≅ F) :
F.IsCorepresentable :=
(corepresentableByEquiv.symm e).isCorepresentable | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | IsCorepresentable.mk' | Alternative constructor for `F.IsCorepresentable`, which takes as an input an
isomorphism `coyoneda.obj (op X) ≅ F`. |
noncomputable reprX : C :=
hF.has_representation.choose | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | reprX | The representing object for the representable functor `F`. |
noncomputable representableBy : F.RepresentableBy F.reprX :=
hF.has_representation.choose_spec.some | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | representableBy | A chosen term in `F.RepresentableBy (reprX F)` when `F.IsRepresentable` holds. |
noncomputable RepresentableBy.isoReprX {Y : C} (e : F.RepresentableBy Y) :
Y ≅ F.reprX :=
RepresentableBy.uniqueUpToIso e (representableBy F) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | RepresentableBy.isoReprX | Any representing object for a representable functor `F` is isomorphic to `reprX F`. |
noncomputable reprx : F.obj (op F.reprX) :=
F.representableBy.homEquiv (𝟙 _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | reprx | The representing element for the representable functor `F`, sometimes called the universal
element of the functor. |
noncomputable reprW (F : Cᵒᵖ ⥤ Type v₁) [F.IsRepresentable] :
yoneda.obj F.reprX ≅ F := F.representableBy.toIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | reprW | 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`. |
reprW_hom_app (F : Cᵒᵖ ⥤ Type v₁) [F.IsRepresentable]
(X : Cᵒᵖ) (f : unop X ⟶ F.reprX) :
F.reprW.hom.app X f = F.map f.op F.reprx := by
apply RepresentableBy.homEquiv_eq | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | reprW_hom_app | null |
noncomputable coreprX : C :=
hF.has_corepresentation.choose | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coreprX | The representing object for the corepresentable functor `F`. |
noncomputable corepresentableBy : F.CorepresentableBy F.coreprX :=
hF.has_corepresentation.choose_spec.some
variable {F} in | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | corepresentableBy | A chosen term in `F.CorepresentableBy (coreprX F)` when `F.IsCorepresentable` holds. |
noncomputable CorepresentableBy.isoCoreprX {Y : C} (e : F.CorepresentableBy Y) :
Y ≅ F.coreprX :=
CorepresentableBy.uniqueUpToIso e (corepresentableBy F) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | CorepresentableBy.isoCoreprX | Any corepresenting object for a corepresentable functor `F` is isomorphic to `coreprX F`. |
noncomputable coreprx : F.obj F.coreprX :=
F.corepresentableBy.homEquiv (𝟙 _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coreprx | The representing element for the corepresentable functor `F`, sometimes called the universal
element of the functor. |
noncomputable coreprW (F : C ⥤ Type v₁) [F.IsCorepresentable] :
coyoneda.obj (op F.coreprX) ≅ F :=
F.corepresentableBy.toIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coreprW | 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`. |
coreprW_hom_app (F : C ⥤ Type v₁) [F.IsCorepresentable] (X : C) (f : F.coreprX ⟶ X) :
F.coreprW.hom.app X f = F.map f F.coreprx := by
apply CorepresentableBy.homEquiv_eq | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coreprW_hom_app | null |
isRepresentable_of_natIso (F : Cᵒᵖ ⥤ Type v₁) {G} (i : F ≅ G) [F.IsRepresentable] :
G.IsRepresentable :=
(F.representableBy.ofIso i).isRepresentable | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isRepresentable_of_natIso | null |
corepresentable_of_natIso (F : C ⥤ Type v₁) {G} (i : F ≅ G) [F.IsCorepresentable] :
G.IsCorepresentable :=
(F.corepresentableBy.ofIso i).isCorepresentable | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | corepresentable_of_natIso | null |
prodCategoryInstance1 : Category ((Cᵒᵖ ⥤ Type v₁) × Cᵒᵖ) :=
CategoryTheory.prod.{max u₁ v₁, v₁} (Cᵒᵖ ⥤ Type v₁) Cᵒᵖ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | prodCategoryInstance1 | null |
prodCategoryInstance2 : Category (Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)) :=
CategoryTheory.prod.{v₁, max u₁ v₁} Cᵒᵖ (Cᵒᵖ ⥤ Type v₁)
open Yoneda | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | prodCategoryInstance2 | null |
yonedaEquiv {X : C} {F : Cᵒᵖ ⥤ Type v₁} : (yoneda.obj X ⟶ F) ≃ F.obj (op X) where
toFun η := η.app (op X) (𝟙 X)
invFun ξ := { app := fun _ f ↦ F.map f.op ξ }
left_inv := by
intro η
ext Y f
dsimp
rw [← FunctorToTypes.naturality]
simp
right_inv := by intro ξ; simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv | We have a type-level equivalence between natural transformations from the yoneda embedding
and elements of `F.obj X`, without any universe switching. |
yonedaEquiv_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X ⟶ F) :
yonedaEquiv f = f.app (op X) (𝟙 X) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_apply | null |
yonedaEquiv_symm_app_apply {X : C} {F : Cᵒᵖ ⥤ Type v₁} (x : F.obj (op X)) (Y : Cᵒᵖ)
(f : Y.unop ⟶ X) : (yonedaEquiv.symm x).app Y f = F.map f.op x :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_symm_app_apply | null |
yonedaEquiv_naturality {X Y : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X ⟶ F)
(g : Y ⟶ X) : F.map g.op (yonedaEquiv f) = yonedaEquiv (yoneda.map g ≫ f) := by
change (f.app (op X) ≫ F.map g.op) (𝟙 X) = f.app (op Y) (𝟙 Y ≫ g)
rw [← f.naturality]
simp | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_naturality | See also `yonedaEquiv_naturality'` for a more general version. |
yonedaEquiv_naturality' {X Y : Cᵒᵖ} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj (unop X) ⟶ F)
(g : X ⟶ Y) : F.map g (yonedaEquiv f) = yonedaEquiv (yoneda.map g.unop ≫ f) :=
yonedaEquiv_naturality _ _ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_naturality' | 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. |
yonedaEquiv_comp {X : C} {F G : Cᵒᵖ ⥤ Type v₁} (α : yoneda.obj X ⟶ F) (β : F ⟶ G) :
yonedaEquiv (α ≫ β) = β.app _ (yonedaEquiv α) :=
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_comp | null |
yonedaEquiv_yoneda_map {X Y : C} (f : X ⟶ Y) : yonedaEquiv (yoneda.map f) = f := by
rw [yonedaEquiv_apply]
simp | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_yoneda_map | null |
yonedaEquiv_symm_naturality_left {X X' : C} (f : X' ⟶ X) (F : Cᵒᵖ ⥤ Type v₁)
(x : F.obj ⟨X⟩) : yoneda.map f ≫ yonedaEquiv.symm x = yonedaEquiv.symm ((F.map f.op) x) := by
apply yonedaEquiv.injective
simp only [yonedaEquiv_comp, yoneda_obj_obj, yonedaEquiv_symm_app_apply, Equiv.apply_symm_apply]
erw [yonedaEquiv_yoneda_map] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_symm_naturality_left | null |
yonedaEquiv_symm_naturality_right (X : C) {F F' : Cᵒᵖ ⥤ Type v₁} (f : F ⟶ F')
(x : F.obj ⟨X⟩) : yonedaEquiv.symm x ≫ f = yonedaEquiv.symm (f.app ⟨X⟩ x) := by
apply yonedaEquiv.injective
simp [yonedaEquiv_comp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_symm_naturality_right | null |
map_yonedaEquiv {X Y : C} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj X ⟶ F)
(g : Y ⟶ X) : F.map g.op (yonedaEquiv f) = f.app (op Y) g := by
rw [yonedaEquiv_naturality, yonedaEquiv_comp, yonedaEquiv_yoneda_map] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | map_yonedaEquiv | See also `map_yonedaEquiv'` for a more general version. |
map_yonedaEquiv' {X Y : Cᵒᵖ} {F : Cᵒᵖ ⥤ Type v₁} (f : yoneda.obj (unop X) ⟶ F)
(g : X ⟶ Y) : F.map g (yonedaEquiv f) = f.app Y g.unop := by
rw [yonedaEquiv_naturality', yonedaEquiv_comp, yonedaEquiv_yoneda_map] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | map_yonedaEquiv' | 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. |
yonedaEquiv_symm_map {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Cᵒᵖ ⥤ Type v₁} (t : F.obj X) :
yonedaEquiv.symm (F.map f t) = yoneda.map f.unop ≫ yonedaEquiv.symm t := by
obtain ⟨u, rfl⟩ := yonedaEquiv.surjective t
rw [yonedaEquiv_naturality', Equiv.symm_apply_apply, Equiv.symm_apply_apply] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEquiv_symm_map | null |
hom_ext_yoneda {P Q : Cᵒᵖ ⥤ Type v₁} {f g : P ⟶ Q}
(h : ∀ (X : C) (p : yoneda.obj X ⟶ P), p ≫ f = p ≫ g) :
f = g := by
ext X x
simpa only [yonedaEquiv_comp, Equiv.apply_symm_apply]
using congr_arg (yonedaEquiv) (h _ (yonedaEquiv.symm x))
variable (C) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | hom_ext_yoneda | Two morphisms of presheaves of types `P ⟶ Q` coincide if the precompositions
with morphisms `yoneda.obj X ⟶ P` agree. |
yonedaEvaluation : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁) ⥤ Type max u₁ v₁ :=
evaluationUncurried Cᵒᵖ (Type v₁) ⋙ uliftFunctor
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEvaluation | The "Yoneda evaluation" functor, which sends `X : Cᵒᵖ` and `F : Cᵒᵖ ⥤ Type`
to `F.obj X`, functorially in both `X` and `F`. |
yonedaEvaluation_map_down (P Q : Cᵒᵖ × (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) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaEvaluation_map_down | null |
yonedaPairing : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁) ⥤ Type max u₁ v₁ :=
Functor.prod yoneda.op (𝟭 (Cᵒᵖ ⥤ Type v₁)) ⋙ Functor.hom (Cᵒᵖ ⥤ Type v₁)
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaPairing | The "Yoneda pairing" functor, which sends `X : Cᵒᵖ` and `F : Cᵒᵖ ⥤ Type`
to `yoneda.op.obj X ⟶ F`, functorially in both `X` and `F`. |
yonedaPairingExt {X : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)} {x y : (yonedaPairing C).obj X}
(w : ∀ Y, x.app Y = y.app Y) : x = y :=
NatTrans.ext (funext w)
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaPairingExt | null |
yonedaPairing_map (P Q : Cᵒᵖ × (Cᵒᵖ ⥤ Type v₁)) (α : P ⟶ Q) (β : (yonedaPairing C).obj P) :
(yonedaPairing C).map α β = yoneda.map α.1.unop ≫ β ≫ α.2 :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaPairing_map | null |
@[stacks 001P]
yonedaLemma : yonedaPairing C ≅ yonedaEvaluation C :=
NatIso.ofComponents
(fun _ ↦ Equiv.toIso (yonedaEquiv.trans Equiv.ulift.symm))
(by intro (X, F) (Y, G) f
ext (a : yoneda.obj X.unop ⟶ F)
apply ULift.ext
dsimp [yonedaEvaluation, yonedaEquiv]
simp [← FunctorToTypes.naturality])
variable {C}
/- Porting note: this used to be two calls to `tidy` -/ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaLemma | 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`. |
curriedYonedaLemma {C : Type u₁} [SmallCategory C] :
(yoneda.op ⋙ coyoneda : Cᵒᵖ ⥤ (Cᵒᵖ ⥤ Type u₁) ⥤ Type u₁) ≅ evaluation Cᵒᵖ (Type u₁) :=
NatIso.ofComponents (fun X ↦ NatIso.ofComponents (fun _ ↦ Equiv.toIso yonedaEquiv)) (by
intro X Y f
ext a b
simp [yonedaEquiv, ← FunctorToTypes.naturality]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | curriedYonedaLemma | The curried version of yoneda lemma when `C` is small. |
largeCurriedYonedaLemma {C : Type u₁} [Category.{v₁} C] :
yoneda.op ⋙ coyoneda ≅
evaluation Cᵒᵖ (Type v₁) ⋙ (whiskeringRight _ _ _).obj uliftFunctor.{u₁} :=
NatIso.ofComponents
(fun X => NatIso.ofComponents
(fun _ => Equiv.toIso <| yonedaEquiv.trans Equiv.ulift.symm)
(by
intro Y Z f
ext g
rw [← ULift.down_inj]
simpa using yonedaEquiv_comp _ _))
(by
intro Y Z f
ext F g
rw [← ULift.down_inj]
simpa using (yonedaEquiv_naturality _ _).symm) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | largeCurriedYonedaLemma | The curried version of the Yoneda lemma. |
yonedaOpCompYonedaObj {C : Type u₁} [Category.{v₁} C] (P : Cᵒᵖ ⥤ Type v₁) :
yoneda.op ⋙ yoneda.obj P ≅ P ⋙ uliftFunctor.{u₁} :=
isoWhiskerRight largeCurriedYonedaLemma ((evaluation _ _).obj P) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaOpCompYonedaObj | Version of the Yoneda lemma where the presheaf is fixed but the argument varies. |
curriedYonedaLemma' {C : Type u₁} [SmallCategory C] :
yoneda ⋙ (whiskeringLeft Cᵒᵖ (Cᵒᵖ ⥤ Type u₁)ᵒᵖ (Type u₁)).obj yoneda.op
≅ 𝟭 (Cᵒᵖ ⥤ Type u₁) :=
NatIso.ofComponents (fun F ↦ NatIso.ofComponents (fun _ ↦ Equiv.toIso yonedaEquiv) (by
intro X Y f
ext a
dsimp [yonedaEquiv]
simp [← FunctorToTypes.naturality])) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | curriedYonedaLemma' | The curried version of yoneda lemma when `C` is small. |
isIso_of_yoneda_map_bijective {X Y : C} (f : X ⟶ Y)
(hf : ∀ (T : C), Function.Bijective (fun (x : T ⟶ X) => x ≫ f)) :
IsIso f := by
obtain ⟨g, hg : g ≫ f = 𝟙 Y⟩ := (hf Y).2 (𝟙 Y)
exact ⟨g, (hf _).1 (by cat_disch), hg⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_of_yoneda_map_bijective | null |
isIso_iff_yoneda_map_bijective {X Y : C} (f : X ⟶ Y) :
IsIso f ↔ (∀ (T : C), Function.Bijective (fun (x : T ⟶ X) => x ≫ f)) := by
refine ⟨fun _ ↦ ?_, fun hf ↦ isIso_of_yoneda_map_bijective f hf⟩
intro T
rw [← isIso_iff_bijective]
exact inferInstanceAs (IsIso ((yoneda.map f).app _)) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_iff_yoneda_map_bijective | null |
isIso_iff_isIso_yoneda_map {X Y : C} (f : X ⟶ Y) :
IsIso f ↔ ∀ c : C, IsIso ((yoneda.map f).app ⟨c⟩) := by
rw [isIso_iff_yoneda_map_bijective]
exact forall_congr' fun _ ↦ (isIso_iff_bijective _).symm | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_iff_isIso_yoneda_map | null |
@[simps! -isSimp]
uliftYonedaEquiv {X : C} {F : Cᵒᵖ ⥤ Type (max w v₁)} :
(uliftYoneda.{w}.obj X ⟶ F) ≃ F.obj (op X) where
toFun τ := τ.app (op X) (ULift.up (𝟙 _))
invFun x := { app Y y := F.map y.down.op x }
left_inv τ := by
ext ⟨Y⟩ ⟨y⟩
simp [uliftYoneda, ← FunctorToTypes.naturality]
right_inv x := by simp
@[deprecated (since := "2025-08-04")] alias yonedaCompUliftFunctorEquiv :=
uliftYonedaEquiv
attribute [simp] uliftYonedaEquiv_symm_apply_app | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaEquiv | 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`. |
uliftYonedaEquiv_naturality {X Y : Cᵒᵖ} {F : Cᵒᵖ ⥤ Type max w v₁}
(f : uliftYoneda.{w}.obj (unop X) ⟶ F)
(g : X ⟶ Y) : F.map g (uliftYonedaEquiv.{w} f) =
uliftYonedaEquiv.{w} (uliftYoneda.map g.unop ≫ f) := by
simp [uliftYonedaEquiv, uliftYoneda,
← FunctorToTypes.naturality _ _ f g (ULift.up (𝟙 _))] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaEquiv_naturality | null |
uliftYonedaEquiv_comp {X : C} {F G : Cᵒᵖ ⥤ Type max w v₁}
(α : uliftYoneda.{w}.obj X ⟶ F) (β : F ⟶ G) :
uliftYonedaEquiv.{w} (α ≫ β) = β.app _ (uliftYonedaEquiv α) :=
rfl
@[reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaEquiv_comp | null |
uliftYonedaEquiv_symm_map {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Cᵒᵖ ⥤ Type max w v₁}
(t : F.obj X) :
uliftYonedaEquiv.{w}.symm (F.map f t) =
uliftYoneda.map f.unop ≫ uliftYonedaEquiv.symm t := by
obtain ⟨u, rfl⟩ := uliftYonedaEquiv.surjective t
rw [uliftYonedaEquiv_naturality]
simp
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaEquiv_symm_map | null |
uliftYonedaEquiv_uliftYoneda_map {X Y : C} (f : X ⟶ Y) :
DFunLike.coe (β := fun _ ↦ ULift.{w} (X ⟶ Y))
uliftYonedaEquiv.{w} (uliftYoneda.map f) = ULift.up f := by
simp [uliftYonedaEquiv, uliftYoneda] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaEquiv_uliftYoneda_map | null |
hom_ext_uliftYoneda {P Q : Cᵒᵖ ⥤ Type max w v₁} {f g : P ⟶ Q}
(h : ∀ (X : C) (p : uliftYoneda.{w}.obj X ⟶ P), p ≫ f = p ≫ g) :
f = g := by
ext X x
simpa [uliftYonedaEquiv] using congr_arg uliftYonedaEquiv.{w} (h _ (uliftYonedaEquiv.symm x)) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | hom_ext_uliftYoneda | Two morphisms of presheaves of types `P ⟶ Q` coincide if the precompositions
with morphisms `uliftYoneda.obj X ⟶ P` agree. |
coyonedaEquiv {X : C} {F : C ⥤ Type v₁} : (coyoneda.obj (op X) ⟶ F) ≃ F.obj X where
toFun η := η.app X (𝟙 X)
invFun ξ := { app := fun _ x ↦ F.map x ξ }
left_inv := fun η ↦ by
ext Y (x : X ⟶ Y)
dsimp
rw [← FunctorToTypes.naturality]
simp
right_inv := by intro ξ; simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv | We have a type-level equivalence between natural transformations from the coyoneda embedding
and elements of `F.obj X.unop`, without any universe switching. |
coyonedaEquiv_apply {X : C} {F : C ⥤ Type v₁} (f : coyoneda.obj (op X) ⟶ F) :
coyonedaEquiv f = f.app X (𝟙 X) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_apply | null |
coyonedaEquiv_symm_app_apply {X : C} {F : C ⥤ Type v₁} (x : F.obj X) (Y : C)
(f : X ⟶ Y) : (coyonedaEquiv.symm x).app Y f = F.map f x :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_symm_app_apply | null |
coyonedaEquiv_naturality {X Y : C} {F : C ⥤ Type v₁} (f : coyoneda.obj (op X) ⟶ F)
(g : X ⟶ Y) : F.map g (coyonedaEquiv f) = coyonedaEquiv (coyoneda.map g.op ≫ f) := by
change (f.app X ≫ F.map g) (𝟙 X) = f.app Y (g ≫ 𝟙 Y)
rw [← f.naturality]
simp | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_naturality | null |
coyonedaEquiv_comp {X : C} {F G : C ⥤ Type v₁} (α : coyoneda.obj (op X) ⟶ F) (β : F ⟶ G) :
coyonedaEquiv (α ≫ β) = β.app _ (coyonedaEquiv α) := by
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_comp | null |
coyonedaEquiv_coyoneda_map {X Y : C} (f : X ⟶ Y) :
coyonedaEquiv (coyoneda.map f.op) = f := by
rw [coyonedaEquiv_apply]
simp | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_coyoneda_map | null |
map_coyonedaEquiv {X Y : C} {F : C ⥤ Type v₁} (f : coyoneda.obj (op X) ⟶ F)
(g : X ⟶ Y) : F.map g (coyonedaEquiv f) = f.app Y g := by
rw [coyonedaEquiv_naturality, coyonedaEquiv_comp, coyonedaEquiv_coyoneda_map] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | map_coyonedaEquiv | null |
coyonedaEquiv_symm_map {X Y : C} (f : X ⟶ Y) {F : C ⥤ Type v₁} (t : F.obj X) :
coyonedaEquiv.symm (F.map f t) = coyoneda.map f.op ≫ coyonedaEquiv.symm t := by
obtain ⟨u, rfl⟩ := coyonedaEquiv.surjective t
simp [coyonedaEquiv_naturality u f]
variable (C) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEquiv_symm_map | null |
coyonedaEvaluation : C × (C ⥤ Type v₁) ⥤ Type max u₁ v₁ :=
evaluationUncurried C (Type v₁) ⋙ uliftFunctor
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEvaluation | The "Coyoneda evaluation" functor, which sends `X : C` and `F : C ⥤ Type`
to `F.obj X`, functorially in both `X` and `F`. |
coyonedaEvaluation_map_down (P Q : C × (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) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaEvaluation_map_down | null |
coyonedaPairing : C × (C ⥤ Type v₁) ⥤ Type max u₁ v₁ :=
Functor.prod coyoneda.rightOp (𝟭 (C ⥤ Type v₁)) ⋙ Functor.hom (C ⥤ Type v₁)
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaPairing | The "Coyoneda pairing" functor, which sends `X : C` and `F : C ⥤ Type`
to `coyoneda.rightOp.obj X ⟶ F`, functorially in both `X` and `F`. |
coyonedaPairingExt {X : C × (C ⥤ Type v₁)} {x y : (coyonedaPairing C).obj X}
(w : ∀ Y, x.app Y = y.app Y) : x = y :=
NatTrans.ext (funext w)
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaPairingExt | null |
coyonedaPairing_map (P Q : C × (C ⥤ Type v₁)) (α : P ⟶ Q) (β : (coyonedaPairing C).obj P) :
(coyonedaPairing C).map α β = coyoneda.map α.1.op ≫ β ≫ α.2 :=
rfl
variable {C} in | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaPairing_map | null |
coyonedaCompUliftFunctorEquiv (F : C ⥤ Type max v₁ w) (X : Cᵒᵖ) :
(coyoneda.obj X ⋙ uliftFunctor ⟶ F) ≃ F.obj X.unop where
toFun φ := φ.app X.unop (ULift.up (𝟙 _))
invFun f :=
{ app := fun _ x => F.map (ULift.down x) f }
left_inv φ := by
ext Y f
dsimp
rw [← FunctorToTypes.naturality]
dsimp
rw [Category.id_comp]
rfl
right_inv f := by simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaCompUliftFunctorEquiv | A bijection `(coyoneda.obj X ⋙ uliftFunctor ⟶ F) ≃ F.obj (unop X)` which is a variant
of `coyonedaEquiv` with heterogeneous universes. |
@[stacks 001P]
coyonedaLemma : coyonedaPairing C ≅ coyonedaEvaluation C :=
NatIso.ofComponents
(fun _ ↦ Equiv.toIso (coyonedaEquiv.trans Equiv.ulift.symm))
(by intro (X, F) (Y, G) f
ext (a : coyoneda.obj (op X) ⟶ F)
apply ULift.ext
dsimp [coyonedaEquiv, coyonedaEvaluation]
simp [← FunctorToTypes.naturality])
variable {C}
/- Porting note: this used to be two calls to `tidy` -/ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaLemma | 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`. |
curriedCoyonedaLemma {C : Type u₁} [SmallCategory C] :
coyoneda.rightOp ⋙ coyoneda ≅ evaluation C (Type u₁) :=
NatIso.ofComponents (fun X ↦ NatIso.ofComponents (fun _ ↦ Equiv.toIso coyonedaEquiv)) (by
intro X Y f
ext a b
simp [coyonedaEquiv, ← FunctorToTypes.naturality]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | curriedCoyonedaLemma | The curried version of coyoneda lemma when `C` is small. |
largeCurriedCoyonedaLemma {C : Type u₁} [Category.{v₁} C] :
(coyoneda.rightOp ⋙ coyoneda) ≅
evaluation C (Type v₁) ⋙ (whiskeringRight _ _ _).obj uliftFunctor.{u₁} :=
NatIso.ofComponents
(fun X => NatIso.ofComponents
(fun _ => Equiv.toIso <| coyonedaEquiv.trans Equiv.ulift.symm)
(by
intro Y Z f
ext g
rw [← ULift.down_inj]
simpa using coyonedaEquiv_comp _ _))
(by
intro Y Z f
ext F g
rw [← ULift.down_inj]
simpa using (coyonedaEquiv_naturality _ _).symm) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | largeCurriedCoyonedaLemma | The curried version of the Coyoneda lemma. |
coyonedaCompYonedaObj {C : Type u₁} [Category.{v₁} C] (P : C ⥤ Type v₁) :
coyoneda.rightOp ⋙ yoneda.obj P ≅ P ⋙ uliftFunctor.{u₁} :=
isoWhiskerRight largeCurriedCoyonedaLemma ((evaluation _ _).obj P) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyonedaCompYonedaObj | Version of the Coyoneda lemma where the presheaf is fixed but the argument varies. |
curriedCoyonedaLemma' {C : Type u₁} [SmallCategory C] :
yoneda ⋙ (whiskeringLeft C (C ⥤ Type u₁)ᵒᵖ (Type u₁)).obj coyoneda.rightOp
≅ 𝟭 (C ⥤ Type u₁) :=
NatIso.ofComponents (fun F ↦ NatIso.ofComponents (fun _ ↦ Equiv.toIso coyonedaEquiv) (by
intro X Y f
ext a
simp [coyonedaEquiv, ← FunctorToTypes.naturality])) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | curriedCoyonedaLemma' | The curried version of coyoneda lemma when `C` is small. |
isIso_of_coyoneda_map_bijective {X Y : C} (f : X ⟶ Y)
(hf : ∀ (T : C), Function.Bijective (fun (x : Y ⟶ T) => f ≫ x)) :
IsIso f := by
obtain ⟨g, hg : f ≫ g = 𝟙 X⟩ := (hf X).2 (𝟙 X)
refine ⟨g, hg, (hf _).1 ?_⟩
simp only [Category.comp_id, ← Category.assoc, hg, Category.id_comp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_of_coyoneda_map_bijective | null |
isIso_iff_coyoneda_map_bijective {X Y : C} (f : X ⟶ Y) :
IsIso f ↔ (∀ (T : C), Function.Bijective (fun (x : Y ⟶ T) => f ≫ x)) := by
refine ⟨fun _ ↦ ?_, fun hf ↦ isIso_of_coyoneda_map_bijective f hf⟩
intro T
rw [← isIso_iff_bijective]
exact inferInstanceAs (IsIso ((coyoneda.map f.op).app _)) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_iff_coyoneda_map_bijective | null |
isIso_iff_isIso_coyoneda_map {X Y : C} (f : X ⟶ Y) :
IsIso f ↔ ∀ c : C, IsIso ((coyoneda.map f.op).app c) := by
rw [isIso_iff_coyoneda_map_bijective]
exact forall_congr' fun _ ↦ (isIso_iff_bijective _).symm | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso_iff_isIso_coyoneda_map | null |
yonedaMap (X : C) : yoneda.obj X ⟶ F.op ⋙ yoneda.obj (F.obj X) where
app _ f := F.map f
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaMap | The natural transformation `yoneda.obj X ⟶ F.op ⋙ yoneda.obj (F.obj X)`
when `F : C ⥤ D` and `X : C`. |
yonedaMap_app_apply {Y : C} {X : Cᵒᵖ} (f : X.unop ⟶ Y) :
(yonedaMap F Y).app X f = F.map f := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yonedaMap_app_apply | null |
uliftYonedaMap (X : C) :
uliftYoneda.{max w v₂}.obj X ⟶ F.op ⋙ uliftYoneda.{max w v₁}.obj (F.obj X) where
app _ f := ULift.up (F.map (ULift.down f))
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaMap | The natural transformation `uliftYoneda.obj X ⟶ F.op ⋙ uliftYoneda.obj (F.obj X)`
when `F : C ⥤ D` and `X : C`. |
uliftYonedaMap_app_apply {Y : C} {X : Cᵒᵖ} (f : X.unop ⟶ Y) :
(uliftYonedaMap.{w} F Y).app X (ULift.up f) = ULift.up (F.map f) := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaMap_app_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.