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

full_name: MagmaCat
code: /-- The category of magmas and magma morphisms. -/
@[to_additive]
def MagmaCat : Type (u + 1) 
goal: Type (u + 1)

full_name: AddMagmaCat
code: /-- The category of magmas and magma morphisms. -/
@[to_additive]
def MagmaCat : Type (u + 1) 
goal: Type (u + 1)

full_name: AddMagmaCat.bundledHom
code: @[to_additive]
instance bundledHom : BundledHom @MulHom 
goal: CategoryTheory.BundledHom AddHom

full_name: MagmaCat.bundledHom
code: @[to_additive]
instance bundledHom : BundledHom @MulHom 
goal: CategoryTheory.BundledHom MulHom

full_name: MagmaCat.instConcreteCategory
code: instance instConcreteCategory : ConcreteCategory MagmaCat 
goal: CategoryTheory.ConcreteCategory MagmaCat

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

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

full_name: MagmaCat.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : MagmaCat) where ⊢
  (forget MagmaCat).obj R ≟ R
goal: Prop

full_name: AddMagmaCat.forget_obj_eq_coe
code: unif_hint _root_.AddMagmaCat.forget_obj_eq_coe (R : AddMagmaCat) where ⊢
  (forget AddMagmaCat).obj R ≟ R
goal: Prop

full_name: MagmaCat.instMulα
code: @[to_additive]
instance (X : MagmaCat) : Mul X 
goal: Mul ↑X

full_name: AddMagmaCat.instMulα
code: @[to_additive]
instance (X : MagmaCat) : Mul X 
goal: Add ↑X

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

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

full_name: MagmaCat.instMulHomClass
code: @[to_additive]
instance instMulHomClass (X Y : MagmaCat) : MulHomClass (X ⟶ Y) X Y 
goal: MulHomClass (X ⟶ Y) ↑X ↑Y

full_name: AddMagmaCat.instAddHomClass
code: @[to_additive]
instance instMulHomClass (X Y : MagmaCat) : MulHomClass (X ⟶ Y) X Y 
goal: AddHomClass (X ⟶ Y) ↑X ↑Y

full_name: AddMagmaCat.of
code: /-- Construct a bundled `MagmaCat` from the underlying type and typeclass. -/
@[to_additive]
def of (M : Type u) [Mul M] : MagmaCat 
goal: AddMagmaCat

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

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

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

full_name: MagmaCat.mulEquiv_coe_eq
code: @[to_additive (attr := simp)]
lemma mulEquiv_coe_eq {X Y : Type _} [Mul X] [Mul Y] (e : X ≃* Y) :
    (@DFunLike.coe (MagmaCat.of X ⟶ MagmaCat.of Y) _ (fun _ => (forget MagmaCat).obj _)
      ConcreteCategory.instFunLike (e : X →ₙ* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: AddMagmaCat.addEquiv_coe_eq
code: @[to_additive (attr := simp)]
lemma mulEquiv_coe_eq {X Y : Type _} [Mul X] [Mul Y] (e : X ≃* Y) :
    (@DFunLike.coe (MagmaCat.of X ⟶ MagmaCat.of Y) _ (fun _ => (forget MagmaCat).obj _)
      ConcreteCategory.instFunLike (e : X →ₙ* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

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

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

full_name: AddMagmaCat.ofHom_apply
code: @[to_additive] -- Porting note: simp removed, simpNF says LHS simplifies to itself
theorem ofHom_apply {X Y : Type u} [Mul X] [Mul Y] (f : X →ₙ* Y) (x : X) : ofHom f x = f x 
goal: (AddMagmaCat.ofHom f) x = f x

full_name: MagmaCat.ofHom_apply
code: @[to_additive] -- Porting note: simp removed, simpNF says LHS simplifies to itself
theorem ofHom_apply {X Y : Type u} [Mul X] [Mul Y] (f : X →ₙ* Y) (x : X) : ofHom f x = f x 
goal: (MagmaCat.ofHom f) x = f x

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

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

full_name: Semigrp
code: /-- The category of semigroups and semigroup morphisms. -/
@[to_additive]
def Semigrp : Type (u + 1) 
goal: Type (u + 1)

full_name: AddSemigrp
code: /-- The category of semigroups and semigroup morphisms. -/
@[to_additive]
def Semigrp : Type (u + 1) 
goal: Type (u + 1)

full_name: AddSemigrp.instParentProjectionAddAddSemigroupToAdd
code: @[to_additive]
instance : BundledHom.ParentProjection @Semigroup.toMul 
goal: CategoryTheory.BundledHom.ParentProjection @AddSemigroup.toAdd

full_name: Semigrp.instParentProjectionMulSemigroupToMul
code: @[to_additive]
instance : BundledHom.ParentProjection @Semigroup.toMul 
goal: CategoryTheory.BundledHom.ParentProjection @Semigroup.toMul

full_name: Semigrp.instConcreteCategory
code: instance instConcreteCategory : ConcreteCategory Semigrp 
goal: CategoryTheory.ConcreteCategory Semigrp

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

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

full_name: Semigrp.forget_obj_eq_coe
code: unif_hint forget_obj_eq_coe (R : Semigrp) where ⊢
  (forget Semigrp).obj R ≟ R
goal: Prop

full_name: AddSemigrp.forget_obj_eq_coe
code: unif_hint _root_.AddSemigrp.forget_obj_eq_coe (R : AddSemigrp) where ⊢
  (forget AddSemigrp).obj R ≟ R
goal: Prop

full_name: AddSemigrp.instSemigroupα
code: @[to_additive]
instance (X : Semigrp) : Semigroup X 
goal: AddSemigroup ↑X

full_name: Semigrp.instSemigroupα
code: @[to_additive]
instance (X : Semigrp) : Semigroup X 
goal: Semigroup ↑X

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

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

full_name: AddSemigrp.instAddHomClass
code: @[to_additive]
instance instMulHomClass (X Y : Semigrp) : MulHomClass (X ⟶ Y) X Y 
goal: AddHomClass (X ⟶ Y) ↑X ↑Y

full_name: Semigrp.instMulHomClass
code: @[to_additive]
instance instMulHomClass (X Y : Semigrp) : MulHomClass (X ⟶ Y) X Y 
goal: MulHomClass (X ⟶ Y) ↑X ↑Y

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

full_name: AddSemigrp.of
code: /-- Construct a bundled `Semigrp` from the underlying type and typeclass. -/
@[to_additive]
def of (M : Type u) [Semigroup M] : Semigrp 
goal: AddSemigrp

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

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

full_name: Semigrp.mulEquiv_coe_eq
code: @[to_additive (attr := simp)]
lemma mulEquiv_coe_eq {X Y : Type _} [Semigroup X] [Semigroup Y] (e : X ≃* Y) :
    (@DFunLike.coe (Semigrp.of X ⟶ Semigrp.of Y) _ (fun _ => (forget Semigrp).obj _)
      ConcreteCategory.instFunLike (e : X →ₙ* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

full_name: AddSemigrp.addEquiv_coe_eq
code: @[to_additive (attr := simp)]
lemma mulEquiv_coe_eq {X Y : Type _} [Semigroup X] [Semigroup Y] (e : X ≃* Y) :
    (@DFunLike.coe (Semigrp.of X ⟶ Semigrp.of Y) _ (fun _ => (forget Semigrp).obj _)
      ConcreteCategory.instFunLike (e : X →ₙ* Y) : X → Y) = ↑e 
goal: ⇑↑e = ⇑e

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

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

full_name: Semigrp.ofHom_apply
code: @[to_additive] -- Porting note: simp removed, simpNF says LHS simplifies to itself
theorem ofHom_apply {X Y : Type u} [Semigroup X] [Semigroup Y] (f : X →ₙ* Y) (x : X) :
    ofHom f x = f x 
goal: (Semigrp.ofHom f) x = f x

full_name: AddSemigrp.ofHom_apply
code: @[to_additive] -- Porting note: simp removed, simpNF says LHS simplifies to itself
theorem ofHom_apply {X Y : Type u} [Semigroup X] [Semigroup Y] (f : X →ₙ* Y) (x : X) :
    ofHom f x = f x 
goal: (AddSemigrp.ofHom f) x = f x

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

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

full_name: Semigrp.hasForgetToMagmaCat
code: @[to_additive]
instance hasForgetToMagmaCat : HasForget₂ Semigrp MagmaCat 
goal: CategoryTheory.HasForget₂ Semigrp MagmaCat

full_name: AddSemigrp.hasForgetToAddMagmaCat
code: @[to_additive]
instance hasForgetToMagmaCat : HasForget₂ Semigrp MagmaCat 
goal: CategoryTheory.HasForget₂ AddSemigrp AddMagmaCat

full_name: MulEquiv.toMagmaCatIso_inv_apply
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: ∀ (a : Y), e.toMagmaCatIso.inv a = e.symm.toFun a

full_name: AddEquiv.toAddMagmaCatIso_hom_apply
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: ∀ (a : X), e.toAddMagmaCatIso.hom a = e.toFun a

full_name: AddEquiv.toAddMagmaCatIso
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: AddMagmaCat.of X ≅ AddMagmaCat.of Y

full_name: MulEquiv.toMagmaCatIso_hom_apply
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: ∀ (a : X), e.toMagmaCatIso.hom a = e.toFun a

full_name: MulEquiv.toMagmaCatIso
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: MagmaCat.of X ≅ MagmaCat.of Y

full_name: AddEquiv.toAddMagmaCatIso_inv_apply
code: /-- Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. -/
@[to_additive (attr := simps)
      "Build an isomorphism in the category `AddMagmaCat` from an `AddEquiv` between `Add`s."]
def MulEquiv.toMagmaCatIso (e : X ≃* Y) : MagmaCat.of X ≅ MagmaCat.of Y 
goal: ∀ (a : Y), e.toAddMagmaCatIso.inv a = e.symm.toFun a

full_name: AddEquiv.toAddSemigrpIso_inv_apply
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: ∀ (a : Y), e.toAddSemigrpIso.inv a = e.symm.toFun a

full_name: MulEquiv.toSemigrpIso_inv_apply
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: ∀ (a : Y), e.toSemigrpIso.inv a = e.symm.toFun a

full_name: AddEquiv.toAddSemigrpIso_hom_apply
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: ∀ (a : X), e.toAddSemigrpIso.hom a = e.toFun a

full_name: MulEquiv.toSemigrpIso
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: Semigrp.of X ≅ Semigrp.of Y

full_name: AddEquiv.toAddSemigrpIso
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: AddSemigrp.of X ≅ AddSemigrp.of Y

full_name: MulEquiv.toSemigrpIso_hom_apply
code: /-- Build an isomorphism in the category `Semigroup` from a `MulEquiv` between `Semigroup`s. -/
@[to_additive (attr := simps)
  "Build an isomorphism in the category
  `AddSemigroup` from an `AddEquiv` between `AddSemigroup`s."]
def MulEquiv.toSemigrpIso (e : X ≃* Y) : Semigrp.of X ≅ Semigrp.of Y 
goal: ∀ (a : X), e.toSemigrpIso.hom a = e.toFun a

full_name: CategoryTheory.Iso.addMagmaCatIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `MagmaCat`. -/
@[to_additive
      "Build an `AddEquiv` from an isomorphism in the category `AddMagmaCat`."]
def magmaCatIsoToMulEquiv {X Y : MagmaCat} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

full_name: CategoryTheory.Iso.magmaCatIsoToMulEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `MagmaCat`. -/
@[to_additive
      "Build an `AddEquiv` from an isomorphism in the category `AddMagmaCat`."]
def magmaCatIsoToMulEquiv {X Y : MagmaCat} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃* ↑Y

full_name: CategoryTheory.Iso.addSemigrpIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `Semigroup`. -/
@[to_additive
  "Build an `AddEquiv` from an isomorphism in the category `AddSemigroup`."]
def semigrpIsoToMulEquiv {X Y : Semigrp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

full_name: CategoryTheory.Iso.semigrpIsoToMulEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `Semigroup`. -/
@[to_additive
  "Build an `AddEquiv` from an isomorphism in the category `AddSemigroup`."]
def semigrpIsoToMulEquiv {X Y : Semigrp} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃* ↑Y

full_name: addEquivIsoAddMagmaIso
code: /-- multiplicative equivalences between `Mul`s are the same as (isomorphic to) isomorphisms
in `MagmaCat` -/
@[to_additive
    "additive equivalences between `Add`s are the same
    as (isomorphic to) isomorphisms in `AddMagmaCat`"]
def mulEquivIsoMagmaIso {X Y : Type u} [Mul X] [Mul Y] :
    X ≃* Y ≅ MagmaCat.of X ≅ MagmaCat.of Y 
goal: X ≃+ Y ≅ AddMagmaCat.of X ≅ AddMagmaCat.of Y

full_name: mulEquivIsoMagmaIso
code: /-- multiplicative equivalences between `Mul`s are the same as (isomorphic to) isomorphisms
in `MagmaCat` -/
@[to_additive
    "additive equivalences between `Add`s are the same
    as (isomorphic to) isomorphisms in `AddMagmaCat`"]
def mulEquivIsoMagmaIso {X Y : Type u} [Mul X] [Mul Y] :
    X ≃* Y ≅ MagmaCat.of X ≅ MagmaCat.of Y 
goal: X ≃* Y ≅ MagmaCat.of X ≅ MagmaCat.of Y

full_name: addEquivIsoAddSemigrpIso
code: /-- multiplicative equivalences between `Semigroup`s are the same as (isomorphic to) isomorphisms
in `Semigroup` -/
@[to_additive
  "additive equivalences between `AddSemigroup`s are
  the same as (isomorphic to) isomorphisms in `AddSemigroup`"]
def mulEquivIsoSemigrpIso {X Y : Type u} [Semigroup X] [Semigroup Y] :
    X ≃* Y ≅ Semigrp.of X ≅ Semigrp.of Y 
goal: X ≃+ Y ≅ AddSemigrp.of X ≅ AddSemigrp.of Y

full_name: mulEquivIsoSemigrpIso
code: /-- multiplicative equivalences between `Semigroup`s are the same as (isomorphic to) isomorphisms
in `Semigroup` -/
@[to_additive
  "additive equivalences between `AddSemigroup`s are
  the same as (isomorphic to) isomorphisms in `AddSemigroup`"]
def mulEquivIsoSemigrpIso {X Y : Type u} [Semigroup X] [Semigroup Y] :
    X ≃* Y ≅ Semigrp.of X ≅ Semigrp.of Y 
goal: X ≃* Y ≅ Semigrp.of X ≅ Semigrp.of Y

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

full_name: AddMagmaCat.forgetReflectsIsos
code: @[to_additive]
instance MagmaCat.forgetReflectsIsos : (forget MagmaCat.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget AddMagmaCat).ReflectsIsomorphisms

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

full_name: AddSemigrp.forgetReflectsIsos
code: @[to_additive]
instance Semigrp.forgetReflectsIsos : (forget Semigrp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget AddSemigrp).ReflectsIsomorphisms

full_name: Semigrp.forget₂_full
code: @[to_additive]
instance Semigrp.forget₂_full : (forget₂ Semigrp MagmaCat).Full 
goal: (CategoryTheory.forget₂ Semigrp MagmaCat).Full

full_name: AddSemigrp.forget₂_full
code: @[to_additive]
instance Semigrp.forget₂_full : (forget₂ Semigrp MagmaCat).Full 
goal: (CategoryTheory.forget₂ AddSemigrp AddMagmaCat).Full