l3lab/ntp-mathlib huggingface dataset:
/-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def Functor.obj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D where
  obj X :=
    { X := A.X.obj X
      one := A.one.app X
      mul := A.mul.app X
      one_mul := congr_app A.one_mul X
      mul_one := congr_app A.mul_one X
      mul_assoc := congr_app A.mul_assoc X }
  map f :=
    { hom := A.X.map f
      one_hom := by rw [← A.one.naturality, tensorUnit_map]; dsimp; rw [Category.id_comp]
      mul_hom := by dsimp; rw [← A.mul.naturality, tensorObj_map] }
  map_id X := by ext; dsimp; rw [CategoryTheory.Functor.map_id]
  map_comp f g := by ext; 

Proof state:
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun X => Mon_.mk (A.X.obj X) (A.one.app X) (A.mul.app X),
            map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
        (f ≫ g)).hom =
    ({ obj := fun X => Mon_.mk (A.X.obj X) (A.one.app X) (A.mul.app X),
              map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
          f ≫
        { obj := fun X => Mon_.mk (A.X.obj X) (A.one.app X) (A.mul.app X),
              map := fun {X Y} f => Mon_.Hom.mk (A.X.map f) }.map
          g).hom

Next tactic:
dsimp
/-- A monoid object in a functor category induces a functor to the category of monoid objects. -/
@[simps]
def Functor.obj (A : Mon_ (C ⥤ D)) : C ⥤ Mon_ D where
  obj X :=
    { X := A.X.obj X
      one := A.one.app X
      mul := A.mul.app X
      one_mul := congr_app A.one_mul X
      mul_one := congr_app A.mul_one X
      mul_assoc := congr_app A.mul_assoc X }
  map f :=
    { hom := A.X.map f
      one_hom := by rw [← A.one.naturality, tensorUnit_map]; dsimp; rw [Category.id_comp]
      mul_hom := by dsimp; rw [← A.mul.naturality, tensorObj_map] }
  map_id X := by ext; dsimp; rw [CategoryTheory.Functor.map_id]
  map_comp f g := by ext; dsimp; 

Proof state:
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ A.X.map (f ≫ g) = A.X.map f ≫ A.X.map g

Next tactic:
rw [Functor.map_comp]
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ (((NatTrans.mk fun X => (F.obj X).one) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (λ_ (F ⋙ Mon_.forget D)).hom

Next tactic:
ext X
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ (((NatTrans.mk fun X => (F.obj X).one) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul).app X =
    (λ_ (F ⋙ Mon_.forget D)).hom.app X

Next tactic:
exact (F.obj X).one_mul
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by ext X; exact (F.obj X).one_mul
  mul_one := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ ((𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).one) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (ρ_ (F ⋙ Mon_.forget D)).hom

Next tactic:
ext X
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by ext X; exact (F.obj X).one_mul
  mul_one := by ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ ((𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).one) ≫ NatTrans.mk fun X => (F.obj X).mul).app X =
    (ρ_ (F ⋙ Mon_.forget D)).hom.app X

Next tactic:
exact (F.obj X).mul_one
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by ext X; exact (F.obj X).one_mul
  mul_one := by ext X; exact (F.obj X).mul_one
  mul_assoc := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
⊢ (((NatTrans.mk fun X => (F.obj X).mul) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul) =
    (α_ (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D)).hom ≫
      (𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).mul) ≫ NatTrans.mk fun X => (F.obj X).mul

Next tactic:
ext X
/-- A functor to the category of monoid objects can be translated as a monoid object
in the functor category. -/
@[simps]
def Inverse.obj (F : C ⥤ Mon_ D) : Mon_ (C ⥤ D) where
  X := F ⋙ Mon_.forget D
  one := { app := fun X => (F.obj X).one }
  mul := { app := fun X => (F.obj X).mul }
  one_mul := by ext X; exact (F.obj X).one_mul
  mul_one := by ext X; exact (F.obj X).mul_one
  mul_assoc := by ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : C ⥤ Mon_ D
X : C
⊢ (((NatTrans.mk fun X => (F.obj X).mul) ⊗ 𝟙 (F ⋙ Mon_.forget D)) ≫ NatTrans.mk fun X => (F.obj X).mul).app X =
    ((α_ (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D) (F ⋙ Mon_.forget D)).hom ≫
          (𝟙 (F ⋙ Mon_.forget D) ⊗ NatTrans.mk fun X => (F.obj X).mul) ≫ NatTrans.mk fun X => (F.obj X).mul).app
      X

Next tactic:
exact (F.obj X).mul_assoc
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
⊢ ((Inverse.obj X✝).one ≫ NatTrans.mk fun X => (α.app X).hom) = (Inverse.obj Y✝).one

Next tactic:
ext x
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by ext x; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ ((Inverse.obj X✝).one ≫ NatTrans.mk fun X => (α.app X).hom).app x = (Inverse.obj Y✝).one.app x

Next tactic:
dsimp
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by ext x; dsimp; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ (X✝.obj x).one ≫ (α.app x).hom = (Y✝.obj x).one

Next tactic:
rw [(α.app x).one_hom]
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by ext x; dsimp; rw [(α.app x).one_hom]
      mul_hom := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
⊢ ((Inverse.obj X✝).mul ≫ NatTrans.mk fun X => (α.app X).hom) =
    ((NatTrans.mk fun X => (α.app X).hom) ⊗ NatTrans.mk fun X => (α.app X).hom) ≫ (Inverse.obj Y✝).mul

Next tactic:
ext x
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by ext x; dsimp; rw [(α.app x).one_hom]
      mul_hom := by ext x; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ ((Inverse.obj X✝).mul ≫ NatTrans.mk fun X => (α.app X).hom).app x =
    (((NatTrans.mk fun X => (α.app X).hom) ⊗ NatTrans.mk fun X => (α.app X).hom) ≫ (Inverse.obj Y✝).mul).app x

Next tactic:
dsimp
/-- 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) where
  obj := Inverse.obj
  map α :=
    { hom :=
        { app := fun X => (α.app X).hom
          naturality := fun X Y f => congr_arg Mon_.Hom.hom (α.naturality f) }
      one_hom := by ext x; dsimp; rw [(α.app x).one_hom]
      mul_hom := by ext x; dsimp; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : C ⥤ Mon_ D
α : X✝ ⟶ Y✝
x : C
⊢ (X✝.obj x).mul ≫ (α.app x).hom = ((α.app x).hom ⊗ (α.app x).hom) ≫ (Y✝.obj x).mul

Next tactic:
rw [(α.app x).mul_hom]
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) =
    ((functor ⋙ inverse).obj A).one

Next tactic:
ext X
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)).app X =
    ((functor ⋙ inverse).obj A).one.app X

Next tactic:
dsimp
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ A.one.app X ≫ 𝟙 (A.X.obj X) = A.one.app X

Next tactic:
simp only [Category.comp_id]
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ≫
      ((functor ⋙ inverse).obj A).mul

Next tactic:
ext X
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ (((𝟭 (Mon_ (C ⥤ D))).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)).app X =
    (((NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ⊗
            NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)) ≫
          ((functor ⋙ inverse).obj A).mul).app
      X

Next tactic:
dsimp
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ A.mul.app X ≫ 𝟙 (A.X.obj X) = (𝟙 (A.X.obj X) ⊗ 𝟙 (A.X.obj X)) ≫ A.mul.app X

Next tactic:
simp only [tensor_id, Category.id_comp, Category.comp_id]
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((𝟭 (Mon_ (C ⥤ D))).obj A).one

Next tactic:
ext X
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ (((functor ⋙ inverse).obj A).one ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)).app X =
    ((𝟭 (Mon_ (C ⥤ D))).obj A).one.app X

Next tactic:
dsimp
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; 

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ A.one.app X ≫ 𝟙 (A.X.obj X) = A.one.app X

Next tactic:
simp only [Category.comp_id]
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
⊢ (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) =
    ((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
        NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
      ((𝟭 (Mon_ (C ⥤ D))).obj A).mul

Next tactic:
ext X
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X
              

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ (((functor ⋙ inverse).obj A).mul ≫ NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)).app X =
    (((NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ⊗
            NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x)) ≫
          ((𝟭 (Mon_ (C ⥤ D))).obj A).mul).app
      X

Next tactic:
dsimp
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X
              dsimp
              

Proof state:
case w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : Mon_ (C ⥤ D)
X : C
⊢ A.mul.app X ≫ 𝟙 (A.X.obj X) = (𝟙 (A.X.obj X) ⊗ 𝟙 (A.X.obj X)) ≫ A.mul.app X

Next tactic:
simp only [tensor_id, Category.id_comp, Category.comp_id]
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X
              dsimp
              simp only [tensor_id, Category.id_comp, Category.comp_id] } })
    fun f => by
      

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : Mon_ (C ⥤ D)
f : X✝ ⟶ Y✝
⊢ (𝟭 (Mon_ (C ⥤ D))).map f ≫
      ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          Y✝).hom =
    ((fun A =>
            Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
              (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
          X✝).hom ≫
      (functor ⋙ inverse).map f

Next tactic:
ext X
/-- The unit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def unitIso : 𝟭 (Mon_ (C ⥤ D)) ≅ functor ⋙ inverse :=
  NatIso.ofComponents
    (fun A =>
      { hom :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X; dsimp; simp only [tensor_id, Category.id_comp, Category.comp_id] }
        inv :=
          { hom := { app := fun _ => 𝟙 _ }
            one_hom := by ext X; dsimp; simp only [Category.comp_id]
            mul_hom := by
              ext X
              dsimp
              simp only [tensor_id, Category.id_comp, Category.comp_id] } })
    fun f => by
      ext X
      

Proof state:
case w.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
X✝ Y✝ : Mon_ (C ⥤ D)
f : X✝ ⟶ Y✝
X : C
⊢ ((𝟭 (Mon_ (C ⥤ D))).map f ≫
            ((fun A =>
                  Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
                    (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
                Y✝).hom).hom.app
      X =
    (((fun A =>
                  Iso.mk (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((𝟭 (Mon_ (C ⥤ D))).obj A).X.obj x)))
                    (Mon_.Hom.mk (NatTrans.mk fun x => 𝟙 (((functor ⋙ inverse).obj A).X.obj x))))
                X✝).hom ≫
            (functor ⋙ inverse).map f).hom.app
      X

Next tactic:
simp only [Functor.id_map, Mon_.comp_hom', NatTrans.comp_app, Category.comp_id,
        Functor.comp_map, inverse_map_hom_app, functor_map_app_hom, Category.id_comp]
/-- The counit for the equivalence `Mon_ (C ⥤ D) ≌ C ⥤ Mon_ D`.
-/
@[simps!]
def counitIso : inverse ⋙ functor ≅ 𝟭 (C ⥤ Mon_ D) :=
  NatIso.ofComponents
    (fun A =>
      NatIso.ofComponents
        (fun X =>
          { hom := { hom := 𝟙 _ }
            inv := { hom := 𝟙 _ } })
        (by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
A : C ⥤ Mon_ D
⊢ ∀ {X Y : C} (f : X ⟶ Y),
    ((inverse ⋙ functor).obj A).map f ≫
        ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            Y).hom =
      ((fun X =>
              Iso.mk (Mon_.Hom.mk (𝟙 (((inverse ⋙ functor).obj A).obj X).X))
                (Mon_.Hom.mk (𝟙 (((𝟭 (C ⥤ Mon_ D)).obj A).obj X).X)))
            X).hom ≫
        ((𝟭 (C ⥤ Mon_ D)).obj A).map f

Next tactic:
aesop_cat