l3lab/ntp-mathlib huggingface dataset:
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' 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 : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y X' Y' : D
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (G.map f ⊗ G.map g) ≫
      (fun X Y =>
          (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y)))
        Y Y' =
    (fun X Y =>
          (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y)))
        X X' ≫
      G.map (f ⊗ g)

Next tactic:
rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity 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 : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ ((fun X Y =>
            (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (h.counit.app X ⊗ h.counit.app Y)))
          X Y ⊗
        𝟙 (G.obj Z)) ≫
      (fun X Y =>
            (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (h.counit.app X ⊗ h.counit.app Y)))
          (X ⊗ Y) Z ≫
        G.map (α_ X Y Z).hom =
    (α_ (G.obj X) (G.obj Y) (G.obj Z)).hom ≫
      (𝟙 (G.obj X) ⊗
          (fun X Y =>
              (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
                (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                  (h.counit.app X ⊗ h.counit.app Y)))
            Y Z) ≫
        (fun X Y =>
            (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (h.counit.app X ⊗ h.counit.app Y)))
          X (Y ⊗ Z)

Next tactic:
dsimp only
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity X Y Z := by
    dsimp only
    

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 : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ ((Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y)) ⊗
        𝟙 (G.obj Z)) ≫
      (Adjunction.homEquiv h (G.obj (X ⊗ Y) ⊗ G.obj Z) ((X ⊗ Y) ⊗ Z))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj (X ⊗ Y)) (G.obj Z)) ≫
            (h.counit.app (X ⊗ Y) ⊗ h.counit.app Z)) ≫
        G.map (α_ X Y Z).hom =
    (α_ (G.obj X) (G.obj Y) (G.obj Z)).hom ≫
      (𝟙 (G.obj X) ⊗
          (Adjunction.homEquiv h (G.obj Y ⊗ G.obj Z) (Y ⊗ Z))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z)) ≫
              (h.counit.app Y ⊗ h.counit.app Z))) ≫
        (Adjunction.homEquiv h (G.obj X ⊗ G.obj (Y ⊗ Z)) (X ⊗ Y ⊗ Z))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj (Y ⊗ Z))) ≫
            (h.counit.app X ⊗ h.counit.app (Y ⊗ Z)))

Next tactic:
rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ←
      h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
      F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, assoc, IsIso.hom_inv_id_assoc, ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
      tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ←
      tensor_comp_assoc, id_comp, id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp,
      assoc, assoc, h.counit_naturality, h.left_triangle_components_assoc, Functor.map_comp,
      assoc, h.counit_naturality, h.left_triangle_components_assoc]
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity X Y Z := by
    dsimp only
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ←
      h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
      F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, assoc, IsIso.hom_inv_id_assoc, ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
      tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ←
      tensor_comp_assoc, id_comp, id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp,
      assoc, assoc, h.counit_naturality, h.left_triangle_components_assoc, Functor.map_comp,
      assoc, h.counit_naturality, h.left_triangle_components_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 : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y) ≫
          inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y) ⊗
        h.counit.app Z) ≫
      (α_ X Y Z).hom =
    (α_ (F.obj (G.obj X)) (F.obj (G.obj Y)) (F.obj (G.obj Z))).hom ≫
      (h.counit.app X ⊗
        LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z) ≫
          inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z)) ≫ (h.counit.app Y ⊗ h.counit.app Z))

Next tactic:
simp
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity X Y Z := by
    dsimp only
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ←
      h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
      F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, assoc, IsIso.hom_inv_id_assoc, ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
      tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ←
      tensor_comp_assoc, id_comp, id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp,
      assoc, assoc, h.counit_naturality, h.left_triangle_components_assoc, Functor.map_comp,
      assoc, h.counit_naturality, h.left_triangle_components_assoc]
    simp
  left_unitality 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ (λ_ (G.obj X)).hom =
    ((Adjunction.homEquiv h (𝟙_ C) (𝟙_ D)) (inv F.ε) ⊗ 𝟙 (G.obj X)) ≫
      (fun X Y =>
            (Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (h.counit.app X ⊗ h.counit.app Y)))
          (𝟙_ D) X ≫
        G.map (λ_ X).hom

Next tactic:
rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq,
      h.homEquiv_counit, F.map_leftUnitor, h.homEquiv_unit, assoc, assoc, assoc, F.map_tensor,
      assoc, assoc, IsIso.hom_inv_id_assoc, ← tensor_comp_assoc, Functor.map_id, id_comp,
      Functor.map_comp, assoc, h.counit_naturality, h.left_triangle_components_assoc, ←
      leftUnitor_naturality, ← tensor_comp_assoc, id_comp, comp_id]
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity X Y Z := by
    dsimp only
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ←
      h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
      F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, assoc, IsIso.hom_inv_id_assoc, ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
      tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ←
      tensor_comp_assoc, id_comp, id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp,
      assoc, assoc, h.counit_naturality, h.left_triangle_components_assoc, Functor.map_comp,
      assoc, h.counit_naturality, h.left_triangle_components_assoc]
    simp
  left_unitality X := by
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq,
      h.homEquiv_counit, F.map_leftUnitor, h.homEquiv_unit, assoc, assoc, assoc, F.map_tensor,
      assoc, assoc, IsIso.hom_inv_id_assoc, ← tensor_comp_assoc, Functor.map_id, id_comp,
      Functor.map_comp, assoc, h.counit_naturality, h.left_triangle_components_assoc, ←
      leftUnitor_naturality, ← tensor_comp_assoc, id_comp, comp_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 : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) (G.obj X)) ≫
      (inv F.ε ⊗ h.counit.app X) ≫ (λ_ ((𝟭 D).obj X)).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) (G.obj X)) ≫ (inv F.ε ⊗ h.counit.app X) ≫ (λ_ X).hom

Next tactic:
simp
/-- If we have a right adjoint functor `G` to a monoidal functor `F`, then `G` has a lax monoidal
structure as well.
-/
@[simps]
noncomputable def monoidalAdjoint (F : MonoidalFunctor C D) {G : D ⥤ C} (h : F.toFunctor ⊣ G) :
    LaxMonoidalFunctor D C where
  toFunctor := G
  ε := h.homEquiv _ _ (inv F.ε)
  μ X Y := h.homEquiv _ (X ⊗ Y) (inv (F.μ (G.obj X) (G.obj Y)) ≫ (h.counit.app X ⊗ h.counit.app Y))
  μ_natural := @fun X Y X' Y' f g => by
    rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc,
      IsIso.eq_inv_comp, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ←
      tensor_comp, Adjunction.counit_naturality, Adjunction.counit_naturality, tensor_comp]
  associativity X Y Z := by
    dsimp only
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ←
      h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
      cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
      F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, assoc, IsIso.hom_inv_id_assoc, ←
      F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
      tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ←
      tensor_comp_assoc, id_comp, id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp,
      assoc, assoc, h.counit_naturality, h.left_triangle_components_assoc, Functor.map_comp,
      assoc, h.counit_naturality, h.left_triangle_components_assoc]
    simp
  left_unitality X := by
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq,
      h.homEquiv_counit, F.map_leftUnitor, h.homEquiv_unit, assoc, assoc, assoc, F.map_tensor,
      assoc, assoc, IsIso.hom_inv_id_assoc, ← tensor_comp_assoc, Functor.map_id, id_comp,
      Functor.map_comp, assoc, h.counit_naturality, h.left_triangle_components_assoc, ←
      leftUnitor_naturality, ← tensor_comp_assoc, id_comp, comp_id]
    simp
  right_unitality X := by
    rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq,
      h.homEquiv_counit, F.map_rightUnitor, assoc, assoc, ← rightUnitor_naturality, ←
      tensor_comp_assoc, comp_id, id_comp, h.homEquiv_unit, F.map_tensor, assoc, assoc, assoc,
      IsIso.hom_inv_id_assoc, Functor.map_comp, Functor.map_id, ← tensor_comp_assoc, assoc,
      h.counit_naturality, h.left_triangle_components_assoc, 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
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (𝟙_ C)) ≫
      (h.counit.app X ⊗ inv F.ε) ≫ (ρ_ ((𝟭 D).obj X)).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (𝟙_ C)) ≫ (h.counit.app X ⊗ inv F.ε) ≫ (ρ_ X).hom

Next tactic:
simp
/-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    MonoidalFunctor D C
    where
  toLaxMonoidalFunctor := monoidalAdjoint F (asEquivalence _).toAdjunction
  ε_isIso := 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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
⊢ IsIso (monoidalAdjoint F (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction).ε

Next tactic:
dsimp [Equivalence.toAdjunction]
/-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    MonoidalFunctor D C
    where
  toLaxMonoidalFunctor := monoidalAdjoint F (asEquivalence _).toAdjunction
  ε_isIso := by
    dsimp [Equivalence.toAdjunction]
    

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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
⊢ IsIso
    ((asEquivalence F.toLaxMonoidalFunctor.1).unit.app (𝟙_ C) ≫ (Functor.inv F.toLaxMonoidalFunctor.1).map (inv F.ε))

Next tactic:
infer_instance
/-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    MonoidalFunctor D C
    where
  toLaxMonoidalFunctor := monoidalAdjoint F (asEquivalence _).toAdjunction
  ε_isIso := by
    dsimp [Equivalence.toAdjunction]
    infer_instance
  μ_isIso 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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
X Y : D
⊢ IsIso (LaxMonoidalFunctor.μ (monoidalAdjoint F (asEquivalence F.toLaxMonoidalFunctor.1).toAdjunction) X Y)

Next tactic:
dsimp [Equivalence.toAdjunction]
/-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse (F : MonoidalFunctor C D) [IsEquivalence F.toFunctor] :
    MonoidalFunctor D C
    where
  toLaxMonoidalFunctor := monoidalAdjoint F (asEquivalence _).toAdjunction
  ε_isIso := by
    dsimp [Equivalence.toAdjunction]
    infer_instance
  μ_isIso X Y := by
    dsimp [Equivalence.toAdjunction]
    

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 : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
X Y : D
⊢ IsIso
    ((asEquivalence F.toLaxMonoidalFunctor.1).unit.app
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      (Functor.inv F.toLaxMonoidalFunctor.1).map
        (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)))

Next tactic:
infer_instance
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) :
    ((⨅ i, f i : α →o β) : α → β) = ⨅ i, (f i : α → β) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
⊢ ⇑(⨅ i, f i) = ⨅ i, ⇑(f i)

Next tactic:
funext x
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) :
    ((⨅ i, f i : α →o β) : α → β) = ⨅ i, (f i : α → β) := by
  funext x; 

Proof state:
case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ (⨅ i, f i) x = iInf (fun i => ⇑(f i)) x

Next tactic:
simp [iInf_apply]
@[simp, norm_cast]
theorem coe_iSup {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) :
    ((⨆ i, f i : α →o β) : α → β) = ⨆ i, (f i : α → β) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
⊢ ⇑(⨆ i, f i) = ⨆ i, ⇑(f i)

Next tactic:
funext x
@[simp, norm_cast]
theorem coe_iSup {ι : Sort*} [CompleteLattice β] (f : ι → α →o β) :
    ((⨆ i, f i : α →o β) : α → β) = ⨆ i, (f i : α → β) := by
  funext x; 

Proof state:
case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ (⨆ i, f i) x = iSup (fun i => ⇑(f i)) x

Next tactic:
simp [iSup_apply]
instance [CompleteLattice β] : CompleteLattice (α →o β) :=
  { (_ : Lattice (α →o β)), OrderHom.orderTop, OrderHom.orderBot with
    -- sSup := SupSet.sSup   -- Porting note: removed, unnecessary?
    -- Porting note: Added `by apply`, was `fun s f hf x => le_iSup_of_le f (le_iSup _ hf)`
    le_sSup := fun s f hf x => le_iSup_of_le f (by 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : CompleteLattice β
src✝² : Lattice (α →o β) := lattice
src✝¹ : OrderTop (α →o β) := orderTop
src✝ : OrderBot (α →o β) := orderBot
s : Set (α →o β)
f : α →o β
hf : f ∈ s
x : α
⊢ toFun f x ≤ ⨆ (_ : f ∈ s), f x

Next tactic:
apply le_iSup _ hf
theorem iterate_sup_le_sup_iff {α : Type*} [SemilatticeSup α] (f : α →o α) :
    (∀ n₁ n₂ a₁ a₂, f^[n₁ + n₂] (a₁ ⊔ a₂) ≤ f^[n₁] a₁ ⊔ f^[n₂] a₂) ↔
      ∀ a₁ a₂, f (a₁ ⊔ a₂) ≤ f a₁ ⊔ a₂ := by
  

Proof state:
α✝ : Type u_1
β : Type u_2
inst✝¹ : Preorder α✝
α : Type u_3
inst✝ : SemilatticeSup α
f : α →o α
⊢ (∀ (n₁ n₂ : ℕ) (a₁ a₂ : α), (⇑f)^[n₁ + n₂] (a₁ ⊔ a₂) ≤ (⇑f)^[n₁] a₁ ⊔ (⇑f)^[n₂] a₂) ↔
    ∀ (a₁ a₂ : α), f (a₁ ⊔ a₂) ≤ f a₁ ⊔ a₂

Next tactic:
constructor
theorem iterate_sup_le_sup_iff {α : Type*} [SemilatticeSup α] (f : α →o α) :
    (∀ n₁ n₂ a₁ a₂, f^[n₁ + n₂] (a₁ ⊔ a₂) ≤ f^[n₁] a₁ ⊔ f^[n₂] a₂) ↔
      ∀ a₁ a₂, f (a₁ ⊔ a₂) ≤ f a₁ ⊔ a₂ := by
  constructor <;> 

Proof state:
case mp
α✝ : Type u_1
β : Type u_2
inst✝¹ : Preorder α✝
α : Type u_3
inst✝ : SemilatticeSup α
f : α →o α
⊢ (∀ (n₁ n₂ : ℕ) (a₁ a₂ : α), (⇑f)^[n₁ + n₂] (a₁ ⊔ a₂) ≤ (⇑f)^[n₁] a₁ ⊔ (⇑f)^[n₂] a₂) →
    ∀ (a₁ a₂ : α), f (a₁ ⊔ a₂) ≤ f a₁ ⊔ a₂

Next tactic:
intro h