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 ⌀ |
|---|---|---|---|---|---|---|
functor : C ⥤ Quotient r where
obj a := { as := a }
map := @fun _ _ f ↦ Quot.mk _ f | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | functor | The functor from a category to its quotient. |
full_functor : (functor r).Full where
map_surjective f := ⟨Quot.out f, by simp [functor]⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | full_functor | null |
essSurj_functor : (functor r).EssSurj where
mem_essImage Y :=
⟨Y.as, ⟨eqToIso (by
ext
rfl)⟩⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | essSurj_functor | null |
protected induction {P : ∀ {a b : Quotient r}, (a ⟶ b) → Prop}
(h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)) :
∀ {a b : Quotient r} (f : a ⟶ b), P f := by
rintro ⟨x⟩ ⟨y⟩ ⟨f⟩
exact h f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | induction | null |
protected sound {a b : C} {f₁ f₂ : a ⟶ b} (h : r f₁ f₂) :
(functor r).map f₁ = (functor r).map f₂ := by
simpa using Quot.sound (CompClosure.intro (𝟙 a) f₁ f₂ (𝟙 b) h) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | sound | null |
compClosure_iff_self [h : Congruence r] {X Y : C} (f g : X ⟶ Y) :
CompClosure r f g ↔ r f g := by
constructor
· rintro ⟨hfg⟩
exact Congruence.compLeft _ (Congruence.compRight _ (by assumption))
· exact CompClosure.of _ _ _
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | compClosure_iff_self | null |
compClosure_eq_self [h : Congruence r] :
CompClosure r = r := by
ext
simp only [compClosure_iff_self] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | compClosure_eq_self | null |
functor_map_eq_iff [h : Congruence r] {X Y : C} (f f' : X ⟶ Y) :
(functor r).map f = (functor r).map f' ↔ r f f' := by
dsimp [functor]
rw [Equivalence.quot_mk_eq_iff, compClosure_eq_self r]
simpa only [compClosure_eq_self r] using h.equivalence | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | functor_map_eq_iff | null |
functor_homRel_eq_compClosure_eqvGen {X Y : C} (f g : X ⟶ Y) :
(functor r).homRel f g ↔ Relation.EqvGen (@CompClosure C _ r X Y) f g :=
Quot.eq | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | functor_homRel_eq_compClosure_eqvGen | null |
compClosure.congruence :
Congruence fun X Y => Relation.EqvGen (@CompClosure C _ r X Y) := by
convert inferInstanceAs (Congruence (functor r).homRel)
ext
rw [functor_homRel_eq_compClosure_eqvGen]
variable {D : Type _} [Category D] (F : C ⥤ D) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | compClosure.congruence | null |
lift (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) : Quotient r ⥤ D where
obj a := F.obj a.as
map := @fun a b hf ↦
Quot.liftOn hf (fun f ↦ F.map f)
(by
rintro _ _ ⟨_, _, _, _, h⟩
simp [H _ _ _ _ h])
map_id a := F.map_id a.as
map_comp := by
rintro a b c ⟨f⟩ ⟨g⟩
exact F.map_comp f g
variable (H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift | The induced functor on the quotient category. |
lift_spec : functor r ⋙ lift r F H = F := by
tauto | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift_spec | null |
lift_unique (Φ : Quotient r ⥤ D) (hΦ : functor r ⋙ Φ = F) : Φ = lift r F H := by
subst_vars
fapply Functor.hext
· rintro X
dsimp [lift, Functor]
congr
· rintro _ _ f
dsimp [lift, Functor]
refine Quot.inductionOn f fun _ ↦ ?_
simp only [heq_eq_eq]
congr | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift_unique | null |
lift_unique' (F₁ F₂ : Quotient r ⥤ D) (h : functor r ⋙ F₁ = functor r ⋙ F₂) :
F₁ = F₂ := by
rw [lift_unique r (functor r ⋙ F₂) _ F₂ rfl]; swap
· rintro X Y f g h
dsimp
rw [Quotient.sound r h]
apply lift_unique
rw [h] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift_unique' | null |
lift.isLift : functor r ⋙ lift r F H ≅ F :=
NatIso.ofComponents fun _ ↦ Iso.refl _
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift.isLift | The original functor factors through the induced functor. |
lift.isLift_hom (X : C) : (lift.isLift r F H).hom.app X = 𝟙 (F.obj X) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift.isLift_hom | null |
lift.isLift_inv (X : C) : (lift.isLift r F H).inv.app X = 𝟙 (F.obj X) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift.isLift_inv | null |
lift_obj_functor_obj (X : C) :
(lift r F H).obj ((functor r).obj X) = F.obj X := rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift_obj_functor_obj | null |
lift_map_functor_map {X Y : C} (f : X ⟶ Y) :
(lift r F H).map ((functor r).map f) = F.map f :=
rfl
variable {r} | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | lift_map_functor_map | null |
natTrans_ext {F G : Quotient r ⥤ D} (τ₁ τ₂ : F ⟶ G)
(h : whiskerLeft (Quotient.functor r) τ₁ = whiskerLeft (Quotient.functor r) τ₂) : τ₁ = τ₂ :=
NatTrans.ext (by ext1 ⟨X⟩; exact NatTrans.congr_app h X)
variable (r) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | natTrans_ext | null |
natTransLift {F G : Quotient r ⥤ D} (τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G) :
F ⟶ G where
app := fun ⟨X⟩ => τ.app X
naturality := fun ⟨X⟩ ⟨Y⟩ => by
rintro ⟨f⟩
exact τ.naturality f
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | natTransLift | In order to define a natural transformation `F ⟶ G` with `F G : Quotient r ⥤ D`, it suffices
to do so after precomposing with `Quotient.functor r`. |
natTransLift_app (F G : Quotient r ⥤ D)
(τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G) (X : C) :
(natTransLift r τ).app ((Quotient.functor r).obj X) = τ.app X := rfl
@[reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | natTransLift_app | null |
comp_natTransLift {F G H : Quotient r ⥤ D}
(τ : Quotient.functor r ⋙ F ⟶ Quotient.functor r ⋙ G)
(τ' : Quotient.functor r ⋙ G ⟶ Quotient.functor r ⋙ H) :
natTransLift r τ ≫ natTransLift r τ' = natTransLift r (τ ≫ τ') := by cat_disch
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | comp_natTransLift | null |
natTransLift_id (F : Quotient r ⥤ D) :
natTransLift r (𝟙 (Quotient.functor r ⋙ F)) = 𝟙 _ := by cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | natTransLift_id | null |
@[simps]
natIsoLift {F G : Quotient r ⥤ D} (τ : Quotient.functor r ⋙ F ≅ Quotient.functor r ⋙ G) :
F ≅ G where
hom := natTransLift _ τ.hom
inv := natTransLift _ τ.inv
hom_inv_id := by rw [comp_natTransLift, τ.hom_inv_id, natTransLift_id]
inv_hom_id := by rw [comp_natTransLift, τ.inv_hom_id, natTransLift_id]
variable (D) | def | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | natIsoLift | In order to define a natural isomorphism `F ≅ G` with `F G : Quotient r ⥤ D`, it suffices
to do so after precomposing with `Quotient.functor r`. |
full_whiskeringLeft_functor :
((whiskeringLeft C _ D).obj (functor r)).Full where
map_surjective f := ⟨natTransLift r f, by cat_disch⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | full_whiskeringLeft_functor | null |
faithful_whiskeringLeft_functor :
((whiskeringLeft C _ D).obj (functor r)).Faithful := ⟨by apply natTrans_ext⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.NatIso",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Quotient.lean | faithful_whiskeringLeft_functor | null |
Retract (X Y : C) where
/-- the split monomorphism -/
i : X ⟶ Y
/-- the split epimorphism -/
r : Y ⟶ X
retract : i ≫ r = 𝟙 X := by cat_disch | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | Retract | An object `X` is a retract of `Y` if there are morphisms `i : X ⟶ Y` and `r : Y ⟶ X` such
that `i ≫ r = 𝟙 X`. |
@[simps]
op : Retract (op X) (op Y) where
i := h.r.op
r := h.i.op
retract := by simp [← op_comp, h.retract] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | op | Retracts are preserved when passing to the opposite category. |
@[simps]
map (F : C ⥤ D) : Retract (F.obj X) (F.obj Y) where
i := F.map h.i
r := F.map h.r
retract := by rw [← F.map_comp h.i h.r, h.retract, F.map_id] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | map | If `X` is a retract of `Y`, then `F.obj X` is a retract of `F.obj Y`. |
@[simps] splitEpi : SplitEpi h.r where
section_ := h.i | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | splitEpi | a retract determines a split epimorphism. |
@[simps] splitMono : SplitMono h.i where
retraction := h.r | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | splitMono | a retract determines a split monomorphism. |
@[simps]
refl : Retract X X where
i := 𝟙 X
r := 𝟙 X | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | refl | Any object is a retract of itself. |
@[simps]
trans {Z : C} (h' : Retract Y Z) : Retract X Z where
i := h.i ≫ h'.i
r := h'.r ≫ h.r | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | trans | A retract of a retract is a retract. |
ofIso (e : X ≅ Y) : Retract X Y where
i := e.hom
r := e.inv | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | ofIso | If `e : X ≅ Y`, then `X` is a retract of `Y`. |
RetractArrow {X Y Z W : C} (f : X ⟶ Y) (g : Z ⟶ W) := Retract (Arrow.mk f) (Arrow.mk g) | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | RetractArrow | ```
X -------> Z -------> X
| | |
f g f
| | |
v v v
Y -------> W -------> Y
```
A morphism `f : X ⟶ Y` is a retract of `g : Z ⟶ W` if there are morphisms `i : f ⟶ g`
and `r : g ⟶ f` in the arrow category such that `i ≫ r = 𝟙 f`. |
@[reassoc]
i_w : h.i.left ≫ g = f ≫ h.i.right := h.i.w
@[reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | i_w | null |
r_w : h.r.left ≫ f = g ≫ h.r.right := h.r.w | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | r_w | null |
@[simps!]
left : Retract X Z := h.map Arrow.leftFunc | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | left | The top of a retract diagram of morphisms determines a retract of objects. |
@[simps!]
right : Retract Y W := h.map Arrow.rightFunc
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | right | The bottom of a retract diagram of morphisms determines a retract of objects. |
retract_left : h.i.left ≫ h.r.left = 𝟙 X := h.left.retract
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | retract_left | null |
retract_right : h.i.right ≫ h.r.right = 𝟙 Y := h.right.retract | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | retract_right | null |
@[simps]
retract {X Y : C} (e : X ≅ Y) : Retract X Y where
i := e.hom
r := e.inv | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.EpiMono"
] | Mathlib/CategoryTheory/Retract.lean | retract | If `X` is isomorphic to `Y`, then `X` is a retract of `Y`. |
Simple (X : C) : Prop where
mono_isIso_iff_nonzero : ∀ {Y : C} (f : Y ⟶ X) [Mono f], IsIso f ↔ f ≠ 0 | class | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | Simple | An object is simple if monomorphisms into it are (exclusively) either isomorphisms or zero. |
isIso_of_mono_of_nonzero {X Y : C} [Simple Y] {f : X ⟶ Y} [Mono f] (w : f ≠ 0) : IsIso f :=
(Simple.mono_isIso_iff_nonzero f).mpr w | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | isIso_of_mono_of_nonzero | A nonzero monomorphism to a simple object is an isomorphism. |
Simple.of_iso {X Y : C} [Simple Y] (i : X ≅ Y) : Simple X :=
{ mono_isIso_iff_nonzero := fun f m => by
constructor
· intro h w
have j : IsIso (f ≫ i.hom) := by infer_instance
rw [Simple.mono_isIso_iff_nonzero] at j
subst w
simp at j
· intro h
have j : IsIso (f ≫ i.hom) := by
apply isIso_of_mono_of_nonzero
intro w
apply h
simpa using (cancel_mono i.inv).2 w
rw [← Category.comp_id f, ← i.hom_inv_id, ← Category.assoc]
infer_instance } | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | Simple.of_iso | null |
Simple.iff_of_iso {X Y : C} (i : X ≅ Y) : Simple X ↔ Simple Y :=
⟨fun _ => Simple.of_iso i.symm, fun _ => Simple.of_iso i⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | Simple.iff_of_iso | null |
kernel_zero_of_nonzero_from_simple {X Y : C} [Simple X] {f : X ⟶ Y} [HasKernel f]
(w : f ≠ 0) : kernel.ι f = 0 := by
classical
by_contra h
haveI := isIso_of_mono_of_nonzero h
exact w (eq_zero_of_epi_kernel f) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | kernel_zero_of_nonzero_from_simple | null |
epi_of_nonzero_to_simple [HasEqualizers C] {X Y : C} [Simple Y] {f : X ⟶ Y} [HasImage f]
(w : f ≠ 0) : Epi f := by
rw [← image.fac f]
haveI : IsIso (image.ι f) := isIso_of_mono_of_nonzero fun h => w (eq_zero_of_image_eq_zero h)
apply epi_comp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | epi_of_nonzero_to_simple | A nonzero morphism `f` to a simple object is an epimorphism
(assuming `f` has an image, and `C` has equalizers). |
mono_to_simple_zero_of_not_iso {X Y : C} [Simple Y] {f : X ⟶ Y} [Mono f]
(w : IsIso f → False) : f = 0 := by
classical
by_contra h
exact w (isIso_of_mono_of_nonzero h) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | mono_to_simple_zero_of_not_iso | null |
id_nonzero (X : C) [Simple.{v} X] : 𝟙 X ≠ 0 :=
(Simple.mono_isIso_iff_nonzero (𝟙 X)).mp (by infer_instance) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | id_nonzero | null |
Simple.not_isZero (X : C) [Simple X] : ¬IsZero X := by
simpa [Limits.IsZero.iff_id_eq_zero] using id_nonzero X
variable [HasZeroObject C]
open ZeroObject
variable (C) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | Simple.not_isZero | null |
zero_not_simple [Simple (0 : C)] : False :=
(Simple.mono_isIso_iff_nonzero (0 : (0 : C) ⟶ (0 : C))).mp ⟨⟨0, by simp⟩⟩ rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | zero_not_simple | We don't want the definition of 'simple' to include the zero object, so we check that here. |
simple_of_cosimple (X : C) (h : ∀ {Z : C} (f : X ⟶ Z) [Epi f], IsIso f ↔ f ≠ 0) :
Simple X :=
⟨fun {Y} f I => by
classical
fconstructor
· intros
have hx := cokernel.π_of_epi f
by_contra h
subst h
exact (h _).mp (cokernel.π_of_zero _ _) hx
· intro hf
suffices Epi f by exact isIso_of_mono_of_epi _
apply Preadditive.epi_of_cokernel_zero
by_contra h'
exact cokernel_not_iso_of_nonzero hf ((h _).mpr h')⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | simple_of_cosimple | In an abelian category, an object satisfying the dual of the definition of a simple object is
simple. |
isIso_of_epi_of_nonzero {X Y : C} [Simple X] {f : X ⟶ Y} [Epi f] (w : f ≠ 0) : IsIso f :=
haveI : Mono f :=
Preadditive.mono_of_kernel_zero (mono_to_simple_zero_of_not_iso (kernel_not_iso_of_nonzero w))
isIso_of_mono_of_epi f | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | isIso_of_epi_of_nonzero | A nonzero epimorphism from a simple object is an isomorphism. |
cokernel_zero_of_nonzero_to_simple {X Y : C} [Simple Y] {f : X ⟶ Y} (w : f ≠ 0) :
cokernel.π f = 0 := by
classical
by_contra h
haveI := isIso_of_epi_of_nonzero h
exact w (eq_zero_of_mono_cokernel f) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | cokernel_zero_of_nonzero_to_simple | null |
epi_from_simple_zero_of_not_iso {X Y : C} [Simple X] {f : X ⟶ Y} [Epi f]
(w : IsIso f → False) : f = 0 := by
classical
by_contra h
exact w (isIso_of_epi_of_nonzero h) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | epi_from_simple_zero_of_not_iso | null |
Biprod.isIso_inl_iff_isZero (X Y : C) : IsIso (biprod.inl : X ⟶ X ⊞ Y) ↔ IsZero Y := by
rw [biprod.isIso_inl_iff_id_eq_fst_comp_inl, ← biprod.total, add_eq_left]
constructor
· intro h
replace h := h =≫ biprod.snd
simpa [← IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] using h
· intro h
rw [IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] at h
rw [h, zero_comp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | Biprod.isIso_inl_iff_isZero | null |
indecomposable_of_simple (X : C) [Simple X] : Indecomposable X :=
⟨Simple.not_isZero X, fun Y Z i => by
refine or_iff_not_imp_left.mpr fun h => ?_
rw [IsZero.iff_isSplitMono_eq_zero (biprod.inl : Y ⟶ Y ⊞ Z)] at h
change biprod.inl ≠ 0 at h
have : Simple (Y ⊞ Z) := Simple.of_iso i.symm
rw [← Simple.mono_isIso_iff_nonzero biprod.inl] at h
rwa [Biprod.isIso_inl_iff_isZero] at h⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | indecomposable_of_simple | Any simple object in a preadditive category is indecomposable. |
simple_of_isSimpleOrder_subobject (X : C) [IsSimpleOrder (Subobject X)] : Simple X := by
constructor; intro Y f hf; constructor
· intro i
rw [Subobject.isIso_iff_mk_eq_top] at i
intro w
rw [← Subobject.mk_eq_bot_iff_zero] at w
exact IsSimpleOrder.bot_ne_top (w.symm.trans i)
· intro i
rcases IsSimpleOrder.eq_bot_or_eq_top (Subobject.mk f) with (h | h)
· rw [Subobject.mk_eq_bot_iff_zero] at h
exact False.elim (i h)
· exact (Subobject.isIso_iff_mk_eq_top _).mpr h | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | simple_of_isSimpleOrder_subobject | If `X` has subobject lattice `{⊥, ⊤}`, then `X` is simple. |
simple_iff_subobject_isSimpleOrder (X : C) : Simple X ↔ IsSimpleOrder (Subobject X) :=
⟨by
intro h
infer_instance, by
intro h
exact simple_of_isSimpleOrder_subobject X⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | simple_iff_subobject_isSimpleOrder | `X` is simple iff it has subobject lattice `{⊥, ⊤}`. |
subobject_simple_iff_isAtom {X : C} (Y : Subobject X) : Simple (Y : C) ↔ IsAtom Y :=
(simple_iff_subobject_isSimpleOrder _).trans
((OrderIso.isSimpleOrder_iff (subobjectOrderIso Y)).trans Set.isSimpleOrder_Iic_iff_isAtom) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms",
"Mathlib.CategoryTheory.Limits.Shapes.Kernels",
"Mathlib.CategoryTheory.Abelian.Basic",
"Mathlib.CategoryTheory.Subobject.Lattice",
"Mathlib.Order.Atoms"
] | Mathlib/CategoryTheory/Simple.lean | subobject_simple_iff_isAtom | A subobject is simple iff it is an atom in the subobject lattice. |
SingleObj :=
Quiver.SingleObj | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | SingleObj | Abbreviation that allows writing `CategoryTheory.SingleObj` rather than `Quiver.SingleObj`. |
categoryStruct [One M] [Mul M] : CategoryStruct (SingleObj M) where
Hom _ _ := M
comp x y := y * x
id _ := 1
variable [Monoid M] [Group G] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | categoryStruct | One and `flip (*)` become `id` and `comp` for morphisms of the single object category. |
category : Category (SingleObj M) where
comp_id := one_mul
id_comp := mul_one
assoc x y z := (mul_assoc z y x).symm | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | category | Monoid laws become category laws for the single object category. |
id_as_one (x : SingleObj M) : 𝟙 x = 1 :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | id_as_one | null |
comp_as_mul {x y z : SingleObj M} (f : x ⟶ y) (g : y ⟶ z) : f ≫ g = g * f :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | comp_as_mul | null |
finCategoryOfFintype (M : Type) [Fintype M] [Monoid M] : FinCategory (SingleObj M) where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | finCategoryOfFintype | If `M` is finite and in universe zero, then `SingleObj M` is a `FinCategory`. |
@[stacks 0019]
groupoid : Groupoid (SingleObj G) where
inv x := x⁻¹
inv_comp := mul_inv_cancel
comp_inv := inv_mul_cancel | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | groupoid | Groupoid structure on `SingleObj M`. |
inv_as_inv {x y : SingleObj G} (f : x ⟶ y) : inv f = f⁻¹ := by
apply IsIso.inv_eq_of_hom_inv_id
rw [comp_as_mul, inv_mul_cancel, id_as_one] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | inv_as_inv | null |
star : SingleObj M :=
Quiver.SingleObj.star M | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | star | Abbreviation that allows writing `CategoryTheory.SingleObj.star` rather than
`Quiver.SingleObj.star`. |
toEnd : M ≃* End (SingleObj.star M) :=
{ Equiv.refl M with map_mul' := fun _ _ => rfl } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toEnd | The endomorphisms monoid of the only object in `SingleObj M` is equivalent to the original
monoid `M`. |
toEnd_def (x : M) : toEnd M x = x :=
rfl
variable (N : Type v) [Monoid N] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toEnd_def | null |
@[stacks 001F "We do not characterize when the functor is full or faithful."]
mapHom : (M →* N) ≃ SingleObj M ⥤ SingleObj N where
toFun f :=
{ obj := id
map := ⇑f
map_id := fun _ => f.map_one
map_comp := fun x y => f.map_mul y x }
invFun f :=
{ toFun := fun x => f.map ((toEnd M) x)
map_one' := f.map_id _
map_mul' := fun x y => f.map_comp y x }
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | mapHom | There is a 1-1 correspondence between monoid homomorphisms `M → N` and functors between the
corresponding single-object categories. It means that `SingleObj` is a fully faithful functor. |
mapHom_id : mapHom M M (MonoidHom.id M) = 𝟭 _ :=
rfl
variable {M N G} | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | mapHom_id | null |
mapHom_comp (f : M →* N) {P : Type w} [Monoid P] (g : N →* P) :
mapHom M P (g.comp f) = mapHom M N f ⋙ mapHom N P g :=
rfl
variable {C : Type v} [Category.{w} C] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | mapHom_comp | null |
@[simps]
differenceFunctor (f : C → G) : C ⥤ SingleObj G where
obj _ := ()
map {x y} _ := f y * (f x)⁻¹
map_id := by
intro
simp only [SingleObj.id_as_one, mul_inv_cancel]
map_comp := by
intros
rw [SingleObj.comp_as_mul, ← mul_assoc, mul_left_inj, mul_assoc, inv_mul_cancel, mul_one] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | differenceFunctor | Given a function `f : C → G` from a category to a group, we get a functor
`C ⥤ G` sending any morphism `x ⟶ y` to `f y * (f x)⁻¹`. |
@[simps]
functor {X : C} (f : M →* End X) : SingleObj M ⥤ C where
obj _ := X
map a := f a
map_id _ := MonoidHom.map_one f
map_comp a b := MonoidHom.map_mul f b a | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | functor | A monoid homomorphism `f: M → End X` into the endomorphisms of an object `X` of a category `C`
induces a functor `SingleObj M ⥤ C`. |
@[simps]
natTrans {F G : SingleObj M ⥤ C} (u : F.obj (SingleObj.star M) ⟶ G.obj (SingleObj.star M))
(h : ∀ a : M, F.map a ≫ u = u ≫ G.map a) : F ⟶ G where
app _ := u
naturality _ _ a := h a | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | natTrans | Construct a natural transformation between functors `SingleObj M ⥤ C` by
giving a compatible morphism `SingleObj.star M`. |
toFunctor (f : M →* N) : SingleObj M ⥤ SingleObj N :=
SingleObj.mapHom M N f
@[simp] | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toFunctor | Reinterpret a monoid homomorphism `f : M → N` as a functor `(single_obj M) ⥤ (single_obj N)`.
See also `CategoryTheory.SingleObj.mapHom` for an equivalence between these types. |
comp_toFunctor (f : M →* N) {P : Type w} [Monoid P] (g : N →* P) :
(g.comp f).toFunctor = f.toFunctor ⋙ g.toFunctor :=
rfl
variable (M)
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | comp_toFunctor | null |
id_toFunctor : (id M).toFunctor = 𝟭 _ :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | id_toFunctor | null |
@[simps!]
toSingleObjEquiv (e : M ≃* N) : SingleObj M ≌ SingleObj N where
functor := e.toMonoidHom.toFunctor
inverse := e.symm.toMonoidHom.toFunctor
unitIso := eqToIso (by
rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
congr 1
simp)
counitIso := eqToIso (by
rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
congr 1
simp) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toSingleObjEquiv | Reinterpret a monoid isomorphism `f : M ≃* N` as an equivalence `SingleObj M ≌ SingleObj N`. |
toAut : Mˣ ≃* Aut (SingleObj.star M) :=
MulEquiv.trans (Units.mapEquiv (SingleObj.toEnd M))
(Aut.unitsEndEquivAut (SingleObj.star M))
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toAut | The units in a monoid are (multiplicatively) equivalent to
the automorphisms of `star` when we think of the monoid as a single-object category. |
toAut_hom (x : Mˣ) : (toAut M x).hom = SingleObj.toEnd M x :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toAut_hom | null |
toAut_inv (x : Mˣ) : (toAut M x).inv = SingleObj.toEnd M (x⁻¹ : Mˣ) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toAut_inv | null |
toCat : MonCat ⥤ Cat where
obj x := Cat.of (SingleObj x)
map {x y} f := SingleObj.mapHom x y f.hom | def | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toCat | The fully faithful functor from `MonCat` to `Cat`. |
toCat_full : toCat.Full where
map_surjective y :=
let ⟨x, h⟩ := (SingleObj.mapHom _ _).surjective y
⟨ofHom x, h⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toCat_full | null |
toCat_faithful : toCat.Faithful where
map_injective h := MonCat.hom_ext <| by rwa [toCat, (SingleObj.mapHom _ _).apply_eq_iff_eq] at h | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.CategoryTheory.Category.Cat",
"Mathlib.Algebra.Category.MonCat.Basic",
"Mathlib.Combinatorics.Quiver.SingleObj",
"Mathlib.Algebra.Group.Units.Equiv"
] | Mathlib/CategoryTheory/SingleObj.lean | toCat_faithful | null |
Skeletal : Prop :=
∀ ⦃X Y : C⦄, IsIsomorphic X Y → X = Y | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | Skeletal | A category is skeletal if isomorphic objects are equal. |
IsSkeletonOf (F : D ⥤ C) : Prop where
/-- The category `D` has isomorphic objects equal -/
skel : Skeletal D
/-- The functor `F` is an equivalence -/
eqv : F.IsEquivalence := by infer_instance
attribute [local instance] isIsomorphicSetoid
variable {C D} | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | IsSkeletonOf | `IsSkeletonOf C D F` says that `F : D ⥤ C` exhibits `D` as a skeletal full subcategory of `C`,
in particular `F` is a (strong) equivalence and `D` is skeletal. |
Functor.eq_of_iso {F₁ F₂ : D ⥤ C} [Quiver.IsThin C] (hC : Skeletal C) (hF : F₁ ≅ F₂) :
F₁ = F₂ :=
Functor.ext (fun X => hC ⟨hF.app X⟩) fun _ _ _ => Subsingleton.elim _ _ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | Functor.eq_of_iso | If `C` is thin and skeletal, then any naturally isomorphic functors to `C` are equal. |
functor_skeletal [Quiver.IsThin C] (hC : Skeletal C) : Skeletal (D ⥤ C) := fun _ _ h =>
h.elim (Functor.eq_of_iso hC)
variable (C D)
noncomputable section | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | functor_skeletal | If `C` is thin and skeletal, `D ⥤ C` is skeletal.
`CategoryTheory.functor_thin` shows it is thin also. |
Skeleton : Type u₁ := InducedCategory (C := Quotient (isIsomorphicSetoid C)) C Quotient.out
deriving
Category,
[Inhabited C] → Inhabited _,
(α : Sort _) → [CoeSort C α] → CoeSort _ α | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | Skeleton | Construct the skeleton category as the induced category on the isomorphism classes, and derive
its category structure. |
@[simps!]
noncomputable fromSkeleton : Skeleton C ⥤ C :=
inducedFunctor _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | fromSkeleton | The functor from the skeleton of `C` to `C`. |
noncomputable fromSkeleton.isEquivalence : (fromSkeleton C).IsEquivalence where
variable {C} | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | fromSkeleton.isEquivalence | null |
toSkeleton (X : C) : Skeleton C := ⟦X⟧ | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | toSkeleton | The class of an object in the skeleton. |
noncomputable preCounitIso (X : C) : (fromSkeleton C).obj (toSkeleton X) ≅ X :=
Nonempty.some (Quotient.mk_out X)
alias fromSkeletonToSkeletonIso := preCounitIso
variable (C) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | preCounitIso | The isomorphism between `⟦X⟧.out` and `X`. |
@[simps] noncomputable toSkeletonFunctor : C ⥤ Skeleton C where
obj := toSkeleton
map {X Y} f := by apply (preCounitIso X).hom ≫ f ≫ (preCounitIso Y).inv
map_id _ := by aesop
map_comp _ _ := by change _ = CategoryStruct.comp (obj := C) _ _; simp | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | toSkeletonFunctor | An inverse to `fromSkeleton C` that forms an equivalence with it. |
@[simps] noncomputable skeletonEquivalence : Skeleton C ≌ C where
functor := fromSkeleton C
inverse := toSkeletonFunctor C
unitIso := NatIso.ofComponents
(fun X ↦ InducedCategory.isoMk (Nonempty.some <| Quotient.mk_out X.out).symm)
fun _ ↦ .symm <| Iso.inv_hom_id_assoc _ _
counitIso := NatIso.ofComponents preCounitIso
functor_unitIso_comp _ := Iso.inv_hom_id _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Adjunction.Basic",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.IsomorphismClasses",
"Mathlib.CategoryTheory.Thin"
] | Mathlib/CategoryTheory/Skeletal.lean | skeletonEquivalence | The equivalence between the skeleton and the category itself. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.