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 ⌀ |
|---|---|---|---|---|---|---|
forget : DifferentialObject S C ⥤ C where
obj X := X.obj
map f := f.f | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | forget | The forgetful functor taking a differential object to its underlying object. |
forget_faithful : (forget S C).Faithful where
variable {S C} | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | forget_faithful | null |
@[simp]
zero_f (P Q : DifferentialObject S C) : (0 : P ⟶ Q).f = 0 := rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | zero_f | null |
hasZeroMorphisms : HasZeroMorphisms (DifferentialObject S C) where | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | hasZeroMorphisms | null |
@[simps]
isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj where
hom := f.hom.f
inv := f.inv.f
hom_inv_id := by rw [← comp_f, Iso.hom_inv_id, id_f]
inv_hom_id := by rw [← comp_f, Iso.inv_hom_id, id_f]
@[simp] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | isoApp | An isomorphism of differential objects gives an isomorphism of the underlying objects. |
isoApp_refl (X : DifferentialObject S C) : isoApp (Iso.refl X) = Iso.refl X.obj := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | isoApp_refl | null |
isoApp_symm {X Y : DifferentialObject S C} (f : X ≅ Y) : isoApp f.symm = (isoApp f).symm :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | isoApp_symm | null |
isoApp_trans {X Y Z : DifferentialObject S C} (f : X ≅ Y) (g : Y ≅ Z) :
isoApp (f ≪≫ g) = isoApp f ≪≫ isoApp g := rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | isoApp_trans | null |
@[simps]
mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
X ≅ Y where
hom := ⟨f.hom, hf⟩
inv := ⟨f.inv, by
rw [← Functor.mapIso_inv, Iso.comp_inv_eq, Category.assoc, Iso.eq_inv_comp, Functor.mapIso_hom,
hf]⟩
hom_inv_id := by ext1; dsimp; exact f.hom_inv_id
inv_hom_id := by ext1; dsimp; exact f.inv_hom_id | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | mkIso | An isomorphism of differential objects can be constructed
from an isomorphism of the underlying objects that commutes with the differentials. |
@[simps]
mapDifferentialObject (F : C ⥤ D)
(η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
(hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D where
obj X :=
{ obj := F.obj X.obj
d := F.map X.d ≫ η.app X.obj
d_squared := by
rw [Functor.map_comp, ← Functor.comp_map F (shiftFunctor D (1 : S))]
slice_lhs 2 3 => rw [← η.naturality X.d]
rw [Functor.comp_map]
slice_lhs 1 2 => rw [← F.map_comp, X.d_squared, hF]
rw [zero_comp, zero_comp] }
map f :=
{ f := F.map f.f
comm := by
dsimp
slice_lhs 2 3 => rw [← Functor.comp_map F (shiftFunctor D (1 : S)), ← η.naturality f.f]
slice_lhs 1 2 => rw [Functor.comp_map, ← F.map_comp, f.comm, F.map_comp]
rw [Category.assoc] }
map_id := by intros; ext; simp
map_comp := by intros; ext; simp | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | mapDifferentialObject | A functor `F : C ⥤ D` which commutes with shift functors on `C` and `D` and preserves zero
morphisms can be lifted to a functor `DifferentialObject S C ⥤ DifferentialObject S D`. |
hasZeroObject : HasZeroObject (DifferentialObject S C) where
zero := ⟨{ obj := 0, d := 0 },
{ unique_to := fun X => ⟨⟨⟨{ f := 0 }⟩, fun f => by ext⟩⟩,
unique_from := fun X => ⟨⟨⟨{ f := 0 }⟩, fun f => by ext⟩⟩ }⟩ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | hasZeroObject | null |
hasForgetOfDifferentialObjects : HasForget (DifferentialObject S C) where
forget := forget S C ⋙ CategoryTheory.forget C | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | hasForgetOfDifferentialObjects | null |
HomSubtype (X Y : DifferentialObject S C) :=
{ f : FC X.obj Y.obj // X.d ≫ (ConcreteCategory.ofHom f)⟦1⟧' = (ConcreteCategory.ofHom f) ≫ Y.d } | abbrev | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | HomSubtype | The type of `C`-morphisms that can be lifted back to morphisms in the category `DifferentialObject`. |
concreteCategoryOfDifferentialObjects :
ConcreteCategory (DifferentialObject S C) (HomSubtype S C) where
hom f := ⟨ConcreteCategory.hom (C := C) f.1, by simp [ConcreteCategory.ofHom_hom]⟩
ofHom f := ⟨ConcreteCategory.ofHom (C := C) f, by simpa [ConcreteCategory.hom_ofHom] using f.2⟩
hom_ofHom _ := by dsimp; ext; simp [ConcreteCategory.hom_ofHom]
ofHom_hom _ := by ext; simp [ConcreteCategory.ofHom_hom]
id_apply := ConcreteCategory.id_apply (C := C)
comp_apply _ _ := ConcreteCategory.comp_apply (C := C) _ _ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | concreteCategoryOfDifferentialObjects | null |
@[simps]
shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C where
obj X :=
{ obj := X.obj⟦n⟧
d := X.d⟦n⟧' ≫ (shiftComm _ _ _).hom
d_squared := by
rw [Functor.map_comp, Category.assoc, shiftComm_hom_comp_assoc, ← Functor.map_comp_assoc,
X.d_squared, Functor.map_zero, zero_comp] }
map f :=
{ f := f.f⟦n⟧'
comm := by
dsimp
rw [Category.assoc]
erw [shiftComm_hom_comp]
rw [← Functor.map_comp_assoc, f.comm, Functor.map_comp_assoc]
rfl }
map_id X := by ext1; dsimp; rw [Functor.map_id]
map_comp f g := by ext1; dsimp; rw [Functor.map_comp] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | shiftFunctor | The shift functor on `DifferentialObject S C`. |
@[simps!]
shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
refine NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) ?_) (fun f => ?_)
· erw [← NatTrans.naturality]
dsimp
simp only [shiftFunctorZero_hom_app_shift, Category.assoc]
· cat_disch | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | shiftZero | The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
refine NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) ?_) (fun f => ?_)
· dsimp
rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
rw [← NatTrans.naturality_assoc]
dsimp
simp only [Functor.map_comp, Category.assoc,
shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app 1 m n X.obj,
Iso.inv_hom_id_app_assoc]
· ext; dsimp; exact NatTrans.naturality _ _
section
/-- The shift by zero is naturally isomorphic to the identity. |
DinatTrans (F G : Cᵒᵖ ⥤ C ⥤ D) : Type max u₁ v₂ where
/-- The component of a natural transformation. -/
app (X : C) : (F.obj (op X)).obj X ⟶ (G.obj (op X)).obj X
/-- The commutativity square for a given morphism. -/
dinaturality {X Y : C} (f : X ⟶ Y) :
(F.map f.op).app X ≫ app X ≫ (G.obj (op X)).map f =
(F.obj (op Y)).map f ≫ app Y ≫ (G.map f.op).app Y := by cat_disch
attribute [reassoc (attr := simp)] DinatTrans.dinaturality | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/DinatTrans.lean | DinatTrans | Dinatural transformations between two difunctors. |
@[simps]
compNatTrans (δ : F ⤞ G) (α : G ⟶ H) : F ⤞ H where
app X := δ.app X ≫ (α.app (op X)).app X
dinaturality f := by
rw [Category.assoc, Category.assoc, ← NatTrans.naturality_app,
← δ.dinaturality_assoc f, NatTrans.naturality] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/DinatTrans.lean | compNatTrans | Notation for dinatural transformations. -/
scoped infixr:50 " ⤞ " => DinatTrans
variable {F G H : Cᵒᵖ ⥤ C ⥤ D}
/-- Post-composition with a natural transformation. |
@[simps]
precompNatTrans (δ : G ⤞ H) (α : F ⟶ G) : F ⤞ H where
app X := (α.app (op X)).app X ≫ δ.app X | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites"
] | Mathlib/CategoryTheory/DinatTrans.lean | precompNatTrans | Pre-composition with a natural transformation. |
Functor.Elements (F : C ⥤ Type w) :=
Σ c : C, F.obj c | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Functor.Elements | The type of objects for the category of elements of a functor `F : C ⥤ Type`
is a pair `(X : C, x : F.obj X)`. |
Functor.elementsMk (F : C ⥤ Type w) (X : C) (x : F.obj X) : F.Elements := ⟨X, x⟩ | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Functor.elementsMk | Constructor for the type `F.Elements` when `F` is a functor to types. |
Functor.Elements.ext {F : C ⥤ Type w} (x y : F.Elements) (h₁ : x.fst = y.fst)
(h₂ : F.map (eqToHom h₁) x.snd = y.snd) : x = y := by
cases x
cases y
cases h₁
simp only [eqToHom_refl, FunctorToTypes.map_id_apply] at h₂
simp [h₂] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Functor.Elements.ext | null |
categoryOfElements (F : C ⥤ Type w) : Category.{v} F.Elements where
Hom p q := { f : p.1 ⟶ q.1 // (F.map f) p.2 = q.2 }
id p := ⟨𝟙 p.1, by simp⟩
comp {X Y Z} f g := ⟨f.val ≫ g.val, by simp [f.2, g.2]⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | categoryOfElements | The category structure on `F.Elements`, for `F : C ⥤ Type`.
A morphism `(X, x) ⟶ (Y, y)` is a morphism `f : X ⟶ Y` in `C`, so `F.map f` takes `x` to `y`. |
@[simps]
NatTrans.mapElements {F G : C ⥤ Type w} (φ : F ⟶ G) : F.Elements ⥤ G.Elements where
obj := fun ⟨X, x⟩ ↦ ⟨_, φ.app X x⟩
map {p q} := fun ⟨f, h⟩ ↦ ⟨f, by have hb := congrFun (φ.naturality f) p.2; cat_disch⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | NatTrans.mapElements | Natural transformations are mapped to functors between category of elements |
@[simps]
Functor.elementsFunctor : (C ⥤ Type w) ⥤ Cat where
obj F := Cat.of F.Elements
map n := NatTrans.mapElements n | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Functor.elementsFunctor | The functor mapping functors `C ⥤ Type w` to their category of elements |
@[simps]
homMk {F : C ⥤ Type w} (x y : F.Elements) (f : x.1 ⟶ y.1) (hf : F.map f x.snd = y.snd) :
x ⟶ y :=
⟨f, hf⟩
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | homMk | Constructor for morphisms in the category of elements of a functor to types. |
ext (F : C ⥤ Type w) {x y : F.Elements} (f g : x ⟶ y) (w : f.val = g.val) : f = g :=
Subtype.ext w
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | ext | null |
comp_val {F : C ⥤ Type w} {p q r : F.Elements} {f : p ⟶ q} {g : q ⟶ r} :
(f ≫ g).val = f.val ≫ g.val :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | comp_val | null |
id_val {F : C ⥤ Type w} {p : F.Elements} : (𝟙 p : p ⟶ p).val = 𝟙 p.1 :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | id_val | null |
map_snd {F : C ⥤ Type w} {p q : F.Elements} (f : p ⟶ q) : (F.map f.val) p.2 = q.2 :=
f.property | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | map_snd | null |
@[simps]
isoMk {F : C ⥤ Type w} (x y : F.Elements) (e : x.1 ≅ y.1) (he : F.map e.hom x.snd = y.snd) :
x ≅ y where
hom := homMk x y e.hom he
inv := homMk y x e.inv (by rw [← he, FunctorToTypes.map_inv_map_hom_apply]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | isoMk | Constructor for isomorphisms in the category of elements of a functor to types. |
groupoidOfElements {G : Type u} [Groupoid.{v} G] (F : G ⥤ Type w) :
Groupoid F.Elements where
inv {p q} f :=
⟨Groupoid.inv f.val,
calc
F.map (Groupoid.inv f.val) q.2 = F.map (Groupoid.inv f.val) (F.map f.val p.2) := by rw [f.2]
_ = (F.map f.val ≫ F.map (Groupoid.inv f.val)) p.2 := rfl
_ = p.2 := by
rw [← F.map_comp]
simp
⟩
inv_comp _ := by
ext
simp
comp_inv _ := by
ext
simp | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | groupoidOfElements | null |
@[simps]
π : F.Elements ⥤ C where
obj X := X.1
map f := f.val | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | π | The functor out of the category of elements which forgets the element. |
@[simps]
map {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : F₁.Elements ⥤ F₂.Elements where
obj t := ⟨t.1, α.app t.1 t.2⟩
map {t₁ t₂} k := ⟨k.1, by simpa [map_snd] using (FunctorToTypes.naturality _ _ α k.1 t₁.2).symm⟩
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | map | A natural transformation between functors induces a functor between the categories of elements. |
map_π {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : map α ⋙ π F₂ = π F₁ :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | map_π | null |
toStructuredArrow : F.Elements ⥤ StructuredArrow PUnit F where
obj X := StructuredArrow.mk fun _ => X.2
map {X Y} f := StructuredArrow.homMk f.val (by funext; simp [f.2])
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | toStructuredArrow | The forward direction of the equivalence `F.Elements ≅ (*, F)`. |
toStructuredArrow_obj (X) :
(toStructuredArrow F).obj X =
{ left := ⟨⟨⟩⟩
right := X.1
hom := fun _ => X.2 } :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | toStructuredArrow_obj | null |
to_comma_map_right {X Y} (f : X ⟶ Y) : ((toStructuredArrow F).map f).right = f.val :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | to_comma_map_right | null |
fromStructuredArrow : StructuredArrow PUnit F ⥤ F.Elements where
obj X := ⟨X.right, X.hom PUnit.unit⟩
map f := ⟨f.right, congr_fun f.w.symm PUnit.unit⟩
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | fromStructuredArrow | The reverse direction of the equivalence `F.Elements ≅ (*, F)`. |
fromStructuredArrow_obj (X) : (fromStructuredArrow F).obj X = ⟨X.right, X.hom PUnit.unit⟩ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | fromStructuredArrow_obj | null |
fromStructuredArrow_map {X Y} (f : X ⟶ Y) :
(fromStructuredArrow F).map f = ⟨f.right, congr_fun f.w.symm PUnit.unit⟩ :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | fromStructuredArrow_map | null |
@[simps]
structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F where
functor := toStructuredArrow F
inverse := fromStructuredArrow F
unitIso := Iso.refl _
counitIso := Iso.refl _
open Opposite | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | structuredArrowEquivalence | The equivalence between the category of elements `F.Elements`
and the comma category `(*, F)`. |
@[simps]
toCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : F.Elementsᵒᵖ ⥤ CostructuredArrow yoneda F where
obj X := CostructuredArrow.mk (yonedaEquiv.symm (unop X).2)
map f :=
CostructuredArrow.homMk f.unop.val.unop (by
ext Z y
dsimp [yonedaEquiv]
simp only [FunctorToTypes.map_comp_apply, ← f.unop.2]) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | toCostructuredArrow | The forward direction of the equivalence `F.Elementsᵒᵖ ≅ (yoneda, F)`,
given by `CategoryTheory.yonedaEquiv`. |
@[simps]
fromCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : (CostructuredArrow yoneda F)ᵒᵖ ⥤ F.Elements where
obj X := ⟨op (unop X).1, yonedaEquiv.1 (unop X).3⟩
map {X Y} f :=
⟨f.unop.1.op, by
convert (congr_fun ((unop X).hom.naturality f.unop.left.op) (𝟙 _)).symm
simp only [Equiv.toFun_as_coe, Quiver.Hom.unop_op, yonedaEquiv_apply, types_comp_apply,
Category.comp_id, yoneda_obj_map]
have : yoneda.map f.unop.left ≫ (unop X).hom = (unop Y).hom := by
convert f.unop.3
rw [← this]
simp only [yoneda_map_app, FunctorToTypes.comp]
rw [Category.id_comp]⟩
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | fromCostructuredArrow | The reverse direction of the equivalence `F.Elementsᵒᵖ ≅ (yoneda, F)`,
given by `CategoryTheory.yonedaEquiv`. |
fromCostructuredArrow_obj_mk (F : Cᵒᵖ ⥤ Type v) {X : C} (f : yoneda.obj X ⟶ F) :
(fromCostructuredArrow F).obj (op (CostructuredArrow.mk f)) = ⟨op X, yonedaEquiv.1 f⟩ :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | fromCostructuredArrow_obj_mk | null |
@[simps]
costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F where
functor := toCostructuredArrow F
inverse := (fromCostructuredArrow F).rightOp
unitIso :=
NatIso.ofComponents
(fun X ↦ Iso.op (CategoryOfElements.isoMk _ _ (Iso.refl _) (by simp))) (by
rintro ⟨x⟩ ⟨y⟩ ⟨f : y ⟶ x⟩
exact Quiver.Hom.unop_inj (by ext; simp))
counitIso := NatIso.ofComponents (fun X ↦ CostructuredArrow.isoMk (Iso.refl _)) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrowYonedaEquivalence | The equivalence `F.Elementsᵒᵖ ≅ (yoneda, F)` given by yoneda lemma. |
costructuredArrow_yoneda_equivalence_naturality {F₁ F₂ : Cᵒᵖ ⥤ Type v} (α : F₁ ⟶ F₂) :
(map α).op ⋙ toCostructuredArrow F₂ = toCostructuredArrow F₁ ⋙ CostructuredArrow.map α := by
fapply Functor.ext
· intro X
simp only [CostructuredArrow.map_mk, toCostructuredArrow_obj, Functor.op_obj,
Functor.comp_obj]
congr
ext _ f
simpa using congr_fun (α.naturality f.op).symm (unop X).snd
· simp | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrow_yoneda_equivalence_naturality | The equivalence `(-.Elements)ᵒᵖ ≅ (yoneda, -)` of is actually a natural isomorphism of functors. |
@[simps!]
costructuredArrowYonedaEquivalenceFunctorProj (F : Cᵒᵖ ⥤ Type v) :
(costructuredArrowYonedaEquivalence F).functor ⋙ CostructuredArrow.proj _ _ ≅ (π F).leftOp :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrowYonedaEquivalenceFunctorProj | The equivalence `F.elementsᵒᵖ ≌ (yoneda, F)` is compatible with the forgetful functors. |
@[simps!]
costructuredArrowYonedaEquivalenceInverseπ (F : Cᵒᵖ ⥤ Type v) :
(costructuredArrowYonedaEquivalence F).inverse ⋙ (π F).leftOp ≅ CostructuredArrow.proj _ _ :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrowYonedaEquivalenceInverseπ | The equivalence `F.elementsᵒᵖ ≌ (yoneda, F)` is compatible with the forgetful functors. |
@[simps]
costructuredArrowULiftYonedaEquivalence (F : Cᵒᵖ ⥤ Type max w v) :
F.Elementsᵒᵖ ≌ CostructuredArrow uliftYoneda.{w} F where
functor :=
{ obj x := CostructuredArrow.mk (uliftYonedaEquiv.{w}.symm x.unop.2)
map f := CostructuredArrow.homMk f.1.1.unop (by
dsimp
rw [← uliftYonedaEquiv_symm_map, map_snd]) }
inverse :=
{ obj X := op (F.elementsMk _ (uliftYonedaEquiv.{w} X.hom))
map f := (homMk _ _ f.left.op (by
dsimp
rw [← CostructuredArrow.w f, uliftYonedaEquiv_naturality, Quiver.Hom.unop_op])).op }
unitIso := NatIso.ofComponents (fun x ↦ Iso.op (isoMk _ _ (Iso.refl _) (by simp)))
(fun f ↦ Quiver.Hom.unop_inj (by aesop))
counitIso := NatIso.ofComponents (fun X ↦ CostructuredArrow.isoMk (Iso.refl _)) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrowULiftYonedaEquivalence | The opposite of the category of elements of a presheaf of types
is equivalent to a category of costructured arrows for the Yoneda embedding functor. |
costructuredArrowULiftYonedaEquivalenceFunctorCompProjIso (F : Cᵒᵖ ⥤ Type max w v) :
(costructuredArrowULiftYonedaEquivalence.{w} F).functor ⋙ CostructuredArrow.proj _ _ ≅
(π F).leftOp :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | costructuredArrowULiftYonedaEquivalenceFunctorCompProjIso | The equivalence of categories `costructuredArrowULiftYonedaEquivalence`
commutes with the projections. |
Elements.initial (A : C) : (yoneda.obj A).Elements :=
⟨Opposite.op A, 𝟙 _⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Elements.initial | The initial object in the category of elements for a representable functor. In `isInitial` it is
shown that this is initial. |
Elements.isInitial (A : C) : Limits.IsInitial (Elements.initial A) where
desc s := ⟨s.pt.2.op, Category.comp_id _⟩
uniq s m _ := by
simp_rw [← m.2]
dsimp [Elements.initial]
simp
fac := by rintro s ⟨⟨⟩⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.StructuredArrow.Basic",
"Mathlib.CategoryTheory.Category.Cat"
] | Mathlib/CategoryTheory/Elements.lean | Elements.isInitial | Show that `Elements.initial A` is initial in the category of elements for the `yoneda` functor. |
End {C : Type u} [CategoryStruct.{v} C] (X : C) := X ⟶ X | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | End | Endomorphisms of an object in a category. Arguments order in multiplication agrees with
`Function.comp`, not with `CategoryTheory.CategoryStruct.comp`. |
protected one : One (End X) := ⟨𝟙 X⟩ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | one | null |
protected inhabited : Inhabited (End X) := ⟨𝟙 X⟩ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | inhabited | null |
protected mul : Mul (End X) := ⟨fun x y => y ≫ x⟩
variable {X} | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mul | Multiplication of endomorphisms agrees with `Function.comp`, not with
`CategoryTheory.CategoryStruct.comp`. |
of (f : X ⟶ X) : End X := f | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | of | Assist the typechecker by expressing a morphism `X ⟶ X` as a term of `CategoryTheory.End X`. |
asHom (f : End X) : X ⟶ X := f
@[simp] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | asHom | Assist the typechecker by expressing an endomorphism `f : CategoryTheory.End X` as a term of
`X ⟶ X`. |
one_def : (1 : End X) = 𝟙 X := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | one_def | null |
mul_def (xs ys : End X) : xs * ys = ys ≫ xs := rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mul_def | null |
monoid {C : Type u} [Category.{v} C] {X : C} : Monoid (End X) where
mul_one := Category.id_comp
one_mul := Category.comp_id
mul_assoc := fun x y z => (Category.assoc z y x).symm | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | monoid | Endomorphisms of an object form a monoid |
mulActionRight {X Y : C} : MulAction (End Y) (X ⟶ Y) where
smul r f := f ≫ r
one_smul := Category.comp_id
mul_smul _ _ _ := Eq.symm <| Category.assoc _ _ _ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mulActionRight | null |
mulActionLeft {X Y : C} : MulAction (End X)ᵐᵒᵖ (X ⟶ Y) where
smul r f := r.unop ≫ f
one_smul := Category.id_comp
mul_smul _ _ _ := Category.assoc _ _ _ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mulActionLeft | null |
smul_right {X Y : C} {r : End Y} {f : X ⟶ Y} : r • f = f ≫ r :=
rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | smul_right | null |
smul_left {X Y : C} {r : (End X)ᵐᵒᵖ} {f : X ⟶ Y} : r • f = r.unop ≫ f :=
rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | smul_left | null |
group {C : Type u} [Groupoid.{v} C] (X : C) : Group (End X) where
inv_mul_cancel := Groupoid.comp_inv
inv := Groupoid.inv | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | group | In a groupoid, endomorphisms form a group |
isUnit_iff_isIso {C : Type u} [Category.{v} C] {X : C} (f : End X) :
IsUnit (f : End X) ↔ IsIso f :=
⟨fun h => { out := ⟨h.unit.inv, ⟨h.unit.inv_val, h.unit.val_inv⟩⟩ }, fun h =>
⟨⟨f, inv f, by simp, by simp⟩, rfl⟩⟩
variable {C : Type u} [Category.{v} C] (X : C) | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | isUnit_iff_isIso | null |
Aut (X : C) := X ≅ X | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | Aut | Automorphisms of an object in a category.
The order of arguments in multiplication agrees with
`Function.comp`, not with `CategoryTheory.CategoryStruct.comp`. |
@[ext]
ext {X : C} {φ₁ φ₂ : Aut X} (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂ :=
Iso.ext h | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | ext | null |
protected inhabited : Inhabited (Aut X) := ⟨Iso.refl X⟩ | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | inhabited | null |
Aut_mul_def (f g : Aut X) : f * g = g.trans f := rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | Aut_mul_def | null |
Aut_inv_def (f : Aut X) : f⁻¹ = f.symm := rfl | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | Aut_inv_def | null |
unitsEndEquivAut : (End X)ˣ ≃* Aut X where
toFun f := ⟨f.1, f.2, f.4, f.3⟩
invFun f := ⟨f.1, f.2, f.4, f.3⟩
map_mul' f g := by cases f; cases g; rfl | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | unitsEndEquivAut | Units in the monoid of endomorphisms of an object
are (multiplicatively) equivalent to automorphisms of that object. |
@[simps!]
toEnd (X : C) : Aut X →* End X := (Units.coeHom (End X)).comp (Aut.unitsEndEquivAut X).symm | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | toEnd | The inclusion of `Aut X` to `End X` as a monoid homomorphism. |
autMulEquivOfIso {X Y : C} (h : X ≅ Y) : Aut X ≃* Aut Y where
toFun x := { hom := h.inv ≫ x.hom ≫ h.hom, inv := h.inv ≫ x.inv ≫ h.hom }
invFun y := { hom := h.hom ≫ y.hom ≫ h.inv, inv := h.hom ≫ y.inv ≫ h.inv }
left_inv _ := by cat_disch
right_inv _ := by cat_disch
map_mul' := by simp [Aut_mul_def] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | autMulEquivOfIso | Isomorphisms induce isomorphisms of the automorphism group |
@[simps]
mapEnd : End X →* End (f.obj X) where
toFun := f.map
map_mul' x y := f.map_comp y x
map_one' := f.map_id X | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mapEnd | `f.map` as a monoid hom between endomorphism monoids. |
mapAut : Aut X →* Aut (f.obj X) where
toFun := f.mapIso
map_mul' x y := f.mapIso_trans y x
map_one' := f.mapIso_refl X | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mapAut | `f.mapIso` as a group hom between automorphism groups. |
@[simps!]
noncomputable mulEquivEnd (X : C) :
End X ≃* End (f.obj X) where
toEquiv := hf.homEquiv
__ := mapEnd X f | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | mulEquivEnd | `mulEquivEnd` as an isomorphism between endomorphism monoids. |
@[simps!]
noncomputable autMulEquivOfFullyFaithful (X : C) :
Aut X ≃* Aut (f.obj X) where
toEquiv := hf.isoEquiv
__ := mapAut X f | def | CategoryTheory | [
"Mathlib.Algebra.Group.Action.Defs",
"Mathlib.Algebra.Group.Equiv.Defs",
"Mathlib.Algebra.Group.Opposite",
"Mathlib.Algebra.Group.Units.Hom",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/Endomorphism.lean | autMulEquivOfFullyFaithful | `mulEquivAut` as an isomorphism between automorphism groups. |
unop_mono_of_epi {A B : Cᵒᵖ} (f : A ⟶ B) [Epi f] : Mono f.unop :=
⟨fun _ _ eq => Quiver.Hom.op_inj ((cancel_epi f).1 (Quiver.Hom.unop_inj eq))⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | unop_mono_of_epi | null |
unop_epi_of_mono {A B : Cᵒᵖ} (f : A ⟶ B) [Mono f] : Epi f.unop :=
⟨fun _ _ eq => Quiver.Hom.op_inj ((cancel_mono f).1 (Quiver.Hom.unop_inj eq))⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | unop_epi_of_mono | null |
op_mono_of_epi {A B : C} (f : A ⟶ B) [Epi f] : Mono f.op :=
⟨fun _ _ eq => Quiver.Hom.unop_inj ((cancel_epi f).1 (Quiver.Hom.op_inj eq))⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | op_mono_of_epi | null |
op_epi_of_mono {A B : C} (f : A ⟶ B) [Mono f] : Epi f.op :=
⟨fun _ _ eq => Quiver.Hom.unop_inj ((cancel_mono f).1 (Quiver.Hom.op_inj eq))⟩
@[simp] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | op_epi_of_mono | null |
op_mono_iff {X Y : C} (f : X ⟶ Y) :
Mono f.op ↔ Epi f :=
⟨fun _ ↦ unop_epi_of_mono f.op, fun _ ↦ inferInstance⟩
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | op_mono_iff | null |
op_epi_iff {X Y : C} (f : X ⟶ Y) :
Epi f.op ↔ Mono f :=
⟨fun _ ↦ unop_mono_of_epi f.op, fun _ ↦ inferInstance⟩
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | op_epi_iff | null |
unop_mono_iff {X Y : Cᵒᵖ} (f : X ⟶ Y) :
Mono f.unop ↔ Epi f :=
⟨fun _ ↦ op_epi_of_mono f.unop, fun _ ↦ inferInstance⟩
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | unop_mono_iff | null |
unop_epi_iff {X Y : Cᵒᵖ} (f : X ⟶ Y) :
Epi f.unop ↔ Mono f :=
⟨fun _ ↦ op_mono_of_epi f.unop, fun _ ↦ inferInstance⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | unop_epi_iff | null |
IsSplitMono {X Y : C} (f : X ⟶ Y) : Prop where
/-- There is a splitting -/
exists_splitMono : Nonempty (SplitMono f) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitMono | A split monomorphism is a morphism `f : X ⟶ Y` with a given retraction `retraction f : Y ⟶ X`
such that `f ≫ retraction f = 𝟙 X`.
Every split monomorphism is a monomorphism.
-/
@[ext, aesop apply safe (rule_sets := [CategoryTheory])]
structure SplitMono {X Y : C} (f : X ⟶ Y) where
/-- The map splitting `f` -/
retraction : Y ⟶ X
/-- `f` composed with `retraction` is the identity -/
id : f ≫ retraction = 𝟙 X := by cat_disch
attribute [reassoc (attr := simp)] SplitMono.id
/-- `IsSplitMono f` is the assertion that `f` admits a retraction |
@[simps]
SplitMono.comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} (smf : SplitMono f) (smg : SplitMono g) :
SplitMono (f ≫ g) where
retraction := smg.retraction ≫ smf.retraction | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitMono.comp | A composition of `SplitMono` is a `SplitMono`. |
IsSplitMono.mk' {X Y : C} {f : X ⟶ Y} (sm : SplitMono f) : IsSplitMono f :=
⟨Nonempty.intro sm⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitMono.mk' | A constructor for `IsSplitMono f` taking a `SplitMono f` as an argument |
IsSplitEpi {X Y : C} (f : X ⟶ Y) : Prop where
/-- There is a splitting -/
exists_splitEpi : Nonempty (SplitEpi f) | class | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitEpi | A split epimorphism is a morphism `f : X ⟶ Y` with a given section `section_ f : Y ⟶ X`
such that `section_ f ≫ f = 𝟙 Y`.
(Note that `section` is a reserved keyword, so we append an underscore.)
Every split epimorphism is an epimorphism.
-/
@[ext, aesop apply safe (rule_sets := [CategoryTheory])]
structure SplitEpi {X Y : C} (f : X ⟶ Y) where
/-- The map splitting `f` -/
section_ : Y ⟶ X
/-- `section_` composed with `f` is the identity -/
id : section_ ≫ f = 𝟙 Y := by cat_disch
attribute [reassoc (attr := simp)] SplitEpi.id
/-- `IsSplitEpi f` is the assertion that `f` admits a section |
@[simps]
SplitEpi.comp {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} (sef : SplitEpi f) (seg : SplitEpi g) :
SplitEpi (f ≫ g) where
section_ := seg.section_ ≫ sef.section_ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitEpi.comp | A composition of `SplitEpi` is a split `SplitEpi`. |
IsSplitEpi.mk' {X Y : C} {f : X ⟶ Y} (se : SplitEpi f) : IsSplitEpi f :=
⟨Nonempty.intro se⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitEpi.mk' | A constructor for `IsSplitEpi f` taking a `SplitEpi f` as an argument |
noncomputable retraction {X Y : C} (f : X ⟶ Y) [hf : IsSplitMono f] : Y ⟶ X :=
hf.exists_splitMono.some.retraction
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | retraction | The chosen retraction of a split monomorphism. |
IsSplitMono.id {X Y : C} (f : X ⟶ Y) [hf : IsSplitMono f] : f ≫ retraction f = 𝟙 X :=
hf.exists_splitMono.some.id | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | IsSplitMono.id | null |
SplitMono.splitEpi {X Y : C} {f : X ⟶ Y} (sm : SplitMono f) : SplitEpi sm.retraction where
section_ := f | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | SplitMono.splitEpi | The retraction of a split monomorphism has an obvious section. |
retraction_isSplitEpi {X Y : C} (f : X ⟶ Y) [IsSplitMono f] :
IsSplitEpi (retraction f) :=
IsSplitEpi.mk' (SplitMono.splitEpi _) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | retraction_isSplitEpi | The retraction of a split monomorphism is itself a split epimorphism. |
isIso_of_epi_of_isSplitMono {X Y : C} (f : X ⟶ Y) [IsSplitMono f] [Epi f] : IsIso f :=
⟨⟨retraction f, ⟨by simp, by simp [← cancel_epi f]⟩⟩⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | isIso_of_epi_of_isSplitMono | A split mono which is epi is an iso. |
noncomputable section_ {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] : Y ⟶ X :=
hf.exists_splitEpi.some.section_
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Opposites",
"Mathlib.CategoryTheory.Groupoid"
] | Mathlib/CategoryTheory/EpiMono.lean | section_ | The chosen section of a split epimorphism.
(Note that `section` is a reserved keyword, so we append an underscore.) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.