l3lab/ntp-mathlib huggingface dataset:
/-- 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.
-/
def isoOfIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul) : M ≅ N where
  hom :=
    { hom := f.hom
      one_hom := one_f
      mul_hom := mul_f }
  inv :=
    { hom := f.inv
      one_hom := by rw [← one_f]; simp
      mul_hom := by
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ N.mul ≫ f.inv = (f.inv ⊗ f.inv) ≫ M.mul

Next tactic:
rw [← cancel_mono f.hom]
/-- 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.
-/
def isoOfIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul) : M ≅ N where
  hom :=
    { hom := f.hom
      one_hom := one_f
      mul_hom := mul_f }
  inv :=
    { hom := f.inv
      one_hom := by rw [← one_f]; simp
      mul_hom := by
        rw [← cancel_mono f.hom]
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ (N.mul ≫ f.inv) ≫ f.hom = ((f.inv ⊗ f.inv) ≫ M.mul) ≫ f.hom

Next tactic:
slice_rhs 2 3 => rw [mul_f]
/-- 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.
-/
def isoOfIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul) : M ≅ N where
  hom :=
    { hom := f.hom
      one_hom := one_f
      mul_hom := mul_f }
  inv :=
    { hom := f.inv
      one_hom := by rw [← one_f]; simp
      mul_hom := by
        rw [← cancel_mono f.hom]
        slice_rhs 2 3 => 

Proof state:
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| M.mul ≫ f.hom
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| f.inv ⊗ f.inv

Next tactic:
rw [mul_f]
/-- 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.
-/
def isoOfIso {M N : Mon_ C} (f : M.X ≅ N.X) (one_f : M.one ≫ f.hom = N.one)
    (mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul) : M ≅ N where
  hom :=
    { hom := f.hom
      one_hom := one_f
      mul_hom := mul_f }
  inv :=
    { hom := f.inv
      one_hom := by rw [← one_f]; simp
      mul_hom := by
        rw [← cancel_mono f.hom]
        slice_rhs 2 3 => rw [mul_f]
        

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ (N.mul ≫ f.inv) ≫ f.hom = (f.inv ⊗ f.inv) ≫ (f.hom ⊗ f.hom) ≫ N.mul

Next tactic:
simp
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (trivial C).one ≫ A.one = A.one

Next tactic:
dsimp
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ 𝟙 (𝟙_ C) ≫ A.one = A.one

Next tactic:
simp
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (trivial C).mul ≫ A.one = (A.one ⊗ A.one) ≫ A.mul

Next tactic:
dsimp
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by dsimp; 

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (λ_ (𝟙_ C)).hom ≫ A.one = (A.one ⊗ A.one) ≫ A.mul

Next tactic:
simp [A.one_mul, unitors_equal]
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by dsimp; simp [A.one_mul, unitors_equal] }
  uniq f := by
    

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f = default

Next tactic:
ext
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by dsimp; simp [A.one_mul, unitors_equal] }
  uniq f := by
    ext; 

Proof state:
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f.hom = default.hom

Next tactic:
simp
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by dsimp; simp [A.one_mul, unitors_equal] }
  uniq f := by
    ext; simp
    

Proof state:
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f.hom = A.one

Next tactic:
rw [← Category.id_comp f.hom]
instance uniqueHomFromTrivial (A : Mon_ C) : Unique (trivial C ⟶ A) where
  default :=
    { hom := A.one
      one_hom := by dsimp; simp
      mul_hom := by dsimp; simp [A.one_mul, unitors_equal] }
  uniq f := by
    ext; simp
    rw [← Category.id_comp f.hom]
    

Proof state:
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ 𝟙 (trivial C).X ≫ f.hom = A.one

Next tactic:
erw [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
        

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.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul = (λ_ (F.obj A.X)).hom

Next tactic:
conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
/-- 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 => 

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.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul

Next tactic:
rw [comp_tensor_id, ← F.toFunctor.map_id]
/-- 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]
        

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.ε ⊗ F.map (𝟙 A.X)) ≫ (F.map A.one ⊗ F.map (𝟙 A.X))) ≫ μ F A.X A.X ≫ F.map A.mul = (λ_ (F.obj A.X)).hom

Next tactic:
slice_lhs 2 3 => rw [F.μ_natural]
/-- 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 => 

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.map A.one ⊗ F.map (𝟙 A.X)) ≫ μ F 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.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.ε ⊗ F.map (𝟙 A.X)

Next tactic:
rw [F.μ_natural]
/-- 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]
        

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.ε ⊗ F.map (𝟙 A.X)) ≫ (μ F (𝟙_ C) A.X ≫ F.map (A.one ⊗ 𝟙 A.X)) ≫ F.map A.mul = (λ_ (F.obj A.X)).hom

Next tactic:
slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
/-- 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 => 

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.map (A.one ⊗ 𝟙 A.X) ≫ F.map 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.ε ⊗ F.map (𝟙 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 (𝟙_ C) A.X

Next tactic:
rw [← F.toFunctor.map_comp, A.one_mul]
/-- 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]
        

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.ε ⊗ F.map (𝟙 A.X)) ≫ μ F (𝟙_ C) A.X ≫ F.map (λ_ A.X).hom = (λ_ (F.obj A.X)).hom

Next tactic:
rw [F.toFunctor.map_id]
/-- 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]
        

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.ε ⊗ 𝟙 (F.obj A.X)) ≫ μ F (𝟙_ C) A.X ≫ F.map (λ_ A.X).hom = (λ_ (F.obj A.X)).hom

Next tactic:
rw [F.left_unitality]
/-- 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
        

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.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom

Next tactic:
conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
/-- 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 => 

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.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul

Next tactic:
rw [id_tensor_comp, ← F.toFunctor.map_id]
/-- 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]
        

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.map (𝟙 A.X) ⊗ F.ε) ≫ (F.map (𝟙 A.X) ⊗ F.map A.one)) ≫ μ F A.X A.X ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom

Next tactic:
slice_lhs 2 3 => rw [F.μ_natural]
/-- 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 => 

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.map (𝟙 A.X) ⊗ F.map A.one) ≫ μ F 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.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.X) ⊗ F.ε

Next tactic:
rw [F.μ_natural]
/-- 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]
        

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.map (𝟙 A.X) ⊗ F.ε) ≫ (μ F A.X (𝟙_ C) ≫ F.map (𝟙 A.X ⊗ A.one)) ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom

Next tactic:
slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
/-- 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 => 

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.map (𝟙 A.X ⊗ A.one) ≫ F.map 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.X) ⊗ F.ε
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 A.X (𝟙_ C)

Next tactic:
rw [← F.toFunctor.map_comp, A.mul_one]
/-- 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]
        

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.map (𝟙 A.X) ⊗ F.ε) ≫ μ F A.X (𝟙_ C) ≫ F.map (ρ_ A.X).hom = (ρ_ (F.obj A.X)).hom

Next tactic:
rw [F.toFunctor.map_id]
/-- 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]
        

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.obj A.X) ⊗ F.ε) ≫ μ F A.X (𝟙_ C) ≫ F.map (ρ_ A.X).hom = (ρ_ (F.obj A.X)).hom

Next tactic:
rw [F.right_unitality]
/-- 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
        

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.map A.mul ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ 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.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul

Next tactic:
conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]