File: Mathlib/CategoryTheory/Endomorphism.lean

full_name: CategoryTheory.End
code: /-- Endomorphisms of an object in a category. Arguments order in multiplication agrees with
`Function.comp`, not with `CategoryTheory.CategoryStruct.comp`. -/
def End {C : Type u} [CategoryStruct.{v} C] (X : C) 
goal: Type v

full_name: CategoryTheory.End.one
code: protected instance one : One (End X) 
goal: One (CategoryTheory.End X)

full_name: CategoryTheory.End.inhabited
code: protected instance inhabited : Inhabited (End X) 
goal: Inhabited (CategoryTheory.End X)

full_name: CategoryTheory.End.mul
code: /-- Multiplication of endomorphisms agrees with `Function.comp`, not with
`CategoryTheory.CategoryStruct.comp`. -/
protected instance mul : Mul (End X) 
goal: Mul (CategoryTheory.End X)

full_name: CategoryTheory.End.of
code: /-- Assist the typechecker by expressing a morphism `X ⟶ X` as a term of `CategoryTheory.End X`. -/
def of (f : X ⟶ X) : End X 
goal: CategoryTheory.End X

full_name: CategoryTheory.End.asHom
code: /-- Assist the typechecker by expressing an endomorphism `f : CategoryTheory.End X` as a term of
`X ⟶ X`. -/
def asHom (f : End X) : X ⟶ X 
goal: X ⟶ X

full_name: CategoryTheory.End.one_def
code: @[simp, nolint simpNF] -- Porting note (#11215): TODO: use `of`/`asHom`?
theorem one_def : (1 : End X) = 𝟙 X 
goal: 1 = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.End.mul_def
code: @[simp] -- Porting note (#11215): TODO: use `of`/`asHom`?
theorem mul_def (xs ys : End X) : xs * ys = ys ≫ xs 
goal: xs * ys = CategoryTheory.CategoryStruct.comp ys xs

full_name: CategoryTheory.End.monoid
code: /-- Endomorphisms of an object form a monoid -/
instance monoid {C : Type u} [Category.{v} C] {X : C} : Monoid (End X) 
goal: Monoid (CategoryTheory.End X)

full_name: CategoryTheory.End.mulActionRight
code: instance mulActionRight {X Y : C} : MulAction (End Y) (X ⟶ Y) 
goal: MulAction (CategoryTheory.End Y) (X ⟶ Y)

full_name: CategoryTheory.End.mulActionLeft
code: instance mulActionLeft {X : Cᵒᵖ} {Y : C} : MulAction (End X) (unop X ⟶ Y) 
goal: MulAction (CategoryTheory.End X) (Opposite.unop X ⟶ Y)

full_name: CategoryTheory.End.smul_right
code: theorem smul_right {X Y : C} {r : End Y} {f : X ⟶ Y} : r • f = f ≫ r 
goal: r • f = CategoryTheory.CategoryStruct.comp f r

full_name: CategoryTheory.End.smul_left
code: theorem smul_left {X : Cᵒᵖ} {Y : C} {r : End X} {f : unop X ⟶ Y} : r • f = r.unop ≫ f 
goal: r • f = CategoryTheory.CategoryStruct.comp (Quiver.Hom.unop r) f

full_name: CategoryTheory.End.group
code: /-- In a groupoid, endomorphisms form a group -/
instance group {C : Type u} [Groupoid.{v} C] (X : C) : Group (End X) 
goal: Group (CategoryTheory.End X)

full_name: CategoryTheory.isUnit_iff_isIso
code: theorem isUnit_iff_isIso {C : Type u} [Category.{v} C] {X : C} (f : End X) :
    IsUnit (f : End X) ↔ IsIso f 
goal: IsUnit f ↔ CategoryTheory.IsIso f

full_name: CategoryTheory.Aut
code: /-- Automorphisms of an object in a category.

The order of arguments in multiplication agrees with
`Function.comp`, not with `CategoryTheory.CategoryStruct.comp`.
-/
def Aut (X : C) 
goal: Type v

full_name: CategoryTheory.Aut.ext
code: @[ext]
lemma ext {X : C} {φ₁ φ₂ : Aut X} (h : φ₁.hom = φ₂.hom) : φ₁ = φ₂ 
goal: φ₁ = φ₂

full_name: CategoryTheory.Aut.inhabited
code: protected instance inhabited : Inhabited (Aut X) 
goal: Inhabited (CategoryTheory.Aut X)

full_name: CategoryTheory.Aut.instGroup
code: instance : Group (Aut X) 
goal: Group (CategoryTheory.Aut X)

full_name: CategoryTheory.Aut.Aut_mul_def
code: theorem Aut_mul_def (f g : Aut X) : f * g = g.trans f 
goal: f * g = g ≪≫ f

full_name: CategoryTheory.Aut.Aut_inv_def
code: theorem Aut_inv_def (f : Aut X) : f⁻¹ = f.symm 
goal: f⁻¹ = CategoryTheory.Iso.symm f

full_name: CategoryTheory.Aut.unitsEndEquivAut
code: /-- Units in the monoid of endomorphisms of an object
are (multiplicatively) equivalent to automorphisms of that object.
-/
def unitsEndEquivAut : (End X)ˣ ≃* Aut X 
goal: (CategoryTheory.End X)ˣ ≃* CategoryTheory.Aut X

full_name: CategoryTheory.Aut.toEnd
code: /-- The inclusion of `Aut X` to `End X` as a monoid homomorphism. -/
@[simps!]
def toEnd (X : C) : Aut X →* End X 
goal: CategoryTheory.Aut X →* CategoryTheory.End X

full_name: CategoryTheory.Aut.toEnd_apply
code: /-- The inclusion of `Aut X` to `End X` as a monoid homomorphism. -/
@[simps!]
def toEnd (X : C) : Aut X →* End X 
goal: ∀ (a : CategoryTheory.Aut X), (CategoryTheory.Aut.toEnd X) a = ↑((CategoryTheory.Aut.unitsEndEquivAut X).symm a)

full_name: CategoryTheory.Aut.autMulEquivOfIso
code: /-- Isomorphisms induce isomorphisms of the automorphism group -/
def autMulEquivOfIso {X Y : C} (h : X ≅ Y) : Aut X ≃* Aut Y 
goal: CategoryTheory.Aut X ≃* CategoryTheory.Aut Y

full_name: CategoryTheory.Functor.mapEnd
code: /-- `f.map` as a monoid hom between endomorphism monoids. -/
@[simps]
def mapEnd : End X →* End (f.obj X) 
goal: CategoryTheory.End X →* CategoryTheory.End (f.obj X)

full_name: CategoryTheory.Functor.mapEnd_apply
code: /-- `f.map` as a monoid hom between endomorphism monoids. -/
@[simps]
def mapEnd : End X →* End (f.obj X) 
goal: ∀ (a : X ⟶ X), (CategoryTheory.Functor.mapEnd X f) a = f.map a

full_name: CategoryTheory.Functor.mapAut
code: /-- `f.mapIso` as a group hom between automorphism groups. -/
def mapAut : Aut X →* Aut (f.obj X) 
goal: CategoryTheory.Aut X →* CategoryTheory.Aut (f.obj X)

full_name: CategoryTheory.Functor.FullyFaithful.mulEquivEnd_apply
code: /-- `mulEquivEnd` as an isomorphism between endomorphism monoids. -/
@[simps!]
noncomputable def mulEquivEnd (X : C) :
    End X ≃* End (f.obj X) 
goal: ∀ (a : X ⟶ X), (hf.mulEquivEnd X) a = f.map a

full_name: CategoryTheory.Functor.FullyFaithful.mulEquivEnd
code: /-- `mulEquivEnd` as an isomorphism between endomorphism monoids. -/
@[simps!]
noncomputable def mulEquivEnd (X : C) :
    End X ≃* End (f.obj X) 
goal: CategoryTheory.End X ≃* CategoryTheory.End (f.obj X)

full_name: CategoryTheory.Functor.FullyFaithful.mulEquivEnd_symm_apply
code: /-- `mulEquivEnd` as an isomorphism between endomorphism monoids. -/
@[simps!]
noncomputable def mulEquivEnd (X : C) :
    End X ≃* End (f.obj X) 
goal: ∀ (f_1 : f.obj X ⟶ f.obj X), (hf.mulEquivEnd X).symm f_1 = hf.preimage f_1

full_name: CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_apply_inv
code: /-- `mulEquivAut` as an isomorphism between automorphism groups. -/
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
goal: ((hf.autMulEquivOfFullyFaithful X) i).inv = f.map i.inv

full_name: CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_apply_hom
code: /-- `mulEquivAut` as an isomorphism between automorphism groups. -/
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
goal: ((hf.autMulEquivOfFullyFaithful X) i).hom = f.map i.hom

full_name: CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_symm_apply_inv
code: /-- `mulEquivAut` as an isomorphism between automorphism groups. -/
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
goal: ((hf.autMulEquivOfFullyFaithful X).symm e).inv = hf.preimage e.inv

full_name: CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_symm_apply_hom
code: /-- `mulEquivAut` as an isomorphism between automorphism groups. -/
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
goal: ((hf.autMulEquivOfFullyFaithful X).symm e).hom = hf.preimage e.hom

full_name: CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful
code: /-- `mulEquivAut` as an isomorphism between automorphism groups. -/
@[simps!]
noncomputable def autMulEquivOfFullyFaithful (X : C) :
    Aut X ≃* Aut (f.obj X) 
goal: CategoryTheory.Aut X ≃* CategoryTheory.Aut (f.obj X)