l3lab/ntp-mathlib huggingface dataset:
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul

Next tactic:
slice_rhs 1 3 => rw [← F.associativity]
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => 

Proof state:
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ μ F A.X (A.X ⊗ A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.mul)
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul

Next tactic:
rw [← F.associativity]
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (((μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫
      F.map A.mul

Next tactic:
simp only [Category.assoc]
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by 

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) X✝).one ≫ F.map f.hom =
    ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) Y✝).one

Next tactic:
dsimp
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; 

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ (F.ε ≫ F.map X✝.one) ≫ F.map f.hom = F.ε ≫ F.map Y✝.one

Next tactic:
rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) X✝).mul ≫ F.map f.hom =
    (F.map f.hom ⊗ F.map f.hom) ≫
      ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) Y✝).mul

Next tactic:
dsimp
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        dsimp
        

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ (μ F X✝.X X✝.X ≫ F.map X✝.mul) ≫ F.map f.hom = (F.map f.hom ⊗ F.map f.hom) ≫ μ F Y✝.X Y✝.X ≫ F.map Y✝.mul

Next tactic:
rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp,
          f.mul_hom]
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        dsimp
        rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp,
          f.mul_hom] }
  map_id A := by 

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
          map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
      (𝟙 A) =
    𝟙
      ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.obj
        A)

Next tactic:
ext
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        dsimp
        rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp,
          f.mul_hom] }
  map_id A := by ext; 

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
        (𝟙 A)).hom =
    (𝟙
        ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
              map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.obj
          A)).hom

Next tactic:
simp
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        dsimp
        rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp,
          f.mul_hom] }
  map_id A := by ext; simp
  map_comp f g := by 

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

Next tactic:
ext
/-- 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 where
  obj A :=
    { X := F.obj A.X
      one := F.ε ≫ F.map A.one
      mul := F.μ _ _ ≫ F.map A.mul
      one_mul := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
        rw [F.toFunctor.map_id]
        rw [F.left_unitality]
      mul_one := by
        conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
        rw [F.toFunctor.map_id]
        rw [F.right_unitality]
      mul_assoc := by
        conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
        slice_lhs 2 3 => rw [F.μ_natural]
        slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
        conv_lhs => rw [F.toFunctor.map_id]
        conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
        conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
        slice_rhs 3 4 => rw [F.μ_natural]
        conv_rhs => rw [F.toFunctor.map_id]
        slice_rhs 1 3 => rw [← F.associativity]
        simp only [Category.assoc] }
  map f :=
    { hom := F.map f.hom
      one_hom := by dsimp; rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
      mul_hom := by
        dsimp
        rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp,
          f.mul_hom] }
  map_id A := by ext; simp
  map_comp f g := by ext; 

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

Next tactic:
simp
/-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C where
  obj A :=
    { obj := fun _ => A.X
      map := fun _ => 𝟙 _
      ε := A.one
      μ := fun _ _ => A.mul
      map_id := fun _ => rfl
      map_comp := fun _ _ => (Category.id_comp (𝟙 A.X)).symm }
  map f :=
    { app := fun _ => f.hom
      naturality := fun _ _ _ => by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ ((fun A =>
              LaxMonoidalFunctor.mk
                (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                fun x x => A.mul)
            X✝).map
        x✝ ≫
      (fun x => f.hom) x✝¹ =
    (fun x => f.hom) x✝² ≫
      ((fun A =>
              LaxMonoidalFunctor.mk
                (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                fun x x => A.mul)
            Y✝).map
        x✝

Next tactic:
dsimp
/-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def monToLaxMonoidal : Mon_ C ⥤ LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C where
  obj A :=
    { obj := fun _ => A.X
      map := fun _ => 𝟙 _
      ε := A.one
      μ := fun _ _ => A.mul
      map_id := fun _ => rfl
      map_comp := fun _ _ => (Category.id_comp (𝟙 A.X)).symm }
  map f :=
    { app := fun _ => f.hom
      naturality := fun _ _ _ => by dsimp; 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ 𝟙 X✝.X ≫ f.hom = f.hom ≫ 𝟙 Y✝.X

Next tactic:
rw [Category.id_comp, Category.comp_id]