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 ⌀ |
|---|---|---|---|---|---|---|
mapIso_trans (F : C ⥤ D) {X Y Z : C} (i : X ≅ Y) (j : Y ≅ Z) :
F.mapIso (i ≪≫ j) = F.mapIso i ≪≫ F.mapIso j := by
ext; apply Functor.map_comp
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | mapIso_trans | null |
mapIso_refl (F : C ⥤ D) (X : C) : F.mapIso (Iso.refl X) = Iso.refl (F.obj X) :=
Iso.ext <| F.map_id X | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | mapIso_refl | null |
map_isIso (F : C ⥤ D) (f : X ⟶ Y) [IsIso f] : IsIso (F.map f) :=
(F.mapIso (asIso f)).isIso_hom
@[simp] | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_isIso | null |
map_inv (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] : F.map (inv f) = inv (F.map f) := by
apply eq_inv_of_hom_inv_id
simp [← F.map_comp]
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_inv | null |
map_hom_inv (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] :
F.map f ≫ F.map (inv f) = 𝟙 (F.obj X) := by simp
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_hom_inv | null |
map_inv_hom (F : C ⥤ D) {X Y : C} (f : X ⟶ Y) [IsIso f] :
F.map (inv f) ≫ F.map f = 𝟙 (F.obj Y) := by simp | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/Iso.lean | map_inv_hom | null |
IsIsomorphic : C → C → Prop := fun X Y => Nonempty (X ≅ Y)
variable (C) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic"
] | Mathlib/CategoryTheory/IsomorphismClasses.lean | IsIsomorphic | An object `X` is isomorphic to an object `Y`, if `X ≅ Y` is not empty. |
isIsomorphicSetoid : Setoid C where
r := IsIsomorphic
iseqv := ⟨fun X => ⟨Iso.refl X⟩, fun ⟨α⟩ => ⟨α.symm⟩, fun ⟨α⟩ ⟨β⟩ => ⟨α.trans β⟩⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic"
] | Mathlib/CategoryTheory/IsomorphismClasses.lean | isIsomorphicSetoid | `IsIsomorphic` defines a setoid. |
isomorphismClasses : Cat.{v, u} ⥤ Type u where
obj C := Quotient (isIsomorphicSetoid C.α)
map {_ _} F := Quot.map F.obj fun _ _ ⟨f⟩ => ⟨F.mapIso f⟩
map_id {C} := by -- Porting note: this used to be `tidy`
apply funext; intro x
apply @Quot.recOn _ _ _ x
· intro _ _ p
simp only [types_id_apply]
· intro _
rfl
map_comp {C D E} f g := by -- Porting note(s): idem
apply funext; intro x
apply @Quot.recOn _ _ _ x
· intro _ _ _
simp only
· intro _
rfl | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic"
] | Mathlib/CategoryTheory/IsomorphismClasses.lean | isomorphismClasses | The functor that sends each category to the quotient space of its objects up to an isomorphism. |
Groupoid.isIsomorphic_iff_nonempty_hom {C : Type u} [Groupoid.{v} C] {X Y : C} :
IsIsomorphic X Y ↔ Nonempty (X ⟶ Y) :=
(Groupoid.isoEquivHom X Y).nonempty_congr | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic"
] | Mathlib/CategoryTheory/IsomorphismClasses.lean | Groupoid.isIsomorphic_iff_nonempty_hom | null |
Functor.IsLocallyDirected (F : J ⥤ Type*) : Prop where
cond (F) : ∀ {i j k} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
F.map fi xi = F.map fj xj → ∃ (l : J) (fli : l ⟶ i) (flj : l ⟶ j) (x : _),
F.map fli x = xi ∧ F.map flj x = xj
alias Functor.exists_map_eq_of_isLocallyDirected := Functor.IsLocallyDirected.cond | class | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks"
] | Mathlib/CategoryTheory/LocallyDirected.lean | Functor.IsLocallyDirected | We say that a functor `F` to `Type*` is locally directed if for every `x ∈ F.obj k`, the
set of `F.obj` containing `x` is (co)directed.
That is, for each diagram
```
x ∈ Fₖ
↗ ↖
xᵢ ∈ Fᵢ xⱼ ∈ Fⱼ
```
there exists
```
xᵢ ∈ Fᵢ xⱼ ∈ Fⱼ
↖ ↗
xₗ ∈ Fₗ
```
that commutes with it. |
@[simps (attr := grind =)]
app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
F.obj X ≅ G.obj X where
hom := α.hom.app X
inv := α.inv.app X
@[reassoc (attr := simp), grind =] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | app | The application of a natural isomorphism to an object. We put this definition in a different
namespace, so that we can use `α.app` |
hom_inv_id_app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
α.hom.app X ≫ α.inv.app X = 𝟙 (F.obj X) := by cat_disch
@[reassoc (attr := simp), grind =] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | hom_inv_id_app | null |
inv_hom_id_app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
α.inv.app X ≫ α.hom.app X = 𝟙 (G.obj X) := by cat_disch
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_hom_id_app | null |
hom_inv_id_app_app {F G : C ⥤ D ⥤ E} (e : F ≅ G) (X₁ : C) (X₂ : D) :
(e.hom.app X₁).app X₂ ≫ (e.inv.app X₁).app X₂ = 𝟙 _ := by cat_disch
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | hom_inv_id_app_app | null |
inv_hom_id_app_app {F G : C ⥤ D ⥤ E} (e : F ≅ G) (X₁ : C) (X₂ : D) :
(e.inv.app X₁).app X₂ ≫ (e.hom.app X₁).app X₂ = 𝟙 _ := by cat_disch
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_hom_id_app_app | null |
hom_inv_id_app_app_app {F G : C ⥤ D ⥤ E ⥤ E'} (e : F ≅ G)
(X₁ : C) (X₂ : D) (X₃ : E) :
((e.hom.app X₁).app X₂).app X₃ ≫ ((e.inv.app X₁).app X₂).app X₃ = 𝟙 _ := by cat_disch
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | hom_inv_id_app_app_app | null |
inv_hom_id_app_app_app {F G : C ⥤ D ⥤ E ⥤ E'} (e : F ≅ G)
(X₁ : C) (X₂ : D) (X₃ : E) :
((e.inv.app X₁).app X₂).app X₃ ≫ ((e.hom.app X₁).app X₂).app X₃ = 𝟙 _ := by cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_hom_id_app_app_app | null |
@[simp]
trans_app {F G H : C ⥤ D} (α : F ≅ G) (β : G ≅ H) (X : C) :
(α ≪≫ β).app X = α.app X ≪≫ β.app X :=
rfl
@[deprecated Iso.app_hom (since := "2025-03-11")] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | trans_app | null |
app_hom {F G : C ⥤ D} (α : F ≅ G) (X : C) : (α.app X).hom = α.hom.app X :=
rfl
@[deprecated Iso.app_hom (since := "2025-03-11")] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | app_hom | null |
app_inv {F G : C ⥤ D} (α : F ≅ G) (X : C) : (α.app X).inv = α.inv.app X :=
rfl
variable {F G : C ⥤ D} | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | app_inv | null |
hom_app_isIso (α : F ≅ G) (X : C) : IsIso (α.hom.app X) :=
⟨⟨α.inv.app X, ⟨by grind, by grind⟩⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | hom_app_isIso | null |
inv_app_isIso (α : F ≅ G) (X : C) : IsIso (α.inv.app X) :=
⟨⟨α.hom.app X, ⟨by grind, by grind⟩⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_app_isIso | null |
@[simp]
cancel_natIso_hom_left {X : C} {Z : D} (g g' : G.obj X ⟶ Z) :
α.hom.app X ≫ g = α.hom.app X ≫ g' ↔ g = g' := by simp only [cancel_epi, refl]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_hom_left | null |
cancel_natIso_inv_left {X : C} {Z : D} (g g' : F.obj X ⟶ Z) :
α.inv.app X ≫ g = α.inv.app X ≫ g' ↔ g = g' := by simp only [cancel_epi, refl]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_inv_left | null |
cancel_natIso_hom_right {X : D} {Y : C} (f f' : X ⟶ F.obj Y) :
f ≫ α.hom.app Y = f' ≫ α.hom.app Y ↔ f = f' := by simp only [cancel_mono, refl]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_hom_right | null |
cancel_natIso_inv_right {X : D} {Y : C} (f f' : X ⟶ G.obj Y) :
f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f' := by simp only [cancel_mono, refl]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_inv_right | null |
cancel_natIso_hom_right_assoc {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ F.obj Y)
(f' : W ⟶ X') (g' : X' ⟶ F.obj Y) :
f ≫ g ≫ α.hom.app Y = f' ≫ g' ≫ α.hom.app Y ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono, refl]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_hom_right_assoc | null |
cancel_natIso_inv_right_assoc {W X X' : D} {Y : C} (f : W ⟶ X) (g : X ⟶ G.obj Y)
(f' : W ⟶ X') (g' : X' ⟶ G.obj Y) :
f ≫ g ≫ α.inv.app Y = f' ≫ g' ≫ α.inv.app Y ↔ f ≫ g = f' ≫ g' := by
simp only [← Category.assoc, cancel_mono, refl]
attribute [grind ←=] CategoryTheory.IsIso.inv_eq_of_hom_inv_id
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | cancel_natIso_inv_right_assoc | null |
inv_inv_app {F G : C ⥤ D} (e : F ≅ G) (X : C) : inv (e.inv.app X) = e.hom.app X := by
cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_inv_app | null |
naturality_1 (α : F ≅ G) (f : X ⟶ Y) : α.inv.app X ≫ F.map f ≫ α.hom.app Y = G.map f := by
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | naturality_1 | null |
naturality_2 (α : F ≅ G) (f : X ⟶ Y) : α.hom.app X ≫ G.map f ≫ α.inv.app Y = F.map f := by
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | naturality_2 | null |
naturality_1' (α : F ⟶ G) (f : X ⟶ Y) {_ : IsIso (α.app X)} :
inv (α.app X) ≫ F.map f ≫ α.app Y = G.map f := by simp
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | naturality_1' | null |
naturality_2' (α : F ⟶ G) (f : X ⟶ Y) {_ : IsIso (α.app Y)} :
α.app X ≫ G.map f ≫ inv (α.app Y) = F.map f := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | naturality_2' | null |
isIso_app_of_isIso (α : F ⟶ G) [IsIso α] (X) : IsIso (α.app X) :=
⟨⟨(inv α).app X, ⟨by grind, by grind⟩⟩⟩
@[simp] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | isIso_app_of_isIso | The components of a natural isomorphism are isomorphisms. |
isIso_inv_app (α : F ⟶ G) {_ : IsIso α} (X) : (inv α).app X = inv (α.app X) := by cat_disch
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | isIso_inv_app | null |
inv_map_inv_app (F : C ⥤ D ⥤ E) {X Y : C} (e : X ≅ Y) (Z : D) :
inv ((F.map e.inv).app Z) = (F.map e.hom).app Z := by cat_disch
set_option mathlib.tactic.category.grind false in | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | inv_map_inv_app | null |
@[simps (attr := grind =)]
ofComponents (app : ∀ X : C, F.obj X ≅ G.obj X)
(naturality : ∀ {X Y : C} (f : X ⟶ Y),
F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f := by cat_disch) :
F ≅ G where
hom := { app := fun X => (app X).hom }
inv :=
{ app := fun X => (app X).inv,
naturality := fun X Y f => by
have h := congr_arg (fun f => (app X).inv ≫ f ≫ (app Y).inv) (naturality f).symm
simp only [Iso.inv_hom_id_assoc, Iso.hom_inv_id, assoc, comp_id] at h
exact h }
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | ofComponents | Construct a natural isomorphism between functors by giving object level isomorphisms,
and checking naturality only in the forward direction. |
ofComponents.app (app' : ∀ X : C, F.obj X ≅ G.obj X) (naturality) (X) :
(ofComponents app' naturality).app X = app' X := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | ofComponents.app | null |
isIso_of_isIso_app (α : F ⟶ G) [∀ X : C, IsIso (α.app X)] : IsIso α :=
(ofComponents (fun X => asIso (α.app X)) (by simp)).isIso_hom | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | isIso_of_isIso_app | A natural transformation is an isomorphism if all its components are isomorphisms. |
@[simps]
hcomp {F G : C ⥤ D} {H I : D ⥤ E} (α : F ≅ G) (β : H ≅ I) : F ⋙ H ≅ G ⋙ I where
hom := α.hom ◫ β.hom
inv := α.inv ◫ β.inv | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | hcomp | Horizontal composition of natural isomorphisms. |
isIso_map_iff {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) {X Y : C} (f : X ⟶ Y) :
IsIso (F₁.map f) ↔ IsIso (F₂.map f) := by
revert F₁ F₂
suffices ∀ {F₁ F₂ : C ⥤ D} (_ : F₁ ≅ F₂) (_ : IsIso (F₁.map f)), IsIso (F₂.map f) from
fun F₁ F₂ e => ⟨this e, this e.symm⟩
intro F₁ F₂ e hf
exact IsIso.mk ⟨e.inv.app Y ≫ inv (F₁.map f) ≫ e.hom.app X, by cat_disch⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | isIso_map_iff | null |
NatTrans.isIso_iff_isIso_app {F G : C ⥤ D} (τ : F ⟶ G) :
IsIso τ ↔ ∀ X, IsIso (τ.app X) :=
⟨fun _ ↦ inferInstance, fun _ ↦ NatIso.isIso_of_isIso_app _⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | NatTrans.isIso_iff_isIso_app | null |
@[simps obj]
copyObj : C ⥤ D where
obj := obj
map f := (e _).inv ≫ F.map f ≫ (e _).hom | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | copyObj | Constructor for a functor that is isomorphic to a given functor `F : C ⥤ D`,
while being definitionally equal on objects to a given map `obj : C → D`
such that for all `X : C`, we have an isomorphism `F.obj X ≅ obj X`. |
@[simps!]
isoCopyObj : F ≅ F.copyObj obj e :=
NatIso.ofComponents e (by simp [Functor.copyObj]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.Category",
"Mathlib.CategoryTheory.Iso"
] | Mathlib/CategoryTheory/NatIso.lean | isoCopyObj | The functor constructed with `copyObj` is isomorphic to the given functor. |
@[ext]
NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
/-- The component of a natural transformation. -/
app : ∀ X : C, F.obj X ⟶ G.obj X
/-- The naturality square for a given morphism. -/
naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by cat_disch
attribute [reassoc (attr := simp)] NatTrans.naturality
attribute [grind _=_] NatTrans.naturality | structure | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | NatTrans | `NatTrans F G` represents a natural transformation between functors `F` and `G`.
The field `app` provides the components of the natural transformation.
Naturality is expressed by `α.naturality`. |
congr_app {F G : C ⥤ D} {α β : NatTrans F G} (h : α = β) (X : C) : α.app X = β.app X := by
cat_disch | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | congr_app | null |
protected id (F : C ⥤ D) : NatTrans F F where app X := 𝟙 (F.obj X)
@[simp] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | id | `NatTrans.id F` is the identity natural transformation on a functor `F`. |
id_app' (F : C ⥤ D) (X : C) : (NatTrans.id F).app X = 𝟙 (F.obj X) := rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | id_app' | null |
vcomp (α : NatTrans F G) (β : NatTrans G H) : NatTrans F H where
app X := α.app X ≫ β.app X | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | vcomp | `vcomp α β` is the vertical compositions of natural transformations. |
vcomp_app (α : NatTrans F G) (β : NatTrans G H) (X : C) :
(vcomp α β).app X = α.app X ≫ β.app X := rfl
attribute [grind =] vcomp_app | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Reassoc"
] | Mathlib/CategoryTheory/NatTrans.lean | vcomp_app | null |
Noetherian : Prop extends EssentiallySmall C where
isNoetherianObject : ∀ X : C, IsNoetherianObject X
attribute [instance] Noetherian.isNoetherianObject | class | CategoryTheory | [
"Mathlib.CategoryTheory.Subobject.ArtinianObject",
"Mathlib.CategoryTheory.Subobject.NoetherianObject"
] | Mathlib/CategoryTheory/Noetherian.lean | Noetherian | A category is Noetherian if it is essentially small and all objects are Noetherian. |
Artinian : Prop extends EssentiallySmall C where
isArtinianObject : ∀ X : C, IsArtinianObject X
attribute [instance] Artinian.isArtinianObject
open Subobject | class | CategoryTheory | [
"Mathlib.CategoryTheory.Subobject.ArtinianObject",
"Mathlib.CategoryTheory.Subobject.NoetherianObject"
] | Mathlib/CategoryTheory/Noetherian.lean | Artinian | A category is Artinian if it is essentially small and all objects are Artinian. |
Quiver.Hom.op_inj {X Y : C} :
Function.Injective (Quiver.Hom.op : (X ⟶ Y) → (Opposite.op Y ⟶ Opposite.op X)) := fun _ _ H =>
congr_arg Quiver.Hom.unop H | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Quiver.Hom.op_inj | null |
Quiver.Hom.unop_inj {X Y : Cᵒᵖ} :
Function.Injective (Quiver.Hom.unop : (X ⟶ Y) → (Opposite.unop Y ⟶ Opposite.unop X)) :=
fun _ _ H => congr_arg Quiver.Hom.op H
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Quiver.Hom.unop_inj | null |
Quiver.Hom.unop_op {X Y : C} (f : X ⟶ Y) : f.op.unop = f :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Quiver.Hom.unop_op | null |
Quiver.Hom.unop_op' {X Y : Cᵒᵖ} {x} :
@Quiver.Hom.unop C _ X Y no_index (Opposite.op (unop := x)) = x := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Quiver.Hom.unop_op' | null |
Quiver.Hom.op_unop {X Y : Cᵒᵖ} (f : X ⟶ Y) : f.unop.op = f :=
rfl
@[simp] theorem Quiver.Hom.unop_mk {X Y : Cᵒᵖ} (f : X ⟶ Y) : Quiver.Hom.unop {unop := f} = f := rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Quiver.Hom.op_unop | null |
@[stacks 001M]
Category.opposite : Category.{v₁} Cᵒᵖ where
comp f g := (g.unop ≫ f.unop).op
id X := (𝟙 (unop X)).op
@[simp, reassoc] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | Category.opposite | The opposite category. |
op_comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).op = g.op ≫ f.op :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_comp | null |
op_id {X : C} : (𝟙 X).op = 𝟙 (op X) :=
rfl
@[simp, reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_id | null |
unop_comp {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g).unop = g.unop ≫ f.unop :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_comp | null |
unop_id {X : Cᵒᵖ} : (𝟙 X).unop = 𝟙 (unop X) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_id | null |
unop_id_op {X : C} : (𝟙 (op X)).unop = 𝟙 X :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_id_op | null |
op_id_unop {X : Cᵒᵖ} : (𝟙 (unop X)).op = 𝟙 X :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_id_unop | null |
@[simps]
unopUnop : Cᵒᵖᵒᵖ ⥤ C where
obj X := unop (unop X)
map f := f.unop.unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unopUnop | The functor from the double-opposite of a category to the underlying category. |
@[simps]
opOp : C ⥤ Cᵒᵖᵒᵖ where
obj X := op (op X)
map f := f.op.op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opOp | The functor from a category to its double-opposite. |
@[simps]
opOpEquivalence : Cᵒᵖᵒᵖ ≌ C where
functor := unopUnop C
inverse := opOp C
unitIso := Iso.refl (𝟭 Cᵒᵖᵒᵖ)
counitIso := Iso.refl (opOp C ⋙ unopUnop C) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opOpEquivalence | The double opposite category is equivalent to the original. |
isIso_op {X Y : C} (f : X ⟶ Y) [IsIso f] : IsIso f.op :=
⟨⟨(inv f).op, ⟨Quiver.Hom.unop_inj (by simp), Quiver.Hom.unop_inj (by simp)⟩⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isIso_op | If `f` is an isomorphism, so is `f.op` |
isIso_of_op {X Y : C} (f : X ⟶ Y) [IsIso f.op] : IsIso f :=
⟨⟨(inv f.op).unop, ⟨Quiver.Hom.op_inj (by simp), Quiver.Hom.op_inj (by simp)⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isIso_of_op | If `f.op` is an isomorphism `f` must be too.
(This cannot be an instance as it would immediately loop!) |
isIso_op_iff {X Y : C} (f : X ⟶ Y) : IsIso f.op ↔ IsIso f :=
⟨fun _ => isIso_of_op _, fun _ => inferInstance⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isIso_op_iff | null |
isIso_unop_iff {X Y : Cᵒᵖ} (f : X ⟶ Y) : IsIso f.unop ↔ IsIso f := by
rw [← isIso_op_iff f.unop, Quiver.Hom.op_unop] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isIso_unop_iff | null |
isIso_unop {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso f] : IsIso f.unop :=
(isIso_unop_iff _).2 inferInstance
@[simp] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | isIso_unop | null |
op_inv {X Y : C} (f : X ⟶ Y) [IsIso f] : (inv f).op = inv f.op := by
apply IsIso.eq_inv_of_hom_inv_id
rw [← op_comp, IsIso.inv_hom_id, op_id]
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op_inv | null |
unop_inv {X Y : Cᵒᵖ} (f : X ⟶ Y) [IsIso f] : (inv f).unop = inv f.unop := by
apply IsIso.eq_inv_of_hom_inv_id
rw [← unop_comp, IsIso.inv_hom_id, unop_id] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop_inv | null |
@[simps]
protected op (F : C ⥤ D) : Cᵒᵖ ⥤ Dᵒᵖ where
obj X := op (F.obj (unop X))
map f := (F.map f.unop).op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | op | The opposite of a functor, i.e. considering a functor `F : C ⥤ D` as a functor `Cᵒᵖ ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made between these. |
@[simps]
protected unop (F : Cᵒᵖ ⥤ Dᵒᵖ) : C ⥤ D where
obj X := unop (F.obj (op X))
map f := (F.map f.op).unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unop | Given a functor `F : Cᵒᵖ ⥤ Dᵒᵖ` we can take the "unopposite" functor `F : C ⥤ D`.
In informal mathematics no distinction is made between these. |
@[simps!]
opUnopIso (F : C ⥤ D) : F.op.unop ≅ F :=
NatIso.ofComponents fun _ => Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opUnopIso | The isomorphism between `F.op.unop` and `F`. |
@[simps!]
unopOpIso (F : Cᵒᵖ ⥤ Dᵒᵖ) : F.unop.op ≅ F :=
NatIso.ofComponents fun _ => Iso.refl _
variable (C D) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unopOpIso | The isomorphism between `F.unop.op` and `F`. |
@[simps]
opHom : (C ⥤ D)ᵒᵖ ⥤ Cᵒᵖ ⥤ Dᵒᵖ where
obj F := (unop F).op
map α :=
{ app := fun X => (α.unop.app (unop X)).op
naturality := fun _ _ f => Quiver.Hom.unop_inj (α.unop.naturality f.unop).symm } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opHom | Taking the opposite of a functor is functorial. |
@[simps]
opInv : (Cᵒᵖ ⥤ Dᵒᵖ) ⥤ (C ⥤ D)ᵒᵖ where
obj F := op F.unop
map α :=
Quiver.Hom.op
{ app := fun X => (α.app (op X)).unop
naturality := fun _ _ f => Quiver.Hom.op_inj <| (α.naturality f.op).symm }
variable {C D} | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opInv | Take the "unopposite" of a functor is functorial. |
@[simps!]
opComp (F : C ⥤ D) (G : D ⥤ E) : (F ⋙ G).op ≅ F.op ⋙ G.op := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opComp | Compatibility of `Functor.op` with respect to functor composition. |
@[simps!]
unopComp (F : Cᵒᵖ ⥤ Dᵒᵖ) (G : Dᵒᵖ ⥤ Eᵒᵖ) : (F ⋙ G).unop ≅ F.unop ⋙ G.unop := Iso.refl _
variable (C) in | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unopComp | Compatibility of `Functor.unop` with respect to functor composition. |
@[simps!]
opId : (𝟭 C).op ≅ 𝟭 (Cᵒᵖ) := Iso.refl _
variable (C) in | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | opId | `Functor.op` transforms identity functors to identity functors. |
@[simps!]
unopId : (𝟭 Cᵒᵖ).unop ≅ 𝟭 C := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | unopId | `Functor.unop` transforms identity functors to identity functors. |
@[simps]
protected leftOp (F : C ⥤ Dᵒᵖ) : Cᵒᵖ ⥤ D where
obj X := unop (F.obj (unop X))
map f := (F.map f.unop).unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp | Another variant of the opposite of functor, turning a functor `C ⥤ Dᵒᵖ` into a functor `Cᵒᵖ ⥤ D`.
In informal mathematics no distinction is made. |
@[simps]
protected rightOp (F : Cᵒᵖ ⥤ D) : C ⥤ Dᵒᵖ where
obj X := op (F.obj (op X))
map f := (F.map f.op).op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp | Another variant of the opposite of functor, turning a functor `Cᵒᵖ ⥤ D` into a functor `C ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made. |
rightOp_map_unop {F : Cᵒᵖ ⥤ D} {X Y} (f : X ⟶ Y) :
(F.rightOp.map f).unop = F.map f.op := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_map_unop | null |
protected FullyFaithful.op {F : C ⥤ D} (hF : F.FullyFaithful) : F.op.FullyFaithful where
preimage {X Y} f := .op <| hF.preimage f.unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | FullyFaithful.op | The opposite of a fully faithful functor is fully faithful. |
rightOp_faithful {F : Cᵒᵖ ⥤ D} [Faithful F] : Faithful F.rightOp where
map_injective h := Quiver.Hom.op_inj (map_injective F (Quiver.Hom.op_inj h)) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_faithful | If F is faithful then the right_op of F is also faithful. |
leftOp_faithful {F : C ⥤ Dᵒᵖ} [Faithful F] : Faithful F.leftOp where
map_injective h := Quiver.Hom.unop_inj (map_injective F (Quiver.Hom.unop_inj h)) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp_faithful | If F is faithful then the left_op of F is also faithful. |
rightOp_full {F : Cᵒᵖ ⥤ D} [Full F] : Full F.rightOp where
map_surjective f := ⟨(F.preimage f.unop).unop, by simp⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOp_full | null |
leftOp_full {F : C ⥤ Dᵒᵖ} [Full F] : Full F.leftOp where
map_surjective f := ⟨(F.preimage f.op).op, by simp⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOp_full | null |
protected FullyFaithful.leftOp {F : C ⥤ Dᵒᵖ} (hF : F.FullyFaithful) :
F.leftOp.FullyFaithful where
preimage {X Y} f := .op <| hF.preimage f.op | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | FullyFaithful.leftOp | The opposite of a fully faithful functor is fully faithful. |
protected FullyFaithful.rightOp {F : Cᵒᵖ ⥤ D} (hF : F.FullyFaithful) :
F.rightOp.FullyFaithful where
preimage {X Y} f := .unop <| hF.preimage f.unop | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | FullyFaithful.rightOp | The opposite of a fully faithful functor is fully faithful. |
@[simps!]
rightOpComp {E : Type*} [Category E] (F : Cᵒᵖ ⥤ D) (G : D ⥤ E) :
(F ⋙ G).rightOp ≅ F.rightOp ⋙ G.op :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOpComp | Compatibility of `Functor.rightOp` with respect to functor composition. |
@[simps!]
leftOpComp {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ Eᵒᵖ) :
(F ⋙ G).leftOp ≅ F.op ⋙ G.leftOp :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOpComp | Compatibility of `Functor.leftOp` with respect to functor composition. |
@[simps!]
rightOpId : (𝟭 Cᵒᵖ).rightOp ≅ opOp C := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | rightOpId | `Functor.rightOp` sends identity functors to the canonical isomorphism `opOp`. |
@[simps!]
leftOpId : (𝟭 Cᵒᵖ).leftOp ≅ unopUnop C := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOpId | `Functor.leftOp` sends identity functors to the canonical isomorphism `unopUnop`. |
@[simps!]
leftOpRightOpIso (F : C ⥤ Dᵒᵖ) : F.leftOp.rightOp ≅ F :=
NatIso.ofComponents fun _ => Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Equivalence"
] | Mathlib/CategoryTheory/Opposites.lean | leftOpRightOpIso | The isomorphism between `F.leftOp.rightOp` and `F`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.