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

full_name: AddMonCat
code: /-- The category of monoids and monoid morphisms. -/
@[to_additive AddMonCat]
def MonCat : Type (u + 1) 
goal: Type (u + 1)

full_name: MonCat
code: /-- The category of monoids and monoid morphisms. -/
@[to_additive AddMonCat]
def MonCat : Type (u + 1) 
goal: Type (u + 1)

full_name: MonCat.AssocMonoidHom
code: /-- `MonoidHom` doesn't actually assume associativity. This alias is needed to make the category
theory machinery work. -/
@[to_additive]
abbrev AssocMonoidHom (M N : Type*) [Monoid M] [Monoid N] 
goal: Type (max u_1 u_2)

full_name: AddMonCat.AssocAddMonoidHom
code: /-- `MonoidHom` doesn't actually assume associativity. This alias is needed to make the category
theory machinery work. -/
@[to_additive]
abbrev AssocMonoidHom (M N : Type*) [Monoid M] [Monoid N] 
goal: Type (max u_1 u_2)

full_name: MonCat.bundledHom
code: @[to_additive]
instance bundledHom : BundledHom AssocMonoidHom 
goal: CategoryTheory.BundledHom MonCat.AssocMonoidHom

full_name: AddMonCat.bundledHom
code: @[to_additive]
instance bundledHom : BundledHom AssocMonoidHom 
goal: CategoryTheory.BundledHom AddMonCat.AssocAddMonoidHom

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

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

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

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

full_name: MonCat.instMonoidα
code: @[to_additive]
instance (X : MonCat) : Monoid X 
goal: Monoid ↑X

full_name: AddMonCat.instMonoidα
code: @[to_additive]
instance (X : MonCat) : Monoid X 
goal: AddMonoid ↑X

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

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

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

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

full_name: MonCat.instMonoidHomClass
code: @[to_additive]
instance instMonoidHomClass (X Y : MonCat) : MonoidHomClass (X ⟶ Y) X Y 
goal: MonoidHomClass (X ⟶ Y) ↑X ↑Y

full_name: AddMonCat.instAddMonoidHomClass
code: @[to_additive]
instance instMonoidHomClass (X Y : MonCat) : MonoidHomClass (X ⟶ Y) X Y 
goal: AddMonoidHomClass (X ⟶ Y) ↑X ↑Y

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

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

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

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

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

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

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

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

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

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

full_name: MonCat.coe_of
code: @[to_additive]
theorem coe_of (R : Type u) [Monoid R] : (MonCat.of R : Type u) = R 
goal: ↑(MonCat.of R) = R

full_name: AddMonCat.coe_of
code: @[to_additive]
theorem coe_of (R : Type u) [Monoid R] : (MonCat.of R : Type u) = R 
goal: ↑(AddMonCat.of R) = R

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

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

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

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

full_name: MonCat.ofHom_apply
code: @[to_additive (attr := simp)]
lemma ofHom_apply {X Y : Type u} [Monoid X] [Monoid Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (MonCat.ofHom f) x = f x

full_name: AddMonCat.ofHom_apply
code: @[to_additive (attr := simp)]
lemma ofHom_apply {X Y : Type u} [Monoid X] [Monoid Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (AddMonCat.ofHom f) x = f x

full_name: MonCat.instOneHom
code: @[to_additive]
instance (X Y : MonCat.{u}) : One (X ⟶ Y) 
goal: One (X ⟶ Y)

full_name: AddMonCat.instZeroHom
code: @[to_additive]
instance (X Y : MonCat.{u}) : One (X ⟶ Y) 
goal: Zero (X ⟶ Y)

full_name: AddMonCat.zeroHom_apply
code: @[to_additive (attr := simp)]
lemma oneHom_apply (X Y : MonCat.{u}) (x : X) : (1 : X ⟶ Y) x = 1 
goal: 0 x = 0

full_name: MonCat.oneHom_apply
code: @[to_additive (attr := simp)]
lemma oneHom_apply (X Y : MonCat.{u}) (x : X) : (1 : X ⟶ Y) x = 1 
goal: 1 x = 1

full_name: MonCat.one_of
code: @[to_additive (attr := simp)]
lemma one_of {A : Type*} [Monoid A] : (1 : MonCat.of A) = (1 : A) 
goal: 1 = 1

full_name: AddMonCat.zero_of
code: @[to_additive (attr := simp)]
lemma one_of {A : Type*} [Monoid A] : (1 : MonCat.of A) = (1 : A) 
goal: 0 = 0

full_name: MonCat.mul_of
code: @[to_additive (attr := simp)]
lemma mul_of {A : Type*} [Monoid A] (a b : A) :
    @HMul.hMul (MonCat.of A) (MonCat.of A) (MonCat.of A) _ a b = a * b 
goal: a * b = a * b

full_name: AddMonCat.add_of
code: @[to_additive (attr := simp)]
lemma mul_of {A : Type*} [Monoid A] (a b : A) :
    @HMul.hMul (MonCat.of A) (MonCat.of A) (MonCat.of A) _ a b = a * b 
goal: a + b = a + b

full_name: MonCat.instGroupαMonoidOf
code: @[to_additive]
instance {G : Type*} [Group G] : Group (MonCat.of G) 
goal: Group ↑(MonCat.of G)

full_name: AddMonCat.instGroupαAddMonoidOf
code: @[to_additive]
instance {G : Type*} [Group G] : Group (MonCat.of G) 
goal: AddGroup ↑(AddMonCat.of G)

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

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

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

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

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

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

full_name: AddCommMonCat
code: /-- The category of commutative monoids and monoid morphisms. -/
@[to_additive AddCommMonCat]
def CommMonCat : Type (u + 1) 
goal: Type (u + 1)

full_name: CommMonCat
code: /-- The category of commutative monoids and monoid morphisms. -/
@[to_additive AddCommMonCat]
def CommMonCat : Type (u + 1) 
goal: Type (u + 1)

full_name: AddCommMonCat.instParentProjectionAddMonoidAddCommMonoidToAddMonoid
code: @[to_additive]
instance : BundledHom.ParentProjection @CommMonoid.toMonoid 
goal: CategoryTheory.BundledHom.ParentProjection @AddCommMonoid.toAddMonoid

full_name: CommMonCat.instParentProjectionMonoidCommMonoidToMonoid
code: @[to_additive]
instance : BundledHom.ParentProjection @CommMonoid.toMonoid 
goal: CategoryTheory.BundledHom.ParentProjection @CommMonoid.toMonoid

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

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

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

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

full_name: CommMonCat.instCommMonoidα
code: @[to_additive]
instance (X : CommMonCat) : CommMonoid X 
goal: CommMonoid ↑X

full_name: AddCommMonCat.instCommMonoidα
code: @[to_additive]
instance (X : CommMonCat) : CommMonoid X 
goal: AddCommMonoid ↑X

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: CommMonCat.coe_of
code: @[to_additive]
theorem coe_of (R : Type u) [CommMonoid R] : (CommMonCat.of R : Type u) = R 
goal: ↑(CommMonCat.of R) = R

full_name: AddCommMonCat.coe_of
code: @[to_additive]
theorem coe_of (R : Type u) [CommMonoid R] : (CommMonCat.of R : Type u) = R 
goal: ↑(AddCommMonCat.of R) = R

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

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

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

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

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

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

full_name: AddCommMonCat.ofHom_apply
code: @[to_additive (attr := simp)]
lemma ofHom_apply {X Y : Type u} [CommMonoid X] [CommMonoid Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (AddCommMonCat.ofHom f) x = f x

full_name: CommMonCat.ofHom_apply
code: @[to_additive (attr := simp)]
lemma ofHom_apply {X Y : Type u} [CommMonoid X] [CommMonoid Y] (f : X →* Y) (x : X) :
    (ofHom f) x = f x 
goal: (CommMonCat.ofHom f) x = f x

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

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

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

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

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

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

full_name: AddEquiv.toAddMonCatIso_hom
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: e.toAddMonCatIso.hom = AddMonCat.ofHom e.toAddMonoidHom

full_name: AddEquiv.toAddMonCatIso
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: AddMonCat.of X ≅ AddMonCat.of Y

full_name: MulEquiv.toMonCatIso_inv
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: e.toMonCatIso.inv = MonCat.ofHom e.symm.toMonoidHom

full_name: AddEquiv.toAddMonCatIso_inv
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: e.toAddMonCatIso.inv = AddMonCat.ofHom e.symm.toAddMonoidHom

full_name: MulEquiv.toMonCatIso_hom
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: e.toMonCatIso.hom = MonCat.ofHom e.toMonoidHom

full_name: MulEquiv.toMonCatIso
code: /-- Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddMonCatIso
      "Build an isomorphism in the category `AddMonCat` from\nan `AddEquiv` between `AddMonoid`s."]
def MulEquiv.toMonCatIso (e : X ≃* Y) : MonCat.of X ≅ MonCat.of Y 
goal: MonCat.of X ≅ MonCat.of Y

full_name: MulEquiv.toCommMonCatIso_inv
code: /-- Build an isomorphism in the category `CommMonCat` from a `MulEquiv` between `CommMonoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddCommMonCatIso]
def MulEquiv.toCommMonCatIso (e : X ≃* Y) : CommMonCat.of X ≅ CommMonCat.of Y 
goal: e.toCommMonCatIso.inv = CommMonCat.ofHom e.symm.toMonoidHom

full_name: AddEquiv.toAddCommMonCatIso
code: /-- Build an isomorphism in the category `CommMonCat` from a `MulEquiv` between `CommMonoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddCommMonCatIso]
def MulEquiv.toCommMonCatIso (e : X ≃* Y) : CommMonCat.of X ≅ CommMonCat.of Y 
goal: AddCommMonCat.of X ≅ AddCommMonCat.of Y

full_name: AddEquiv.toAddCommMonCatIso_hom
code: /-- Build an isomorphism in the category `CommMonCat` from a `MulEquiv` between `CommMonoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddCommMonCatIso]
def MulEquiv.toCommMonCatIso (e : X ≃* Y) : CommMonCat.of X ≅ CommMonCat.of Y 
goal: e.toAddCommMonCatIso.hom = AddCommMonCat.ofHom e.toAddMonoidHom

full_name: AddEquiv.toAddCommMonCatIso_inv
code: /-- Build an isomorphism in the category `CommMonCat` from a `MulEquiv` between `CommMonoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddCommMonCatIso]
def MulEquiv.toCommMonCatIso (e : X ≃* Y) : CommMonCat.of X ≅ CommMonCat.of Y 
goal: e.toAddCommMonCatIso.inv = AddCommMonCat.ofHom e.symm.toAddMonoidHom

full_name: MulEquiv.toCommMonCatIso_hom
code: /-- Build an isomorphism in the category `CommMonCat` from a `MulEquiv` between `CommMonoid`s. -/
@[to_additive (attr := simps) AddEquiv.toAddCommMonCatIso]
def MulEquiv.toCommMonCatIso (e : X ≃* Y) : CommMonCat.of X ≅ CommMonCat.of Y 
goal: e.toCommMonCatIso.hom = CommMonCat.ofHom e.toMonoidHom

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

full_name: CategoryTheory.Iso.addMonCatIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `MonCat`. -/
@[to_additive addMonCatIsoToAddEquiv
      "Build an `AddEquiv` from an isomorphism in the category\n`AddMonCat`."]
def monCatIsoToMulEquiv {X Y : MonCat} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

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

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

full_name: CategoryTheory.Iso.commMonCatIsoToAddEquiv
code: /-- Build a `MulEquiv` from an isomorphism in the category `CommMonCat`. -/
@[to_additive "Build an `AddEquiv` from an isomorphism in the category\n`AddCommMonCat`."]
def commMonCatIsoToMulEquiv {X Y : CommMonCat} (i : X ≅ Y) : X ≃* Y 
goal: ↑X ≃+ ↑Y

full_name: addEquivIsoAddMonCatIso
code: /-- multiplicative equivalences between `Monoid`s are the same as (isomorphic to) isomorphisms
in `MonCat` -/
@[to_additive addEquivIsoAddMonCatIso]
def mulEquivIsoMonCatIso {X Y : Type u} [Monoid X] [Monoid Y] :
    X ≃* Y ≅ MonCat.of X ≅ MonCat.of Y 
goal: X ≃+ Y ≅ AddMonCat.of X ≅ AddMonCat.of Y

full_name: mulEquivIsoMonCatIso
code: /-- multiplicative equivalences between `Monoid`s are the same as (isomorphic to) isomorphisms
in `MonCat` -/
@[to_additive addEquivIsoAddMonCatIso]
def mulEquivIsoMonCatIso {X Y : Type u} [Monoid X] [Monoid Y] :
    X ≃* Y ≅ MonCat.of X ≅ MonCat.of Y 
goal: X ≃* Y ≅ MonCat.of X ≅ MonCat.of Y

full_name: mulEquivIsoCommMonCatIso
code: /-- multiplicative equivalences between `CommMonoid`s are the same as (isomorphic to) isomorphisms
in `CommMonCat` -/
@[to_additive addEquivIsoAddCommMonCatIso]
def mulEquivIsoCommMonCatIso {X Y : Type u} [CommMonoid X] [CommMonoid Y] :
    X ≃* Y ≅ CommMonCat.of X ≅ CommMonCat.of Y 
goal: X ≃* Y ≅ CommMonCat.of X ≅ CommMonCat.of Y

full_name: addEquivIsoAddCommMonCatIso
code: /-- multiplicative equivalences between `CommMonoid`s are the same as (isomorphic to) isomorphisms
in `CommMonCat` -/
@[to_additive addEquivIsoAddCommMonCatIso]
def mulEquivIsoCommMonCatIso {X Y : Type u} [CommMonoid X] [CommMonoid Y] :
    X ≃* Y ≅ CommMonCat.of X ≅ CommMonCat.of Y 
goal: X ≃+ Y ≅ AddCommMonCat.of X ≅ AddCommMonCat.of Y

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

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

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

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

full_name: AddCommMonCat.forget₂_full
code: @[to_additive]
instance CommMonCat.forget₂_full : (forget₂ CommMonCat MonCat).Full 
goal: (CategoryTheory.forget₂ AddCommMonCat AddMonCat).Full

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

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

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

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

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

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

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

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

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