l3lab/ntp-mathlib huggingface dataset:
/-- Horizontal composition of monoidal natural transformations. -/
@[simps]
def hcomp {F G : LaxMonoidalFunctor C D} {H K : LaxMonoidalFunctor D E} (α : MonoidalNatTrans F G)
    (β : MonoidalNatTrans H K) : MonoidalNatTrans (F ⊗⋙ H) (G ⊗⋙ K) :=
  { NatTrans.hcomp α.toNatTrans β.toNatTrans with
    unit := by
      dsimp; simp
      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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F G : LaxMonoidalFunctor C D
H K : LaxMonoidalFunctor D E
α : MonoidalNatTrans F G
β : MonoidalNatTrans H K
src✝ : F.toFunctor ⋙ H.toFunctor ⟶ G.toFunctor ⋙ K.toFunctor := α.toNatTrans ◫ β.toNatTrans
| K.ε ≫ K.map F.ε ≫ K.map (α.app (𝟙_ C))

Next tactic:
rw [← K.toFunctor.map_comp, α.unit]
/-- Horizontal composition of monoidal natural transformations. -/
@[simps]
def hcomp {F G : LaxMonoidalFunctor C D} {H K : LaxMonoidalFunctor D E} (α : MonoidalNatTrans F G)
    (β : MonoidalNatTrans H K) : MonoidalNatTrans (F ⊗⋙ H) (G ⊗⋙ K) :=
  { NatTrans.hcomp α.toNatTrans β.toNatTrans with
    unit := by
      dsimp; simp
      conv_lhs => rw [← K.toFunctor.map_comp, α.unit]
    tensor := fun X Y => 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 G : LaxMonoidalFunctor C D
H K : LaxMonoidalFunctor D E
α : MonoidalNatTrans F G
β : MonoidalNatTrans H K
src✝ : F.toFunctor ⋙ H.toFunctor ⟶ G.toFunctor ⋙ K.toFunctor := α.toNatTrans ◫ β.toNatTrans
X Y : C
⊢ LaxMonoidalFunctor.μ (F ⊗⋙ H) X Y ≫ (NatTrans.mk src✝.app).app (X ⊗ Y) =
    ((NatTrans.mk src✝.app).app X ⊗ (NatTrans.mk src✝.app).app Y) ≫ LaxMonoidalFunctor.μ (G ⊗⋙ K) X Y

Next tactic:
dsimp
/-- Horizontal composition of monoidal natural transformations. -/
@[simps]
def hcomp {F G : LaxMonoidalFunctor C D} {H K : LaxMonoidalFunctor D E} (α : MonoidalNatTrans F G)
    (β : MonoidalNatTrans H K) : MonoidalNatTrans (F ⊗⋙ H) (G ⊗⋙ K) :=
  { NatTrans.hcomp α.toNatTrans β.toNatTrans with
    unit := by
      dsimp; simp
      conv_lhs => rw [← K.toFunctor.map_comp, α.unit]
    tensor := fun X Y => 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 G : LaxMonoidalFunctor C D
H K : LaxMonoidalFunctor D E
α : MonoidalNatTrans F G
β : MonoidalNatTrans H K
src✝ : F.toFunctor ⋙ H.toFunctor ⟶ G.toFunctor ⋙ K.toFunctor := α.toNatTrans ◫ β.toNatTrans
X Y : C
⊢ (LaxMonoidalFunctor.μ H (F.obj X) (F.obj Y) ≫ H.map (LaxMonoidalFunctor.μ F X Y)) ≫
      β.app (F.obj (X ⊗ Y)) ≫ K.map (α.app (X ⊗ Y)) =
    (β.app (F.obj X) ≫ K.map (α.app X) ⊗ β.app (F.obj Y) ≫ K.map (α.app Y)) ≫
      LaxMonoidalFunctor.μ K (G.obj X) (G.obj Y) ≫ K.map (LaxMonoidalFunctor.μ G X Y)

Next tactic:
simp
/-- Horizontal composition of monoidal natural transformations. -/
@[simps]
def hcomp {F G : LaxMonoidalFunctor C D} {H K : LaxMonoidalFunctor D E} (α : MonoidalNatTrans F G)
    (β : MonoidalNatTrans H K) : MonoidalNatTrans (F ⊗⋙ H) (G ⊗⋙ K) :=
  { NatTrans.hcomp α.toNatTrans β.toNatTrans with
    unit := by
      dsimp; simp
      conv_lhs => rw [← K.toFunctor.map_comp, α.unit]
    tensor := fun X Y => by
      dsimp; 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F G : LaxMonoidalFunctor C D
H K : LaxMonoidalFunctor D E
α : MonoidalNatTrans F G
β : MonoidalNatTrans H K
src✝ : F.toFunctor ⋙ H.toFunctor ⟶ G.toFunctor ⋙ K.toFunctor := α.toNatTrans ◫ β.toNatTrans
X Y : C
⊢ (β.app (F.obj X) ⊗ β.app (F.obj Y)) ≫
      LaxMonoidalFunctor.μ K (F.obj X) (F.obj Y) ≫ K.map (LaxMonoidalFunctor.μ F X Y) ≫ K.map (α.app (X ⊗ Y)) =
    (β.app (F.obj X) ⊗ β.app (F.obj Y)) ≫
      LaxMonoidalFunctor.μ K (F.obj X) (F.obj Y) ≫ K.map (α.app X ⊗ α.app Y) ≫ K.map (LaxMonoidalFunctor.μ G X Y)

Next tactic:
conv_lhs => rw [← K.toFunctor.map_comp, α.tensor, K.toFunctor.map_comp]
/-- Horizontal composition of monoidal natural transformations. -/
@[simps]
def hcomp {F G : LaxMonoidalFunctor C D} {H K : LaxMonoidalFunctor D E} (α : MonoidalNatTrans F G)
    (β : MonoidalNatTrans H K) : MonoidalNatTrans (F ⊗⋙ H) (G ⊗⋙ K) :=
  { NatTrans.hcomp α.toNatTrans β.toNatTrans with
    unit := by
      dsimp; simp
      conv_lhs => rw [← K.toFunctor.map_comp, α.unit]
    tensor := fun X Y => by
      dsimp; simp
      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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F G : LaxMonoidalFunctor C D
H K : LaxMonoidalFunctor D E
α : MonoidalNatTrans F G
β : MonoidalNatTrans H K
src✝ : F.toFunctor ⋙ H.toFunctor ⟶ G.toFunctor ⋙ K.toFunctor := α.toNatTrans ◫ β.toNatTrans
X Y : C
| (β.app (F.obj X) ⊗ β.app (F.obj Y)) ≫
    LaxMonoidalFunctor.μ K (F.obj X) (F.obj Y) ≫ K.map (LaxMonoidalFunctor.μ F X Y) ≫ K.map (α.app (X ⊗ Y))

Next tactic:
rw [← K.toFunctor.map_comp, α.tensor, K.toFunctor.map_comp]
/-- Construct a monoidal natural isomorphism from object level isomorphisms,
and the monoidal naturality in the forward direction. -/
def ofComponents (app : ∀ X : C, F.obj X ≅ G.obj X)
    (naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f)
    (unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε)
    (tensor' : ∀ X Y, F.μ X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ G.μ X Y) :
    F ≅ G where
  hom := { app := fun X => (app X).hom }
  inv := {
    (NatIso.ofComponents app @naturality').inv with
    app := fun X => (app X).inv
    unit := 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 G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor' :
  ∀ (X Y : C), LaxMonoidalFunctor.μ F X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ LaxMonoidalFunctor.μ G X Y
src✝ : G.toFunctor ⟶ F.toFunctor := (NatIso.ofComponents app).inv
⊢ G.ε ≫ (NatTrans.mk fun X => (app X).inv).app (𝟙_ C) = F.ε

Next tactic:
dsimp
/-- Construct a monoidal natural isomorphism from object level isomorphisms,
and the monoidal naturality in the forward direction. -/
def ofComponents (app : ∀ X : C, F.obj X ≅ G.obj X)
    (naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f)
    (unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε)
    (tensor' : ∀ X Y, F.μ X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ G.μ X Y) :
    F ≅ G where
  hom := { app := fun X => (app X).hom }
  inv := {
    (NatIso.ofComponents app @naturality').inv with
    app := fun X => (app X).inv
    unit := 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 G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor' :
  ∀ (X Y : C), LaxMonoidalFunctor.μ F X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ LaxMonoidalFunctor.μ G X Y
src✝ : G.toFunctor ⟶ F.toFunctor := (NatIso.ofComponents app).inv
⊢ G.ε ≫ (app (𝟙_ C)).inv = F.ε

Next tactic:
rw [← unit', assoc, Iso.hom_inv_id, comp_id]
/-- Construct a monoidal natural isomorphism from object level isomorphisms,
and the monoidal naturality in the forward direction. -/
def ofComponents (app : ∀ X : C, F.obj X ≅ G.obj X)
    (naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f)
    (unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε)
    (tensor' : ∀ X Y, F.μ X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ G.μ X Y) :
    F ≅ G where
  hom := { app := fun X => (app X).hom }
  inv := {
    (NatIso.ofComponents app @naturality').inv with
    app := fun X => (app X).inv
    unit := by
      dsimp
      rw [← unit', assoc, Iso.hom_inv_id, comp_id]
    tensor := fun X Y => 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 G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor' :
  ∀ (X Y : C), LaxMonoidalFunctor.μ F X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ LaxMonoidalFunctor.μ G X Y
src✝ : G.toFunctor ⟶ F.toFunctor := (NatIso.ofComponents app).inv
X Y : C
⊢ LaxMonoidalFunctor.μ G X Y ≫ (NatTrans.mk fun X => (app X).inv).app (X ⊗ Y) =
    ((NatTrans.mk fun X => (app X).inv).app X ⊗ (NatTrans.mk fun X => (app X).inv).app Y) ≫ LaxMonoidalFunctor.μ F X Y

Next tactic:
dsimp
/-- Construct a monoidal natural isomorphism from object level isomorphisms,
and the monoidal naturality in the forward direction. -/
def ofComponents (app : ∀ X : C, F.obj X ≅ G.obj X)
    (naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f)
    (unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε)
    (tensor' : ∀ X Y, F.μ X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ G.μ X Y) :
    F ≅ G where
  hom := { app := fun X => (app X).hom }
  inv := {
    (NatIso.ofComponents app @naturality').inv with
    app := fun X => (app X).inv
    unit := by
      dsimp
      rw [← unit', assoc, Iso.hom_inv_id, comp_id]
    tensor := fun X Y => 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 G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality' : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit' : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor' :
  ∀ (X Y : C), LaxMonoidalFunctor.μ F X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ LaxMonoidalFunctor.μ G X Y
src✝ : G.toFunctor ⟶ F.toFunctor := (NatIso.ofComponents app).inv
X Y : C
⊢ LaxMonoidalFunctor.μ G X Y ≫ (app (X ⊗ Y)).inv = ((app X).inv ⊗ (app Y).inv) ≫ LaxMonoidalFunctor.μ F X Y

Next tactic:
rw [Iso.comp_inv_eq, assoc, tensor', ← tensor_comp_assoc,
        Iso.inv_hom_id, Iso.inv_hom_id, tensor_id, id_comp]
@[simp]
theorem ofComponents.inv_app (app : ∀ X : C, F.obj X ≅ G.obj X) (naturality) (unit) (tensor) (X) :
    (ofComponents app naturality unit tensor).inv.app X = (app X).inv := 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 G : LaxMonoidalFunctor C D
app : (X : C) → F.obj X ≅ G.obj X
naturality : ∀ {X Y : C} (f : X ⟶ Y), F.map f ≫ (app Y).hom = (app X).hom ≫ G.map f
unit : F.ε ≫ (app (𝟙_ C)).hom = G.ε
tensor :
  ∀ (X Y : C), LaxMonoidalFunctor.μ F X Y ≫ (app (X ⊗ Y)).hom = ((app X).hom ⊗ (app Y).hom) ≫ LaxMonoidalFunctor.μ G X Y
X : C
⊢ (ofComponents app naturality unit tensor).inv.app X = (app X).inv

Next tactic:
simp [ofComponents]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      

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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ LaxMonoidalFunctor.μ (LaxMonoidalFunctor.id C) X Y ≫ e.unit.app (X ⊗ Y) =
    (e.unit.app X ⊗ e.unit.app Y) ≫
      LaxMonoidalFunctor.μ (F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor) X Y

Next tactic:
dsimp
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ 𝟙 (X ⊗ Y) ≫ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (Adjunction.homEquiv (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
              (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y))
            (F.obj X ⊗ F.obj Y))
          (inv
              (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X))
                ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y))) ≫
            ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj X) ⊗
              (asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj Y))) ≫
        (Functor.inv F.toLaxMonoidalFunctor.1).map (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y)

Next tactic:
simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, assoc]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      dsimp
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, 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
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
          ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
            (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
        (Functor.inv F.toLaxMonoidalFunctor.1).map
            (inv
                (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X))
                  ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y))) ≫
              ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj X) ⊗
                (asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj Y))) ≫
          (Functor.inv F.toLaxMonoidalFunctor.1).map (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y)

Next tactic:
simp only [← Functor.map_comp, assoc]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      dsimp
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, assoc]
      simp only [← Functor.map_comp, 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
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
          ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
            (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
        (Functor.inv F.toLaxMonoidalFunctor.1).map
          (inv
              (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X))
                ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y))) ≫
            ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj X) ⊗
                (asEquivalence F.toLaxMonoidalFunctor.1).counit.app (F.obj Y)) ≫
              LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y)

Next tactic:
erw [e.counit_app_functor, e.counit_app_functor,
        F.toLaxMonoidalFunctor.μ_natural, IsIso.inv_hom_id_assoc]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      dsimp
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, assoc]
      simp only [← Functor.map_comp, assoc]
      erw [e.counit_app_functor, e.counit_app_functor,
        F.toLaxMonoidalFunctor.μ_natural, IsIso.inv_hom_id_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
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
          ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
            (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
        (Functor.inv F.toLaxMonoidalFunctor.1).map (F.map (e.unitInv.app X ⊗ e.unitInv.app Y))

Next tactic:
simp only [CategoryTheory.IsEquivalence.inv_fun_map]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      dsimp
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, assoc]
      simp only [← Functor.map_comp, assoc]
      erw [e.counit_app_functor, e.counit_app_functor,
        F.toLaxMonoidalFunctor.μ_natural, IsIso.inv_hom_id_assoc]
      simp only [CategoryTheory.IsEquivalence.inv_fun_map]
      

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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
          ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
            (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
        (asEquivalence F.toLaxMonoidalFunctor.1).unitInv.app
            (((asEquivalence F.toFunctor).functor ⋙ (asEquivalence F.toFunctor).inverse).obj X ⊗
              ((asEquivalence F.toFunctor).functor ⋙ (asEquivalence F.toFunctor).inverse).obj Y) ≫
          ((asEquivalence F.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app Y) ≫
            (asEquivalence F.toLaxMonoidalFunctor.1).unit.app ((𝟭 C).obj X ⊗ (𝟭 C).obj Y)

Next tactic:
slice_rhs 2 3 => erw [Iso.hom_inv_id_app]
/-- The unit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalUnit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    LaxMonoidalFunctor.id C ⟶ F.toLaxMonoidalFunctor ⊗⋙ (monoidalInverse F).toLaxMonoidalFunctor :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.unit
    tensor := fun X Y => by
      -- This proof is not pretty; golfing welcome!
      dsimp
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right,
        id_comp, assoc]
      simp only [← Functor.map_comp, assoc]
      erw [e.counit_app_functor, e.counit_app_functor,
        F.toLaxMonoidalFunctor.μ_natural, IsIso.inv_hom_id_assoc]
      simp only [CategoryTheory.IsEquivalence.inv_fun_map]
      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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
| (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
      ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
    (asEquivalence F.toLaxMonoidalFunctor.1).unitInv.app
      (((asEquivalence F.toFunctor).functor ⋙ (asEquivalence F.toFunctor).inverse).obj X ⊗
        ((asEquivalence F.toFunctor).functor ⋙ (asEquivalence F.toFunctor).inverse).obj Y)
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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
| (asEquivalence F.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app Y
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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
| (asEquivalence F.toLaxMonoidalFunctor.1).unit.app ((𝟭 C).obj X ⊗ (𝟭 C).obj Y)
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
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
| (asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y

Next tactic:
erw [Iso.hom_inv_id_app]