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 ⌀ |
|---|---|---|---|---|---|---|
UnivLE.ofEssSurj (w : (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj) :
UnivLE.{max u v, v} where
small α := by
obtain ⟨a', ⟨m⟩⟩ := w.mem_essImage α
exact ⟨a', ⟨(Iso.toEquiv m).symm.trans Equiv.ulift⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.Logic.UnivLE"
] | Mathlib/CategoryTheory/UnivLE.lean | UnivLE.ofEssSurj | null |
EssSurj.ofUnivLE [UnivLE.{max u v, v}] :
(uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj where
mem_essImage α :=
⟨Shrink α, ⟨Equiv.toIso (Equiv.ulift.trans (equivShrink α).symm)⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.Logic.UnivLE"
] | Mathlib/CategoryTheory/UnivLE.lean | EssSurj.ofUnivLE | null |
UnivLE_iff_essSurj :
UnivLE.{max u v, v} ↔ (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj :=
⟨fun _ => inferInstance, fun w => UnivLE.ofEssSurj w⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.Logic.UnivLE"
] | Mathlib/CategoryTheory/UnivLE.lean | UnivLE_iff_essSurj | null |
UnivLE.witness [UnivLE.{max u v, v}] : Type u ⥤ Type v :=
uliftFunctor.{v, u} ⋙ (uliftFunctor.{u, v}).inv | def | CategoryTheory | [
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.Logic.UnivLE"
] | Mathlib/CategoryTheory/UnivLE.lean | UnivLE.witness | null |
@[simps]
whiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) :
F ⋙ G ⟶ F ⋙ H where
app X := α.app (F.obj X)
naturality X Y f := by rw [Functor.comp_map, Functor.comp_map, α.naturality]
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft | If `α : G ⟶ H` then `whiskerLeft F α : F ⋙ G ⟶ F ⋙ H` has components `α.app (F.obj X)`. |
id_hcomp (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) : 𝟙 F ◫ α = whiskerLeft F α := by
ext
simp | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | id_hcomp | null |
@[simps]
whiskerRight {G H : C ⥤ D} (α : G ⟶ H) (F : D ⥤ E) :
G ⋙ F ⟶ H ⋙ F where
app X := F.map (α.app X)
naturality X Y f := by
rw [Functor.comp_map, Functor.comp_map, ← F.map_comp, ← F.map_comp, α.naturality]
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight | If `α : G ⟶ H` then `whiskerRight α F : G ⋙ F ⟶ H ⋙ F` has components `F.map (α.app X)`. |
hcomp_id {G H : C ⥤ D} (α : G ⟶ H) (F : D ⥤ E) : α ◫ 𝟙 F = whiskerRight α F := by
ext
simp
variable (C D E) | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | hcomp_id | null |
@[simps]
whiskeringLeft : (C ⥤ D) ⥤ (D ⥤ E) ⥤ C ⥤ E where
obj F :=
{ obj := fun G => F ⋙ G
map := fun α => whiskerLeft F α }
map τ :=
{ app := fun H =>
{ app := fun c => H.map (τ.app c)
naturality := fun X Y f => by dsimp; rw [← H.map_comp, ← H.map_comp, ← τ.naturality] }
naturality := fun X Y f => by ext; dsimp; rw [f.naturality] } | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft | Left-composition gives a functor `(C ⥤ D) ⥤ ((D ⥤ E) ⥤ (C ⥤ E))`.
`(whiskeringLeft.obj F).obj G` is `F ⋙ G`, and
`(whiskeringLeft.obj F).map α` is `whiskerLeft F α`. |
@[simps]
whiskeringRight : (D ⥤ E) ⥤ (C ⥤ D) ⥤ C ⥤ E where
obj H :=
{ obj := fun F => F ⋙ H
map := fun α => whiskerRight α H }
map τ :=
{ app := fun F =>
{ app := fun c => τ.app (F.obj c)
naturality := fun X Y f => by dsimp; rw [τ.naturality] }
naturality := fun X Y f => by ext; dsimp; rw [← NatTrans.naturality] }
variable {C} {D} {E} | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringRight | Right-composition gives a functor `(D ⥤ E) ⥤ ((C ⥤ D) ⥤ (C ⥤ E))`.
`(whiskeringRight.obj H).obj F` is `F ⋙ H`, and
`(whiskeringRight.obj H).map α` is `whiskerRight α H`. |
faithful_whiskeringRight_obj {F : D ⥤ E} [F.Faithful] :
((whiskeringRight C D E).obj F).Faithful where
map_injective hαβ := by
ext X
exact F.map_injective <| congr_fun (congr_arg NatTrans.app hαβ) X | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | faithful_whiskeringRight_obj | null |
@[simps]
FullyFaithful.whiskeringRight {F : D ⥤ E} (hF : F.FullyFaithful)
(C : Type*) [Category C] :
((whiskeringRight C D E).obj F).FullyFaithful where
preimage f :=
{ app := fun X => hF.preimage (f.app X)
naturality := fun _ _ g => by
apply hF.map_injective
dsimp
simp only [map_comp, map_preimage]
apply f.naturality } | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | FullyFaithful.whiskeringRight | If `F : D ⥤ E` is fully faithful, then so is
`(whiskeringRight C D E).obj F : (C ⥤ D) ⥤ C ⥤ E`. |
whiskeringLeft_obj_id : (whiskeringLeft C C E).obj (𝟭 _) = 𝟭 _ :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft_obj_id | null |
@[simps!]
whiskeringLeftObjIdIso : (whiskeringLeft C C E).obj (𝟭 _) ≅ 𝟭 _ :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeftObjIdIso | The isomorphism between left-whiskering on the identity functor and the identity of the functor
between the resulting functor categories. |
whiskeringLeft_obj_comp {D' : Type u₄} [Category.{v₄} D'] (F : C ⥤ D) (G : D ⥤ D') :
(whiskeringLeft C D' E).obj (F ⋙ G) =
(whiskeringLeft D D' E).obj G ⋙ (whiskeringLeft C D E).obj F :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft_obj_comp | null |
@[simps!]
whiskeringLeftObjCompIso {D' : Type u₄} [Category.{v₄} D'] (F : C ⥤ D) (G : D ⥤ D') :
(whiskeringLeft C D' E).obj (F ⋙ G) ≅
(whiskeringLeft D D' E).obj G ⋙ (whiskeringLeft C D E).obj F :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeftObjCompIso | The isomorphism between left-whiskering on the composition of functors and the composition
of two left-whiskering applications. |
whiskeringRight_obj_id : (whiskeringRight E C C).obj (𝟭 _) = 𝟭 _ :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringRight_obj_id | null |
@[simps!]
whiskeringRightObjIdIso : (whiskeringRight E C C).obj (𝟭 _) ≅ 𝟭 _ :=
Iso.refl _
@[deprecated (since := "2025-04-04")] alias wiskeringRightObjIdIso := whiskeringRightObjIdIso | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringRightObjIdIso | The isomorphism between right-whiskering on the identity functor and the identity of the functor
between the resulting functor categories. |
whiskeringRight_obj_comp {D' : Type u₄} [Category.{v₄} D'] (F : C ⥤ D) (G : D ⥤ D') :
(whiskeringRight E C D).obj F ⋙ (whiskeringRight E D D').obj G =
(whiskeringRight E C D').obj (F ⋙ G) :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringRight_obj_comp | null |
@[simps!]
whiskeringRightObjCompIso {D' : Type u₄} [Category.{v₄} D'] (F : C ⥤ D) (G : D ⥤ D') :
(whiskeringRight E C D).obj F ⋙ (whiskeringRight E D D').obj G ≅
(whiskeringRight E C D').obj (F ⋙ G) :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringRightObjCompIso | The isomorphism between right-whiskering on the composition of functors and the composition
of two right-whiskering applications. |
full_whiskeringRight_obj {F : D ⥤ E} [F.Faithful] [F.Full] :
((whiskeringRight C D E).obj F).Full :=
((Functor.FullyFaithful.ofFullyFaithful F).whiskeringRight C).full
@[simp] | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | full_whiskeringRight_obj | null |
whiskerLeft_id (F : C ⥤ D) {G : D ⥤ E} :
whiskerLeft F (NatTrans.id G) = NatTrans.id (F.comp G) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft_id | null |
whiskerLeft_id' (F : C ⥤ D) {G : D ⥤ E} : whiskerLeft F (𝟙 G) = 𝟙 (F.comp G) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft_id' | null |
whiskerRight_id {G : C ⥤ D} (F : D ⥤ E) :
whiskerRight (NatTrans.id G) F = NatTrans.id (G.comp F) :=
((whiskeringRight C D E).obj F).map_id _
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight_id | null |
whiskerRight_id' {G : C ⥤ D} (F : D ⥤ E) : whiskerRight (𝟙 G) F = 𝟙 (G.comp F) :=
((whiskeringRight C D E).obj F).map_id _
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight_id' | null |
whiskerLeft_comp (F : C ⥤ D) {G H K : D ⥤ E} (α : G ⟶ H) (β : H ⟶ K) :
whiskerLeft F (α ≫ β) = whiskerLeft F α ≫ whiskerLeft F β :=
rfl
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft_comp | null |
whiskerRight_comp {G H K : C ⥤ D} (α : G ⟶ H) (β : H ⟶ K) (F : D ⥤ E) :
whiskerRight (α ≫ β) F = whiskerRight α F ≫ whiskerRight β F :=
((whiskeringRight C D E).obj F).map_comp α β
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight_comp | null |
whiskerLeft_comp_whiskerRight {F G : C ⥤ D} {H K : D ⥤ E} (α : F ⟶ G) (β : H ⟶ K) :
whiskerLeft F β ≫ whiskerRight α K = whiskerRight α H ≫ whiskerLeft G β := by
ext
simp | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft_comp_whiskerRight | null |
NatTrans.hcomp_eq_whiskerLeft_comp_whiskerRight {F G : C ⥤ D} {H K : D ⥤ E}
(α : F ⟶ G) (β : H ⟶ K) : α ◫ β = whiskerLeft F β ≫ whiskerRight α K := by
ext
simp | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | NatTrans.hcomp_eq_whiskerLeft_comp_whiskerRight | null |
isoWhiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) : F ⋙ G ≅ F ⋙ H :=
((whiskeringLeft C D E).obj F).mapIso α
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft | If `α : G ≅ H` is a natural isomorphism then
`isoWhiskerLeft F α : (F ⋙ G) ≅ (F ⋙ H)` has components `α.app (F.obj X)`. |
isoWhiskerLeft_hom (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
(isoWhiskerLeft F α).hom = whiskerLeft F α.hom :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_hom | null |
isoWhiskerLeft_inv (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
(isoWhiskerLeft F α).inv = whiskerLeft F α.inv :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_inv | null |
isoWhiskerLeft_symm (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
(isoWhiskerLeft F α).symm = isoWhiskerLeft F α.symm :=
rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_symm | null |
isoWhiskerLeft_refl (F : C ⥤ D) (G : D ⥤ E) :
isoWhiskerLeft F (Iso.refl G) = Iso.refl _ :=
rfl | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_refl | null |
isoWhiskerRight {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) : G ⋙ F ≅ H ⋙ F :=
((whiskeringRight C D E).obj F).mapIso α
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight | If `α : G ≅ H` then
`isoWhiskerRight α F : (G ⋙ F) ≅ (H ⋙ F)` has components `F.map_iso (α.app X)`. |
isoWhiskerRight_hom {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
(isoWhiskerRight α F).hom = whiskerRight α.hom F :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_hom | null |
isoWhiskerRight_inv {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
(isoWhiskerRight α F).inv = whiskerRight α.inv F :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_inv | null |
isoWhiskerRight_symm {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
(isoWhiskerRight α F).symm = isoWhiskerRight α.symm F :=
rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_symm | null |
isoWhiskerRight_refl (F : C ⥤ D) (G : D ⥤ E) :
isoWhiskerRight (Iso.refl F) G = Iso.refl _ := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_refl | null |
isIso_whiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) [IsIso α] :
IsIso (whiskerLeft F α) :=
(isoWhiskerLeft F (asIso α)).isIso_hom | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isIso_whiskerLeft | null |
isIso_whiskerRight {G H : C ⥤ D} (α : G ⟶ H) (F : D ⥤ E) [IsIso α] :
IsIso (whiskerRight α F) :=
(isoWhiskerRight (asIso α) F).isIso_hom
@[simp] | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isIso_whiskerRight | null |
inv_whiskerRight {G H : C ⥤ D} (α : G ⟶ H) (F : D ⥤ E) [IsIso α] :
inv (whiskerRight α F) = whiskerRight (inv α) F := by
symm
apply IsIso.eq_inv_of_inv_hom_id
simp [← whiskerRight_comp]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | inv_whiskerRight | null |
inv_whiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) [IsIso α] :
inv (whiskerLeft F α) = whiskerLeft F (inv α) := by
symm
apply IsIso.eq_inv_of_inv_hom_id
simp [← whiskerLeft_comp]
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | inv_whiskerLeft | null |
isoWhiskerLeft_trans (F : C ⥤ D) {G H K : D ⥤ E} (α : G ≅ H) (β : H ≅ K) :
isoWhiskerLeft F (α ≪≫ β) = isoWhiskerLeft F α ≪≫ isoWhiskerLeft F β :=
rfl
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_trans | null |
isoWhiskerRight_trans {G H K : C ⥤ D} (α : G ≅ H) (β : H ≅ K) (F : D ⥤ E) :
isoWhiskerRight (α ≪≫ β) F = isoWhiskerRight α F ≪≫ isoWhiskerRight β F :=
((whiskeringRight C D E).obj F).mapIso_trans α β
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_trans | null |
isoWhiskerLeft_trans_isoWhiskerRight {F G : C ⥤ D} {H K : D ⥤ E} (α : F ≅ G) (β : H ≅ K) :
isoWhiskerLeft F β ≪≫ isoWhiskerRight α K = isoWhiskerRight α H ≪≫ isoWhiskerLeft G β := by
ext
simp
variable {B : Type u₄} [Category.{v₄} B]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_trans_isoWhiskerRight | null |
whiskerLeft_twice (F : B ⥤ C) (G : C ⥤ D) {H K : D ⥤ E} (α : H ⟶ K) :
whiskerLeft F (whiskerLeft G α) =
(Functor.associator _ _ _).inv ≫ whiskerLeft (F ⋙ G) α ≫ (Functor.associator _ _ _).hom := by
cat_disch
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerLeft_twice | null |
whiskerRight_twice {H K : B ⥤ C} (F : C ⥤ D) (G : D ⥤ E) (α : H ⟶ K) :
whiskerRight (whiskerRight α F) G =
(Functor.associator _ _ _).hom ≫ whiskerRight α (F ⋙ G) ≫ (Functor.associator _ _ _).inv := by
cat_disch | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight_twice | null |
whiskerRight_left (F : B ⥤ C) {G H : C ⥤ D} (α : G ⟶ H) (K : D ⥤ E) :
whiskerRight (whiskerLeft F α) K =
(Functor.associator _ _ _).hom ≫ whiskerLeft F (whiskerRight α K) ≫
(Functor.associator _ _ _).inv := by
cat_disch
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskerRight_left | null |
isoWhiskerLeft_twice (F : B ⥤ C) (G : C ⥤ D) {H K : D ⥤ E} (α : H ≅ K) :
isoWhiskerLeft F (isoWhiskerLeft G α) =
(Functor.associator _ _ _).symm ≪≫ isoWhiskerLeft (F ⋙ G) α ≪≫ Functor.associator _ _ _ := by
cat_disch
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_twice | null |
isoWhiskerRight_twice {H K : B ⥤ C} (F : C ⥤ D) (G : D ⥤ E) (α : H ≅ K) :
isoWhiskerRight (isoWhiskerRight α F) G =
Functor.associator _ _ _ ≪≫ isoWhiskerRight α (F ⋙ G) ≪≫ (Functor.associator _ _ _).symm := by
cat_disch
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_twice | null |
isoWhiskerRight_left (F : B ⥤ C) {G H : C ⥤ D} (α : G ≅ H) (K : D ⥤ E) :
isoWhiskerRight (isoWhiskerLeft F α) K =
Functor.associator _ _ _ ≪≫ isoWhiskerLeft F (isoWhiskerRight α K) ≪≫
(Functor.associator _ _ _).symm := by
cat_disch
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerRight_left | null |
isoWhiskerLeft_right (F : B ⥤ C) {G H : C ⥤ D} (α : G ≅ H) (K : D ⥤ E) :
isoWhiskerLeft F (isoWhiskerRight α K) =
(Functor.associator _ _ _).symm ≪≫ isoWhiskerRight (isoWhiskerLeft F α) K ≪≫
Functor.associator _ _ _ := by
cat_disch | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | isoWhiskerLeft_right | null |
@[reassoc]
triangleIso :
associator F (𝟭 B) G ≪≫ isoWhiskerLeft F (leftUnitor G) =
isoWhiskerRight (rightUnitor F) G := by cat_disch
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | triangleIso | null |
pentagonIso :
isoWhiskerRight (associator F G H) K ≪≫
associator F (G ⋙ H) K ≪≫ isoWhiskerLeft F (associator G H K) =
associator (F ⋙ G) H K ≪≫ associator F G (H ⋙ K) := by cat_disch | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | pentagonIso | null |
triangle :
(associator F (𝟭 B) G).hom ≫ whiskerLeft F (leftUnitor G).hom =
whiskerRight (rightUnitor F).hom G := by cat_disch | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | triangle | null |
pentagon :
whiskerRight (associator F G H).hom K ≫
(associator F (G ⋙ H) K).hom ≫ whiskerLeft F (associator G H K).hom =
(associator (F ⋙ G) H K).hom ≫ (associator F G (H ⋙ K)).hom := by cat_disch
variable {C₁ C₂ C₃ D₁ D₂ D₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
[Category D₁] [Category D₂] [Category D₃] (E : Type*) [Category E] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | pentagon | null |
@[simps!]
whiskeringLeft₂ :
(C₁ ⥤ D₁) ⥤ (C₂ ⥤ D₂) ⥤ (D₁ ⥤ D₂ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ E) where
obj F₁ :=
{ obj := fun F₂ ↦
(whiskeringRight D₁ (D₂ ⥤ E) (C₂ ⥤ E)).obj ((whiskeringLeft C₂ D₂ E).obj F₂) ⋙
(whiskeringLeft C₁ D₁ (C₂ ⥤ E)).obj F₁
map := fun φ ↦ whiskerRight
((whiskeringRight D₁ (D₂ ⥤ E) (C₂ ⥤ E)).map ((whiskeringLeft C₂ D₂ E).map φ)) _ }
map ψ :=
{ app := fun F₂ ↦ whiskerLeft _ ((whiskeringLeft C₁ D₁ (C₂ ⥤ E)).map ψ) } | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₂ | The obvious functor `(C₁ ⥤ D₁) ⥤ (C₂ ⥤ D₂) ⥤ (D₁ ⥤ D₂ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ E)`. |
@[simps!]
whiskeringLeft₃ObjObjObj (F₁ : C₁ ⥤ D₁) (F₂ : C₂ ⥤ D₂) (F₃ : C₃ ⥤ D₃) :
(D₁ ⥤ D₂ ⥤ D₃ ⥤ E) ⥤ C₁ ⥤ C₂ ⥤ C₃ ⥤ E :=
(whiskeringRight _ _ _).obj (((whiskeringLeft₂ E).obj F₂).obj F₃) ⋙
(whiskeringLeft C₁ D₁ _).obj F₁ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃ObjObjObj | Auxiliary definition for `whiskeringLeft₃`. |
@[simps]
whiskeringLeft₃ObjObjMap (F₁ : C₁ ⥤ D₁) (F₂ : C₂ ⥤ D₂) {F₃ F₃' : C₃ ⥤ D₃} (τ₃ : F₃ ⟶ F₃') :
whiskeringLeft₃ObjObjObj E F₁ F₂ F₃ ⟶
whiskeringLeft₃ObjObjObj E F₁ F₂ F₃' where
app F := whiskerLeft _ (whiskerLeft _ (((whiskeringLeft₂ E).obj F₂).map τ₃))
variable (C₃ D₃) in | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃ObjObjMap | Auxiliary definition for `whiskeringLeft₃`. |
@[simps]
whiskeringLeft₃ObjObj (F₁ : C₁ ⥤ D₁) (F₂ : C₂ ⥤ D₂) :
(C₃ ⥤ D₃) ⥤ (D₁ ⥤ D₂ ⥤ D₃ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E) where
obj F₃ := whiskeringLeft₃ObjObjObj E F₁ F₂ F₃
map τ₃ := whiskeringLeft₃ObjObjMap E F₁ F₂ τ₃
variable (C₃ D₃) in | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃ObjObj | Auxiliary definition for `whiskeringLeft₃`. |
@[simps]
whiskeringLeft₃ObjMap (F₁ : C₁ ⥤ D₁) {F₂ F₂' : C₂ ⥤ D₂} (τ₂ : F₂ ⟶ F₂') :
whiskeringLeft₃ObjObj C₃ D₃ E F₁ F₂ ⟶ whiskeringLeft₃ObjObj C₃ D₃ E F₁ F₂' where
app F₃ := whiskerRight ((whiskeringRight _ _ _).map (((whiskeringLeft₂ E).map τ₂).app F₃)) _
variable (C₂ C₃ D₂ D₃) in | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃ObjMap | Auxiliary definition for `whiskeringLeft₃`. |
@[simps]
whiskeringLeft₃Obj (F₁ : C₁ ⥤ D₁) :
(C₂ ⥤ D₂) ⥤ (C₃ ⥤ D₃) ⥤ (D₁ ⥤ D₂ ⥤ D₃ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E) where
obj F₂ := whiskeringLeft₃ObjObj C₃ D₃ E F₁ F₂
map τ₂ := whiskeringLeft₃ObjMap C₃ D₃ E F₁ τ₂
variable (C₂ C₃ D₂ D₃) in | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃Obj | Auxiliary definition for `whiskeringLeft₃`. |
@[simps]
whiskeringLeft₃Map {F₁ F₁' : C₁ ⥤ D₁} (τ₁ : F₁ ⟶ F₁') :
whiskeringLeft₃Obj C₂ C₃ D₂ D₃ E F₁ ⟶ whiskeringLeft₃Obj C₂ C₃ D₂ D₃ E F₁' where
app F₂ := { app F₃ := whiskerLeft _ ((whiskeringLeft _ _ _).map τ₁) } | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃Map | Auxiliary definition for `whiskeringLeft₃`. |
@[simps!]
whiskeringLeft₃ :
(C₁ ⥤ D₁) ⥤ (C₂ ⥤ D₂) ⥤ (C₃ ⥤ D₃) ⥤ (D₁ ⥤ D₂ ⥤ D₃ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E) where
obj F₁ := whiskeringLeft₃Obj C₂ C₃ D₂ D₃ E F₁
map τ₁ := whiskeringLeft₃Map C₂ C₃ D₂ D₃ E τ₁
variable {E} | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | whiskeringLeft₃ | The obvious functor
`(C₁ ⥤ D₁) ⥤ (C₂ ⥤ D₂) ⥤ (C₃ ⥤ D₃) ⥤ (D₁ ⥤ D₂ ⥤ D₃ ⥤ E) ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E)`. |
@[simps!]
postcompose₂ {E' : Type*} [Category E'] :
(E ⥤ E') ⥤ (C₁ ⥤ C₂ ⥤ E) ⥤ C₁ ⥤ C₂ ⥤ E' :=
whiskeringRight C₂ _ _ ⋙ whiskeringRight C₁ _ _ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | postcompose₂ | The "postcomposition" with a functor `E ⥤ E'` gives a functor
`(E ⥤ E') ⥤ (C₁ ⥤ C₂ ⥤ E) ⥤ C₁ ⥤ C₂ ⥤ E'`. |
@[simps!]
postcompose₃ {E' : Type*} [Category E'] :
(E ⥤ E') ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E) ⥤ C₁ ⥤ C₂ ⥤ C₃ ⥤ E' :=
whiskeringRight C₃ _ _ ⋙ whiskeringRight C₂ _ _ ⋙ whiskeringRight C₁ _ _ | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.IsoReassoc",
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Functor.FullyFaithful"
] | Mathlib/CategoryTheory/Whiskering.lean | postcompose₃ | The "postcomposition" with a functor `E ⥤ E'` gives a functor
`(E ⥤ E') ⥤ (C₁ ⥤ C₂ ⥤ C₃ ⥤ E) ⥤ C₁ ⥤ C₂ ⥤ C₃ ⥤ E'`. |
@[nolint unusedArguments]
InducedWideCategory (_F : C → D) (_P : MorphismProperty D) [IsMultiplicative _P] :=
C
variable {D} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | InducedWideCategory | `InducedWideCategory D F P`, where `F : C → D`, is a typeclass synonym for `C`,
which provides a category structure so that the morphisms `X ⟶ Y` are the morphisms
in `D` from `F X` to `F Y` which satisfy a property `P : MorphismProperty D` that is multiplicative. |
InducedWideCategory.hasCoeToSort {α : Sort*} [CoeSort D α] :
CoeSort (InducedWideCategory D F P) α :=
⟨fun c => F c⟩
@[simps!] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | InducedWideCategory.hasCoeToSort | null |
InducedWideCategory.category :
Category (InducedWideCategory D F P) where
Hom X Y := {f : F X ⟶ F Y | P f}
id X := ⟨𝟙 (F X), P.id_mem (F X)⟩
comp {_ _ _} f g := ⟨f.1 ≫ g.1, P.comp_mem _ _ f.2 g.2⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | InducedWideCategory.category | null |
@[simps]
wideInducedFunctor : InducedWideCategory D F P ⥤ D where
obj := F
map {_ _} f := f.1 | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | wideInducedFunctor | The forgetful functor from an induced wide category to the original category. |
InducedWideCategory.faithful : (wideInducedFunctor F P).Faithful where
map_injective {X Y} f g eq := by
cases f
cases g
aesop | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | InducedWideCategory.faithful | The induced functor `wideInducedFunctor F P : InducedWideCategory D F P ⥤ D`
is faithful. |
@[ext, nolint unusedArguments]
WideSubcategory (_P : MorphismProperty C) [IsMultiplicative _P] where
/-- The category of which this is a wide subcategory -/
obj : C | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | WideSubcategory | Structure for wide subcategories. Objects ignore the morphism property. |
WideSubcategory.category : Category.{v₁} (WideSubcategory P) :=
InducedWideCategory.category WideSubcategory.obj P
@[simp] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | WideSubcategory.category | null |
WideSubcategory.id_def (X : WideSubcategory P) : (CategoryStruct.id X).1 = 𝟙 X.obj := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | WideSubcategory.id_def | null |
WideSubcategory.comp_def {X Y Z : WideSubcategory P} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).1 = (f.1 ≫ g.1 : X.obj ⟶ Z.obj) := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | WideSubcategory.comp_def | null |
wideSubcategoryInclusion : WideSubcategory P ⥤ C :=
wideInducedFunctor WideSubcategory.obj P
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | wideSubcategoryInclusion | The forgetful functor from a wide subcategory into the original category
("forgetting" the condition). |
wideSubcategoryInclusion.obj (X) : (wideSubcategoryInclusion P).obj X = X.obj :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | wideSubcategoryInclusion.obj | null |
wideSubcategoryInclusion.map {X Y} {f : X ⟶ Y} :
(wideSubcategoryInclusion P).map f = f.1 :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | wideSubcategoryInclusion.map | null |
wideSubcategory.faithful : (wideSubcategoryInclusion P).Faithful :=
inferInstanceAs (wideInducedFunctor WideSubcategory.obj P).Faithful | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.MorphismProperty.Composition"
] | Mathlib/CategoryTheory/Widesubcategory.lean | wideSubcategory.faithful | The inclusion of a wide subcategory is faithful. |
@[simps, stacks 001O]
yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁ where
obj X :=
{ obj := fun Y => unop Y ⟶ X
map := fun f g => f.unop ≫ g }
map f :=
{ app := fun _ g => g ≫ f } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yoneda | The Yoneda embedding, as a functor from `C` into presheaves on `C`. |
@[pp_with_univ, simps!]
uliftYoneda : C ⥤ Cᵒᵖ ⥤ Type (max w v₁) :=
yoneda ⋙ (whiskeringRight _ _ _).obj uliftFunctor.{w} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYoneda | Variant of the Yoneda embedding which allows a raise in the universe level
for the category of types. |
@[simps!]
uliftYonedaIsoYoneda {C : Type u₁} [Category.{max w v₁} C] :
uliftYoneda.{w} (C := C) ≅ yoneda :=
NatIso.ofComponents (fun _ ↦ NatIso.ofComponents (fun _ ↦ Equiv.ulift.toIso)) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | uliftYonedaIsoYoneda | If `C` is a category with `[Category.{max w v₁} C]`, this is the isomorphism
`uliftYoneda.{w} (C := C) ≅ yoneda`. |
@[simps]
coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁ where
obj X :=
{ obj := fun Y => unop X ⟶ Y
map := fun f g => g ≫ f }
map f :=
{ app := fun _ g => f.unop ≫ g } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyoneda | The co-Yoneda embedding, as a functor from `Cᵒᵖ` into co-presheaves on `C`. |
obj_map_id {X Y : C} (f : op X ⟶ op Y) :
(yoneda.obj X).map f (𝟙 X) = (yoneda.map f.unop).app (op Y) (𝟙 Y) := by
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | obj_map_id | null |
naturality {X Y : C} (α : yoneda.obj X ⟶ yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z')
(h : Z' ⟶ X) : f ≫ α.app (op Z') h = α.app (op Z) (f ≫ h) :=
(FunctorToTypes.naturality _ _ α f.op h).symm | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | naturality | null |
fullyFaithful : (yoneda (C := C)).FullyFaithful where
preimage f := f.app _ (𝟙 _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | fullyFaithful | The Yoneda embedding is fully faithful. |
fullyFaithful_preimage {X Y : C} (f : yoneda.obj X ⟶ yoneda.obj Y) :
fullyFaithful.preimage f = f.app (op X) (𝟙 X) := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | fullyFaithful_preimage | null |
@[stacks 001P]
yoneda_full : (yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁).Full :=
fullyFaithful.full | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yoneda_full | The Yoneda embedding is full. |
@[stacks 001P]
yoneda_faithful : (yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁).Faithful :=
fullyFaithful.faithful | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | yoneda_faithful | The Yoneda embedding is faithful. |
ext (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 (f ≫ g) = f ≫ p g) : X ≅ Y :=
fullyFaithful.preimageIso
(NatIso.ofComponents fun Z =>
{ hom := p
inv := q }) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | ext | 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`.
``` |
isIso {X Y : C} (f : X ⟶ Y) [IsIso (yoneda.map f)] : IsIso f :=
isIso_of_fully_faithful yoneda f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | isIso | If `yoneda.map f` is an isomorphism, so was `f`. |
fullyFaithful : (uliftYoneda.{w} (C := C)).FullyFaithful :=
Yoneda.fullyFaithful.comp (fullyFaithfulULiftFunctor.whiskeringRight _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | fullyFaithful | When `C` is category such that `Category.{v₁} C`, then
the functor `uliftYoneda.{w} : C ⥤ Cᵒᵖ ⥤ Type max w v₁` is fully faithful. |
@[simp]
naturality {X Y : Cᵒᵖ} (α : coyoneda.obj X ⟶ coyoneda.obj Y) {Z Z' : C} (f : Z' ⟶ Z)
(h : unop X ⟶ Z') : α.app Z' h ≫ f = α.app Z (h ≫ f) :=
(FunctorToTypes.naturality _ _ α f h).symm | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | naturality | null |
fullyFaithful : (coyoneda (C := C)).FullyFaithful where
preimage f := (f.app _ (𝟙 _)).op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | fullyFaithful | The co-Yoneda embedding is fully faithful. |
fullyFaithful_preimage {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) :
fullyFaithful.preimage f = (f.app X.unop (𝟙 X.unop)).op := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | fullyFaithful_preimage | null |
preimage {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) : X ⟶ Y :=
(f.app _ (𝟙 X.unop)).op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | preimage | The morphism `X ⟶ Y` corresponding to a natural transformation
`coyoneda.obj X ⟶ coyoneda.obj Y`. |
coyoneda_full : (coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁).Full :=
fullyFaithful.full | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyoneda_full | null |
coyoneda_faithful : (coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁).Faithful :=
fullyFaithful.faithful | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | coyoneda_faithful | null |
ext (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 (f ≫ g) = q f ≫ g) : X ≅ Y :=
fullyFaithful.preimageIso
(NatIso.ofComponents (fun Z =>
{ hom := q
inv := p })
) |>.unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Hom",
"Mathlib.CategoryTheory.Products.Basic",
"Mathlib.Data.ULift",
"Mathlib.Logic.Function.ULift"
] | Mathlib/CategoryTheory/Yoneda.lean | ext | 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`.
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.