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 ⌀ |
|---|---|---|---|---|---|---|
@[simps!]
rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F :=
NatIso.ofComponents fun _ => Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOpLeftOpIso | The isomorphism between `F.rightOp.leftOp` and `F`. |
rightOp_leftOp_eq (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp = F := by
cases F
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_leftOp_eq | Whenever possible, it is advisable to use the isomorphism `rightOpLeftOpIso`
instead of this equality of functors. |
@[simps]
protected op (α : F ⟶ G) : G.op ⟶ F.op where
app X := (α.app (unop X)).op
naturality X Y f := Quiver.Hom.unop_inj (by simp)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op | The opposite of a natural transformation. |
op_id (F : C ⥤ D) : NatTrans.op (𝟙 F) = 𝟙 F.op :=
rfl
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_id | null |
op_comp {H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H) :
NatTrans.op (α ≫ β) = NatTrans.op β ≫ NatTrans.op α :=
rfl
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_comp | null |
op_whiskerRight {E : Type*} [Category E] {H : D ⥤ E} (α : F ⟶ G) :
NatTrans.op (whiskerRight α H) =
(Functor.opComp _ _).hom ≫ whiskerRight (NatTrans.op α) H.op ≫ (Functor.opComp _ _).inv := by
cat_disch
@[reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_whiskerRight | null |
op_whiskerLeft {E : Type*} [Category E] {H : E ⥤ C} (α : F ⟶ G) :
NatTrans.op (whiskerLeft H α) =
(Functor.opComp _ _).hom ≫ whiskerLeft H.op (NatTrans.op α) ≫ (Functor.opComp _ _).inv := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_whiskerLeft | null |
@[simps]
protected unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ⟶ G) : G.unop ⟶ F.unop where
app X := (α.app (op X)).unop
naturality X Y f := Quiver.Hom.op_inj (by simp)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop | The "unopposite" of a natural transformation. |
unop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.unop (𝟙 F) = 𝟙 F.unop :=
rfl
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_id | null |
unop_comp {F G H : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ⟶ G) (β : G ⟶ H) :
NatTrans.unop (α ≫ β) = NatTrans.unop β ≫ NatTrans.unop α :=
rfl
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_comp | null |
unop_whiskerRight {F G : Cᵒᵖ ⥤ Dᵒᵖ} {E : Type*} [Category E] {H : Dᵒᵖ ⥤ Eᵒᵖ} (α : F ⟶ G) :
NatTrans.unop (whiskerRight α H) =
(Functor.unopComp _ _).hom ≫ whiskerRight (NatTrans.unop α) H.unop ≫
(Functor.unopComp _ _).inv := by
cat_disch
@[reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_whiskerRight | null |
unop_whiskerLeft {F G : Cᵒᵖ ⥤ Dᵒᵖ} {E : Type*} [Category E] {H : Eᵒᵖ ⥤ Cᵒᵖ} (α : F ⟶ G) :
NatTrans.unop (whiskerLeft H α) =
(Functor.unopComp _ _).hom ≫ whiskerLeft H.unop (NatTrans.unop α) ≫
(Functor.unopComp _ _).inv := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_whiskerLeft | null |
@[simps]
protected removeOp (α : F.op ⟶ G.op) : G ⟶ F where
app X := (α.app (op X)).unop
naturality X Y f :=
Quiver.Hom.op_inj <| by simpa only [Functor.op_map] using (α.naturality f.op).symm
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeOp | Given a natural transformation `α : F.op ⟶ G.op`,
we can take the "unopposite" of each component obtaining a natural transformation `G ⟶ F`. |
removeOp_id (F : C ⥤ D) : NatTrans.removeOp (𝟙 F.op) = 𝟙 F :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeOp_id | null |
@[simps]
protected removeUnop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F.unop ⟶ G.unop) : G ⟶ F where
app X := (α.app (unop X)).op
naturality X Y f :=
Quiver.Hom.unop_inj <| by simpa only [Functor.unop_map] using (α.naturality f.unop).symm
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeUnop | Given a natural transformation `α : F.unop ⟶ G.unop`, we can take the opposite of each
component obtaining a natural transformation `G ⟶ F`. |
removeUnop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.removeUnop (𝟙 F.unop) = 𝟙 F :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeUnop_id | null |
@[simps]
protected leftOp (α : F ⟶ G) : G.leftOp ⟶ F.leftOp where
app X := (α.app (unop X)).unop
naturality X Y f := Quiver.Hom.op_inj (by simp)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp | Given a natural transformation `α : F ⟶ G`, for `F G : C ⥤ Dᵒᵖ`,
taking `unop` of each component gives a natural transformation `G.leftOp ⟶ F.leftOp`. |
leftOp_id : NatTrans.leftOp (𝟙 F : F ⟶ F) = 𝟙 F.leftOp :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp_id | null |
leftOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.leftOp (α ≫ β) =
NatTrans.leftOp β ≫ NatTrans.leftOp α :=
rfl
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp_comp | null |
leftOpWhiskerRight {E : Type*} [Category E] {H : E ⥤ C} (α : F ⟶ G) :
(whiskerLeft H α).leftOp = (Functor.leftOpComp H G).hom ≫ whiskerLeft _ α.leftOp ≫
(Functor.leftOpComp H F).inv := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOpWhiskerRight | null |
@[simps]
protected removeLeftOp (α : F.leftOp ⟶ G.leftOp) : G ⟶ F where
app X := (α.app (op X)).op
naturality X Y f :=
Quiver.Hom.unop_inj <| by simpa only [Functor.leftOp_map] using (α.naturality f.op).symm
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeLeftOp | Given a natural transformation `α : F.leftOp ⟶ G.leftOp`, for `F G : C ⥤ Dᵒᵖ`,
taking `op` of each component gives a natural transformation `G ⟶ F`. |
removeLeftOp_id : NatTrans.removeLeftOp (𝟙 F.leftOp) = 𝟙 F :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeLeftOp_id | null |
@[simps]
protected rightOp (α : F ⟶ G) : G.rightOp ⟶ F.rightOp where
app _ := (α.app _).op
naturality X Y f := Quiver.Hom.unop_inj (by simp)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp | Given a natural transformation `α : F ⟶ G`, for `F G : Cᵒᵖ ⥤ D`,
taking `op` of each component gives a natural transformation `G.rightOp ⟶ F.rightOp`. |
rightOp_id : NatTrans.rightOp (𝟙 F : F ⟶ F) = 𝟙 F.rightOp :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_id | null |
rightOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.rightOp (α ≫ β) =
NatTrans.rightOp β ≫ NatTrans.rightOp α :=
rfl
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_comp | null |
rightOpWhiskerRight {E : Type*} [Category E] {H : D ⥤ E} (α : F ⟶ G) :
(whiskerRight α H).rightOp = (Functor.rightOpComp G H).hom ≫ whiskerRight α.rightOp H.op ≫
(Functor.rightOpComp F H).inv := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOpWhiskerRight | null |
@[simps]
protected removeRightOp (α : F.rightOp ⟶ G.rightOp) : G ⟶ F where
app X := (α.app X.unop).unop
naturality X Y f :=
Quiver.Hom.op_inj <| by simpa only [Functor.rightOp_map] using (α.naturality f.unop).symm
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeRightOp | Given a natural transformation `α : F.rightOp ⟶ G.rightOp`, for `F G : Cᵒᵖ ⥤ D`,
taking `unop` of each component gives a natural transformation `G ⟶ F`. |
removeRightOp_id : NatTrans.removeRightOp (𝟙 F.rightOp) = 𝟙 F :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeRightOp_id | null |
@[simps]
protected op (α : X ≅ Y) : op Y ≅ op X where
hom := α.hom.op
inv := α.inv.op
hom_inv_id := Quiver.Hom.unop_inj α.inv_hom_id
inv_hom_id := Quiver.Hom.unop_inj α.hom_inv_id | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op | The opposite isomorphism. |
@[simps]
unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop where
hom := f.hom.unop
inv := f.inv.unop
hom_inv_id := by simp only [← unop_comp, f.inv_hom_id, unop_id]
inv_hom_id := by simp only [← unop_comp, f.hom_inv_id, unop_id]
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop | The isomorphism obtained from an isomorphism in the opposite category. |
unop_op {X Y : Cᵒᵖ} (f : X ≅ Y) : f.unop.op = f := by (ext; rfl)
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_op | null |
op_unop {X Y : C} (f : X ≅ Y) : f.op.unop = f := by (ext; rfl)
variable (X) in
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_unop | null |
op_refl : Iso.op (Iso.refl X) = Iso.refl (op X) := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_refl | null |
op_trans {Z : C} (α : X ≅ Y) (β : Y ≅ Z) :
Iso.op (α ≪≫ β) = Iso.op β ≪≫ Iso.op α :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_trans | null |
op_symm (α : X ≅ Y) : Iso.op α.symm = (Iso.op α).symm := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_symm | null |
unop_refl (X : Cᵒᵖ) : Iso.unop (Iso.refl X) = Iso.refl X.unop := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_refl | null |
unop_trans {X Y Z : Cᵒᵖ} (α : X ≅ Y) (β : Y ≅ Z) :
Iso.unop (α ≪≫ β) = Iso.unop β ≪≫ Iso.unop α :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_trans | null |
unop_symm {X Y : Cᵒᵖ} (α : X ≅ Y) : Iso.unop α.symm = (Iso.unop α).symm := rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_symm | null |
@[reassoc (attr := simp)]
unop_hom_inv_id_app : (e.hom.app X).unop ≫ (e.inv.app X).unop = 𝟙 _ := by
rw [← unop_comp, inv_hom_id_app, unop_id]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_hom_inv_id_app | null |
unop_inv_hom_id_app : (e.inv.app X).unop ≫ (e.hom.app X).unop = 𝟙 _ := by
rw [← unop_comp, hom_inv_id_app, unop_id] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_inv_hom_id_app | null |
@[simps]
protected op (α : F ≅ G) : G.op ≅ F.op where
hom := NatTrans.op α.hom
inv := NatTrans.op α.inv
hom_inv_id := by ext; dsimp; rw [← op_comp]; rw [α.inv_hom_id_app]; rfl
inv_hom_id := by ext; dsimp; rw [← op_comp]; rw [α.hom_inv_id_app]; rfl
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op | The natural isomorphism between opposite functors `G.op ≅ F.op` induced by a natural
isomorphism between the original functors `F ≅ G`. |
op_refl : NatIso.op (Iso.refl F) = Iso.refl F.op := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_refl | null |
op_trans {H : C ⥤ D} (α : F ≅ G) (β : G ≅ H) :
NatIso.op (α ≪≫ β) = NatIso.op β ≪≫ NatIso.op α :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_trans | null |
op_symm (α : F ≅ G) : NatIso.op α.symm = (NatIso.op α).symm := rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_symm | null |
@[simps]
protected removeOp (α : F.op ≅ G.op) : G ≅ F where
hom := NatTrans.removeOp α.hom
inv := NatTrans.removeOp α.inv | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | removeOp | The natural isomorphism between functors `G ≅ F` induced by a natural isomorphism
between the opposite functors `F.op ≅ G.op`. |
@[simps]
protected unop {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : G.unop ≅ F.unop where
hom := NatTrans.unop α.hom
inv := NatTrans.unop α.inv
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop | The natural isomorphism between functors `G.unop ≅ F.unop` induced by a natural isomorphism
between the original functors `F ≅ G`. |
unop_refl (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatIso.unop (Iso.refl F) = Iso.refl F.unop := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_refl | null |
unop_trans {F G H : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) (β : G ≅ H) :
NatIso.unop (α ≪≫ β) = NatIso.unop β ≪≫ NatIso.unop α :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_trans | null |
unop_symm {F G : Cᵒᵖ ⥤ Dᵒᵖ} (α : F ≅ G) : NatIso.unop α.symm = (NatIso.unop α).symm := rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_symm | null |
op_isoWhiskerRight {E : Type*} [Category E] {H : D ⥤ E} (α : F ≅ G) :
NatIso.op (isoWhiskerRight α H) =
(Functor.opComp _ _) ≪≫ isoWhiskerRight (NatIso.op α) H.op ≪≫ (Functor.opComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_isoWhiskerRight | null |
op_isoWhiskerLeft {E : Type*} [Category E] {H : E ⥤ C} (α : F ≅ G) :
NatIso.op (isoWhiskerLeft H α) =
(Functor.opComp _ _) ≪≫ isoWhiskerLeft H.op (NatIso.op α) ≪≫ (Functor.opComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_isoWhiskerLeft | null |
unop_whiskerRight {F G : Cᵒᵖ ⥤ Dᵒᵖ} {E : Type*} [Category E] {H : Dᵒᵖ ⥤ Eᵒᵖ} (α : F ≅ G) :
NatIso.unop (isoWhiskerRight α H) =
(Functor.unopComp _ _) ≪≫ isoWhiskerRight (NatIso.unop α) H.unop ≪≫
(Functor.unopComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_whiskerRight | null |
unop_whiskerLeft {F G : Cᵒᵖ ⥤ Dᵒᵖ} {E : Type*} [Category E] {H : Eᵒᵖ ⥤ Cᵒᵖ} (α : F ≅ G) :
NatIso.unop (isoWhiskerLeft H α) =
(Functor.unopComp _ _) ≪≫ isoWhiskerLeft H.unop (NatIso.unop α) ≪≫
(Functor.unopComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_whiskerLeft | null |
op_leftUnitor :
NatIso.op F.leftUnitor =
F.op.leftUnitor.symm ≪≫
isoWhiskerRight (Functor.opId C).symm F.op ≪≫
(Functor.opComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_leftUnitor | null |
op_rightUnitor :
NatIso.op F.rightUnitor =
F.op.rightUnitor.symm ≪≫
isoWhiskerLeft F.op (Functor.opId D).symm ≪≫
(Functor.opComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_rightUnitor | null |
op_associator {E E' : Type*} [Category E] [Category E'] {F : C ⥤ D} {G : D ⥤ E} {H : E ⥤ E'} :
NatIso.op (Functor.associator F G H) =
Functor.opComp _ _ ≪≫ isoWhiskerLeft F.op (Functor.opComp _ _) ≪≫
(Functor.associator F.op G.op H.op).symm ≪≫
isoWhiskerRight (Functor.opComp _ _).symm H.op ≪≫ (Functor.opComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_associator | null |
unop_leftUnitor {F : Cᵒᵖ ⥤ Dᵒᵖ} :
NatIso.unop F.leftUnitor =
F.unop.leftUnitor.symm ≪≫
isoWhiskerRight (Functor.unopId C).symm F.unop ≪≫
(Functor.unopComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_leftUnitor | null |
unop_rightUnitor {F : Cᵒᵖ ⥤ Dᵒᵖ} :
NatIso.unop F.rightUnitor =
F.unop.rightUnitor.symm ≪≫
isoWhiskerLeft F.unop (Functor.unopId D).symm ≪≫
(Functor.unopComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_rightUnitor | null |
unop_associator {E E' : Type*} [Category E] [Category E']
{F : Cᵒᵖ ⥤ Dᵒᵖ} {G : Dᵒᵖ ⥤ Eᵒᵖ} {H : Eᵒᵖ ⥤ E'ᵒᵖ} :
NatIso.unop (Functor.associator F G H) =
Functor.unopComp _ _ ≪≫ isoWhiskerLeft F.unop (Functor.unopComp _ _) ≪≫
(Functor.associator F.unop G.unop H.unop).symm ≪≫
isoWhiskerRight (Functor.unopComp _ _).symm H.unop ≪≫ (Functor.unopComp _ _).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_associator | null |
@[simps]
op (e : C ≌ D) : Cᵒᵖ ≌ Dᵒᵖ where
functor := e.functor.op
inverse := e.inverse.op
unitIso := (NatIso.op e.unitIso).symm
counitIso := (NatIso.op e.counitIso).symm
functor_unitIso_comp X := by
apply Quiver.Hom.unop_inj
simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op | An equivalence between categories gives an equivalence between the opposite categories. |
@[simps]
unop (e : Cᵒᵖ ≌ Dᵒᵖ) : C ≌ D where
functor := e.functor.unop
inverse := e.inverse.unop
unitIso := (NatIso.unop e.unitIso).symm
counitIso := (NatIso.unop e.counitIso).symm
functor_unitIso_comp X := by
apply Quiver.Hom.op_inj
simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop | An equivalence between opposite categories gives an equivalence between the original categories. |
@[simps!] leftOp (e : C ≌ Dᵒᵖ) : Cᵒᵖ ≌ D := e.op.trans (opOpEquivalence D) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp | An equivalence between `C` and `Dᵒᵖ` gives an equivalence between `Cᵒᵖ` and `D`. |
@[simps!] rightOp (e : Cᵒᵖ ≌ D) : C ≌ Dᵒᵖ := (opOpEquivalence C).symm.trans e.op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp | An equivalence between `Cᵒᵖ` and `D` gives an equivalence between `C` and `Dᵒᵖ`. |
@[simps]
opEquiv (A B : Cᵒᵖ) : (A ⟶ B) ≃ (B.unop ⟶ A.unop) where
toFun f := f.unop
invFun g := g.op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opEquiv | The equivalence between arrows of the form `A ⟶ B` and `B.unop ⟶ A.unop`. Useful for building
adjunctions.
Note that this (definitionally) gives variants
```
def opEquiv' (A : C) (B : Cᵒᵖ) : (Opposite.op A ⟶ B) ≃ (B.unop ⟶ A) :=
opEquiv _ _
def opEquiv'' (A : Cᵒᵖ) (B : C) : (A ⟶ Opposite.op B) ≃ (B ⟶ A.unop) :=
opEquiv _ _
def opEquiv''' (A B : C) : (Opposite.op A ⟶ Opposite.op B) ≃ (B ⟶ A) :=
opEquiv _ _
``` |
subsingleton_of_unop (A B : Cᵒᵖ) [Subsingleton (unop B ⟶ unop A)] : Subsingleton (A ⟶ B) :=
(opEquiv A B).subsingleton | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | subsingleton_of_unop | null |
decidableEqOfUnop (A B : Cᵒᵖ) [DecidableEq (unop B ⟶ unop A)] : DecidableEq (A ⟶ B) :=
(opEquiv A B).decidableEq | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | decidableEqOfUnop | null |
@[simps]
isoOpEquiv (A B : Cᵒᵖ) : (A ≅ B) ≃ (B.unop ≅ A.unop) where
toFun f := f.unop
invFun g := g.op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isoOpEquiv | The equivalence between isomorphisms of the form `A ≅ B` and `B.unop ≅ A.unop`.
Note this is definitionally the same as the other three variants:
* `(Opposite.op A ≅ B) ≃ (B.unop ≅ A)`
* `(A ≅ Opposite.op B) ≃ (B ≅ A.unop)`
* `(Opposite.op A ≅ Opposite.op B) ≃ (B ≅ A)` |
@[simps]
opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ where
functor := opHom _ _
inverse := opInv _ _
unitIso :=
NatIso.ofComponents (fun F => F.unop.opUnopIso.op)
(by
intro F G f
dsimp [opUnopIso]
rw [show f = f.unop.op by simp, ← op_comp, ← op_comp]
congr 1
cat_disch)
counitIso := NatIso.ofComponents fun F => F.unopOpIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opUnopEquiv | The equivalence of functor categories induced by `op` and `unop`. |
@[simps!]
leftOpRightOpEquiv : (Cᵒᵖ ⥤ D)ᵒᵖ ≌ C ⥤ Dᵒᵖ where
functor :=
{ obj := fun F => F.unop.rightOp
map := fun η => NatTrans.rightOp η.unop }
inverse :=
{ obj := fun F => op F.leftOp
map := fun η => η.leftOp.op }
unitIso :=
NatIso.ofComponents (fun F => F.unop.rightOpLeftOpIso.op)
(by
intro F G η
dsimp
rw [show η = η.unop.op by simp, ← op_comp, ← op_comp]
congr 1
cat_disch)
counitIso := NatIso.ofComponents fun F => F.leftOpRightOpIso | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOpRightOpEquiv | The equivalence of functor categories induced by `leftOp` and `rightOp`. |
functorOfIsEmpty [IsEmpty C] : C ⥤ D where
obj := isEmptyElim
map := fun {X} ↦ isEmptyElim X
map_id := fun {X} ↦ isEmptyElim X
map_comp := fun {X} ↦ isEmptyElim X
variable {C D} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | functorOfIsEmpty | The (unique) functor from an empty category. |
Functor.isEmptyExt [IsEmpty C] (F G : C ⥤ D) : F ≅ G :=
NatIso.ofComponents isEmptyElim (fun {X} ↦ isEmptyElim X)
variable (C D) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | Functor.isEmptyExt | Any two functors out of an empty category are isomorphic. |
equivalenceOfIsEmpty [IsEmpty C] [IsEmpty D] : C ≌ D where
functor := functorOfIsEmpty C D
inverse := functorOfIsEmpty D C
unitIso := Functor.isEmptyExt _ _
counitIso := Functor.isEmptyExt _ _
functor_unitIso_comp := isEmptyElim | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | equivalenceOfIsEmpty | The equivalence between two empty categories. |
emptyEquivalence : Discrete.{w} PEmpty ≌ Discrete.{v} PEmpty := equivalenceOfIsEmpty _ _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | emptyEquivalence | Equivalence between two empty categories. |
empty : Discrete.{w} PEmpty ⥤ C :=
Discrete.functor PEmpty.elim
variable {C} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | empty | The canonical functor out of the empty category. |
emptyExt (F G : Discrete.{w} PEmpty ⥤ C) : F ≅ G :=
Discrete.natIso fun x => x.as.elim | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | emptyExt | Any two functors out of the empty category are isomorphic. |
uniqueFromEmpty (F : Discrete.{w} PEmpty ⥤ C) : F ≅ empty C :=
emptyExt _ _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | uniqueFromEmpty | Any functor out of the empty category is isomorphic to the canonical functor from the empty
category. |
empty_ext' (F G : Discrete.{w} PEmpty ⥤ C) : F = G :=
Functor.ext (fun x => x.as.elim) fun x _ _ => x.as.elim | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PEmpty.lean | empty_ext' | Any two functors out of the empty category are *equal*. You probably want to use
`emptyExt` instead of this. |
@[simps!]
star : C ⥤ Discrete PUnit.{w + 1} :=
(Functor.const _).obj ⟨⟨⟩⟩
variable {C} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | star | The constant functor sending everything to `PUnit.star`. |
@[simps!]
punitExt (F G : C ⥤ Discrete PUnit.{w + 1}) : F ≅ G :=
NatIso.ofComponents fun X => eqToIso (by simp only [eq_iff_true_of_subsingleton]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | punitExt | Any two functors to `Discrete PUnit` are isomorphic. |
punit_ext' (F G : C ⥤ Discrete PUnit.{w + 1}) : F = G :=
Functor.ext fun X => by simp only [eq_iff_true_of_subsingleton] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | punit_ext' | Any two functors to `Discrete PUnit` are *equal*.
You probably want to use `punitExt` instead of this. |
fromPUnit (X : C) : Discrete PUnit.{w + 1} ⥤ C :=
(Functor.const _).obj X | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | fromPUnit | The functor from `Discrete PUnit` sending everything to the given object. |
@[simps]
equiv : Discrete PUnit.{w + 1} ⥤ C ≌ C where
functor :=
{ obj := fun F => F.obj ⟨⟨⟩⟩
map := fun θ => θ.app ⟨⟨⟩⟩ }
inverse := Functor.const _
unitIso := NatIso.ofComponents fun _ => Discrete.natIso fun _ => Iso.refl _
counitIso := NatIso.ofComponents Iso.refl | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | equiv | Functors from `Discrete PUnit` are equivalent to the category itself. |
equiv_punit_iff_unique :
Nonempty (C ≌ Discrete PUnit.{w + 1}) ↔ Nonempty C ∧ ∀ x y : C, Nonempty <| Unique (x ⟶ y) := by
constructor
· rintro ⟨h⟩
refine ⟨⟨h.inverse.obj ⟨⟨⟩⟩⟩, fun x y => Nonempty.intro ?_⟩
let f : x ⟶ y := by
have hx : x ⟶ h.inverse.obj ⟨⟨⟩⟩ := by convert h.unit.app x
have hy : h.inverse.obj ⟨⟨⟩⟩ ⟶ y := by convert h.unitInv.app y
exact hx ≫ hy
suffices sub : Subsingleton (x ⟶ y) from uniqueOfSubsingleton f
have : ∀ z, z = h.unit.app x ≫ (h.functor ⋙ h.inverse).map z ≫ h.unitInv.app y := by
intro z
simp
apply Subsingleton.intro
intro a b
rw [this a, this b]
simp only [Functor.comp_map]
congr 3
apply ULift.ext
simp [eq_iff_true_of_subsingleton]
· rintro ⟨⟨p⟩, h⟩
haveI := fun x y => (h x y).some
refine
Nonempty.intro
(CategoryTheory.Equivalence.mk ((Functor.const _).obj ⟨⟨⟩⟩)
((@Functor.const <| Discrete PUnit).obj p) ?_ (by apply Functor.punitExt))
exact
NatIso.ofComponents fun _ =>
{ hom := default
inv := default } | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.CategoryTheory.Discrete.Basic"
] | Mathlib/CategoryTheory/PUnit.lean | equiv_punit_iff_unique | A category being equivalent to `PUnit` is equivalent to it having a unique morphism between
any two objects. (In fact, such a category is also a groupoid;
see `CategoryTheory.Groupoid.ofHomUnique`) |
HomRel (C) [Quiver C] :=
∀ ⦃X Y : C⦄, (X ⟶ Y) → (X ⟶ Y) → Prop
deriving Inhabited | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | HomRel | A `HomRel` on `C` consists of a relation on every hom-set. |
Functor.homRel : HomRel C :=
fun _ _ f g ↦ F.map f = F.map g
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Functor.homRel | A functor induces a `HomRel` on its domain, relating those maps that have the same image. |
Functor.homRel_iff {X Y : C} (f g : X ⟶ Y) :
F.homRel f g ↔ F.map f = F.map g := Iff.rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Functor.homRel_iff | null |
Congruence : Prop where
/-- `r` is an equivalence on every hom-set. -/
equivalence : ∀ {X Y}, _root_.Equivalence (@r X Y)
/-- Precomposition with an arrow respects `r`. -/
compLeft : ∀ {X Y Z} (f : X ⟶ Y) {g g' : Y ⟶ Z}, r g g' → r (f ≫ g) (f ≫ g')
/-- Postcomposition with an arrow respects `r`. -/
compRight : ∀ {X Y Z} {f f' : X ⟶ Y} (g : Y ⟶ Z), r f f' → r (f ≫ g) (f' ≫ g) | class | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Congruence | A `HomRel` is a congruence when it's an equivalence on every hom-set, and it can be composed
from left and right. |
Functor.congruence_homRel {C D : Type*} [Category C] [Category D] (F : C ⥤ D) :
Congruence F.homRel where
equivalence :=
{ refl := fun _ ↦ rfl
symm := by aesop
trans := by aesop }
compLeft := by aesop
compRight := by aesop | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Functor.congruence_homRel | For `F : C ⥤ D`, `F.homRel` is a congruence. |
@[ext]
Quotient (r : HomRel C) where
/-- The object of `C`. -/
as : C | structure | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Quotient | A type synonym for `C`, thought of as the objects of the quotient category. |
CompClosure (r : HomRel C) ⦃s t : C⦄ : (s ⟶ t) → (s ⟶ t) → Prop
| intro {a b : C} (f : s ⟶ a) (m₁ m₂ : a ⟶ b) (g : b ⟶ t) (h : r m₁ m₂) :
CompClosure r (f ≫ m₁ ≫ g) (f ≫ m₂ ≫ g) | inductive | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | CompClosure | Generates the closure of a family of relations w.r.t. composition from left and right. |
CompClosure.of {a b : C} (m₁ m₂ : a ⟶ b) (h : r m₁ m₂) : CompClosure r m₁ m₂ := by
simpa using CompClosure.intro (𝟙 _) m₁ m₂ (𝟙 _) h | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | CompClosure.of | null |
comp_left {a b c : C} (f : a ⟶ b) :
∀ (g₁ g₂ : b ⟶ c) (_ : CompClosure r g₁ g₂), CompClosure r (f ≫ g₁) (f ≫ g₂)
| _, _, ⟨x, m₁, m₂, y, h⟩ => by simpa using CompClosure.intro (f ≫ x) m₁ m₂ y h | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | comp_left | null |
comp_right {a b c : C} (g : b ⟶ c) :
∀ (f₁ f₂ : a ⟶ b) (_ : CompClosure r f₁ f₂), CompClosure r (f₁ ≫ g) (f₂ ≫ g)
| _, _, ⟨x, m₁, m₂, y, h⟩ => by simpa using CompClosure.intro x m₁ m₂ (y ≫ g) h | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | comp_right | null |
Hom (s t : Quotient r) :=
Quot <| @CompClosure C _ r s.as t.as | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | Hom | Hom-sets of the quotient category. |
comp ⦃a b c : Quotient r⦄ : Hom r a b → Hom r b c → Hom r a c := fun hf hg ↦
Quot.liftOn hf
(fun f ↦
Quot.liftOn hg (fun g ↦ Quot.mk _ (f ≫ g)) fun g₁ g₂ h ↦
Quot.sound <| comp_left r f g₁ g₂ h)
fun f₁ f₂ h ↦ Quot.inductionOn hg fun g ↦ Quot.sound <| comp_right r g f₁ f₂ h
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | comp | Composition in the quotient category. |
comp_mk {a b c : Quotient r} (f : a.as ⟶ b.as) (g : b.as ⟶ c.as) :
comp r (Quot.mk _ f) (Quot.mk _ g) = Quot.mk _ (f ≫ g) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | comp_mk | null |
category : Category (Quotient r) where
Hom := Hom r
id a := Quot.mk _ (𝟙 a.as)
comp := @comp _ _ r
comp_id f := Quot.inductionOn f <| by simp
id_comp f := Quot.inductionOn f <| by simp
assoc f g h := Quot.inductionOn f <| Quot.inductionOn g <| Quot.inductionOn h <| by simp
noncomputable section
variable {G : Type*} [Groupoid G] (r : HomRel G) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | category | null |
protected inv {X Y : Quotient r} (f : X ⟶ Y) : Y ⟶ X :=
Quot.liftOn f (fun f' => Quot.mk _ (Groupoid.inv f')) (fun _ _ con => by
rcases con with ⟨ _, f, g, _, hfg ⟩
have := Quot.sound <| CompClosure.intro (Groupoid.inv g) f g (Groupoid.inv f) hfg
simp only [Groupoid.inv_eq_inv, IsIso.hom_inv_id, Category.comp_id,
IsIso.inv_hom_id_assoc] at this
simp only [Groupoid.inv_eq_inv, IsIso.inv_comp, Category.assoc]
repeat rw [← comp_mk]
rw [this])
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | inv | Inverse of a map in the quotient category of a groupoid. |
inv_mk {X Y : Quotient r} (f : X.as ⟶ Y.as) :
Quotient.inv r (Quot.mk _ f) = Quot.mk _ (Groupoid.inv f) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | inv_mk | null |
groupoid : Groupoid (Quotient r) where
inv f := Quotient.inv r f
inv_comp f := Quot.inductionOn f <| by simp [CategoryStruct.comp, CategoryStruct.id]
comp_inv f := Quot.inductionOn f <| by simp [CategoryStruct.comp, CategoryStruct.id] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | groupoid | The quotient of a groupoid is a groupoid. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.