File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

full_name: Mon_.mul_one
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: self.X ◁ self.one ≫ self.mul = (ρ_ self.X).hom

full_name: Mon_
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: Type (max u₁ v₁)

full_name: Mon_.mul
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: self.X ⊗ self.X ⟶ self.X

full_name: Mon_.one
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: 𝟙_ C ⟶ self.X

full_name: Mon_.one_mul
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: self.one ▷ self.X ≫ self.mul = (λ_ self.X).hom

full_name: Mon_.X
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: C

full_name: Mon_.mul_assoc
code: /-- A monoid object internal to a monoidal category.

When the monoidal category is preadditive, this is also sometimes called an "algebra object".
-/
structure Mon_ where
  X : C
  one : 𝟙_ C ⟶ X
  mul : X ⊗ X ⟶ X
  one_mul : (one ▷ X) ≫ mul = (λ_ X).hom := by aesop_cat
  mul_one : (X ◁ one) ≫ mul = (ρ_ X).hom := by aesop_cat
  -- Obviously there is some flexibility stating this axiom.
  -- This one has left- and right-hand sides matching the statement of `Monoid.mul_assoc`,
  -- and chooses to place the associator on the right-hand side.
  -- The heuristic is that unitors and associators "don't have much weight".
  mul_assoc : (mul ▷ X) ≫ mul = (α_ X X X).hom ≫ (X ◁ mul) ≫ mul := by aesop_cat
goal: self.mul ▷ self.X ≫ self.mul = (α_ self.X self.X self.X).hom ≫ self.X ◁ self.mul ≫ self.mul

full_name: Mon_.trivial_X
code: /-- The trivial monoid object. We later show this is initial in `Mon_ C`.
-/
@[simps]
def trivial : Mon_ C 
goal: (Mon_.trivial C).X = 𝟙_ C

full_name: Mon_.trivial_mul
code: /-- The trivial monoid object. We later show this is initial in `Mon_ C`.
-/
@[simps]
def trivial : Mon_ C 
goal: (Mon_.trivial C).mul = (λ_ (𝟙_ C)).hom

full_name: Mon_.trivial
code: /-- The trivial monoid object. We later show this is initial in `Mon_ C`.
-/
@[simps]
def trivial : Mon_ C 
goal: Mon_ C

full_name: Mon_.trivial_one
code: /-- The trivial monoid object. We later show this is initial in `Mon_ C`.
-/
@[simps]
def trivial : Mon_ C 
goal: (Mon_.trivial C).one = 𝟙 (𝟙_ C)

full_name: Mon_.instInhabited
code: instance : Inhabited (Mon_ C) 
goal: Inhabited (Mon_ C)

full_name: Mon_.one_mul_hom
code: @[simp]
theorem one_mul_hom {Z : C} (f : Z ⟶ M.X) : (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f 
goal: (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f

full_name: Mon_.mul_one_hom
code: @[simp]
theorem mul_one_hom {Z : C} (f : Z ⟶ M.X) : (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f 
goal: (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f

full_name: Mon_.mul_assoc_flip
code: theorem mul_assoc_flip :
    (M.X ◁ M.mul) ≫ M.mul = (α_ M.X M.X M.X).inv ≫ (M.mul ▷ M.X) ≫ M.mul 
goal: M.X ◁ M.mul ≫ M.mul = (α_ M.X M.X M.X).inv ≫ M.mul ▷ M.X ≫ M.mul

full_name: Mon_.Hom
code: /-- A morphism of monoid objects. -/
@[ext]
structure Hom (M N : Mon_ C) where
  hom : M.X ⟶ N.X
  one_hom : M.one ≫ hom = N.one := by aesop_cat
  mul_hom : M.mul ≫ hom = (hom ⊗ hom) ≫ N.mul := by aesop_cat
goal: Type v₁

full_name: Mon_.Hom.mul_hom
code: /-- A morphism of monoid objects. -/
@[ext]
structure Hom (M N : Mon_ C) where
  hom : M.X ⟶ N.X
  one_hom : M.one ≫ hom = N.one := by aesop_cat
  mul_hom : M.mul ≫ hom = (hom ⊗ hom) ≫ N.mul := by aesop_cat
goal: M.mul ≫ self.hom = (self.hom ⊗ self.hom) ≫ N.mul

full_name: Mon_.Hom.hom
code: /-- A morphism of monoid objects. -/
@[ext]
structure Hom (M N : Mon_ C) where
  hom : M.X ⟶ N.X
  one_hom : M.one ≫ hom = N.one := by aesop_cat
  mul_hom : M.mul ≫ hom = (hom ⊗ hom) ≫ N.mul := by aesop_cat
goal: M.X ⟶ N.X

full_name: Mon_.Hom.one_hom
code: /-- A morphism of monoid objects. -/
@[ext]
structure Hom (M N : Mon_ C) where
  hom : M.X ⟶ N.X
  one_hom : M.one ≫ hom = N.one := by aesop_cat
  mul_hom : M.mul ≫ hom = (hom ⊗ hom) ≫ N.mul := by aesop_cat
goal: M.one ≫ self.hom = N.one

full_name: Mon_.id
code: /-- The identity morphism on a monoid object. -/
@[simps]
def id (M : Mon_ C) : Hom M M 
goal: M.Hom M

full_name: Mon_.id_hom
code: /-- The identity morphism on a monoid object. -/
@[simps]
def id (M : Mon_ C) : Hom M M 
goal: M.id.hom = 𝟙 M.X

full_name: Mon_.homInhabited
code: instance homInhabited (M : Mon_ C) : Inhabited (Hom M M) 
goal: Inhabited (M.Hom M)

full_name: Mon_.comp_hom
code: /-- Composition of morphisms of monoid objects. -/
@[simps]
def comp {M N O : Mon_ C} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: (Mon_.comp f g).hom = f.hom ≫ g.hom

full_name: Mon_.comp
code: /-- Composition of morphisms of monoid objects. -/
@[simps]
def comp {M N O : Mon_ C} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: M.Hom O

full_name: Mon_.instCategory
code: instance : Category (Mon_ C) 
goal: CategoryTheory.Category.{v₁, max u₁ v₁} (Mon_ C)

full_name: Mon_.ext
code: @[ext]
lemma ext {X Y : Mon_ C} {f g : X ⟶ Y} (w : f.hom = g.hom) : f = g 
goal: f = g

full_name: Mon_.id_hom'
code: @[simp]
theorem id_hom' (M : Mon_ C) : (𝟙 M : Hom M M).hom = 𝟙 M.X 
goal: (𝟙 M).hom = 𝟙 M.X

full_name: Mon_.comp_hom'
code: @[simp]
theorem comp_hom' {M N K : Mon_ C} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : Hom M K).hom = f.hom ≫ g.hom 
goal: (f ≫ g).hom = f.hom ≫ g.hom

full_name: Mon_.forget_obj
code: /-- The forgetful functor from monoid objects to the ambient category. -/
@[simps]
def forget : Mon_ C ⥤ C 
goal: (Mon_.forget C).obj A = A.X

full_name: Mon_.forget
code: /-- The forgetful functor from monoid objects to the ambient category. -/
@[simps]
def forget : Mon_ C ⥤ C 
goal: Mon_ C ⥤ C

full_name: Mon_.forget_map
code: /-- The forgetful functor from monoid objects to the ambient category. -/
@[simps]
def forget : Mon_ C ⥤ C 
goal: ∀ {X Y : Mon_ C} (f : X ⟶ Y), (Mon_.forget C).map f = f.hom

full_name: Mon_.forget_faithful
code: instance forget_faithful : (forget C).Faithful 
goal: (Mon_.forget C).Faithful

full_name: Mon_.instIsIsoHomOfMapForget
code: instance {A B : Mon_ C} (f : A ⟶ B) [e : IsIso ((forget C).map f)] : IsIso f.hom 
goal: CategoryTheory.IsIso f.hom

full_name: Mon_.instReflectsIsomorphismsForget
code: /-- The forgetful functor from monoid objects to the ambient category reflects isomorphisms. -/
instance : (forget C).ReflectsIsomorphisms 
goal: (Mon_.forget C).ReflectsIsomorphisms

full_name: Mon_.mkIso_inv_hom
code: /-- Construct an isomorphism of monoids by giving an isomorphism between the underlying objects
and checking compatibility with unit and multiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one := by aesop_cat)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul := by aesop_cat) : M ≅ N 
goal: (Mon_.mkIso f one_f mul_f).inv.hom = f.inv

full_name: Mon_.mkIso
code: /-- Construct an isomorphism of monoids by giving an isomorphism between the underlying objects
and checking compatibility with unit and multiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one := by aesop_cat)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul := by aesop_cat) : M ≅ N 
goal: M ≅ N

full_name: Mon_.mkIso_hom_hom
code: /-- Construct an isomorphism of monoids by giving an isomorphism between the underlying objects
and checking compatibility with unit and multiplication only in the forward direction.
-/
@[simps]
def mkIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one := by aesop_cat)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul := by aesop_cat) : M ≅ N 
goal: (Mon_.mkIso f one_f mul_f).hom.hom = f.hom

full_name: Mon_.uniqueHomFromTrivial
code: instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) 
goal: Unique (Mon_.trivial C ⟶ A)

full_name: Mon_.instHasInitial
code: instance : HasInitial (Mon_ C) 
goal: CategoryTheory.Limits.HasInitial (Mon_ C)

full_name: CategoryTheory.LaxMonoidalFunctor.mapMon_obj_mul
code: /-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D 
goal: (F.mapMon.obj A).mul = F.μ A.X A.X ≫ F.map A.mul

full_name: CategoryTheory.LaxMonoidalFunctor.mapMon_obj_one
code: /-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D 
goal: (F.mapMon.obj A).one = F.ε ≫ F.map A.one

full_name: CategoryTheory.LaxMonoidalFunctor.mapMon_map_hom
code: /-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D 
goal: ∀ {X Y : Mon_ C} (f : X ⟶ Y), (F.mapMon.map f).hom = F.map f.hom

full_name: CategoryTheory.LaxMonoidalFunctor.mapMon_obj_X
code: /-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D 
goal: (F.mapMon.obj A).X = F.obj A.X

full_name: CategoryTheory.LaxMonoidalFunctor.mapMon
code: /-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D 
goal: Mon_ C ⥤ Mon_ D

full_name: CategoryTheory.LaxMonoidalFunctor.mapMonFunctor_obj
code: /-- `mapMon` is functorial in the lax monoidal functor. -/
@[simps] -- Porting note: added this, not sure how it worked previously without.
def mapMonFunctor : LaxMonoidalFunctor C D ⥤ Mon_ C ⥤ Mon_ D 
goal: (CategoryTheory.LaxMonoidalFunctor.mapMonFunctor C D).obj F = F.mapMon

full_name: CategoryTheory.LaxMonoidalFunctor.mapMonFunctor_map_app_hom
code: /-- `mapMon` is functorial in the lax monoidal functor. -/
@[simps] -- Porting note: added this, not sure how it worked previously without.
def mapMonFunctor : LaxMonoidalFunctor C D ⥤ Mon_ C ⥤ Mon_ D 
goal: ∀ {X Y : CategoryTheory.LaxMonoidalFunctor C D} (α : X ⟶ Y) (A : Mon_ C),
  (((CategoryTheory.LaxMonoidalFunctor.mapMonFunctor C D).map α).app A).hom = α.app A.X

full_name: CategoryTheory.LaxMonoidalFunctor.mapMonFunctor
code: /-- `mapMon` is functorial in the lax monoidal functor. -/
@[simps] -- Porting note: added this, not sure how it worked previously without.
def mapMonFunctor : LaxMonoidalFunctor C D ⥤ Mon_ C ⥤ Mon_ D 
goal: CategoryTheory.LaxMonoidalFunctor C D ⥤ Mon_ C ⥤ Mon_ D

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon_map
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def laxMonoidalToMon : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ⥤ Mon_ C 
goal: ∀ {X Y : CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C} (α : X ⟶ Y),
  (Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C).map α =
    ((CategoryTheory.LaxMonoidalFunctor.mapMonFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C).map α).app
      (Mon_.trivial (CategoryTheory.Discrete PUnit.{u + 1}))

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def laxMonoidalToMon : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ⥤ Mon_ C 
goal: CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C ⥤ Mon_ C

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon_obj
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def laxMonoidalToMon : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ⥤ Mon_ C 
goal: (Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C).obj F =
  F.mapMon.obj (Mon_.trivial (CategoryTheory.Discrete PUnit.{u + 1}))

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_obj_toFunctor_map
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: ∀ {X Y : CategoryTheory.Discrete PUnit.{u + 1}} (x : X ⟶ Y),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C).obj A).map x = 𝟙 ((fun x => A.X) X)

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_obj_μ
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: ∀ (x x_1 : CategoryTheory.Discrete PUnit.{u + 1}),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C).obj A).μ x x_1 = A.mul

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: Mon_ C ⥤ CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_map_toNatTrans_app
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: ∀ {X Y : Mon_ C} (f : X ⟶ Y) (x : CategoryTheory.Discrete PUnit.{u + 1}),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C).map f).app x = f.hom

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_obj_toFunctor_obj
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: ∀ (x : CategoryTheory.Discrete PUnit.{u + 1}),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C).obj A).obj x = A.X

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_obj_ε
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C 
goal: ((Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C).obj A).ε = A.one

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.unitIso
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def unitIso :
    𝟭 (LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C) ≅ laxMonoidalToMon C ⋙ monToLaxMonoidal C 
goal: 𝟭 (CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C) ≅
  Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C ⋙ Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.unitIso_inv_app_toNatTrans_app
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def unitIso :
    𝟭 (LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C) ≅ laxMonoidalToMon C ⋙ monToLaxMonoidal C 
goal: ∀ (X_1 : CategoryTheory.Discrete PUnit.{u + 1}),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.unitIso C).inv.app X).app X_1 =
    𝟙 (X.obj (𝟙_ (CategoryTheory.Discrete PUnit.{u + 1})))

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.unitIso_hom_app_toNatTrans_app
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def unitIso :
    𝟭 (LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C) ≅ laxMonoidalToMon C ⋙ monToLaxMonoidal C 
goal: ∀ (X_1 : CategoryTheory.Discrete PUnit.{u + 1}),
  ((Mon_.EquivLaxMonoidalFunctorPUnit.unitIso C).hom.app X).app X_1 = 𝟙 (X.obj X_1)

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.counitIso
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def counitIso : monToLaxMonoidal C ⋙ laxMonoidalToMon C ≅ 𝟭 (Mon_ C) 
goal: Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C ⋙ Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C ≅ 𝟭 (Mon_ C)

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.counitIso_inv_app_hom
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def counitIso : monToLaxMonoidal C ⋙ laxMonoidalToMon C ≅ 𝟭 (Mon_ C) 
goal: ((Mon_.EquivLaxMonoidalFunctorPUnit.counitIso C).inv.app X).hom = 𝟙 X.X

full_name: Mon_.EquivLaxMonoidalFunctorPUnit.counitIso_hom_app_hom
code: /-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps!]
def counitIso : monToLaxMonoidal C ⋙ laxMonoidalToMon C ≅ 𝟭 (Mon_ C) 
goal: ((Mon_.EquivLaxMonoidalFunctorPUnit.counitIso C).hom.app X).hom = 𝟙 X.X

full_name: Mon_.equivLaxMonoidalFunctorPUnit_inverse
code: /--
Monoid objects in `C` are "just" lax monoidal functors from the trivial monoidal category to `C`.
-/
@[simps]
def equivLaxMonoidalFunctorPUnit : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ≌ Mon_ C 
goal: (Mon_.equivLaxMonoidalFunctorPUnit C).inverse = Mon_.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal C

full_name: Mon_.equivLaxMonoidalFunctorPUnit_unitIso
code: /--
Monoid objects in `C` are "just" lax monoidal functors from the trivial monoidal category to `C`.
-/
@[simps]
def equivLaxMonoidalFunctorPUnit : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ≌ Mon_ C 
goal: (Mon_.equivLaxMonoidalFunctorPUnit C).unitIso = Mon_.EquivLaxMonoidalFunctorPUnit.unitIso C

full_name: Mon_.equivLaxMonoidalFunctorPUnit
code: /--
Monoid objects in `C` are "just" lax monoidal functors from the trivial monoidal category to `C`.
-/
@[simps]
def equivLaxMonoidalFunctorPUnit : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ≌ Mon_ C 
goal: CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{u + 1}) C ≌ Mon_ C

full_name: Mon_.equivLaxMonoidalFunctorPUnit_functor
code: /--
Monoid objects in `C` are "just" lax monoidal functors from the trivial monoidal category to `C`.
-/
@[simps]
def equivLaxMonoidalFunctorPUnit : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ≌ Mon_ C 
goal: (Mon_.equivLaxMonoidalFunctorPUnit C).functor = Mon_.EquivLaxMonoidalFunctorPUnit.laxMonoidalToMon C

full_name: Mon_.equivLaxMonoidalFunctorPUnit_counitIso
code: /--
Monoid objects in `C` are "just" lax monoidal functors from the trivial monoidal category to `C`.
-/
@[simps]
def equivLaxMonoidalFunctorPUnit : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ≌ Mon_ C 
goal: (Mon_.equivLaxMonoidalFunctorPUnit C).counitIso = Mon_.EquivLaxMonoidalFunctorPUnit.counitIso C

full_name: Mon_.one_associator
code: theorem one_associator {M N P : Mon_ C} :
    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)) 
goal: ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one))

full_name: Mon_.one_leftUnitor
code: theorem one_leftUnitor {M : Mon_ C} :
    ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one 
goal: ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one

full_name: Mon_.one_rightUnitor
code: theorem one_rightUnitor {M : Mon_ C} :
    ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one 
goal: ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one

full_name: Mon_.Mon_tensor_one_mul
code: theorem Mon_tensor_one_mul (M N : Mon_ C) :
    (((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ▷ (M.X ⊗ N.X)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
      (λ_ (M.X ⊗ N.X)).hom 
goal: ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ▷ (M.X ⊗ N.X) ≫ CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
  (λ_ (M.X ⊗ N.X)).hom

full_name: Mon_.Mon_tensor_mul_one
code: theorem Mon_tensor_mul_one (M N : Mon_ C) :
    (M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
      (ρ_ (M.X ⊗ N.X)).hom 
goal: (M.X ⊗ N.X) ◁ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫ CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
  (ρ_ (M.X ⊗ N.X)).hom

full_name: Mon_.Mon_tensor_mul_assoc
code: theorem Mon_tensor_mul_assoc (M N : Mon_ C) :
    ((tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ▷ (M.X ⊗ N.X)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
      (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
        ((M.X ⊗ N.X) ◁ (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))) ≫
          tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) 
goal: (CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ▷ (M.X ⊗ N.X) ≫
    CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
  (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
    (M.X ⊗ N.X) ◁ (CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
      CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)

full_name: Mon_.mul_associator
code: theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)) 
goal: (CategoryTheory.tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
    (α_ M.X N.X P.X).hom =
  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
    CategoryTheory.tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
      (M.mul ⊗ CategoryTheory.tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))

full_name: Mon_.mul_leftUnitor
code: theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul 
goal: (CategoryTheory.tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
  ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul

full_name: Mon_.mul_rightUnitor
code: theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul 
goal: (CategoryTheory.tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
  ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul

full_name: Mon_.monMonoidalStruct
code: @[simps tensorObj_X tensorHom_hom]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) 
goal: CategoryTheory.MonoidalCategoryStruct (Mon_ C)

full_name: Mon_.monMonoidalStruct_tensorObj_X
code: @[simps tensorObj_X tensorHom_hom]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) 
goal: (M ⊗ N).X = M.X ⊗ N.X

full_name: Mon_.monMonoidalStruct_tensorHom_hom
code: @[simps tensorObj_X tensorHom_hom]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) 
goal: ∀ {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂), (f ⊗ g).hom = f.hom ⊗ g.hom

full_name: Mon_.tensorUnit_X
code: @[simp]
theorem tensorUnit_X : (𝟙_ (Mon_ C)).X = 𝟙_ C 
goal: (𝟙_ (Mon_ C)).X = 𝟙_ C

full_name: Mon_.tensorUnit_one
code: @[simp]
theorem tensorUnit_one : (𝟙_ (Mon_ C)).one = 𝟙 (𝟙_ C) 
goal: (𝟙_ (Mon_ C)).one = 𝟙 (𝟙_ C)

full_name: Mon_.tensorUnit_mul
code: @[simp]
theorem tensorUnit_mul : (𝟙_ (Mon_ C)).mul = (λ_ (𝟙_ C)).hom 
goal: (𝟙_ (Mon_ C)).mul = (λ_ (𝟙_ C)).hom

full_name: Mon_.tensorObj_one
code: @[simp]
theorem tensorObj_one (X Y : Mon_ C) : (X ⊗ Y).one = (λ_ (𝟙_ C)).inv ≫ (X.one ⊗ Y.one) 
goal: (X ⊗ Y).one = (λ_ (𝟙_ C)).inv ≫ (X.one ⊗ Y.one)

full_name: Mon_.tensorObj_mul
code: @[simp]
theorem tensorObj_mul (X Y : Mon_ C) :
    (X ⊗ Y).mul = tensor_μ C (X.X, Y.X) (X.X, Y.X) ≫ (X.mul ⊗ Y.mul) 
goal: (X ⊗ Y).mul = CategoryTheory.tensor_μ C (X.X, Y.X) (X.X, Y.X) ≫ (X.mul ⊗ Y.mul)

full_name: Mon_.whiskerLeft_hom
code: @[simp]
theorem whiskerLeft_hom {X Y : Mon_ C} (f : X ⟶ Y) (Z : Mon_ C) :
    (f ▷ Z).hom = f.hom ▷ Z.X 
goal: (f ▷ Z).hom = f.hom ▷ Z.X

full_name: Mon_.whiskerRight_hom
code: @[simp]
theorem whiskerRight_hom (X : Mon_ C) {Y Z : Mon_ C} (f : Y ⟶ Z) :
    (X ◁ f).hom = X.X ◁ f.hom 
goal: (X ◁ f).hom = X.X ◁ f.hom

full_name: Mon_.leftUnitor_hom_hom
code: @[simp]
theorem leftUnitor_hom_hom (X : Mon_ C) : (λ_ X).hom.hom = (λ_ X.X).hom 
goal: (λ_ X).hom.hom = (λ_ X.X).hom

full_name: Mon_.leftUnitor_inv_hom
code: @[simp]
theorem leftUnitor_inv_hom (X : Mon_ C) : (λ_ X).inv.hom = (λ_ X.X).inv 
goal: (λ_ X).inv.hom = (λ_ X.X).inv

full_name: Mon_.rightUnitor_hom_hom
code: @[simp]
theorem rightUnitor_hom_hom (X : Mon_ C) : (ρ_ X).hom.hom = (ρ_ X.X).hom 
goal: (ρ_ X).hom.hom = (ρ_ X.X).hom

full_name: Mon_.rightUnitor_inv_hom
code: @[simp]
theorem rightUnitor_inv_hom (X : Mon_ C) : (ρ_ X).inv.hom = (ρ_ X.X).inv 
goal: (ρ_ X).inv.hom = (ρ_ X.X).inv

full_name: Mon_.associator_hom_hom
code: @[simp]
theorem associator_hom_hom (X Y Z : Mon_ C) : (α_ X Y Z).hom.hom = (α_ X.X Y.X Z.X).hom 
goal: (α_ X Y Z).hom.hom = (α_ X.X Y.X Z.X).hom

full_name: Mon_.associator_inv_hom
code: @[simp]
theorem associator_inv_hom (X Y Z : Mon_ C) : (α_ X Y Z).inv.hom = (α_ X.X Y.X Z.X).inv 
goal: (α_ X Y Z).inv.hom = (α_ X.X Y.X Z.X).inv

full_name: Mon_.tensor_one
code: @[simp]
theorem tensor_one (M N : Mon_ C) : (M ⊗ N).one = (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) 
goal: (M ⊗ N).one = (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)

full_name: Mon_.tensor_mul
code: @[simp]
theorem tensor_mul (M N : Mon_ C) : (M ⊗ N).mul =
    tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) 
goal: (M ⊗ N).mul = CategoryTheory.tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)

full_name: Mon_.monMonoidal
code: instance monMonoidal : MonoidalCategory (Mon_ C) 
goal: CategoryTheory.MonoidalCategory (Mon_ C)

full_name: Mon_.forgetMonoidal
code: /-- The forgetful functor from `Mon_ C` to `C` is monoidal when `C` is braided monoidal. -/
def forgetMonoidal : MonoidalFunctor (Mon_ C) C 
goal: CategoryTheory.MonoidalFunctor (Mon_ C) C

full_name: Mon_.forgetMonoidal_toFunctor
code: @[simp] theorem forgetMonoidal_toFunctor : (forgetMonoidal C).toFunctor = forget C 
goal: (Mon_.forgetMonoidal C).toFunctor = Mon_.forget C

full_name: Mon_.forgetMonoidal_ε
code: @[simp] theorem forgetMonoidal_ε : (forgetMonoidal C).ε = 𝟙 (𝟙_ C) 
goal: (Mon_.forgetMonoidal C).ε = 𝟙 (𝟙_ C)

full_name: Mon_.forgetMonoidal_μ
code: @[simp] theorem forgetMonoidal_μ (X Y : Mon_ C) : (forgetMonoidal C).μ X Y = 𝟙 (X.X ⊗ Y.X) 
goal: (Mon_.forgetMonoidal C).μ X Y = 𝟙 (X.X ⊗ Y.X)

full_name: Mon_.one_braiding
code: theorem one_braiding {X Y : Mon_ C} : (X ⊗ Y).one ≫ (β_ X.X Y.X).hom = (Y ⊗ X).one 
goal: (X ⊗ Y).one ≫ (β_ X.X Y.X).hom = (Y ⊗ X).one

full_name: Mon_.mul_braiding
code: theorem mul_braiding {X Y : Mon_ C} :
    (X ⊗ Y).mul ≫ (β_ X.X Y.X).hom = ((β_ X.X Y.X).hom ⊗ (β_ X.X Y.X).hom) ≫ (Y ⊗ X).mul 
goal: (X ⊗ Y).mul ≫ (β_ X.X Y.X).hom = ((β_ X.X Y.X).hom ⊗ (β_ X.X Y.X).hom) ≫ (Y ⊗ X).mul

full_name: Mon_.instSymmetricCategory
code: instance : SymmetricCategory (Mon_ C) 
goal: CategoryTheory.SymmetricCategory (Mon_ C)