l3lab/ntp-mathlib huggingface dataset:
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_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 : D
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      F.map
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
        F.map
            ((Functor.inv F.toLaxMonoidalFunctor.1).map
              (inv
                (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
                  ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)))) ≫
          F.map
              ((Functor.inv F.toLaxMonoidalFunctor.1).map
                ((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

Next tactic:
simp only [IsEquivalence.fun_inv_map]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_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 : D
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      F.map
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
        ((asEquivalence F.toFunctor).counit.app
              (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
            inv
                (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
                  ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              (asEquivalence F.toFunctor).counitInv.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y))) ≫
          ((asEquivalence F.toFunctor).counit.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗
                  (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y) ≫
                (asEquivalence F.toFunctor).counitInv.app (X ⊗ Y)) ≫
            (asEquivalence F.toFunctor).counit.app (X ⊗ Y) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
erw [e.counit_app_functor]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      

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
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
        (e.functor.map
              (e.unitInv.app
                ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
            inv
                (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
                  ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              (asEquivalence F.toFunctor).counitInv.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y))) ≫
          ((asEquivalence F.toFunctor).counit.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗
                  (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y) ≫
                (asEquivalence F.toFunctor).counitInv.app (X ⊗ Y)) ≫
            (asEquivalence F.toFunctor).counit.app (X ⊗ Y) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
simp only [assoc]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      simp only [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 : D
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      F.map
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
        (asEquivalence F.toFunctor).functor.map
            ((asEquivalence F.toFunctor).unitInv.app
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
          inv
              (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
                ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
            (asEquivalence F.toFunctor).counitInv.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              (asEquivalence F.toFunctor).counit.app
                  (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                    F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
                ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗
                    (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y) ≫
                  (asEquivalence F.toFunctor).counitInv.app (X ⊗ Y) ≫ (asEquivalence F.toFunctor).counit.app (X ⊗ Y) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
erw [← e.functor.map_comp_assoc]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      simp only [assoc]
      erw [← e.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 : D
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      e.functor.map
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
            (asEquivalence F.toFunctor).unitInv.app
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
        inv
            (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
          (asEquivalence F.toFunctor).counitInv.app
              (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
            (asEquivalence F.toFunctor).counit.app
                (F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj X) ⊗
                  F.obj ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
              ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗
                  (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y) ≫
                (asEquivalence F.toFunctor).counitInv.app (X ⊗ Y) ≫ (asEquivalence F.toFunctor).counit.app (X ⊗ Y) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
simp only [CategoryTheory.Iso.inv_hom_id_app, CategoryTheory.Iso.inv_hom_id_app_assoc]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      simp only [assoc]
      erw [← e.functor.map_comp_assoc]
      simp only [CategoryTheory.Iso.inv_hom_id_app, CategoryTheory.Iso.inv_hom_id_app_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 : D
⊢ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      (asEquivalence F.toFunctor).functor.map
          ((asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction.unit.app
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
            (asEquivalence F.toFunctor).unitInv.app
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj 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) ≫
            𝟙 ((𝟭 D).obj (X ⊗ Y)) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
erw [Iso.hom_inv_id_app, CategoryTheory.Functor.map_id]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      simp only [assoc]
      erw [← e.functor.map_comp_assoc]
      simp only [CategoryTheory.Iso.inv_hom_id_app, CategoryTheory.Iso.inv_hom_id_app_assoc]
      erw [Iso.hom_inv_id_app, CategoryTheory.Functor.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 : 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) ≫
      𝟙
          ((asEquivalence F.toFunctor).functor.obj
            ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj 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) ≫
            𝟙 ((𝟭 D).obj (X ⊗ Y)) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
simp only [id_comp, CategoryTheory.Iso.inv_hom_id_app,
        CategoryTheory.IsIso.hom_inv_id_assoc]
/-- 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
      simp only [Adjunction.homEquiv_unit, Adjunction.homEquiv_naturality_right, assoc,
        comp_id, Functor.map_comp]
      simp only [IsEquivalence.fun_inv_map]
      erw [e.counit_app_functor]
      simp only [assoc]
      erw [← e.functor.map_comp_assoc]
      simp only [CategoryTheory.Iso.inv_hom_id_app, CategoryTheory.Iso.inv_hom_id_app_assoc]
      erw [Iso.hom_inv_id_app, CategoryTheory.Functor.map_id]
      simp only [id_comp, CategoryTheory.Iso.inv_hom_id_app,
        CategoryTheory.IsIso.hom_inv_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 : D
⊢ ((asEquivalence F.toLaxMonoidalFunctor.1).counit.app X ⊗ (asEquivalence F.toLaxMonoidalFunctor.1).counit.app Y) ≫
      𝟙 ((𝟭 D).obj (X ⊗ Y)) =
    (asEquivalence F.toFunctor).counit.app X ⊗ (asEquivalence F.toFunctor).counit.app Y

Next tactic:
erw [comp_id]
instance (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] : IsIso (monoidalCounit F) :=
  haveI : ∀ X : D, IsIso ((monoidalCounit 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 : D), IsIso ((monoidalCounit F).app X)

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

Next tactic:
infer_instance
/-- Transferring from `IsField` to `Semifield`. -/
noncomputable def IsField.toSemifield {R : Type u} [Semiring R] (h : IsField R) : Semifield R :=
  { ‹Semiring R›, h with
    inv := fun a => if ha : a = 0 then 0 else Classical.choose (IsField.mul_inv_cancel h ha),
    inv_zero := dif_pos rfl,
    mul_inv_cancel := fun a ha => by
      

Proof state:
R : Type u
inst✝ : Semiring R
h : IsField R
src✝ : Semiring R := inst✝
a : R
ha : a ≠ 0
⊢ a * a⁻¹ = 1

Next tactic:
convert Classical.choose_spec (IsField.mul_inv_cancel h ha)
/-- Transferring from `IsField` to `Semifield`. -/
noncomputable def IsField.toSemifield {R : Type u} [Semiring R] (h : IsField R) : Semifield R :=
  { ‹Semiring R›, h with
    inv := fun a => if ha : a = 0 then 0 else Classical.choose (IsField.mul_inv_cancel h ha),
    inv_zero := dif_pos rfl,
    mul_inv_cancel := fun a ha => by
      convert Classical.choose_spec (IsField.mul_inv_cancel h ha)
      

Proof state:
case h.e'_2.h.e'_6
R : Type u
inst✝ : Semiring R
h : IsField R
src✝ : Semiring R := inst✝
a : R
ha : a ≠ 0
⊢ a⁻¹ = choose (_ : ∃ b, a * b = 1)

Next tactic:
exact dif_neg ha
/-- For each field, and for each nonzero element of said field, there is a unique inverse.
Since `IsField` doesn't remember the data of an `inv` function and as such,
a lemma that there is a unique inverse could be useful.
-/
theorem uniq_inv_of_isField (R : Type u) [Ring R] (hf : IsField R) :
    ∀ x : R, x ≠ 0 → ∃! y : R, x * y = 1 := by
  

Proof state:
R : Type u
inst✝ : Ring R
hf : IsField R
⊢ ∀ (x : R), x ≠ 0 → ∃! y, x * y = 1

Next tactic:
intro x hx
/-- For each field, and for each nonzero element of said field, there is a unique inverse.
Since `IsField` doesn't remember the data of an `inv` function and as such,
a lemma that there is a unique inverse could be useful.
-/
theorem uniq_inv_of_isField (R : Type u) [Ring R] (hf : IsField R) :
    ∀ x : R, x ≠ 0 → ∃! y : R, x * y = 1 := by
  intro x hx
  

Proof state:
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃! y, x * y = 1

Next tactic:
apply exists_unique_of_exists_of_unique
/-- For each field, and for each nonzero element of said field, there is a unique inverse.
Since `IsField` doesn't remember the data of an `inv` function and as such,
a lemma that there is a unique inverse could be useful.
-/
theorem uniq_inv_of_isField (R : Type u) [Ring R] (hf : IsField R) :
    ∀ x : R, x ≠ 0 → ∃! y : R, x * y = 1 := by
  intro x hx
  apply exists_unique_of_exists_of_unique
  · 

Proof state:
case hex
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∃ x_1, x * x_1 = 1

Next tactic:
exact hf.mul_inv_cancel hx
/-- For each field, and for each nonzero element of said field, there is a unique inverse.
Since `IsField` doesn't remember the data of an `inv` function and as such,
a lemma that there is a unique inverse could be useful.
-/
theorem uniq_inv_of_isField (R : Type u) [Ring R] (hf : IsField R) :
    ∀ x : R, x ≠ 0 → ∃! y : R, x * y = 1 := by
  intro x hx
  apply exists_unique_of_exists_of_unique
  · exact hf.mul_inv_cancel hx
  · 

Proof state:
case hunique
R : Type u
inst✝ : Ring R
hf : IsField R
x : R
hx : x ≠ 0
⊢ ∀ (y₁ y₂ : R), x * y₁ = 1 → x * y₂ = 1 → y₁ = y₂

Next tactic:
intro y z hxy hxz