l3lab/ntp-mathlib huggingface dataset:
theorem map_rightUnitor (X : C) :
    F.map (ρ_ X).hom = inv (F.μ X (𝟙_ C)) ≫ (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (ρ_ (F.obj X)).hom := by
  simp only [LaxMonoidalFunctor.right_unitality]
  slice_rhs 2 3 =>
    

Proof state:
case a.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 : MonoidalFunctor C D
X : C
| (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (𝟙 (F.obj X) ⊗ F.ε)
case a.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 : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
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 : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
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 : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))

Next tactic:
rw [← id_tensor_comp]
theorem map_rightUnitor (X : C) :
    F.map (ρ_ X).hom = inv (F.μ X (𝟙_ C)) ≫ (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (ρ_ (F.obj X)).hom := by
  simp only [LaxMonoidalFunctor.right_unitality]
  slice_rhs 2 3 =>
    rw [← id_tensor_comp]
    

Proof state:
case a.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 : MonoidalFunctor C D
X : C
| 𝟙 (F.obj X) ⊗ inv F.ε ≫ F.ε
case a.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 : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
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 : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
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 : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))

Next tactic:
simp
theorem map_rightUnitor (X : C) :
    F.map (ρ_ X).hom = inv (F.μ X (𝟙_ C)) ≫ (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (ρ_ (F.obj X)).hom := by
  simp only [LaxMonoidalFunctor.right_unitality]
  slice_rhs 2 3 =>
    rw [← id_tensor_comp]
    simp
  

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 : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫
      (𝟙 (F.obj X ⊗ F.obj (𝟙_ C)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫ F.map (ρ_ X).hom

Next tactic:
simp
/-- The tensorator as a natural isomorphism. -/
noncomputable def μNatIso :
    Functor.prod F.toFunctor F.toFunctor ⋙ tensor D ≅ tensor C ⋙ F.toFunctor :=
  NatIso.ofComponents
    (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 : MonoidalFunctor C D
⊢ (X : C × C) → (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).obj X ≅ (tensor C ⋙ F.toFunctor).obj X

Next tactic:
intros
/-- The tensorator as a natural isomorphism. -/
noncomputable def μNatIso :
    Functor.prod F.toFunctor F.toFunctor ⋙ tensor D ≅ tensor C ⋙ F.toFunctor :=
  NatIso.ofComponents
    (by
      intros
      

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 : MonoidalFunctor C D
X✝ : C × C
⊢ (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).obj X✝ ≅ (tensor C ⋙ F.toFunctor).obj X✝

Next tactic:
apply F.μIso
/-- The tensorator as a natural isomorphism. -/
noncomputable def μNatIso :
    Functor.prod F.toFunctor F.toFunctor ⋙ tensor D ≅ tensor C ⋙ F.toFunctor :=
  NatIso.ofComponents
    (by
      intros
      apply F.μIso)
    (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 : MonoidalFunctor C D
⊢ ∀ {X Y : C × C} (f : X ⟶ Y),
    (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).map f ≫ (μIso F Y.1 Y.2).hom =
      (μIso F X.1 X.2).hom ≫ (tensor C ⋙ F.toFunctor).map f

Next tactic:
intros
/-- The tensorator as a natural isomorphism. -/
noncomputable def μNatIso :
    Functor.prod F.toFunctor F.toFunctor ⋙ tensor D ≅ tensor C ⋙ F.toFunctor :=
  NatIso.ofComponents
    (by
      intros
      apply F.μIso)
    (by
      intros
      

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 : MonoidalFunctor C D
X✝ Y✝ : C × C
f✝ : X✝ ⟶ Y✝
⊢ (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).map f✝ ≫ (μIso F Y✝.1 Y✝.2).hom =
    (μIso F X✝.1 X✝.2).hom ≫ (tensor C ⋙ F.toFunctor).map f✝

Next tactic:
apply F.toLaxMonoidalFunctor.μ_natural
/-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor :=
  NatIso.ofComponents (fun Y => F.μIso X Y) @fun Y Z f => 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 : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
⊢ (F.toFunctor ⋙ tensorLeft (F.obj X)).map f ≫ ((fun Y => μIso F X Y) Z).hom =
    ((fun Y => μIso F X Y) Y).hom ≫ (tensorLeft X ⋙ F.toFunctor).map f

Next tactic:
convert F.μ_natural (𝟙 X) f using 2
/-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor :=
  NatIso.ofComponents (fun Y => F.μIso X Y) @fun Y Z f => by
    convert F.μ_natural (𝟙 X) f using 2
    

Proof state:
case h.e'_2.h.h.e'_6.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
e_1✝ :
  ((F.toFunctor ⋙ tensorLeft (F.obj X)).obj Y ⟶ (tensorLeft X ⋙ F.toFunctor).obj Z) =
    (F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Z))
e_3✝ : (F.toFunctor ⋙ tensorLeft (F.obj X)).obj Y = F.obj X ⊗ F.obj Y
e_4✝ : (F.toFunctor ⋙ tensorLeft (F.obj X)).obj Z = F.obj X ⊗ F.obj Z
⊢ (F.toFunctor ⋙ tensorLeft (F.obj X)).map f = F.map (𝟙 X) ⊗ F.map f

Next tactic:
simp
/-- Monoidal functors commute with right tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorRight (X : C) :
    F.toFunctor ⋙ tensorRight (F.toFunctor.obj X) ≅ tensorRight X ⋙ F.toFunctor :=
  NatIso.ofComponents (fun Y => F.μIso Y X) @fun Y Z f => 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 : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
⊢ (F.toFunctor ⋙ tensorRight (F.obj X)).map f ≫ ((fun Y => μIso F Y X) Z).hom =
    ((fun Y => μIso F Y X) Y).hom ≫ (tensorRight X ⋙ F.toFunctor).map f

Next tactic:
convert F.μ_natural f (𝟙 X) using 2
/-- Monoidal functors commute with right tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorRight (X : C) :
    F.toFunctor ⋙ tensorRight (F.toFunctor.obj X) ≅ tensorRight X ⋙ F.toFunctor :=
  NatIso.ofComponents (fun Y => F.μIso Y X) @fun Y Z f => by
    convert F.μ_natural f (𝟙 X) using 2
    

Proof state:
case h.e'_2.h.h.e'_6.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
e_1✝ :
  ((F.toFunctor ⋙ tensorRight (F.obj X)).obj Y ⟶ (tensorRight X ⋙ F.toFunctor).obj Z) =
    (F.obj Y ⊗ F.obj X ⟶ F.obj (Z ⊗ X))
e_3✝ : (F.toFunctor ⋙ tensorRight (F.obj X)).obj Y = F.obj Y ⊗ F.obj X
e_4✝ : (F.toFunctor ⋙ tensorRight (F.obj X)).obj Z = F.obj Z ⊗ F.obj X
⊢ (F.toFunctor ⋙ tensorRight (F.obj X)).map f = F.map f ⊗ F.map (𝟙 X)

Next tactic:
simp
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
x✝³ x✝² x✝¹ x✝ : C
f : x✝³ ⟶ x✝²
g : x✝¹ ⟶ x✝
⊢ ((Functor.mk src✝.toPrefunctor).map f ⊗ (Functor.mk src✝.toPrefunctor).map g) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) x✝² x✝ =
    (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) x✝³ x✝¹ ≫ (Functor.mk src✝.toPrefunctor).map (f ⊗ g)

Next tactic:
simp only [Functor.comp_map, assoc]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
x✝³ x✝² x✝¹ x✝ : C
f : x✝³ ⟶ x✝²
g : x✝¹ ⟶ x✝
⊢ (G.map (F.map f) ⊗ G.map (F.map g)) ≫ μ G (F.obj x✝²) (F.obj x✝) ≫ G.map (μ F x✝² x✝) =
    μ G (F.obj x✝³) (F.obj x✝¹) ≫ G.map (μ F x✝³ x✝¹) ≫ G.map (F.map (f ⊗ g))

Next tactic:
rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ ((fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) X Y ⊗ 𝟙 ((Functor.mk src✝.toPrefunctor).obj Z)) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) (X ⊗ Y) Z ≫
        (Functor.mk src✝.toPrefunctor).map (α_ X Y Z).hom =
    (α_ ((Functor.mk src✝.toPrefunctor).obj X) ((Functor.mk src✝.toPrefunctor).obj Y)
          ((Functor.mk src✝.toPrefunctor).obj Z)).hom ≫
      (𝟙 ((Functor.mk src✝.toPrefunctor).obj X) ⊗ (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) Y Z) ≫
        (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) X (Y ⊗ Z)

Next tactic:
dsimp
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z) ≫ G.map (μ F Y Z)) ≫
        μ G (F.obj X) (F.obj (Y ⊗ Z)) ≫ G.map (μ F X (Y ⊗ Z))

Next tactic:
rw [id_tensor_comp]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      

Proof state:
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      ((𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z))) ≫
        μ G (F.obj X) (F.obj (Y ⊗ Z)) ≫ G.map (μ F X (Y ⊗ Z))

Next tactic:
slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_natural]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      slice_rhs 3 4 => 

Proof state:
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z)) ≫ μ G (F.obj X) (F.obj (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom
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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| 𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)

Next tactic:
rw [← G.toFunctor.map_id, G.μ_natural]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫
        (μ G (F.obj X) (F.obj Y ⊗ F.obj Z) ≫ G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫ G.map (μ F X (Y ⊗ Z))

Next tactic:
slice_rhs 1 3 => rw [← G.associativity]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_natural]
      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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
    (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ μ G (F.obj X) (F.obj Y ⊗ F.obj Z)
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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (𝟙 (F.obj X) ⊗ μ F Y Z)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))

Next tactic:
rw [← G.associativity]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_natural]
      slice_rhs 1 3 => rw [← G.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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
          μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
        G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫
      G.map (μ F X (Y ⊗ Z))

Next tactic:
rw [comp_tensor_id]
/-- The composition of two lax monoidal functors is again lax monoidal. -/
@[simps]
def comp : LaxMonoidalFunctor.{v₁, v₃} C E :=
  { F.toFunctor ⋙ G.toFunctor with
    ε := G.ε ≫ G.map F.ε
    μ := fun X Y => G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)
    μ_natural := @fun _ _ _ _ f g => by
      simp only [Functor.comp_map, assoc]
      rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp,
        ← LaxMonoidalFunctor.μ_natural]
    associativity := fun X Y Z => by
      dsimp
      rw [id_tensor_comp]
      slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_natural]
      slice_rhs 1 3 => rw [← G.associativity]
      rw [comp_tensor_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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ ((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫ (G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z)))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
          μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
        G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫
      G.map (μ F X (Y ⊗ Z))

Next tactic:
slice_lhs 2 3 => rw [← G.toFunctor.map_id, G.μ_natural]