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 ⌀ |
|---|---|---|---|---|---|---|
IsSplitEpi.id {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] : section_ f ≫ f = 𝟙 Y :=
hf.exists_splitEpi.some.id | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitEpi.id | null |
SplitEpi.splitMono {X Y : C} {f : X ⟶ Y} (se : SplitEpi f) : SplitMono se.section_ where
retraction := f | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitEpi.splitMono | The section of a split epimorphism has an obvious retraction. |
section_isSplitMono {X Y : C} (f : X ⟶ Y) [IsSplitEpi f] : IsSplitMono (section_ f) :=
IsSplitMono.mk' (SplitEpi.splitMono _) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | section_isSplitMono | The section of a split epimorphism is itself a split monomorphism. |
isIso_of_mono_of_isSplitEpi {X Y : C} (f : X ⟶ Y) [Mono f] [IsSplitEpi f] : IsIso f :=
⟨⟨section_ f, ⟨by simp [← cancel_mono f], by simp⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | isIso_of_mono_of_isSplitEpi | A split epi which is mono is an iso. |
IsIso.of_mono_retraction' {X Y : C} {f : X ⟶ Y} (hf : SplitMono f) [Mono <| hf.retraction] :
IsIso f :=
⟨⟨hf.retraction, ⟨by simp, (cancel_mono_id <| hf.retraction).mp (by simp)⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsIso.of_mono_retraction' | Every iso is a split mono. -/
instance (priority := 100) IsSplitMono.of_iso {X Y : C} (f : X ⟶ Y) [IsIso f] : IsSplitMono f :=
IsSplitMono.mk' { retraction := inv f }
/-- Every iso is a split epi. -/
instance (priority := 100) IsSplitEpi.of_iso {X Y : C} (f : X ⟶ Y) [IsIso f] : IsSplitEpi f :=
IsSplitEpi.mk' { section_ := inv f }
theorem SplitMono.mono {X Y : C} {f : X ⟶ Y} (sm : SplitMono f) : Mono f :=
{ right_cancellation := fun g h w => by replace w := w =≫ sm.retraction; simpa using w }
/-- Every split mono is a mono. -/
instance (priority := 100) IsSplitMono.mono {X Y : C} (f : X ⟶ Y) [hf : IsSplitMono f] : Mono f :=
hf.exists_splitMono.some.mono
theorem SplitEpi.epi {X Y : C} {f : X ⟶ Y} (se : SplitEpi f) : Epi f :=
{ left_cancellation := fun g h w => by replace w := se.section_ ≫= w; simpa using w }
/-- Every split epi is an epi. -/
instance (priority := 100) IsSplitEpi.epi {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] : Epi f :=
hf.exists_splitEpi.some.epi
instance {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [hf : IsSplitMono f] [hg : IsSplitMono g] :
IsSplitMono (f ≫ g) := IsSplitMono.mk' <| hf.exists_splitMono.some.comp hg.exists_splitMono.some
instance {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [hf : IsSplitEpi f] [hg : IsSplitEpi g] :
IsSplitEpi (f ≫ g) := IsSplitEpi.mk' <| hf.exists_splitEpi.some.comp hg.exists_splitEpi.some
/-- Every split mono whose retraction is mono is an iso. |
IsIso.of_mono_retraction {X Y : C} (f : X ⟶ Y) [hf : IsSplitMono f]
[hf' : Mono <| retraction f] : IsIso f :=
@IsIso.of_mono_retraction' _ _ _ _ _ hf.exists_splitMono.some hf' | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsIso.of_mono_retraction | Every split mono whose retraction is mono is an iso. |
IsIso.of_epi_section' {X Y : C} {f : X ⟶ Y} (hf : SplitEpi f) [Epi <| hf.section_] :
IsIso f :=
⟨⟨hf.section_, ⟨(cancel_epi_id <| hf.section_).mp (by simp), by simp⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsIso.of_epi_section' | Every split epi whose section is epi is an iso. |
IsIso.of_epi_section {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] [hf' : Epi <| section_ f] :
IsIso f :=
@IsIso.of_epi_section' _ _ _ _ _ hf.exists_splitEpi.some hf' | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsIso.of_epi_section | Every split epi whose section is epi is an iso. |
noncomputable Groupoid.ofTruncSplitMono
(all_split_mono : ∀ {X Y : C} (f : X ⟶ Y), Trunc (IsSplitMono f)) : Groupoid.{v₁} C := by
apply Groupoid.ofIsIso
intro X Y f
have ⟨a,_⟩ := Trunc.exists_rep <| all_split_mono f
have ⟨b,_⟩ := Trunc.exists_rep <| all_split_mono <| retraction f
apply IsIso.of_mono_retraction | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | Groupoid.ofTruncSplitMono | A category where every morphism has a `Trunc` retraction is computably a groupoid. |
SplitMonoCategory : Prop where
/-- All monos are split -/
isSplitMono_of_mono : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], IsSplitMono f | class | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitMonoCategory | A split mono category is a category in which every monomorphism is split. |
SplitEpiCategory : Prop where
/-- All epis are split -/
isSplitEpi_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Epi f], IsSplitEpi f | class | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitEpiCategory | A split epi category is a category in which every epimorphism is split. |
isSplitMono_of_mono [SplitMonoCategory C] {X Y : C} (f : X ⟶ Y) [Mono f] : IsSplitMono f :=
SplitMonoCategory.isSplitMono_of_mono _ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | isSplitMono_of_mono | In a category in which every monomorphism is split, every monomorphism splits. This is not an
instance because it would create an instance loop. |
isSplitEpi_of_epi [SplitEpiCategory C] {X Y : C} (f : X ⟶ Y) [Epi f] : IsSplitEpi f :=
SplitEpiCategory.isSplitEpi_of_epi _ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | isSplitEpi_of_epi | In a category in which every epimorphism is split, every epimorphism splits. This is not an
instance because it would create an instance loop. |
@[simps]
SplitMono.map {X Y : C} {f : X ⟶ Y} (sm : SplitMono f) (F : C ⥤ D) : SplitMono (F.map f) where
retraction := F.map sm.retraction
id := by rw [← Functor.map_comp, SplitMono.id, Functor.map_id] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitMono.map | Split monomorphisms are also absolute monomorphisms. |
@[simps]
SplitEpi.map {X Y : C} {f : X ⟶ Y} (se : SplitEpi f) (F : C ⥤ D) : SplitEpi (F.map f) where
section_ := F.map se.section_
id := by rw [← Functor.map_comp, SplitEpi.id, Functor.map_id] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitEpi.map | Split epimorphisms are also absolute epimorphisms. |
@[simp]
epi_comp_iff_of_epi {X Y Z : C} (f : X ⟶ Y) [Epi f] (g : Y ⟶ Z) :
Epi (f ≫ g) ↔ Epi g :=
⟨fun _ ↦ epi_of_epi f _, fun _ ↦ inferInstance⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | epi_comp_iff_of_epi | When `f` is an epimorphism, `f ≫ g` is epic iff `g` is. |
@[simp]
epi_comp_iff_of_isIso {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
Epi (f ≫ g) ↔ Epi f := by
refine ⟨fun h ↦ ?_, fun h ↦ inferInstance⟩
simpa using (inferInstance : Epi ((f ≫ g) ≫ inv g )) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | epi_comp_iff_of_isIso | When `g` is an isomorphism, `f ≫ g` is epic iff `f` is. |
@[simp]
mono_comp_iff_of_isIso {X Y Z : C} (f : X ⟶ Y) [IsIso f] (g : Y ⟶ Z) :
Mono (f ≫ g) ↔ Mono g := by
refine ⟨fun h ↦ ?_, fun h ↦ inferInstance⟩
simpa using (inferInstance : Mono (inv f ≫ f ≫ g)) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | mono_comp_iff_of_isIso | When `f` is an isomorphism, `f ≫ g` is monic iff `g` is. |
@[simp]
mono_comp_iff_of_mono {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) [Mono g] :
Mono (f ≫ g) ↔ Mono f :=
⟨fun _ ↦ mono_of_mono _ g, fun _ ↦ inferInstance⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | mono_comp_iff_of_mono | When `g` is a monomorphism, `f ≫ g` is monic iff `f` is. |
eqToHom {C : Type u₁} [CategoryStruct.{v₁} C] {X Y : C} (p : X = Y) :
X ⟶ Y := by
rw [p]
exact 𝟙 _
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom | An equality `X = Y` gives us a morphism `X ⟶ Y`.
It is typically better to use this, rather than rewriting by the equality then using `𝟙 _`
which usually leads to dependent type theory hell. |
eqToHom_refl {C : Type u₁} [CategoryStruct.{v₁} C] (X : C) (p : X = X) :
eqToHom p = 𝟙 X :=
rfl
variable {C : Type u₁} [Category.{v₁} C]
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_refl | null |
eqToHom_trans {X Y Z : C} (p : X = Y) (q : Y = Z) :
eqToHom p ≫ eqToHom q = eqToHom (p.trans q) := by
cases p
cases q
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_trans | null |
eqToHom_heq_id_dom (X Y : C) (h : X = Y) : eqToHom h ≍ 𝟙 X := by
subst h; rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_heq_id_dom | `eqToHom h` is heterogeneously equal to the identity of its domain. |
eqToHom_heq_id_cod (X Y : C) (h : X = Y) : eqToHom h ≍ 𝟙 Y := by
subst h; rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_heq_id_cod | `eqToHom h` is heterogeneously equal to the identity of its codomain. |
conj_eqToHom_iff_heq {W X Y Z : C} (f : W ⟶ X) (g : Y ⟶ Z) (h : W = Y) (h' : X = Z) :
f = eqToHom h ≫ g ≫ eqToHom h'.symm ↔ f ≍ g := by
cases h
cases h'
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | conj_eqToHom_iff_heq | Two morphisms are conjugate via eqToHom if and only if they are heterogeneously equal.
Note this used to be in the Functor namespace, where it doesn't belong. |
conj_eqToHom_iff_heq' {C} [Category C] {W X Y Z : C}
(f : W ⟶ X) (g : Y ⟶ Z) (h : W = Y) (h' : Z = X) :
f = eqToHom h ≫ g ≫ eqToHom h' ↔ f ≍ g := conj_eqToHom_iff_heq _ _ _ h'.symm | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | conj_eqToHom_iff_heq' | null |
comp_eqToHom_iff {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y') :
f ≫ eqToHom p = g ↔ f = g ≫ eqToHom p.symm :=
{ mp := fun h => h ▸ by simp
mpr := fun h => by simp [eq_whisker h (eqToHom p)] } | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | comp_eqToHom_iff | null |
eqToHom_comp_iff {X X' Y : C} (p : X = X') (f : X ⟶ Y) (g : X' ⟶ Y) :
eqToHom p ≫ g = f ↔ g = eqToHom p.symm ≫ f :=
{ mp := fun h => h ▸ by simp
mpr := fun h => h ▸ by simp } | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_comp_iff | null |
eqToHom_comp_heq {C} [Category C] {W X Y : C}
(f : Y ⟶ X) (h : W = Y) : eqToHom h ≫ f ≍ f := by
rw [← conj_eqToHom_iff_heq _ _ h rfl, eqToHom_refl, Category.comp_id]
@[simp] theorem eqToHom_comp_heq_iff {C} [Category C] {W X Y Z Z' : C}
(f : Y ⟶ X) (g : Z ⟶ Z') (h : W = Y) :
eqToHom h ≫ f ≍ g ↔ f ≍ g :=
⟨(eqToHom_comp_heq ..).symm.trans, (eqToHom_comp_heq ..).trans⟩
@[simp] theorem heq_eqToHom_comp_iff {C} [Category C] {W X Y Z Z' : C}
(f : Y ⟶ X) (g : Z ⟶ Z') (h : W = Y) :
g ≍ eqToHom h ≫ f ↔ g ≍ f :=
⟨(·.trans (eqToHom_comp_heq ..)), (·.trans (eqToHom_comp_heq ..).symm)⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_comp_heq | null |
comp_eqToHom_heq {C} [Category C] {X Y Z : C}
(f : X ⟶ Y) (h : Y = Z) : f ≫ eqToHom h ≍ f := by
rw [← conj_eqToHom_iff_heq' _ _ rfl h, eqToHom_refl, Category.id_comp]
@[simp] theorem comp_eqToHom_heq_iff {C} [Category C] {W X Y Z Z' : C}
(f : X ⟶ Y) (g : Z ⟶ Z') (h : Y = W) :
f ≫ eqToHom h ≍ g ↔ f ≍ g :=
⟨(comp_eqToHom_heq ..).symm.trans, (comp_eqToHom_heq ..).trans⟩
@[simp] theorem heq_comp_eqToHom_iff {C} [Category C] {W X Y Z Z' : C}
(f : X ⟶ Y) (g : Z ⟶ Z') (h : Y = W) :
g ≍ f ≫ eqToHom h ↔ g ≍ f :=
⟨(·.trans (comp_eqToHom_heq ..)), (·.trans (comp_eqToHom_heq ..).symm)⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | comp_eqToHom_heq | null |
heq_comp {C} [Category C] {X Y Z X' Y' Z' : C}
{f : X ⟶ Y} {g : Y ⟶ Z} {f' : X' ⟶ Y'} {g' : Y' ⟶ Z'}
(eq1 : X = X') (eq2 : Y = Y') (eq3 : Z = Z')
(H1 : f ≍ f') (H2 : g ≍ g') :
f ≫ g ≍ f' ≫ g' := by
grind
variable {β : Sort*} | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | heq_comp | null |
@[reassoc (attr := simp)]
eqToHom_naturality {f g : β → C} (z : ∀ b, f b ⟶ g b) {j j' : β} (w : j = j') :
z j ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ z j' := by
cases w
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_naturality | We can push `eqToHom` to the left through families of morphisms. |
@[reassoc (attr := simp)]
eqToHom_iso_hom_naturality {f g : β → C} (z : ∀ b, f b ≅ g b) {j j' : β} (w : j = j') :
(z j).hom ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ (z j').hom := by
cases w
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_iso_hom_naturality | A variant on `eqToHom_naturality` that helps Lean identify the families `f` and `g`. |
@[reassoc (attr := simp)]
eqToHom_iso_inv_naturality {f g : β → C} (z : ∀ b, f b ≅ g b) {j j' : β} (w : j = j') :
(z j).inv ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ (z j').inv := by
cases w
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_iso_inv_naturality | A variant on `eqToHom_naturality` that helps Lean identify the families `f` and `g`. |
@[simp]
congrArg_cast_hom_left {X Y Z : C} (p : X = Y) (q : Y ⟶ Z) :
cast (congrArg (fun W : C => W ⟶ Z) p.symm) q = eqToHom p ≫ q := by
cases p
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congrArg_cast_hom_left | Reducible form of congrArg_mpr_hom_left |
congrArg_mpr_hom_left {X Y Z : C} (p : X = Y) (q : Y ⟶ Z) :
(congrArg (fun W : C => W ⟶ Z) p).mpr q = eqToHom p ≫ q := by
cases p
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congrArg_mpr_hom_left | If we (perhaps unintentionally) perform equational rewriting on
the source object of a morphism,
we can replace the resulting `_.mpr f` term by a composition with an `eqToHom`.
It may be advisable to introduce any necessary `eqToHom` morphisms manually,
rather than relying on this lemma firing. |
@[simp]
congrArg_cast_hom_right {X Y Z : C} (p : X ⟶ Y) (q : Z = Y) :
cast (congrArg (fun W : C => X ⟶ W) q.symm) p = p ≫ eqToHom q.symm := by
cases q
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congrArg_cast_hom_right | Reducible form of `congrArg_mpr_hom_right` |
congrArg_mpr_hom_right {X Y Z : C} (p : X ⟶ Y) (q : Z = Y) :
(congrArg (fun W : C => X ⟶ W) q).mpr p = p ≫ eqToHom q.symm := by
cases q
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congrArg_mpr_hom_right | If we (perhaps unintentionally) perform equational rewriting on
the target object of a morphism,
we can replace the resulting `_.mpr f` term by a composition with an `eqToHom`.
It may be advisable to introduce any necessary `eqToHom` morphisms manually,
rather than relying on this lemma firing. |
eqToIso {X Y : C} (p : X = Y) : X ≅ Y :=
⟨eqToHom p, eqToHom p.symm, by simp, by simp⟩
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso | An equality `X = Y` gives us an isomorphism `X ≅ Y`.
It is typically better to use this, rather than rewriting by the equality then using `Iso.refl _`
which usually leads to dependent type theory hell. |
eqToIso.hom {X Y : C} (p : X = Y) : (eqToIso p).hom = eqToHom p :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso.hom | null |
eqToIso.inv {X Y : C} (p : X = Y) : (eqToIso p).inv = eqToHom p.symm :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso.inv | null |
eqToIso_refl {X : C} (p : X = X) : eqToIso p = Iso.refl X :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso_refl | null |
eqToIso_trans {X Y Z : C} (p : X = Y) (q : Y = Z) :
eqToIso p ≪≫ eqToIso q = eqToIso (p.trans q) := by ext; simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso_trans | null |
eqToHom_op {X Y : C} (h : X = Y) : (eqToHom h).op = eqToHom (congr_arg op h.symm) := by
cases h
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_op | null |
eqToHom_unop {X Y : Cᵒᵖ} (h : X = Y) :
(eqToHom h).unop = eqToHom (congr_arg unop h.symm) := by
cases h
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_unop | null |
@[simp]
inv_eqToHom {X Y : C} (h : X = Y) : inv (eqToHom h) = eqToHom h.symm := by
cat_disch
variable {D : Type u₂} [Category.{v₂} D] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | inv_eqToHom | null |
ext {F G : C ⥤ D} (h_obj : ∀ X, F.obj X = G.obj X)
(h_map : ∀ X Y f,
F.map f = eqToHom (h_obj X) ≫ G.map f ≫ eqToHom (h_obj Y).symm := by cat_disch) :
F = G := by
match F, G with
| mk F_obj _ _ _, mk G_obj _ _ _ =>
obtain rfl : F_obj = G_obj := by
ext X
apply h_obj
congr
funext X Y f
simpa using h_map X Y f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | ext | Proving equality between functors. This isn't an extensionality lemma,
because usually you don't really want to do this. |
ext_of_iso {F G : C ⥤ D} (e : F ≅ G) (hobj : ∀ X, F.obj X = G.obj X)
(happ : ∀ X, e.hom.app X = eqToHom (hobj X) := by cat_disch) : F = G :=
Functor.ext hobj (fun X Y f => by
rw [← cancel_mono (e.hom.app Y), e.hom.naturality f, happ, happ, Category.assoc,
Category.assoc, eqToHom_trans, eqToHom_refl, Category.comp_id]) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | ext_of_iso | null |
hext {F G : C ⥤ D} (h_obj : ∀ X, F.obj X = G.obj X)
(h_map : ∀ (X Y) (f : X ⟶ Y), F.map f ≍ G.map f) : F = G :=
Functor.ext h_obj fun _ _ f => (conj_eqToHom_iff_heq _ _ (h_obj _) (h_obj _)).2 <| h_map _ _ f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | hext | Proving equality between functors using heterogeneous equality. |
congr_obj {F G : C ⥤ D} (h : F = G) (X) : F.obj X = G.obj X := by rw [h]
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congr_obj | null |
congr_hom {F G : C ⥤ D} (h : F = G) {X Y} (f : X ⟶ Y) :
F.map f = eqToHom (congr_obj h X) ≫ G.map f ≫ eqToHom (congr_obj h Y).symm := by
subst h; simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congr_hom | null |
congr_inv_of_congr_hom (F G : C ⥤ D) {X Y : C} (e : X ≅ Y) (hX : F.obj X = G.obj X)
(hY : F.obj Y = G.obj Y)
(h₂ : F.map e.hom = eqToHom (by rw [hX]) ≫ G.map e.hom ≫ eqToHom (by rw [hY])) :
F.map e.inv = eqToHom (by rw [hY]) ≫ G.map e.inv ≫ eqToHom (by rw [hX]) := by
simp only [← IsIso.Iso.inv_hom e, Functor.map_inv, h₂, IsIso.inv_comp, inv_eqToHom,
Category.assoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | congr_inv_of_congr_hom | null |
map_comp_heq (hx : F.obj X = G.obj X) (hy : F.obj Y = G.obj Y) (hz : F.obj Z = G.obj Z)
(hf : F.map f ≍ G.map f) (hg : F.map g ≍ G.map g) :
F.map (f ≫ g) ≍ G.map (f ≫ g) := by
rw [F.map_comp, G.map_comp]
congr | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | map_comp_heq | null |
map_comp_heq' (hobj : ∀ X : C, F.obj X = G.obj X)
(hmap : ∀ {X Y} (f : X ⟶ Y), F.map f ≍ G.map f) :
F.map (f ≫ g) ≍ G.map (f ≫ g) := by
rw [Functor.hext hobj fun _ _ => hmap] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | map_comp_heq' | null |
precomp_map_heq (H : E ⥤ C) (hmap : ∀ {X Y} (f : X ⟶ Y), F.map f ≍ G.map f) {X Y : E}
(f : X ⟶ Y) : (H ⋙ F).map f ≍ (H ⋙ G).map f :=
hmap _ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | precomp_map_heq | null |
postcomp_map_heq (H : D ⥤ E) (hx : F.obj X = G.obj X) (hy : F.obj Y = G.obj Y)
(hmap : F.map f ≍ G.map f) : (F ⋙ H).map f ≍ (G ⋙ H).map f := by
dsimp
congr | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | postcomp_map_heq | null |
postcomp_map_heq' (H : D ⥤ E) (hobj : ∀ X : C, F.obj X = G.obj X)
(hmap : ∀ {X Y} (f : X ⟶ Y), F.map f ≍ G.map f) :
(F ⋙ H).map f ≍ (G ⋙ H).map f := by rw [Functor.hext hobj fun _ _ => hmap] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | postcomp_map_heq' | null |
hcongr_hom {F G : C ⥤ D} (h : F = G) {X Y} (f : X ⟶ Y) : F.map f ≍ G.map f := by
rw [h] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | hcongr_hom | null |
eqToHom_map (F : C ⥤ D) {X Y : C} (p : X = Y) :
F.map (eqToHom p) = eqToHom (congr_arg F.obj p) := by cases p; simp
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_map | This is not always a good idea as a `@[simp]` lemma,
as we lose the ability to use results that interact with `F`,
e.g. the naturality of a natural transformation.
In some files it may be appropriate to use `attribute [local simp] eqToHom_map`, however. |
eqToHom_map_comp (F : C ⥤ D) {X Y Z : C} (p : X = Y) (q : Y = Z) :
F.map (eqToHom p) ≫ F.map (eqToHom q) = F.map (eqToHom <| p.trans q) := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_map_comp | null |
eqToIso_map (F : C ⥤ D) {X Y : C} (p : X = Y) :
F.mapIso (eqToIso p) = eqToIso (congr_arg F.obj p) := by ext; cases p; simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso_map | See the note on `eqToHom_map` regarding using this as a `simp` lemma. |
eqToIso_map_trans (F : C ⥤ D) {X Y Z : C} (p : X = Y) (q : Y = Z) :
F.mapIso (eqToIso p) ≪≫ F.mapIso (eqToIso q) = F.mapIso (eqToIso <| p.trans q) := by cat_disch
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToIso_map_trans | null |
eqToHom_app {F G : C ⥤ D} (h : F = G) (X : C) :
(eqToHom h : F ⟶ G).app X = eqToHom (Functor.congr_obj h X) := by subst h; rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eqToHom_app | null |
NatTrans.congr {F G : C ⥤ D} (α : F ⟶ G) {X Y : C} (h : X = Y) :
α.app X = F.map (eqToHom h) ≫ α.app Y ≫ G.map (eqToHom h.symm) := by
rw [α.naturality_assoc]
simp [eqToHom_map] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | NatTrans.congr | null |
eq_conj_eqToHom {X Y : C} (f : X ⟶ Y) : f = eqToHom rfl ≫ f ≫ eqToHom rfl := by
simp only [Category.id_comp, eqToHom_refl, Category.comp_id] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | eq_conj_eqToHom | null |
dcongr_arg {ι : Type*} {F G : ι → C} (α : ∀ i, F i ⟶ G i) {i j : ι} (h : i = j) :
α i = eqToHom (congr_arg F h) ≫ α j ≫ eqToHom (congr_arg G h.symm) := by
subst h
simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | dcongr_arg | null |
@[simps]
Equivalence.induced {T : Type*} (e : T ≃ D) :
InducedCategory D e ≌ D where
functor := inducedFunctor e
inverse :=
{ obj := e.symm
map {X Y} f := show e (e.symm X) ⟶ e (e.symm Y) from
eqToHom (e.apply_symm_apply X) ≫ f ≫
eqToHom (e.apply_symm_apply Y).symm
map_comp {X Y Z} f g := by
dsimp
rw [Category.assoc]
erw [Category.assoc]
rw [Category.assoc, eqToHom_trans_assoc, eqToHom_refl, Category.id_comp] }
unitIso := NatIso.ofComponents (fun _ ↦ eqToIso (by simp)) (fun {X Y} f ↦ by
dsimp
erw [eqToHom_trans_assoc _ (by simp), eqToHom_refl, Category.id_comp]
rfl )
counitIso := NatIso.ofComponents (fun _ ↦ eqToIso (by simp))
functor_unitIso_comp X := eqToHom_trans (by simp) (by simp) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/EqToHom.lean | Equivalence.induced | If `T ≃ D` is a bijection and `D` is a category, then
`InducedCategory D e` is equivalent to `D`. |
@[ext, stacks 001J]
Equivalence (C : Type u₁) (D : Type u₂) [Category.{v₁} C] [Category.{v₂} D] where mk' ::
/-- The forwards direction of an equivalence. -/
functor : C ⥤ D
/-- The backwards direction of an equivalence. -/
inverse : D ⥤ C
/-- The composition `functor ⋙ inverse` is isomorphic to the identity. -/
unitIso : 𝟭 C ≅ functor ⋙ inverse
/-- The composition `inverse ⋙ functor` is isomorphic to the identity. -/
counitIso : inverse ⋙ functor ≅ 𝟭 D
/-- The triangle law for the forwards direction of an equivalence: the unit and counit compose
to the identity when whiskered along the forwards direction.
We state this as a family of equalities among morphisms instead of an equality of natural
transformations to avoid abusing defeq or inserting natural transformations like `F ⟶ F𝟭`. -/
functor_unitIso_comp :
∀ X : C, functor.map (unitIso.hom.app X) ≫ counitIso.hom.app (functor.obj X) =
𝟙 (functor.obj X) := by cat_disch
@[inherit_doc Equivalence]
infixr:10 " ≌ " => Equivalence
variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D] | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | Equivalence | An equivalence of categories.
We define an equivalence between `C` and `D`, with notation `C ≌ D`, as a half-adjoint equivalence:
a pair of functors `F : C ⥤ D` and `G : D ⥤ C` with a unit `η : 𝟭 C ≅ F ⋙ G` and counit
`ε : G ⋙ F ≅ 𝟭 D`, such that the natural isomorphisms `η` and `ε` satisfy the triangle law for
`F`: namely, `Fη ≫ εF = 𝟙 F`. Or, in other words, the composite `F` ⟶ `F ⋙ G ⋙ F` ⟶ `F` is the
identity.
In `unit_inverse_comp`, we show that this is sufficient to establish a full adjoint
equivalence. I.e., the composite `G` ⟶ `G ⋙ F ⋙ G` ⟶ `G` is also the identity.
The triangle equation `functor_unitIso_comp` is written as a family of equalities between
morphisms. It is more complicated if we write it as an equality of natural transformations, because
then we would either have to insert natural transformations like `F ⟶ F𝟭` or abuse defeq. |
unit (e : C ≌ D) : 𝟭 C ⟶ e.functor ⋙ e.inverse :=
e.unitIso.hom | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | unit | The unit of an equivalence of categories. |
counit (e : C ≌ D) : e.inverse ⋙ e.functor ⟶ 𝟭 D :=
e.counitIso.hom | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counit | The counit of an equivalence of categories. |
unitInv (e : C ≌ D) : e.functor ⋙ e.inverse ⟶ 𝟭 C :=
e.unitIso.inv | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | unitInv | The inverse of the unit of an equivalence of categories. |
counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.functor :=
e.counitIso.inv | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counitInv | The inverse of the counit of an equivalence of categories. |
mkHom {e f : C ≌ D} (η : e.functor ⟶ f.functor) : e ⟶ f := η | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | mkHom | Promote a natural transformation `e.functor ⟶ f.functor` to a morphism in `C ≌ D`. |
asNatTrans {e f : C ≌ D} (η : e ⟶ f) : e.functor ⟶ f.functor := η
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | asNatTrans | Recover a natural transformation between `e.functor` and `f.functor` from the data of
a morphism `e ⟶ f`. |
hom_ext {e f : C ≌ D} {α β : e ⟶ f} (h : asNatTrans α = asNatTrans β) : α = β := h
@[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 | hom_ext | null |
mkHom_asNatTrans {e f : C ≌ D} (η : e.functor ⟶ f.functor) :
mkHom (asNatTrans η) = η :=
rfl
@[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 | mkHom_asNatTrans | null |
asNatTrans_mkHom {e f : C ≌ D} (η : e ⟶ f) :
asNatTrans (mkHom η) = η :=
rfl
@[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 | asNatTrans_mkHom | null |
id_asNatTrans {e : C ≌ D} : asNatTrans (𝟙 e) = 𝟙 _ := rfl
@[simp, reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | id_asNatTrans | null |
comp_asNatTrans {e f g : C ≌ D} (α : e ⟶ f) (β : f ⟶ g) :
asNatTrans (α ≫ β) = asNatTrans α ≫ asNatTrans β :=
rfl
@[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 | comp_asNatTrans | null |
mkHom_id_functor {e : C ≌ D} : mkHom (𝟙 e.functor) = 𝟙 e := rfl
@[simp, reassoc] | 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_functor | null |
mkHom_comp {e f g : C ≌ D} (α : e.functor ⟶ f.functor) (β : f.functor ⟶ g.functor) :
mkHom (α ≫ β) = mkHom α ≫ mkHom β :=
rfl | 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_comp | null |
@[simps]
mkIso {e f : C ≌ D} (η : e.functor ≅ f.functor) : e ≅ f where
hom := mkHom η.hom
inv := mkHom η.inv
variable (C D) 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 | mkIso | Construct an isomorphism in `C ≌ D` from a natural isomorphism between the functors
of the equivalences. |
@[simps!]
functorFunctor : (C ≌ D) ⥤ C ⥤ D where
obj f := f.functor
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 | functorFunctor | The `functor` functor that sends an equivalence of categories to its functor. |
@[simp]
Equivalence_mk'_unit (functor inverse unit_iso counit_iso f) :
(⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unit = unit_iso.hom :=
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 | Equivalence_mk'_unit | null |
Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
(⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counit = counit_iso.hom :=
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 | Equivalence_mk'_counit | null |
Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
(⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unitInv = unit_iso.inv :=
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 | Equivalence_mk'_unitInv | null |
Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
(⟨functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counitInv = counit_iso.inv :=
rfl
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | Equivalence_mk'_counitInv | null |
counit_naturality (e : C ≌ D) {X Y : D} (f : X ⟶ Y) :
e.functor.map (e.inverse.map f) ≫ e.counit.app Y = e.counit.app X ≫ f :=
e.counit.naturality f
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counit_naturality | null |
unit_naturality (e : C ≌ D) {X Y : C} (f : X ⟶ Y) :
e.unit.app X ≫ e.inverse.map (e.functor.map f) = f ≫ e.unit.app Y :=
(e.unit.naturality f).symm
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | unit_naturality | null |
counitInv_naturality (e : C ≌ D) {X Y : D} (f : X ⟶ Y) :
e.counitInv.app X ≫ e.functor.map (e.inverse.map f) = f ≫ e.counitInv.app Y :=
(e.counitInv.naturality f).symm
@[reassoc] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counitInv_naturality | null |
unitInv_naturality (e : C ≌ D) {X Y : C} (f : X ⟶ Y) :
e.inverse.map (e.functor.map f) ≫ e.unitInv.app Y = e.unitInv.app X ≫ f :=
e.unitInv.naturality f
@[reassoc (attr := 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 | unitInv_naturality | null |
functor_unit_comp (e : C ≌ D) (X : C) :
e.functor.map (e.unit.app X) ≫ e.counit.app (e.functor.obj X) = 𝟙 (e.functor.obj X) :=
e.functor_unitIso_comp X
@[reassoc (attr := 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 | functor_unit_comp | null |
counitInv_functor_comp (e : C ≌ D) (X : C) :
e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X) := by
simpa using Iso.inv_eq_inv
(e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X)) (Iso.refl _) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counitInv_functor_comp | null |
counitInv_app_functor (e : C ≌ D) (X : C) :
e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X) := by
symm
simp only [id_obj, comp_obj, counitInv]
rw [← Iso.app_inv, ← Iso.comp_hom_eq_id (e.counitIso.app _), Iso.app_hom, functor_unit_comp]
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 | counitInv_app_functor | null |
counit_app_functor (e : C ≌ D) (X : C) :
e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X) := by
simpa using Iso.hom_comp_eq_id (e.functor.mapIso (e.unitIso.app X)) (f := e.counit.app _) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | counit_app_functor | null |
@[reassoc (attr := simp)]
unit_inverse_comp (e : C ≌ D) (Y : D) :
e.unit.app (e.inverse.obj Y) ≫ e.inverse.map (e.counit.app Y) = 𝟙 (e.inverse.obj Y) := by
rw [← id_comp (e.inverse.map _), ← map_id e.inverse, ← counitInv_functor_comp, map_comp]
dsimp
rw [← Iso.hom_inv_id_assoc (e.unitIso.app _) (e.inverse.map (e.functor.map _)), Iso.app_hom,
Iso.app_inv]
slice_lhs 2 3 => rw [← e.unit_naturality]
slice_lhs 1 2 => rw [← e.unit_naturality]
slice_lhs 4 4 =>
rw [← Iso.hom_inv_id_assoc (e.inverse.mapIso (e.counitIso.app _)) (e.unitInv.app _)]
slice_lhs 3 4 =>
dsimp only [Functor.mapIso_hom, Iso.app_hom]
rw [← map_comp e.inverse, e.counit_naturality, e.counitIso.hom_inv_id_app]
dsimp only [Functor.comp_obj]
rw [map_id]
dsimp only [comp_obj, id_obj]
rw [id_comp]
slice_lhs 2 3 =>
dsimp only [Functor.mapIso_inv, Iso.app_inv]
rw [← map_comp e.inverse, ← e.counitInv_naturality, map_comp]
slice_lhs 3 4 => rw [e.unitInv_naturality]
slice_lhs 4 5 =>
rw [← map_comp e.inverse, ← map_comp e.functor, e.unitIso.hom_inv_id_app]
dsimp only [Functor.id_obj]
rw [map_id, map_id]
dsimp only [comp_obj, id_obj]
rw [id_comp]
slice_lhs 3 4 => rw [← e.unitInv_naturality]
slice_lhs 2 3 =>
rw [← map_comp e.inverse, e.counitInv_naturality, e.counitIso.hom_inv_id_app]
dsimp only [Functor.comp_obj]
simp
@[reassoc (attr := 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 | unit_inverse_comp | The other triangle equality. The proof follows the following proof in Globular:
http://globular.science/1905.001 |
inverse_counitInv_comp (e : C ≌ D) (Y : D) :
e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) := by
simpa using Iso.inv_eq_inv
(e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y)) (Iso.refl _) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | inverse_counitInv_comp | null |
unit_app_inverse (e : C ≌ D) (Y : D) :
e.unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) := by
simpa using Iso.comp_hom_eq_id (e.inverse.mapIso (e.counitIso.app Y)) (f := e.unit.app _) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Functor.FullyFaithful",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.CategoryTheory.EssentialImage",
"Mathlib.Tactic.CategoryTheory.Slice"
] | Mathlib/CategoryTheory/Equivalence.lean | unit_app_inverse | null |
unitInv_app_inverse (e : C ≌ D) (Y : D) :
e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) := by
rw [← Iso.app_inv, ← Iso.app_hom, ← mapIso_hom, Eq.comm, ← Iso.hom_eq_inv]
simpa using unit_app_inverse e Y
@[reassoc, 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 | unitInv_app_inverse | null |
fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
e.functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y :=
(NatIso.naturality_2 e.counitIso f).symm
@[reassoc, 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.