File: Mathlib/Algebra/Category/Grp/Basic.lean

full_name: AddGrp
code: /-- The category of groups and group morphisms. -/
@[to_additive]
def Grp : Type (u + 1) 
goal: Type (u + 1)

full_name: Grp
code: /-- The category of groups and group morphisms. -/
@[to_additive]
def Grp : Type (u + 1) 
goal: Type (u + 1)

full_name: AddGrp.instParentProjectionAddMonoidAddGroup
code: @[to_additive]
instance : BundledHom.ParentProjection
  (fun {α : Type*} (h : Group α) => h.toDivInvMonoid.toMonoid) 
goal: CategoryTheory.BundledHom.ParentProjection fun {α} h => SubNegMonoid.toAddMonoid

full_name: Grp.instParentProjectionMonoidGroup
code: @[to_additive]
instance : BundledHom.ParentProjection
  (fun {α : Type*} (h : Group α) => h.toDivInvMonoid.toMonoid) 
goal: CategoryTheory.BundledHom.ParentProjection fun {α} h => DivInvMonoid.toMonoid

full_name: AddGrp.concreteCategory
code: @[to_additive]
instance concreteCategory : ConcreteCategory Grp 
goal: CategoryTheory.ConcreteCategory AddGrp

full_name: Grp.concreteCategory
code: @[to_additive]
instance concreteCategory : ConcreteCategory Grp 
goal: CategoryTheory.ConcreteCategory Grp

full_name: AddGrp.instCoeSortType
code: @[to_additive]
instance : CoeSort Grp Type* 
goal: CoeSort AddGrp (Type u_1)

full_name: Grp.instCoeSortType
code: @[to_additive]
instance : CoeSort Grp Type* 
goal: CoeSort Grp (Type u_1)

full_name: AddGrp.instGroupα
code: @[to_additive]
instance (X : Grp) : Group X 
goal: AddGroup ↑X

full_name: Grp.instGroupα
code: @[to_additive]
instance (X : Grp) : Group X 
goal: Group ↑X

full_name: AddGrp.instCoeFunHomForallαAddGroup
code: @[to_additive]
instance {X Y : Grp} : CoeFun (X ⟶ Y) fun _ => X → Y 
goal: CoeFun (X ⟶ Y) fun x => ↑X → ↑Y

full_name: Grp.instCoeFunHomForallαGroup
code: @[to_additive]
instance {X Y : Grp} : CoeFun (X ⟶ Y) fun _ => X → Y 
goal: CoeFun (X ⟶ Y) fun x => ↑X → ↑Y

full_name: Grp.instFunLike
code: @[to_additive]
instance instFunLike (X Y : Grp) : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: AddGrp.instFunLike
code: @[to_additive]
instance instFunLike (X Y : Grp) : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: AddGrp.coe_id
code: @[to_additive (attr := simp)]
lemma coe_id {X : Grp} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: Grp.coe_id
code: @[to_additive (attr := simp)]
lemma coe_id {X : Grp} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: Grp.coe_comp
code: @[to_additive (attr := simp)]
lemma coe_comp {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: AddGrp.coe_comp
code: @[to_additive (attr := simp)]
lemma coe_comp {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: Grp.comp_def
code: @[to_additive]
lemma comp_def {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
goal: f ≫ g = MonoidHom.comp g f

full_name: AddGrp.comp_def
code: @[to_additive]
lemma comp_def {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
goal: f ≫ g = AddMonoidHom.comp g f

full_name: Grp.forget_map
code: @[simp] lemma forget_map {X Y : Grp} (f : X ⟶ Y) : (forget Grp).map f = (f : X → Y) 
goal: (CategoryTheory.forget Grp).map f = ⇑f

full_name: AddGrp.ext
code: @[to_additive (attr := ext)]
lemma ext {X Y : Grp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: Grp.ext
code: @[to_additive (attr := ext)]
lemma ext {X Y : Grp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: AddGrp.of
code: /-- Construct a bundled `Group` from the underlying type and typeclass. -/
@[to_additive]
def of (X : Type u) [Group X] : Grp 
goal: AddGrp

full_name: Grp.of
code: /-- Construct a bundled `Group` from the underlying type and typeclass. -/
@[to_additive]
def of (X : Type u) [Group X] : Grp 
goal: Grp

full_name: AddGrp.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Group R] : ↑(Grp.of R) = R 
goal: ↑(AddGrp.of R) = R

full_name: Grp.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Group R] : ↑(Grp.of R) = R 
goal: ↑(Grp.of R) = R

full_name: Grp.coe_comp'
code: @[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [Group G] [Group H] [Group K] (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := Grp.of G) (Y := Grp.of H) (Z := Grp.of K) f g) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: AddGrp.coe_comp'
code: @[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [Group G] [Group H] [Group K] (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := Grp.of G) (Y := Grp.of H) (Z := Grp.of K) f g) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: Grp.coe_id'
code: @[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [Group G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := Grp.of G)) = id 
goal: ⇑(𝟙 (Grp.of G)) = id

full_name: AddGrp.coe_id'
code: @[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [Group G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := Grp.of G)) = id 
goal: ⇑(𝟙 (AddGrp.of G)) = id

full_name: Grp.instInhabited
code: @[to_additive]
instance : Inhabited Grp 
goal: Inhabited Grp

full_name: AddGrp.instInhabited
code: @[to_additive]
instance : Inhabited Grp 
goal: Inhabited AddGrp

full_name: AddGrp.hasForgetToAddMonCat
code: @[to_additive hasForgetToAddMonCat]
instance hasForgetToMonCat : HasForget₂ Grp MonCat 
goal: CategoryTheory.HasForget₂ AddGrp AddMonCat

full_name: Grp.hasForgetToMonCat
code: @[to_additive hasForgetToAddMonCat]
instance hasForgetToMonCat : HasForget₂ Grp MonCat 
goal: CategoryTheory.HasForget₂ Grp MonCat

full_name: AddGrp.instCoeMonCat
code: @[to_additive]
instance : Coe Grp.{u} MonCat.{u} 
goal: Coe AddGrp AddMonCat

full_name: Grp.instCoeMonCat
code: @[to_additive]
instance : Coe Grp.{u} MonCat.{u} 
goal: Coe Grp MonCat

full_name: AddGrp.instZeroHom
code: @[to_additive]
instance (G H : Grp) : One (G ⟶ H) 
goal: Zero (G ⟶ H)

full_name: Grp.instOneHom
code: @[to_additive]
instance (G H : Grp) : One (G ⟶ H) 
goal: One (G ⟶ H)

full_name: AddGrp.zero_apply
code: @[to_additive (attr := simp)]
theorem one_apply (G H : Grp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
goal: 0 g = 0

full_name: Grp.one_apply
code: @[to_additive (attr := simp)]
theorem one_apply (G H : Grp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
goal: 1 g = 1

full_name: AddGrp.ofHom
code: /-- Typecheck a `MonoidHom` as a morphism in `Grp`. -/
@[to_additive]
def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y 
goal: AddGrp.of X ⟶ AddGrp.of Y

full_name: Grp.ofHom
code: /-- Typecheck a `MonoidHom` as a morphism in `Grp`. -/
@[to_additive]
def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y 
goal: Grp.of X ⟶ Grp.of Y

full_name: Grp.ofHom_apply
code: @[to_additive]
theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (Grp.ofHom f) x = f x

full_name: AddGrp.ofHom_apply
code: @[to_additive]
theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (AddGrp.ofHom f) x = f x

full_name: AddGrp.ofUnique
code: @[to_additive]
instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (Grp.of G) 
goal: Unique ↑(AddGrp.of G)

full_name: Grp.ofUnique
code: @[to_additive]
instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (Grp.of G) 
goal: Unique ↑(Grp.of G)

full_name: Grp.uliftFunctor
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: Grp ⥤ Grp

full_name: AddGrp.uliftFunctor
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: AddGrp ⥤ AddGrp

full_name: Grp.uliftFunctor_map
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: Grp.uliftFunctor.map f = Grp.ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom))

full_name: Grp.uliftFunctor_obj
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: Grp.uliftFunctor.obj X = Grp.of (ULift.{v, u} ↑X)

full_name: AddGrp.uliftFunctor_map
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: AddGrp.uliftFunctor.map f =
  AddGrp.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp (AddMonoidHom.comp f AddEquiv.ulift.toAddMonoidHom))

full_name: AddGrp.uliftFunctor_obj
code: /-- Universe lift functor for groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive groups."]
def uliftFunctor : Grp.{u} ⥤ Grp.{max u v} 
goal: AddGrp.uliftFunctor.obj X = AddGrp.of (ULift.{v, u} ↑X)

full_name: AddCommGrp
code: /-- The category of commutative groups and group morphisms. -/
@[to_additive]
def CommGrp : Type (u + 1) 
goal: Type (u + 1)

full_name: CommGrp
code: /-- The category of commutative groups and group morphisms. -/
@[to_additive]
def CommGrp : Type (u + 1) 
goal: Type (u + 1)

full_name: Ab
code: /-- `Ab` is an abbreviation for `AddCommGroup`, for the sake of mathematicians' sanity. -/
abbrev Ab 
goal: Type (u_1 + 1)

full_name: AddCommGrp.instParentProjectionAddGroupAddCommGroupToAddGroup
code: @[to_additive]
instance : BundledHom.ParentProjection @CommGroup.toGroup 
goal: CategoryTheory.BundledHom.ParentProjection @AddCommGroup.toAddGroup

full_name: CommGrp.instParentProjectionGroupCommGroupToGroup
code: @[to_additive]
instance : BundledHom.ParentProjection @CommGroup.toGroup 
goal: CategoryTheory.BundledHom.ParentProjection @CommGroup.toGroup

full_name: CommGrp.concreteCategory
code: @[to_additive]
instance concreteCategory : ConcreteCategory CommGrp 
goal: CategoryTheory.ConcreteCategory CommGrp

full_name: AddCommGrp.concreteCategory
code: @[to_additive]
instance concreteCategory : ConcreteCategory CommGrp 
goal: CategoryTheory.ConcreteCategory AddCommGrp

full_name: CommGrp.instCoeSortType
code: @[to_additive]
instance : CoeSort CommGrp Type* 
goal: CoeSort CommGrp (Type u_1)

full_name: AddCommGrp.instCoeSortType
code: @[to_additive]
instance : CoeSort CommGrp Type* 
goal: CoeSort AddCommGrp (Type u_1)

full_name: AddCommGrp.addCommGroupInstance
code: @[to_additive]
instance commGroupInstance (X : CommGrp) : CommGroup X 
goal: AddCommGroup ↑X

full_name: CommGrp.commGroupInstance
code: @[to_additive]
instance commGroupInstance (X : CommGrp) : CommGroup X 
goal: CommGroup ↑X

full_name: AddCommGrp.instCoeFunHomForallαAddCommGroup
code: @[to_additive]
instance {X Y : CommGrp} : CoeFun (X ⟶ Y) fun _ => X → Y 
goal: CoeFun (X ⟶ Y) fun x => ↑X → ↑Y

full_name: CommGrp.instCoeFunHomForallαCommGroup
code: @[to_additive]
instance {X Y : CommGrp} : CoeFun (X ⟶ Y) fun _ => X → Y 
goal: CoeFun (X ⟶ Y) fun x => ↑X → ↑Y

full_name: CommGrp.instFunLike
code: @[to_additive]
instance instFunLike (X Y : CommGrp) : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: AddCommGrp.instFunLike
code: @[to_additive]
instance instFunLike (X Y : CommGrp) : FunLike (X ⟶ Y) X Y 
goal: FunLike (X ⟶ Y) ↑X ↑Y

full_name: CommGrp.coe_id
code: @[to_additive (attr := simp)]
lemma coe_id {X : CommGrp} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: AddCommGrp.coe_id
code: @[to_additive (attr := simp)]
lemma coe_id {X : CommGrp} : (𝟙 X : X → X) = id 
goal: ⇑(𝟙 X) = id

full_name: AddCommGrp.coe_comp
code: @[to_additive (attr := simp)]
lemma coe_comp {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: CommGrp.coe_comp
code: @[to_additive (attr := simp)]
lemma coe_comp {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: CommGrp.comp_def
code: @[to_additive]
lemma comp_def {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
goal: f ≫ g = MonoidHom.comp g f

full_name: AddCommGrp.comp_def
code: @[to_additive]
lemma comp_def {X Y Z : CommGrp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f 
goal: f ≫ g = AddMonoidHom.comp g f

full_name: AddCommGrp.forget_map
code: @[to_additive (attr := simp)]
lemma forget_map {X Y : CommGrp} (f : X ⟶ Y) :
    (forget CommGrp).map f = (f : X → Y) 
goal: (CategoryTheory.forget AddCommGrp).map f = ⇑f

full_name: CommGrp.forget_map
code: @[to_additive (attr := simp)]
lemma forget_map {X Y : CommGrp} (f : X ⟶ Y) :
    (forget CommGrp).map f = (f : X → Y) 
goal: (CategoryTheory.forget CommGrp).map f = ⇑f

full_name: CommGrp.ext
code: @[to_additive (attr := ext)]
lemma ext {X Y : CommGrp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: AddCommGrp.ext
code: @[to_additive (attr := ext)]
lemma ext {X Y : CommGrp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g 
goal: f = g

full_name: CommGrp.of
code: /-- Construct a bundled `CommGroup` from the underlying type and typeclass. -/
@[to_additive]
def of (G : Type u) [CommGroup G] : CommGrp 
goal: CommGrp

full_name: AddCommGrp.of
code: /-- Construct a bundled `CommGroup` from the underlying type and typeclass. -/
@[to_additive]
def of (G : Type u) [CommGroup G] : CommGrp 
goal: AddCommGrp

full_name: CommGrp.instInhabited
code: @[to_additive]
instance : Inhabited CommGrp 
goal: Inhabited CommGrp

full_name: AddCommGrp.instInhabited
code: @[to_additive]
instance : Inhabited CommGrp 
goal: Inhabited AddCommGrp

full_name: AddCommGrp.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of (R : Type u) [CommGroup R] : (CommGrp.of R : Type u) = R 
goal: ↑(AddCommGrp.of R) = R

full_name: CommGrp.coe_of
code: @[to_additive (attr := simp)]
theorem coe_of (R : Type u) [CommGroup R] : (CommGrp.of R : Type u) = R 
goal: ↑(CommGrp.of R) = R

full_name: CommGrp.coe_comp'
code: @[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [CommGroup G] [CommGroup H] [CommGroup K]
    (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := CommGrp.of G) (Y := CommGrp.of H) (Z := CommGrp.of K) f g) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: AddCommGrp.coe_comp'
code: @[to_additive (attr := simp)]
theorem coe_comp' {G H K : Type _} [CommGroup G] [CommGroup H] [CommGroup K]
    (f : G →* H) (g : H →* K) :
    @DFunLike.coe (G →* K) G (fun _ ↦ K) MonoidHom.instFunLike (CategoryStruct.comp
      (X := CommGrp.of G) (Y := CommGrp.of H) (Z := CommGrp.of K) f g) = g ∘ f 
goal: ⇑(f ≫ g) = ⇑g ∘ ⇑f

full_name: AddCommGrp.coe_id'
code: @[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [CommGroup G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := CommGrp.of G)) = id 
goal: ⇑(𝟙 (AddCommGrp.of G)) = id

full_name: CommGrp.coe_id'
code: @[to_additive (attr := simp)]
theorem coe_id' {G : Type _} [CommGroup G] :
    @DFunLike.coe (G →* G) G (fun _ ↦ G) MonoidHom.instFunLike
      (CategoryStruct.id (X := CommGrp.of G)) = id 
goal: ⇑(𝟙 (CommGrp.of G)) = id

full_name: CommGrp.ofUnique
code: @[to_additive]
instance ofUnique (G : Type*) [CommGroup G] [i : Unique G] : Unique (CommGrp.of G) 
goal: Unique ↑(CommGrp.of G)

full_name: AddCommGrp.ofUnique
code: @[to_additive]
instance ofUnique (G : Type*) [CommGroup G] [i : Unique G] : Unique (CommGrp.of G) 
goal: Unique ↑(AddCommGrp.of G)

full_name: CommGrp.hasForgetToGroup
code: @[to_additive]
instance hasForgetToGroup : HasForget₂ CommGrp Grp 
goal: CategoryTheory.HasForget₂ CommGrp Grp

full_name: AddCommGrp.hasForgetToAddGroup
code: @[to_additive]
instance hasForgetToGroup : HasForget₂ CommGrp Grp 
goal: CategoryTheory.HasForget₂ AddCommGrp AddGrp

full_name: AddCommGrp.instCoeAddGrp
code: @[to_additive]
instance : Coe CommGrp.{u} Grp.{u} 
goal: Coe AddCommGrp AddGrp

full_name: CommGrp.instCoeGrp
code: @[to_additive]
instance : Coe CommGrp.{u} Grp.{u} 
goal: Coe CommGrp Grp

full_name: CommGrp.hasForgetToCommMonCat
code: @[to_additive hasForgetToAddCommMonCat]
instance hasForgetToCommMonCat : HasForget₂ CommGrp CommMonCat 
goal: CategoryTheory.HasForget₂ CommGrp CommMonCat

full_name: AddCommGrp.hasForgetToAddCommMonCat
code: @[to_additive hasForgetToAddCommMonCat]
instance hasForgetToCommMonCat : HasForget₂ CommGrp CommMonCat 
goal: CategoryTheory.HasForget₂ AddCommGrp AddCommMonCat

full_name: CommGrp.instCoeCommMonCat
code: @[to_additive]
instance : Coe CommGrp.{u} CommMonCat.{u} 
goal: Coe CommGrp CommMonCat

full_name: AddCommGrp.instCoeCommMonCat
code: @[to_additive]
instance : Coe CommGrp.{u} CommMonCat.{u} 
goal: Coe AddCommGrp AddCommMonCat

full_name: CommGrp.instOneHom
code: @[to_additive]
instance (G H : CommGrp) : One (G ⟶ H) 
goal: One (G ⟶ H)

full_name: AddCommGrp.instZeroHom
code: @[to_additive]
instance (G H : CommGrp) : One (G ⟶ H) 
goal: Zero (G ⟶ H)

full_name: AddCommGrp.zero_apply
code: @[to_additive (attr := simp)]
theorem one_apply (G H : CommGrp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
goal: 0 g = 0

full_name: CommGrp.one_apply
code: @[to_additive (attr := simp)]
theorem one_apply (G H : CommGrp) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 
goal: 1 g = 1

full_name: AddCommGrp.ofHom
code: /-- Typecheck a `MonoidHom` as a morphism in `CommGroup`. -/
@[to_additive]
def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ of Y 
goal: AddCommGrp.of X ⟶ AddCommGrp.of Y

full_name: CommGrp.ofHom
code: /-- Typecheck a `MonoidHom` as a morphism in `CommGroup`. -/
@[to_additive]
def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ of Y 
goal: CommGrp.of X ⟶ CommGrp.of Y

full_name: CommGrp.ofHom_apply
code: @[to_additive (attr := simp)]
theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
    @DFunLike.coe (X →* Y) X (fun _ ↦ Y) _ (ofHom f) x = f x 
goal: (CommGrp.ofHom f) x = f x

full_name: AddCommGrp.ofHom_apply
code: @[to_additive (attr := simp)]
theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
    @DFunLike.coe (X →* Y) X (fun _ ↦ Y) _ (ofHom f) x = f x 
goal: (AddCommGrp.ofHom f) x = f x

full_name: CommGrp.uliftFunctor_map
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: CommGrp.uliftFunctor.map f =
  CommGrp.ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom))

full_name: CommGrp.uliftFunctor_obj
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: CommGrp.uliftFunctor.obj X = CommGrp.of (ULift.{v, u} ↑X)

full_name: AddCommGrp.uliftFunctor
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: AddCommGrp ⥤ AddCommGrp

full_name: AddCommGrp.uliftFunctor_map
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: AddCommGrp.uliftFunctor.map f =
  AddCommGrp.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp (AddMonoidHom.comp f AddEquiv.ulift.toAddMonoidHom))

full_name: AddCommGrp.uliftFunctor_obj
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: AddCommGrp.uliftFunctor.obj X = AddCommGrp.of (ULift.{v, u} ↑X)

full_name: CommGrp.uliftFunctor
code: /-- Universe lift functor for commutative groups. -/
@[to_additive (attr := simps)
  "Universe lift functor for additive commutative groups."]
def uliftFunctor : CommGrp.{u} ⥤ CommGrp.{max u v} 
goal: CommGrp ⥤ CommGrp

full_name: AddCommGrp.asHom
code: /-- Any element of an abelian group gives a unique morphism from `ℤ` sending
`1` to that element. -/
def asHom {G : AddCommGrp.{0}} (g : G) : AddCommGrp.of ℤ ⟶ G 
goal: AddCommGrp.of ℤ ⟶ G

full_name: AddCommGrp.asHom_apply
code: @[simp]
theorem asHom_apply {G : AddCommGrp.{0}} (g : G) (i : ℤ) :
    @DFunLike.coe (ℤ →+ ↑G) ℤ (fun _ ↦ ↑G) _ (asHom g) i = i • g 
goal: (AddCommGrp.asHom g) i = i • g

full_name: AddCommGrp.asHom_injective
code: theorem asHom_injective {G : AddCommGrp.{0}} : Function.Injective (@asHom G) 
goal: Function.Injective AddCommGrp.asHom

full_name: AddCommGrp.int_hom_ext
code: @[ext]
theorem int_hom_ext {G : AddCommGrp.{0}} (f g : AddCommGrp.of ℤ ⟶ G)
    (w : f (1 : ℤ) = g (1 : ℤ)) : f = g 
goal: f = g

full_name: AddCommGrp.injective_of_mono
code: theorem injective_of_mono {G H : AddCommGrp.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f 
goal: Function.Injective ⇑f

full_name: AddEquiv.toAddGrpIso_hom
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: e.toAddGrpIso.hom = e.toAddMonoidHom

full_name: AddEquiv.toAddGrpIso
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: X ≅ Y

full_name: MulEquiv.toGrpIso_inv
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: e.toGrpIso.inv = e.symm.toMonoidHom

full_name: MulEquiv.toGrpIso_hom
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: e.toGrpIso.hom = e.toMonoidHom

full_name: MulEquiv.toGrpIso
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: X ≅ Y

full_name: AddEquiv.toAddGrpIso_inv
code: /-- Build an isomorphism in the category `Grp` from a `MulEquiv` between `Group`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toGrpIso {X Y : Grp} (e : X ≃* Y) : X ≅ Y 
goal: e.toAddGrpIso.inv = e.symm.toAddMonoidHom

full_name: MulEquiv.toCommGrpIso_inv
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: e.toCommGrpIso.inv = e.symm.toMonoidHom

full_name: AddEquiv.toAddCommGrpIso_hom
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: e.toAddCommGrpIso.hom = e.toAddMonoidHom

full_name: MulEquiv.toCommGrpIso_hom
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: e.toCommGrpIso.hom = e.toMonoidHom

full_name: MulEquiv.toCommGrpIso
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: X ≅ Y

full_name: AddEquiv.toAddCommGrpIso_inv
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: e.toAddCommGrpIso.inv = e.symm.toAddMonoidHom

full_name: AddEquiv.toAddCommGrpIso
code: /-- Build an isomorphism in the category `CommGrp` from a `MulEquiv`
between `CommGroup`s. -/
@[to_additive (attr := simps)]
def MulEquiv.toCommGrpIso {X Y : CommGrp} (e : X ≃* Y) : X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.Iso.addGroupIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `Grp`. -/
@[to_additive (attr := simp)]
def groupIsoToMulEquiv {X Y : Grp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

full_name: CategoryTheory.Iso.groupIsoToMulEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `Grp`. -/
@[to_additive (attr := simp)]
def groupIsoToMulEquiv {X Y : Grp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃* ↑Y

full_name: CategoryTheory.Iso.commGroupIsoToMulEquiv_symm_apply
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: i.commGroupIsoToMulEquiv.symm a = i.inv a

full_name: CategoryTheory.Iso.commGroupIsoToMulEquiv_apply
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: i.commGroupIsoToMulEquiv a = i.hom a

full_name: CategoryTheory.Iso.addCommGroupIsoToAddEquiv_symm_apply
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: i.addCommGroupIsoToAddEquiv.symm a = i.inv a

full_name: CategoryTheory.Iso.addCommGroupIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

full_name: CategoryTheory.Iso.commGroupIsoToMulEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃* ↑Y

full_name: CategoryTheory.Iso.addCommGroupIsoToAddEquiv_apply
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommGroup`. -/
@[to_additive (attr := simps!)]
def commGroupIsoToMulEquiv {X Y : CommGrp} (i : X ≅ Y) : X ≃* Y 
goal: i.addCommGroupIsoToAddEquiv a = i.hom a

full_name: addEquivIsoAddGroupIso
code: /-- multiplicative equivalences between `Group`s are the same as (isomorphic to) isomorphisms
in `Grp` -/
@[to_additive]
def mulEquivIsoGroupIso {X Y : Grp.{u}} : X ≃* Y ≅ X ≅ Y 
goal: ↑X ≃+ ↑Y ≅ X ≅ Y

full_name: mulEquivIsoGroupIso
code: /-- multiplicative equivalences between `Group`s are the same as (isomorphic to) isomorphisms
in `Grp` -/
@[to_additive]
def mulEquivIsoGroupIso {X Y : Grp.{u}} : X ≃* Y ≅ X ≅ Y 
goal: ↑X ≃* ↑Y ≅ X ≅ Y

full_name: mulEquivIsoCommGroupIso
code: /-- Multiplicative equivalences between `CommGroup`s are the same as (isomorphic to) isomorphisms
in `CommGrp`. -/
@[to_additive]
def mulEquivIsoCommGroupIso {X Y : CommGrp.{u}} : X ≃* Y ≅ X ≅ Y 
goal: ↑X ≃* ↑Y ≅ X ≅ Y

full_name: addEquivIsoAddCommGroupIso
code: /-- Multiplicative equivalences between `CommGroup`s are the same as (isomorphic to) isomorphisms
in `CommGrp`. -/
@[to_additive]
def mulEquivIsoCommGroupIso {X Y : CommGrp.{u}} : X ≃* Y ≅ X ≅ Y 
goal: ↑X ≃+ ↑Y ≅ X ≅ Y

full_name: CategoryTheory.Aut.isoPerm
code: /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
of permutations. -/
def isoPerm {α : Type u} : Grp.of (Aut α) ≅ Grp.of (Equiv.Perm α) 
goal: Grp.of (CategoryTheory.Aut α) ≅ Grp.of (Equiv.Perm α)

full_name: CategoryTheory.Aut.mulEquivPerm
code: /-- The (unbundled) group of automorphisms of a type is `MulEquiv` to the (unbundled) group
of permutations. -/
def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α 
goal: CategoryTheory.Aut α ≃* Equiv.Perm α

full_name: Grp.forget_reflects_isos
code: @[to_additive]
instance Grp.forget_reflects_isos : (forget Grp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget Grp).ReflectsIsomorphisms

full_name: AddGrp.forget_reflects_isos
code: @[to_additive]
instance Grp.forget_reflects_isos : (forget Grp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget AddGrp).ReflectsIsomorphisms

full_name: CommGrp.forget_reflects_isos
code: @[to_additive]
instance CommGrp.forget_reflects_isos : (forget CommGrp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget CommGrp).ReflectsIsomorphisms

full_name: AddCommGrp.forget_reflects_isos
code: @[to_additive]
instance CommGrp.forget_reflects_isos : (forget CommGrp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget AddCommGrp).ReflectsIsomorphisms

full_name: GrpMax
code: /-- An alias for `Grp.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) GrpMaxAux
  "An alias for `AddGrp.{max u v}`, to deal around unification issues."]
abbrev GrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: GrpMaxAux
code: /-- An alias for `Grp.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) GrpMaxAux
  "An alias for `AddGrp.{max u v}`, to deal around unification issues."]
abbrev GrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddGrpMax
code: /-- An alias for `AddGrp.{max u v}`, to deal around unification issues. -/
@[nolint checkUnivs]
abbrev AddGrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: CommGrpMax
code: /-- An alias for `CommGrp.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddCommGrpMaxAux
  "An alias for `AddCommGrp.{max u v}`, to deal around unification issues."]
abbrev CommGrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddCommGrpMaxAux
code: /-- An alias for `CommGrp.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddCommGrpMaxAux
  "An alias for `AddCommGrp.{max u v}`, to deal around unification issues."]
abbrev CommGrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddCommGrpMax
code: /-- An alias for `AddCommGrp.{max u v}`, to deal around unification issues. -/
@[nolint checkUnivs]
abbrev AddCommGrpMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddMonoidHom.comp_id_addGrp
code: @[to_additive (attr := simp)] theorem MonoidHom.comp_id_grp
    {G : Grp.{u}} {H : Type u} [Group H] (f : G →* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: MonoidHom.comp_id_grp
code: @[to_additive (attr := simp)] theorem MonoidHom.comp_id_grp
    {G : Grp.{u}} {H : Type u} [Group H] (f : G →* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: AddMonoidHom.id_addGrp_comp
code: @[to_additive (attr := simp)] theorem MonoidHom.id_grp_comp
    {G : Type u} [Group G] {H : Grp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
goal: AddMonoidHom.comp (𝟙 H) f = f

full_name: MonoidHom.id_grp_comp
code: @[to_additive (attr := simp)] theorem MonoidHom.id_grp_comp
    {G : Type u} [Group G] {H : Grp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
goal: MonoidHom.comp (𝟙 H) f = f

full_name: AddMonoidHom.comp_id_addCommGrp
code: @[to_additive (attr := simp)] theorem MonoidHom.comp_id_commGrp
    {G : CommGrp.{u}} {H : Type u} [CommGroup H] (f : G →* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: MonoidHom.comp_id_commGrp
code: @[to_additive (attr := simp)] theorem MonoidHom.comp_id_commGrp
    {G : CommGrp.{u}} {H : Type u} [CommGroup H] (f : G →* H) : f.comp (𝟙 G) = f 
goal: f.comp (𝟙 G) = f

full_name: MonoidHom.id_commGrp_comp
code: @[to_additive (attr := simp)] theorem MonoidHom.id_commGrp_comp
    {G : Type u} [CommGroup G] {H : CommGrp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
goal: MonoidHom.comp (𝟙 H) f = f

full_name: AddMonoidHom.id_addCommGrp_comp
code: @[to_additive (attr := simp)] theorem MonoidHom.id_commGrp_comp
    {G : Type u} [CommGroup G] {H : CommGrp.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f 
goal: AddMonoidHom.comp (𝟙 H) f = f