File: Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj_obj_X
code: /-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def functorObj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D 
goal: ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A).obj X).X = A.X.obj X

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj_map_hom
code: /-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def functorObj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A).map f).hom = A.X.map f

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj_obj_mul
code: /-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def functorObj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D 
goal: ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A).obj X).mul = A.mul.app X

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj_obj_one
code: /-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def functorObj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D 
goal: ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A).obj X).one = A.one.app X

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj
code: /-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def functorObj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D 
goal: C ⥤ Mon_ D

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor
code: /-- Functor translating a monoid object in a functor category
to a functor into the category of monoid objects.
-/
@[simps]
def functor : Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D 
goal: Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor_map_app_hom
code: /-- Functor translating a monoid object in a functor category
to a functor into the category of monoid objects.
-/
@[simps]
def functor : Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D 
goal: ∀ {X Y : Mon_ (C ⥤ D)} (f : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor.map f).app X_1).hom = f.hom.app X_1

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor_obj
code: /-- Functor translating a monoid object in a functor category
to a functor into the category of monoid objects.
-/
@[simps]
def functor : Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D 
goal: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor.obj A =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj_one_app
code: /-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).one.app X = (F.obj X).one

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj
code: /-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) 
goal: Mon_ (C ⥤ D)

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj_X
code: /-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).X = F ⋙ Mon_.forget D

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj_mul_app
code: /-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).mul.app X = (F.obj X).mul

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse_obj
code: /-- Functor translating a functor into the category of monoid objects
to a monoid object in the functor category
-/
@[simps]
def inverse : (C ⥤ Mon_ D) ⥤ Mon_ (C ⥤ D) 
goal: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse.obj F =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse_map_hom_app
code: /-- Functor translating a functor into the category of monoid objects
to a monoid object in the functor category
-/
@[simps]
def inverse : (C ⥤ Mon_ D) ⥤ Mon_ (C ⥤ D) 
goal: ∀ {X Y : C ⥤ Mon_ D} (α : X ⟶ Y) (X_1 : C),
  (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse.map α).hom.app X_1 = (α.app X_1).hom

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse
code: /-- Functor translating a functor into the category of monoid objects
to a monoid object in the functor category
-/
@[simps]
def inverse : (C ⥤ Mon_ D) ⥤ Mon_ (C ⥤ D) 
goal: (C ⥤ Mon_ D) ⥤ Mon_ (C ⥤ D)

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso
code: /-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: 𝟭 (Mon_ (C ⥤ D)) ≅
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor ⋙
    CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso_inv_app_hom_app
code: /-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C), (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso.inv.app X).hom.app x = 𝟙 (X.X.obj x)

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso_hom_app_hom_app
code: /-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C), (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso.hom.app X).hom.app x = 𝟙 (X.X.obj x)

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Mon_ D) 
goal: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse ⋙
    CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor ≅
  𝟭 (C ⥤ Mon_ D)

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso_hom_app_app_hom
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Mon_ D) 
goal: ∀ (X_1 : C), ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso.hom.app X).app X_1).hom = 𝟙 (X.obj X_1).X

full_name: CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso_inv_app_app_hom
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Mon_ D) 
goal: ∀ (X_1 : C), ((CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso.inv.app X).app X_1).hom = 𝟙 (X.obj X_1).X

full_name: CategoryTheory.Monoidal.monFunctorCategoryEquivalence
code: /-- When `D` is a monoidal category,
monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the monoid objects of `D`.
-/
@[simps]
def monFunctorCategoryEquivalence : Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D 
goal: Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D

full_name: CategoryTheory.Monoidal.monFunctorCategoryEquivalence_counitIso
code: /-- When `D` is a monoidal category,
monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the monoid objects of `D`.
-/
@[simps]
def monFunctorCategoryEquivalence : Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D 
goal: (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).counitIso =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.counitIso

full_name: CategoryTheory.Monoidal.monFunctorCategoryEquivalence_unitIso
code: /-- When `D` is a monoidal category,
monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the monoid objects of `D`.
-/
@[simps]
def monFunctorCategoryEquivalence : Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D 
goal: (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).unitIso =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso

full_name: CategoryTheory.Monoidal.monFunctorCategoryEquivalence_functor
code: /-- When `D` is a monoidal category,
monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the monoid objects of `D`.
-/
@[simps]
def monFunctorCategoryEquivalence : Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D 
goal: (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).functor =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor

full_name: CategoryTheory.Monoidal.monFunctorCategoryEquivalence_inverse
code: /-- When `D` is a monoidal category,
monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the monoid objects of `D`.
-/
@[simps]
def monFunctorCategoryEquivalence : Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D 
goal: (CategoryTheory.Monoidal.monFunctorCategoryEquivalence C D).inverse =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj
code: /--
A comonoid object in a functor category induces a functor to the category of comonoid objects.
-/
@[simps]
def functorObj (A : Comon_ (C ⥤ D)) : C ⥤ Comon_ D 
goal: C ⥤ Comon_ D

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj_obj_counit
code: /--
A comonoid object in a functor category induces a functor to the category of comonoid objects.
-/
@[simps]
def functorObj (A : Comon_ (C ⥤ D)) : C ⥤ Comon_ D 
goal: ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj A).obj X).counit = A.counit.app X

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj_map_hom
code: /--
A comonoid object in a functor category induces a functor to the category of comonoid objects.
-/
@[simps]
def functorObj (A : Comon_ (C ⥤ D)) : C ⥤ Comon_ D 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj A).map f).hom = A.X.map f

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj_obj_comul
code: /--
A comonoid object in a functor category induces a functor to the category of comonoid objects.
-/
@[simps]
def functorObj (A : Comon_ (C ⥤ D)) : C ⥤ Comon_ D 
goal: ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj A).obj X).comul = A.comul.app X

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj_obj_X
code: /--
A comonoid object in a functor category induces a functor to the category of comonoid objects.
-/
@[simps]
def functorObj (A : Comon_ (C ⥤ D)) : C ⥤ Comon_ D 
goal: ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj A).obj X).X = A.X.obj X

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor_map_app_hom
code: /-- Functor translating a comonoid object in a functor category
to a functor into the category of comonoid objects.
-/
@[simps]
def functor : Comon_ (C ⥤ D) ⥤ C ⥤ Comon_ D 
goal: ∀ {X Y : Comon_ (C ⥤ D)} (f : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor.map f).app X_1).hom = f.hom.app X_1

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor
code: /-- Functor translating a comonoid object in a functor category
to a functor into the category of comonoid objects.
-/
@[simps]
def functor : Comon_ (C ⥤ D) ⥤ C ⥤ Comon_ D 
goal: Comon_ (C ⥤ D) ⥤ C ⥤ Comon_ D

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor_obj
code: /-- Functor translating a comonoid object in a functor category
to a functor into the category of comonoid objects.
-/
@[simps]
def functor : Comon_ (C ⥤ D) ⥤ C ⥤ Comon_ D 
goal: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor.obj A =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj A

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj_comul_app
code: /-- A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Comon_ D) : Comon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj F).comul.app X = (F.obj X).comul

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj_X
code: /-- A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Comon_ D) : Comon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj F).X = F ⋙ Comon_.forget D

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj
code: /-- A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Comon_ D) : Comon_ (C ⥤ D) 
goal: Comon_ (C ⥤ D)

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj_counit_app
code: /-- A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. -/
@[simps]
def inverseObj (F : C ⥤ Comon_ D) : Comon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj F).counit.app X = (F.obj X).counit

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse
code: /-- Functor translating a functor into the category of comonoid objects
to a comonoid object in the functor category
-/
@[simps]
private def inverse : (C ⥤ Comon_ D) ⥤ Comon_ (C ⥤ D) 
goal: (C ⥤ Comon_ D) ⥤ Comon_ (C ⥤ D)

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse_obj
code: /-- Functor translating a functor into the category of comonoid objects
to a comonoid object in the functor category
-/
@[simps]
private def inverse : (C ⥤ Comon_ D) ⥤ Comon_ (C ⥤ D) 
goal: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse.obj F =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj F

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse_map_hom_app
code: /-- Functor translating a functor into the category of comonoid objects
to a comonoid object in the functor category
-/
@[simps]
private def inverse : (C ⥤ Comon_ D) ⥤ Comon_ (C ⥤ D) 
goal: ∀ {X Y : C ⥤ Comon_ D} (α : X ⟶ Y) (X_1 : C),
  (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse.map α).hom.app X_1 = (α.app X_1).hom

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_inv_app_hom_app
code: /-- The unit for the equivalence `Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D`.
-/
@[simps!]
private def unitIso : 𝟭 (Comon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C), (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso.inv.app X).hom.app x = 𝟙 (X.X.obj x)

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_hom_app_hom_app
code: /-- The unit for the equivalence `Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D`.
-/
@[simps!]
private def unitIso : 𝟭 (Comon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C), (CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso.hom.app X).hom.app x = 𝟙 (X.X.obj x)

full_name: _private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso
code: /-- The unit for the equivalence `Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D`.
-/
@[simps!]
private def unitIso : 𝟭 (Comon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: 𝟭 (Comon_ (C ⥤ D)) ≅
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor ⋙
    CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso_hom_app_app_hom
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Comon_ D) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso.hom.app X).app X_1).hom = 𝟙 (X.obj X_1).X

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso_inv_app_app_hom
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Comon_ D) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso.inv.app X).app X_1).hom = 𝟙 (X.obj X_1).X

full_name: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso
code: /-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Comon_ D) 
goal: CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse ⋙
    CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor ≅
  𝟭 (C ⥤ Comon_ D)

full_name: CategoryTheory.Monoidal.comonFunctorCategoryEquivalence_inverse
code: /-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D 
goal: (CategoryTheory.Monoidal.comonFunctorCategoryEquivalence C D).inverse =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.comonFunctorCategoryEquivalence_functor
code: /-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D 
goal: (CategoryTheory.Monoidal.comonFunctorCategoryEquivalence C D).functor =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor

full_name: CategoryTheory.Monoidal.comonFunctorCategoryEquivalence_counitIso
code: /-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D 
goal: (CategoryTheory.Monoidal.comonFunctorCategoryEquivalence C D).counitIso =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.counitIso

full_name: CategoryTheory.Monoidal.comonFunctorCategoryEquivalence
code: /-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D 
goal: Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D

full_name: CategoryTheory.Monoidal.comonFunctorCategoryEquivalence_unitIso
code: /-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D 
goal: (CategoryTheory.Monoidal.comonFunctorCategoryEquivalence C D).unitIso =
  CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_map_app_hom
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: ∀ {X Y : CommMon_ (C ⥤ D)} (f : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.map f).app X_1).hom = f.hom.app X_1

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_map_hom
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: ∀ {X Y : C} (a : X ⟶ Y),
  ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.obj A).map a).hom = A.X.map a

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_mul
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.obj A).obj X).mul = A.mul.app X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_one
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.obj A).obj X).one = A.one.app X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_X
code: /-- Functor translating a commutative monoid object in a functor category
to a functor into the category of commutative monoid objects.
-/
@[simps!]
def functor : CommMon_ (C ⥤ D) ⥤ C ⥤ CommMon_ D 
goal: ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.obj A).obj X).X = A.X.obj X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_map_hom_app
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: ∀ {X Y : C ⥤ CommMon_ D} (α : X ⟶ Y) (X_1 : C),
  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.map α).hom.app X_1 = (α.app X_1).hom

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D)

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mul_app
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.obj F).mul.app X = (F.obj X).mul

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_X_obj
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.obj F).X.obj X =
  ((CommMon_.forget₂Mon_ D).obj (F.obj X)).X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_X_map
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.obj F).X.map f = (F.map f).hom

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_one_app
code: /-- Functor translating a functor into the category of commutative monoid objects
to a commutative monoid object in the functor category
-/
@[simps!]
def inverse : (C ⥤ CommMon_ D) ⥤ CommMon_ (C ⥤ D) 
goal: (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse.obj F).one.app X = (F.obj X).one

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso_inv_app_hom_app
code: /-- The unit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (CommMon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C),
  (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso.inv.app X).hom.app x =
    𝟙 ((CommMon_.forget₂Mon_ D).obj ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.obj X).obj x)).X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso
code: /-- The unit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (CommMon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: 𝟭 (CommMon_ (C ⥤ D)) ≅
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor ⋙
    CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso_hom_app_hom_app
code: /-- The unit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (CommMon_ (C ⥤ D)) ≅ functor ⋙ inverse 
goal: ∀ (x : C), (CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso.hom.app X).hom.app x = 𝟙 (X.X.obj x)

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso
code: /-- The counit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ CommMon_ D) 
goal: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse ⋙
    CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor ≅
  𝟭 (C ⥤ CommMon_ D)

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso_hom_app_app_hom
code: /-- The counit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ CommMon_ D) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso.hom.app X).app X_1).hom =
    𝟙 ((CommMon_.forget₂Mon_ D).obj (X.obj X_1)).X

full_name: CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso_inv_app_app_hom
code: /-- The counit for the equivalence `CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ CommMon_ D) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso.inv.app X).app X_1).hom = 𝟙 (X.obj X_1).X

full_name: CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_unitIso
code: /-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D 
goal: (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).unitIso =
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso

full_name: CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_counitIso
code: /-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D 
goal: (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).counitIso =
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso

full_name: CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_inverse
code: /-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D 
goal: (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).inverse =
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse

full_name: CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_functor
code: /-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D 
goal: (CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).functor =
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor

full_name: CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence
code: /-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D 
goal: CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D