l3lab/ntp-mathlib huggingface dataset:
/-- 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 => erw [Iso.hom_inv_id_app]
      

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) ≫
      (𝟙
            ((𝟭 C).obj
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗
                (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.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:
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
      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 => erw [Iso.hom_inv_id_app]
      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
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).unit.app X ⊗ (asEquivalence F.toFunctor).unit.app Y) ≫
      (𝟙 ((Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj X) ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj (F.obj Y)) ≫
          ((asEquivalence F.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app Y)) ≫
        (asEquivalence F.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
simp only [CategoryTheory.Category.id_comp]
/-- 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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_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
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.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app Y) ≫
        (asEquivalence F.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
slice_rhs 1 2 =>
        rw [← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app]
        dsimp
        rw [tensor_id]
/-- 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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_comp]
      slice_rhs 1 2 =>
        

Proof state:
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) ≫
    ((asEquivalence F.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app 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.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
rw [← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app]
        dsimp
        rw [tensor_id]
/-- 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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_comp]
      slice_rhs 1 2 =>
        

Proof state:
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) ≫
    ((asEquivalence F.toFunctor).unitInv.app X ⊗ (asEquivalence F.toFunctor).unitInv.app 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.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
rw [← tensor_comp, Iso.hom_inv_id_app, 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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_comp]
      slice_rhs 1 2 =>
        rw [← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app]
        

Proof state:
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
| 𝟙 ((𝟭 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.toLaxMonoidalFunctor.1).unit.app (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
      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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_comp]
      slice_rhs 1 2 =>
        rw [← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app]
        dsimp
        

Proof state:
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
| 𝟙 X ⊗ 𝟙 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.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
rw [tensor_id]
/-- 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 => erw [Iso.hom_inv_id_app]
      dsimp
      simp only [CategoryTheory.Category.id_comp]
      slice_rhs 1 2 =>
        rw [← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app]
        dsimp
        rw [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
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : C
⊢ (asEquivalence F.toFunctor).unit.app (X ⊗ Y) = 𝟙 (X ⊗ Y) ≫ (asEquivalence F.toLaxMonoidalFunctor.1).unit.app (X ⊗ Y)

Next tactic:
simp
instance (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] : IsIso (monoidalUnit F) :=
  haveI : ∀ X : C, IsIso ((monoidalUnit F).toNatTrans.app X) := 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
inst✝ : IsEquivalence F.toFunctor
⊢ ∀ (X : C), IsIso ((monoidalUnit F).app X)

Next tactic:
dsimp
instance (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] : IsIso (monoidalUnit F) :=
  haveI : ∀ X : C, IsIso ((monoidalUnit F).toNatTrans.app X) := 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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
⊢ ∀ (X : C), IsIso ((asEquivalence F.toFunctor).unit.app X)

Next tactic:
infer_instance
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
⊢ ((monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor).ε ≫ e.counit.app (𝟙_ D) =
    (LaxMonoidalFunctor.id D).ε

Next tactic:
dsimp
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
⊢ (F.ε ≫ F.map ((Adjunction.homEquiv (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction (𝟙_ C) (𝟙_ D)) (inv F.ε))) ≫
      (asEquivalence F.toFunctor).counit.app (𝟙_ D) =
    𝟙 (𝟙_ D)

Next tactic:
simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    unit := by
      dsimp
      simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
      

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
⊢ F.ε ≫
      F.map ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app (𝟙_ C)) ≫
        (asEquivalence F.toFunctor).counitIso.hom.app (F.obj (𝟙_ C)) ≫
          inv F.ε ≫
            inv ((asEquivalence F.toFunctor).counit.app (𝟙_ D)) ≫ (asEquivalence F.toFunctor).counit.app (𝟙_ D) =
    𝟙 (𝟙_ D)

Next tactic:
erw [e.counit_app_functor, ← e.functor.map_comp_assoc, Iso.hom_inv_id_app]
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    unit := by
      dsimp
      simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
      erw [e.counit_app_functor, ← e.functor.map_comp_assoc, Iso.hom_inv_id_app]
      

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
⊢ F.ε ≫
      e.functor.map (𝟙 ((𝟭 C).obj (𝟙_ C))) ≫
        inv F.ε ≫ inv ((asEquivalence F.toFunctor).counit.app (𝟙_ D)) ≫ (asEquivalence F.toFunctor).counit.app (𝟙_ D) =
    𝟙 (𝟙_ D)

Next tactic:
dsimp
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    unit := by
      dsimp
      simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
      erw [e.counit_app_functor, ← e.functor.map_comp_assoc, Iso.hom_inv_id_app]
      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
⊢ F.ε ≫
      F.map (𝟙 (𝟙_ C)) ≫
        inv F.ε ≫ inv ((asEquivalence F.toFunctor).counit.app (𝟙_ D)) ≫ (asEquivalence F.toFunctor).counit.app (𝟙_ D) =
    𝟙 (𝟙_ D)

Next tactic:
simp
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    unit := by
      dsimp
      simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
      erw [e.counit_app_functor, ← e.functor.map_comp_assoc, Iso.hom_inv_id_app]
      dsimp; simp
    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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : D
⊢ LaxMonoidalFunctor.μ ((monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor) X Y ≫ e.counit.app (X ⊗ Y) =
    (e.counit.app X ⊗ e.counit.app Y) ≫ LaxMonoidalFunctor.μ (LaxMonoidalFunctor.id D) X Y

Next tactic:
dsimp
/-- The counit of a monoidal equivalence can be upgraded to a monoidal natural transformation. -/
@[simps! toNatTrans] -- Porting note: have to manually specify the toNatTrans projection
def monoidalCounit (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    (monoidalInverse F).toLaxMonoidalFunctor ⊗⋙ F.toLaxMonoidalFunctor ⟶ LaxMonoidalFunctor.id D :=
  let e := F.toFunctor.asEquivalence
  { toNatTrans := e.counit
    unit := by
      dsimp
      simp only [comp_id, assoc, Functor.map_inv, Functor.map_comp,
        NatIso.inv_inv_app, IsIso.inv_comp, IsEquivalence.fun_inv_map, Adjunction.homEquiv_unit]
      erw [e.counit_app_functor, ← e.functor.map_comp_assoc, Iso.hom_inv_id_app]
      dsimp; simp
    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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
e : C ≌ D := asEquivalence F.toFunctor
X Y : D
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
          ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
        F.map
          ((Adjunction.homEquiv (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y) (X ⊗ Y))
            (inv
                (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
                  ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗
                (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y)))) ≫
      (asEquivalence F.toFunctor).counit.app (X ⊗ Y) =
    ((asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y) ≫ 𝟙 (X ⊗ Y)

Next tactic:
simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]