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 ⌀ |
|---|---|---|---|---|---|---|
inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
e.inverse.map (e.functor.map f) = e.unitInv.app X ≫ f ≫ e.unit.app Y :=
(NatIso.naturality_1 e.unitIso f).symm | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inv_fun_map | null |
adjointifyη : 𝟭 C ≅ F ⋙ G := by
calc
𝟭 C ≅ F ⋙ G := η
_ ≅ F ⋙ 𝟭 D ⋙ G := isoWhiskerLeft F (leftUnitor G).symm
_ ≅ F ⋙ (G ⋙ F) ⋙ G := isoWhiskerLeft F (isoWhiskerRight ε.symm G)
_ ≅ F ⋙ G ⋙ F ⋙ G := isoWhiskerLeft F (associator G F G)
_ ≅ (F ⋙ G) ⋙ F ⋙ G := (associator F G (F ⋙ G)).symm
_ ≅ 𝟭 C ⋙ F ⋙ G := isoWhiskerRight η.symm (F ⋙ G)
_ ≅ F ⋙ G := leftUnitor (F ⋙ G)
@[reassoc] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | adjointifyη | If `η : 𝟭 C ≅ F ⋙ G` is part of a (not necessarily half-adjoint) equivalence, we can upgrade it
to a refined natural isomorphism `adjointifyη η : 𝟭 C ≅ F ⋙ G` which exhibits the properties
required for a half-adjoint equivalence. See `Equivalence.mk`. |
adjointify_η_ε (X : C) :
F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) := by
dsimp [adjointifyη,Trans.trans]
simp only [comp_id, assoc, map_comp]
have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this; rw [this]; clear this
rw [← assoc _ _ (F.map _)]
have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this; rw [this]; clear this
have := (ε.app <| F.obj X).hom_inv_id; dsimp at this; rw [this]; clear this
rw [id_comp]; have := (F.mapIso <| η.app X).hom_inv_id; dsimp at this; rw [this] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | adjointify_η_ε | null |
protected mk (F : C ⥤ D) (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) : C ≌ D :=
⟨F, G, adjointifyη η ε, ε, adjointify_η_ε η ε⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | mk | Every equivalence of categories consisting of functors `F` and `G` such that `F ⋙ G` and
`G ⋙ F` are naturally isomorphic to identity functors can be transformed into a half-adjoint
equivalence without changing `F` or `G`. |
@[refl, simps]
refl : C ≌ C :=
⟨𝟭 C, 𝟭 C, Iso.refl _, Iso.refl _, fun _ => Category.id_comp _⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | refl | Equivalence of categories is reflexive. |
@[symm, simps]
symm (e : C ≌ D) : D ≌ C :=
⟨e.inverse, e.functor, e.counitIso.symm, e.unitIso.symm, e.inverse_counitInv_comp⟩
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | symm | Equivalence of categories is symmetric. |
mkHom_id_inverse {e : C ≌ D} : mkHom (𝟙 e.inverse) = 𝟙 e.symm := rfl
variable {E : Type u₃} [Category.{v₃} E] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | mkHom_id_inverse | null |
@[trans, simps]
trans (e : C ≌ D) (f : D ≌ E) : C ≌ E where
functor := e.functor ⋙ f.functor
inverse := f.inverse ⋙ e.inverse
unitIso := e.unitIso ≪≫ isoWhiskerRight (e.functor.rightUnitor.symm ≪≫
isoWhiskerLeft _ f.unitIso ≪≫ (Functor.associator _ _ _ ).symm) _ ≪≫ Functor.associator _ _ _
counitIso := (Functor.associator _ _ _ ).symm ≪≫ isoWhiskerRight ((Functor.associator _ _ _ ) ≪≫
isoWhiskerLeft _ e.counitIso ≪≫ f.inverse.rightUnitor) _ ≪≫ f.counitIso
functor_unitIso_comp X := by
dsimp
simp only [comp_id, id_comp, map_comp, fun_inv_map, comp_obj, id_obj, counitInv,
functor_unit_comp_assoc, assoc]
slice_lhs 2 3 => rw [← Functor.map_comp, Iso.inv_hom_id_app]
simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | trans | Equivalence of categories is transitive. |
funInvIdAssoc (e : C ≌ D) (F : C ⥤ E) : e.functor ⋙ e.inverse ⋙ F ≅ F :=
(Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.unitIso.symm F ≪≫ F.leftUnitor
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | funInvIdAssoc | Composing a functor with both functors of an equivalence yields a naturally isomorphic
functor. |
funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
(funInvIdAssoc e F).hom.app X = F.map (e.unitInv.app X) := by
dsimp [funInvIdAssoc]
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | funInvIdAssoc_hom_app | null |
funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
(funInvIdAssoc e F).inv.app X = F.map (e.unit.app X) := by
dsimp [funInvIdAssoc]
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | funInvIdAssoc_inv_app | null |
invFunIdAssoc (e : C ≌ D) (F : D ⥤ E) : e.inverse ⋙ e.functor ⋙ F ≅ F :=
(Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.counitIso F ≪≫ F.leftUnitor
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | invFunIdAssoc | Composing a functor with both functors of an equivalence yields a naturally isomorphic
functor. |
invFunIdAssoc_hom_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
(invFunIdAssoc e F).hom.app X = F.map (e.counit.app X) := by
dsimp [invFunIdAssoc]
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | invFunIdAssoc_hom_app | null |
invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
(invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) := by
dsimp [invFunIdAssoc]
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | invFunIdAssoc_inv_app | null |
@[simps! functor inverse unitIso counitIso]
congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E where
functor := (whiskeringLeft _ _ _).obj e.inverse
inverse := (whiskeringLeft _ _ _).obj e.functor
unitIso := (NatIso.ofComponents fun F => (e.funInvIdAssoc F).symm)
counitIso := (NatIso.ofComponents fun F => e.invFunIdAssoc F)
functor_unitIso_comp F := by
ext X
dsimp
simp only [funInvIdAssoc_inv_app, id_obj, comp_obj, invFunIdAssoc_hom_app,
Functor.comp_map, ← F.map_comp, unit_inverse_comp, map_id] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | congrLeft | If `C` is equivalent to `D`, then `C ⥤ E` is equivalent to `D ⥤ E`. |
@[simps! functor inverse unitIso counitIso]
congrRight (e : C ≌ D) : E ⥤ C ≌ E ⥤ D where
functor := (whiskeringRight _ _ _).obj e.functor
inverse := (whiskeringRight _ _ _).obj e.inverse
unitIso := NatIso.ofComponents
fun F => F.rightUnitor.symm ≪≫ isoWhiskerLeft F e.unitIso ≪≫ Functor.associator _ _ _
counitIso := NatIso.ofComponents
fun F => Functor.associator _ _ _ ≪≫ isoWhiskerLeft F e.counitIso ≪≫ F.rightUnitor
variable (E) in | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | congrRight | If `C` is equivalent to `D`, then `E ⥤ C` is equivalent to `E ⥤ D`. |
@[simps]
congrRightFunctor : (C ≌ D) ⥤ ((E ⥤ C) ≌ (E ⥤ D)) where
obj e := e.congrRight
map {e f} α := mkHom <| (whiskeringRight _ _ _).map <| asNatTrans α | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | congrRightFunctor | Promoting `Equivalence.congrRight` to a functor. |
@[simp]
cancel_unit_right {X Y : C} (f f' : X ⟶ Y) :
f ≫ e.unit.app Y = f' ≫ e.unit.app Y ↔ f = f' := by simp only [cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_unit_right | null |
cancel_unitInv_right {X Y : C} (f f' : X ⟶ e.inverse.obj (e.functor.obj Y)) :
f ≫ e.unitInv.app Y = f' ≫ e.unitInv.app Y ↔ f = f' := by simp only [cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_unitInv_right | null |
cancel_counit_right {X Y : D} (f f' : X ⟶ e.functor.obj (e.inverse.obj Y)) :
f ≫ e.counit.app Y = f' ≫ e.counit.app Y ↔ f = f' := by simp only [cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_counit_right | null |
cancel_counitInv_right {X Y : D} (f f' : X ⟶ Y) :
f ≫ e.counitInv.app Y = f' ≫ e.counitInv.app Y ↔ f = f' := by simp only [cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_counitInv_right | null |
cancel_unit_right_assoc {W X X' Y : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) :
f ≫ g ≫ e.unit.app Y = f' ≫ g' ≫ e.unit.app Y ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_unit_right_assoc | null |
cancel_counitInv_right_assoc {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
(g' : X' ⟶ Y) : f ≫ g ≫ e.counitInv.app Y = f' ≫ g' ≫ e.counitInv.app Y ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_counitInv_right_assoc | null |
cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
(f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
f ≫ g ≫ h ≫ e.unit.app Z = f' ≫ g' ≫ h' ≫ e.unit.app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h' := by
simp only [← Category.assoc, cancel_mono]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_unit_right_assoc' | null |
cancel_counitInv_right_assoc' {W X X' Y Y' Z : D} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
(f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
f ≫ g ≫ h ≫ e.counitInv.app Z = f' ≫ g' ≫ h' ≫ e.counitInv.app Z ↔
f ≫ g ≫ h = f' ≫ g' ≫ h' := by simp only [← Category.assoc, cancel_mono] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | cancel_counitInv_right_assoc' | null |
powNat (e : C ≌ C) : ℕ → (C ≌ C)
| 0 => Equivalence.refl
| 1 => e
| n + 2 => e.trans (powNat e (n + 1)) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | powNat | Natural number powers of an auto-equivalence. Use `(^)` instead. |
pow (e : C ≌ C) : ℤ → (C ≌ C)
| Int.ofNat n => e.powNat n
| Int.negSucc n => e.symm.powNat (n + 1) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | pow | Powers of an auto-equivalence. Use `(^)` instead. |
@[simp]
pow_zero (e : C ≌ C) : e ^ (0 : ℤ) = Equivalence.refl :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | pow_zero | null |
pow_one (e : C ≌ C) : e ^ (1 : ℤ) = e :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | pow_one | null |
pow_neg_one (e : C ≌ C) : e ^ (-1 : ℤ) = e.symm :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | pow_neg_one | null |
@[stacks 02C3]
essSurj_functor (e : C ≌ E) : e.functor.EssSurj :=
⟨fun Y => ⟨e.inverse.obj Y, ⟨e.counitIso.app Y⟩⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | essSurj_functor | The functor of an equivalence of categories is essentially surjective. |
essSurj_inverse (e : C ≌ E) : e.inverse.EssSurj :=
e.symm.essSurj_functor | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | essSurj_inverse | null |
fullyFaithfulFunctor (e : C ≌ E) : e.functor.FullyFaithful where
preimage {X Y} f := e.unitIso.hom.app X ≫ e.inverse.map f ≫ e.unitIso.inv.app Y | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | fullyFaithfulFunctor | The functor of an equivalence of categories is fully faithful. |
fullyFaithfulInverse (e : C ≌ E) : e.inverse.FullyFaithful where
preimage {X Y} f := e.counitIso.inv.app X ≫ e.functor.map f ≫ e.counitIso.hom.app Y | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | fullyFaithfulInverse | The inverse of an equivalence of categories is fully faithful. |
@[stacks 02C3]
faithful_functor (e : C ≌ E) : e.functor.Faithful :=
e.fullyFaithfulFunctor.faithful | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | faithful_functor | The functor of an equivalence of categories is faithful. |
faithful_inverse (e : C ≌ E) : e.inverse.Faithful :=
e.fullyFaithfulInverse.faithful | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | faithful_inverse | null |
@[stacks 02C3]
full_functor (e : C ≌ E) : e.functor.Full :=
e.fullyFaithfulFunctor.full | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | full_functor | The functor of an equivalence of categories is full. |
full_inverse (e : C ≌ E) : e.inverse.Full :=
e.fullyFaithfulInverse.full | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | full_inverse | null |
@[simps!]
changeFunctor (e : C ≌ D) {G : C ⥤ D} (iso : e.functor ≅ G) : C ≌ D where
functor := G
inverse := e.inverse
unitIso := e.unitIso ≪≫ isoWhiskerRight iso _
counitIso := isoWhiskerLeft _ iso.symm ≪≫ e.counitIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | changeFunctor | If `e : C ≌ D` is an equivalence of categories, and `iso : e.functor ≅ G` is
an isomorphism, then there is an equivalence of categories whose functor is `G`. |
changeFunctor_refl (e : C ≌ D) : e.changeFunctor (Iso.refl _) = e := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | changeFunctor_refl | Compatibility of `changeFunctor` with identity isomorphisms of functors |
changeFunctor_trans (e : C ≌ D) {G G' : C ⥤ D} (iso₁ : e.functor ≅ G) (iso₂ : G ≅ G') :
(e.changeFunctor iso₁).changeFunctor iso₂ = e.changeFunctor (iso₁ ≪≫ iso₂) := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | changeFunctor_trans | Compatibility of `changeFunctor` with the composition of isomorphisms of functors |
@[simps!]
changeInverse (e : C ≌ D) {G : D ⥤ C} (iso : e.inverse ≅ G) : C ≌ D where
functor := e.functor
inverse := G
unitIso := e.unitIso ≪≫ isoWhiskerLeft _ iso
counitIso := isoWhiskerRight iso.symm _ ≪≫ e.counitIso
functor_unitIso_comp X := by
dsimp
rw [← map_comp_assoc, assoc, iso.hom_inv_id_app, comp_id, functor_unit_comp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | changeInverse | If `e : C ≌ D` is an equivalence of categories, and `iso : e.functor ≅ G` is
an isomorphism, then there is an equivalence of categories whose inverse is `G`. |
Functor.IsEquivalence (F : C ⥤ D) : Prop where
faithful : F.Faithful := by infer_instance
full : F.Full := by infer_instance
essSurj : F.EssSurj := by infer_instance | class | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | Functor.IsEquivalence | A functor is an equivalence of categories if it is faithful, full and
essentially surjective. |
Equivalence.isEquivalence_functor (F : C ≌ D) : IsEquivalence F.functor where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | Equivalence.isEquivalence_functor | null |
Equivalence.isEquivalence_inverse (F : C ≌ D) : IsEquivalence F.inverse :=
F.symm.isEquivalence_functor | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | Equivalence.isEquivalence_inverse | null |
protected mk' {F : C ⥤ D} (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) :
IsEquivalence F :=
inferInstanceAs (IsEquivalence (Equivalence.mk F G η ε).functor) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | mk' | To see that a functor is an equivalence, it suffices to provide an inverse functor `G` such that
`F ⋙ G` and `G ⋙ F` are naturally isomorphic to identity functors. |
noncomputable inv (F : C ⥤ D) [F.IsEquivalence] : D ⥤ C where
obj X := F.objPreimage X
map {X Y} f := F.preimage ((F.objObjPreimageIso X).hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
map_id X := by apply F.map_injective; simp
map_comp {X Y Z} f g := by apply F.map_injective; simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inv | A quasi-inverse `D ⥤ C` to a functor that `F : C ⥤ D` that is an equivalence,
i.e. faithful, full, and essentially surjective. |
@[simps functor, stacks 02C3]
noncomputable asEquivalence (F : C ⥤ D) [F.IsEquivalence] : C ≌ D where
functor := F
inverse := F.inv
unitIso := NatIso.ofComponents
(fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
(fun f => F.map_injective (by simp [inv]))
counitIso := NatIso.ofComponents F.objObjPreimageIso (by simp [inv]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | asEquivalence | Interpret a functor that is an equivalence as an equivalence. |
isEquivalence_refl : IsEquivalence (𝟭 C) :=
Equivalence.refl.isEquivalence_functor | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_refl | null |
isEquivalence_inv (F : C ⥤ D) [IsEquivalence F] : IsEquivalence F.inv :=
F.asEquivalence.symm.isEquivalence_functor
variable {E : Type u₃} [Category.{v₃} E] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_inv | null |
isEquivalence_trans (F : C ⥤ D) (G : D ⥤ E) [IsEquivalence F] [IsEquivalence G] :
IsEquivalence (F ⋙ G) where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_trans | null |
@[simp]
fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y := by
simpa using (NatIso.naturality_2 (α := F.asEquivalence.counitIso) (f := f)).symm
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | fun_inv_map | null |
inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y := by
simpa using (NatIso.naturality_1 (α := F.asEquivalence.unitIso) (f := f)).symm | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inv_fun_map | null |
isEquivalence_of_iso {F G : C ⥤ D} (e : F ≅ G) [F.IsEquivalence] : G.IsEquivalence :=
((asEquivalence F).changeFunctor e).isEquivalence_functor | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_of_iso | null |
isEquivalence_iff_of_iso {F G : C ⥤ D} (e : F ≅ G) :
F.IsEquivalence ↔ G.IsEquivalence :=
⟨fun _ => isEquivalence_of_iso e, fun _ => isEquivalence_of_iso e.symm⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_iff_of_iso | null |
isEquivalence_of_comp_right {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E)
[IsEquivalence G] [IsEquivalence (F ⋙ G)] : IsEquivalence F := by
rw [isEquivalence_iff_of_iso (F.rightUnitor.symm ≪≫ isoWhiskerLeft F (G.asEquivalence.unitIso))]
exact ((F ⋙ G).asEquivalence.trans G.asEquivalence.symm).isEquivalence_functor | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_of_comp_right | If `G` and `F ⋙ G` are equivalence of categories, then `F` is also an equivalence. |
isEquivalence_of_comp_left {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E)
[IsEquivalence F] [IsEquivalence (F ⋙ G)] : IsEquivalence G := by
rw [isEquivalence_iff_of_iso (G.leftUnitor.symm ≪≫
isoWhiskerRight F.asEquivalence.counitIso.symm G)]
exact (F.asEquivalence.symm.trans (F ⋙ G).asEquivalence).isEquivalence_functor | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isEquivalence_of_comp_left | If `F` and `F ⋙ G` are equivalence of categories, then `G` is also an equivalence. |
essSurjInducedFunctor {C' : Type*} (e : C' ≃ D) : (inducedFunctor e).EssSurj where
mem_essImage Y := ⟨e.symm Y, by simpa using ⟨default⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | essSurjInducedFunctor | null |
noncomputable inducedFunctorOfEquiv {C' : Type*} (e : C' ≃ D) :
IsEquivalence (inducedFunctor e) where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inducedFunctorOfEquiv | null |
noncomputable fullyFaithfulToEssImage (F : C ⥤ D) [F.Full] [F.Faithful] :
IsEquivalence F.toEssImage where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | fullyFaithfulToEssImage | null |
@[simps]
ObjectProperty.fullSubcategoryCongr {P P' : ObjectProperty C} (h : P = P') :
P.FullSubcategory ≌ P'.FullSubcategory where
functor := ObjectProperty.ιOfLE h.le
inverse := ObjectProperty.ιOfLE h.symm.le
unitIso := Iso.refl _
counitIso := Iso.refl _
@[deprecated (since := "2025-03-04")]
alias Equivalence.ofFullSubcategory := ObjectProperty.fullSubcategoryCongr | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | ObjectProperty.fullSubcategoryCongr | An equality of properties of objects of a category `C` induces an equivalence of the
respective induced full subcategories of `C`. |
@[simps!]
compInverseIso {H : D ≌ E} (i : F ≅ G ⋙ H.functor) : F ⋙ H.inverse ≅ G :=
isoWhiskerRight i H.inverse ≪≫
associator G _ H.inverse ≪≫ isoWhiskerLeft G H.unitIso.symm ≪≫ G.rightUnitor | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | compInverseIso | Construct an isomorphism `F ⋙ H.inverse ≅ G` from an isomorphism `F ≅ G ⋙ H.functor`. |
@[simps!]
isoCompInverse {H : D ≌ E} (i : G ⋙ H.functor ≅ F) : G ≅ F ⋙ H.inverse :=
G.rightUnitor.symm ≪≫ isoWhiskerLeft G H.unitIso ≪≫ (associator _ _ _).symm ≪≫
isoWhiskerRight i H.inverse | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoCompInverse | Construct an isomorphism `G ≅ F ⋙ H.inverse` from an isomorphism `G ⋙ H.functor ≅ F`. |
@[simps!]
inverseCompIso {G : C ≌ D} (i : F ≅ G.functor ⋙ H) : G.inverse ⋙ F ≅ H :=
isoWhiskerLeft G.inverse i ≪≫ (associator _ _ _).symm ≪≫
isoWhiskerRight G.counitIso H ≪≫ H.leftUnitor | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inverseCompIso | Construct an isomorphism `G.inverse ⋙ F ≅ H` from an isomorphism `F ≅ G.functor ⋙ H`. |
@[simps!]
isoInverseComp {G : C ≌ D} (i : G.functor ⋙ H ≅ F) : H ≅ G.inverse ⋙ F :=
H.leftUnitor.symm ≪≫ isoWhiskerRight G.counitIso.symm H ≪≫ associator _ _ _
≪≫ isoWhiskerLeft G.inverse i | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoInverseComp | Construct an isomorphism `H ≅ G.inverse ⋙ F` from an isomorphism `G.functor ⋙ H ≅ F`. |
@[simps!]
isoInverseOfIsoFunctor {G G' : C ≌ D} (i : G.functor ≅ G'.functor) : G.inverse ≅ G'.inverse :=
isoCompInverse ((isoWhiskerLeft G.inverse i).symm ≪≫ G.counitIso) ≪≫ leftUnitor G'.inverse | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoInverseOfIsoFunctor | As a special case, given two equivalences `G` and `G'` between the same categories,
construct an isomorphism `G.inverse ≅ G.inverse` from an isomorphism `G.functor ≅ G.functor`. |
@[simps!]
isoFunctorOfIsoInverse {G G' : C ≌ D} (i : G.inverse ≅ G'.inverse) : G.functor ≅ G'.functor :=
isoInverseOfIsoFunctor (G := G.symm) (G' := G'.symm) i | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoFunctorOfIsoInverse | As a special case, given two equivalences `G` and `G'` between the same categories,
construct an isomorphism `G.functor ≅ G.functor` from an isomorphism `G.inverse ≅ G.inverse`. |
@[simp]
isoFunctorOfIsoInverse_isoInverseOfIsoFunctor {G G' : C ≌ D} (i : G.functor ≅ G'.functor) :
isoFunctorOfIsoInverse (isoInverseOfIsoFunctor i) = i := by
ext X
simp [← NatTrans.naturality]
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoFunctorOfIsoInverse_isoInverseOfIsoFunctor | Sanity check: `isoFunctorOfIsoInverse (isoInverseOfIsoFunctor i)` is just `i`. |
isoInverseOfIsoFunctor_isoFunctorOfIsoInverse {G G' : C ≌ D} (i : G.inverse ≅ G'.inverse) :
isoInverseOfIsoFunctor (isoFunctorOfIsoInverse i) = i :=
isoFunctorOfIsoInverse_isoInverseOfIsoFunctor (G := G.symm) (G' := G'.symm) i | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | isoInverseOfIsoFunctor_isoFunctorOfIsoInverse | null |
essImage (F : C ⥤ D) : ObjectProperty D := fun Y => ∃ X : C, Nonempty (F.obj X ≅ Y) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage | The essential image of a functor `F` consists of those objects in the target category which are
isomorphic to an object in the image of the function `F.obj`. In other words, this is the closure
under isomorphism of the function `F.obj`.
This is the "non-evil" way of describing the image of a functor. |
essImage.witness {Y : D} (h : F.essImage Y) : C :=
h.choose | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.witness | Get the witnessing object that `Y` is in the subcategory given by `F`. |
essImage.getIso {Y : D} (h : F.essImage Y) : F.obj h.witness ≅ Y :=
Classical.choice h.choose_spec | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.getIso | Extract the isomorphism between `F.obj h.witness` and `Y` itself. |
essImage.ofIso {Y Y' : D} (h : Y ≅ Y') (hY : essImage F Y) : essImage F Y' :=
hY.imp fun _ => Nonempty.map (· ≪≫ h) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.ofIso | Being in the essential image is a "hygienic" property: it is preserved under isomorphism. |
essImage.ofNatIso {F' : C ⥤ D} (h : F ≅ F') {Y : D} (hY : essImage F Y) :
essImage F' Y :=
hY.imp fun X => Nonempty.map fun t => h.symm.app X ≪≫ t | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.ofNatIso | If `Y` is in the essential image of `F` then it is in the essential image of `F'` as long as
`F ≅ F'`. |
essImage_eq_of_natIso {F' : C ⥤ D} (h : F ≅ F') : essImage F = essImage F' :=
funext fun _ => propext ⟨essImage.ofNatIso h, essImage.ofNatIso h.symm⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage_eq_of_natIso | Isomorphic functors have equal essential images. |
obj_mem_essImage (F : D ⥤ C) (Y : D) : essImage F (F.obj Y) :=
⟨Y, ⟨Iso.refl _⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | obj_mem_essImage | An object in the image is in the essential image. |
EssImageSubcategory (F : C ⥤ D) := F.essImage.FullSubcategory | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | EssImageSubcategory | The essential image of a functor, interpreted as a full subcategory of the target category. |
@[deprecated "use F.essImage.ι" (since := "2025-03-04")]
essImageInclusion (F : C ⥤ D) : F.EssImageSubcategory ⥤ D :=
F.essImage.ι | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImageInclusion | The essential image as a subcategory has a fully faithful inclusion into the target category. |
essImage_ext (F : C ⥤ D) {X Y : F.EssImageSubcategory} (f g : X ⟶ Y)
(h : F.essImage.ι.map f = F.essImage.ι.map g) : f = g :=
F.essImage.ι.map_injective h | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage_ext | null |
@[simps!]
toEssImage (F : C ⥤ D) : C ⥤ F.EssImageSubcategory :=
F.essImage.lift F (obj_mem_essImage _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | toEssImage | Given a functor `F : C ⥤ D`, we have an (essentially surjective) functor from `C` to the essential
image of `F`. |
@[simps!]
toEssImageCompι (F : C ⥤ D) : F.toEssImage ⋙ F.essImage.ι ≅ F :=
ObjectProperty.liftCompιIso _ _ _
@[deprecated (since := "2025-03-04")] alias toEssImageCompEssentialImageInclusio :=
toEssImageCompι | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | toEssImageCompι | The functor `F` factorises through its essential image, where the first functor is essentially
surjective and the second is fully faithful. |
@[stacks 001C]
EssSurj (F : C ⥤ D) : Prop where
/-- All the objects of the target category are in the essential image. -/
mem_essImage (Y : D) : F.essImage Y | class | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | EssSurj | A functor `F : C ⥤ D` is essentially surjective if every object of `D` is in the essential
image of `F`. In other words, for every `Y : D`, there is some `X : C` with `F.obj X ≅ Y`. |
EssSurj.toEssImage : EssSurj F.toEssImage where
mem_essImage := fun ⟨_, hY⟩ =>
⟨_, ⟨⟨_, _, hY.getIso.hom_inv_id, hY.getIso.inv_hom_id⟩⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | EssSurj.toEssImage | null |
essSurj_of_surj (h : Function.Surjective F.obj) : EssSurj F where
mem_essImage Y := by
obtain ⟨X, rfl⟩ := h Y
apply obj_mem_essImage | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essSurj_of_surj | null |
objPreimage (Y : D) : C :=
essImage.witness (@EssSurj.mem_essImage _ _ _ _ F _ Y) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | objPreimage | Given an essentially surjective functor, we can find a preimage for every object `Y` in the
codomain. Applying the functor to this preimage will yield an object isomorphic to `Y`, see
`obj_obj_preimage_iso`. |
objObjPreimageIso (Y : D) : F.obj (F.objPreimage Y) ≅ Y :=
Functor.essImage.getIso _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | objObjPreimageIso | Applying an essentially surjective functor to a preimage of `Y` yields an object that is
isomorphic to `Y`. |
Faithful.toEssImage (F : C ⥤ D) [Faithful F] : Faithful F.toEssImage := by
dsimp only [Functor.toEssImage]
infer_instance | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | Faithful.toEssImage | The induced functor of a faithful functor is faithful. |
Full.toEssImage (F : C ⥤ D) [Full F] : Full F.toEssImage := by
dsimp only [Functor.toEssImage]
infer_instance | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | Full.toEssImage | The induced functor of a full functor is full. |
instEssSurjId : EssSurj (𝟭 C) where
mem_essImage Y := ⟨Y, ⟨Iso.refl _⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | instEssSurjId | null |
essSurj_of_iso {F G : C ⥤ D} [EssSurj F] (α : F ≅ G) : EssSurj G where
mem_essImage Y := Functor.essImage.ofNatIso α (EssSurj.mem_essImage Y) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essSurj_of_iso | null |
essSurj_comp (F : C ⥤ D) (G : D ⥤ E) [F.EssSurj] [G.EssSurj] :
(F ⋙ G).EssSurj where
mem_essImage Z := ⟨_, ⟨G.mapIso (F.objObjPreimageIso _) ≪≫ G.objObjPreimageIso Z⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essSurj_comp | null |
essSurj_of_comp_fully_faithful (F : C ⥤ D) (G : D ⥤ E) [(F ⋙ G).EssSurj]
[G.Faithful] [G.Full] : F.EssSurj where
mem_essImage X := ⟨_, ⟨G.preimageIso ((F ⋙ G).objObjPreimageIso (G.obj X))⟩⟩
variable {F} {X : E} | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essSurj_of_comp_fully_faithful | null |
essImage_comp_apply_of_essSurj : (F ⋙ G).essImage X ↔ G.essImage X where
mp := fun ⟨Y, ⟨e⟩⟩ ↦ ⟨F.obj Y, ⟨e⟩⟩
mpr := fun ⟨Y, ⟨e⟩⟩ ↦
let ⟨Z, ⟨e'⟩⟩ := Functor.EssSurj.mem_essImage Y; ⟨Z, ⟨(G.mapIso e').trans e⟩⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage_comp_apply_of_essSurj | Pre-composing by an essentially surjective functor doesn't change the essential image. |
@[simp] essImage_comp_of_essSurj : (F ⋙ G).essImage = G.essImage :=
funext fun _X ↦ propext essImage_comp_apply_of_essSurj | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage_comp_of_essSurj | Pre-composing by an essentially surjective functor doesn't change the essential image. |
@[simps] essImage.liftFunctor : J ⥤ C where
obj j := F.toEssImage.objPreimage ⟨G.obj j, hG j⟩
map {i j} f := F.preimage <|
(F.toEssImage.objObjPreimageIso ⟨G.obj i, hG i⟩).hom ≫ G.map f ≫
(F.toEssImage.objObjPreimageIso ⟨G.obj j, hG j⟩).inv
map_id i := F.map_injective <| by
simpa [-Iso.hom_inv_id] using (F.toEssImage.objObjPreimageIso ⟨G.obj i, hG i⟩).hom_inv_id
map_comp {i j k} f g := F.map_injective <| by
simp only [Functor.map_comp, Category.assoc, Functor.map_preimage]
congr 2
symm
convert (F.toEssImage.objObjPreimageIso ⟨G.obj j, hG j⟩).inv_hom_id_assoc (G.map g ≫
(F.toEssImage.objObjPreimageIso ⟨G.obj k, hG k⟩).inv) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.liftFunctor | Lift a functor `G : J ⥤ D` to the essential image of a fully functor `F : C ⥤ D` to a functor
`G' : J ⥤ C` such that `G' ⋙ F ≅ G`. See `essImage.liftFunctorCompIso`. |
@[simps!] essImage.liftFunctorCompIso : essImage.liftFunctor G F hG ⋙ F ≅ G :=
NatIso.ofComponents
(fun i ↦ F.essImage.ι.mapIso (F.toEssImage.objObjPreimageIso ⟨G.obj i, hG _⟩))
fun {i j} f ↦ by
simp only [Functor.comp_obj, liftFunctor_obj, Functor.comp_map, liftFunctor_map,
Functor.map_preimage, Functor.mapIso_hom, ObjectProperty.ι_map, Category.assoc]
congr 1
convert Category.comp_id _
exact (F.toEssImage.objObjPreimageIso ⟨G.obj j, hG j⟩).inv_hom_id | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/EssentialImage.lean | essImage.liftFunctorCompIso | A functor `G : J ⥤ D` to the essential image of a fully functor `F : C ⥤ D` does factor through
`essImage.liftFunctor G F hG`. |
@[pp_with_univ]
EssentiallySmall (C : Type u) [Category.{v} C] : Prop where
/-- An essentially small category is equivalent to some small category. -/
equiv_smallCategory : ∃ (S : Type w) (_ : SmallCategory S), Nonempty (C ≌ S) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Category.ULift",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Skeletal",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.Logic.UnivLE",
"Mathlib.Logic.Small.Basic"
] | Mathlib/CategoryTheory/EssentiallySmall.lean | EssentiallySmall | A category is `EssentiallySmall.{w}` if there exists
an equivalence to some `S : Type w` with `[SmallCategory S]`. |
EssentiallySmall.mk' {C : Type u} [Category.{v} C] {S : Type w} [SmallCategory S]
(e : C ≌ S) : EssentiallySmall.{w} C :=
⟨⟨S, _, ⟨e⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.ULift",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Skeletal",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.Logic.UnivLE",
"Mathlib.Logic.Small.Basic"
] | Mathlib/CategoryTheory/EssentiallySmall.lean | EssentiallySmall.mk' | Constructor for `EssentiallySmall C` from an explicit small category witness. |
@[pp_with_univ]
SmallModel (C : Type u) [Category.{v} C] [EssentiallySmall.{w} C] : Type w :=
Classical.choose (@EssentiallySmall.equiv_smallCategory C _ _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.ULift",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Skeletal",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.Logic.UnivLE",
"Mathlib.Logic.Small.Basic"
] | Mathlib/CategoryTheory/EssentiallySmall.lean | SmallModel | An arbitrarily chosen small model for an essentially small category. |
noncomputable smallCategorySmallModel (C : Type u) [Category.{v} C]
[EssentiallySmall.{w} C] : SmallCategory (SmallModel C) :=
Classical.choose (Classical.choose_spec (@EssentiallySmall.equiv_smallCategory C _ _)) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Category.ULift",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Skeletal",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.Logic.UnivLE",
"Mathlib.Logic.Small.Basic"
] | Mathlib/CategoryTheory/EssentiallySmall.lean | smallCategorySmallModel | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.