l3lab/ntp-mathlib huggingface dataset:
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) :=
  { tensoringRight C with
    ε := (rightUnitorNatIso C).inv
    μ := fun X Y => { app := fun Z => (α_ Z X Y).hom }
    μ_natural := fun f g => by
      ext Z
      dsimp
      simp only [← id_tensor_comp_tensor_id g f, id_tensor_comp, ← tensor_id, Category.assoc,
        associator_naturality, associator_naturality_assoc]
    associativity := fun X Y Z => by
      ext W
      simp [pentagon]
    μ_isIso := fun X Y =>
      -- We could avoid needing to do this explicitly by
      -- constructing a partially applied analogue of `associatorNatIso`.
      ⟨⟨{ app := fun Z => (α_ Z X Y).inv
          naturality := fun Z Z' f => by
            dsimp
            rw [← associator_inv_naturality]
            simp },
          by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
src✝ : C ⥤ C ⥤ C := tensoringRight C
X Y : C
⊢ (LaxMonoidalFunctor.μ
          (LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
            NatTrans.mk fun Z => (α_ Z X Y).hom)
          X Y ≫
        NatTrans.mk fun Z => (α_ Z X Y).inv) =
      𝟙
        ((LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                  NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
            X ⊗
          (LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                  NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
            Y) ∧
    (NatTrans.mk fun Z => (α_ Z X Y).inv) ≫
        LaxMonoidalFunctor.μ
          (LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
            NatTrans.mk fun Z => (α_ Z X Y).hom)
          X Y =
      𝟙
        ((LaxMonoidalFunctor.mk (Functor.mk src✝.toPrefunctor) (rightUnitorNatIso C).inv fun X Y =>
                NatTrans.mk fun Z => (α_ Z X Y).hom).toFunctor.obj
          (X ⊗ Y))

Next tactic:
aesop_cat
@[reassoc (attr := simp)]
theorem ε_inv_naturality {X Y : C} (f : X ⟶ Y) :
    (MonoidalFunctor.εIso F).inv.app X ≫ (𝟙_ (C ⥤ C)).map f = F.εIso.inv.app X ≫ f := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
X Y : C
f : X ⟶ Y
⊢ (MonoidalFunctor.εIso F).inv.app X ≫ (𝟙_ (C ⥤ C)).map f = (MonoidalFunctor.εIso F).inv.app X ≫ f

Next tactic:
aesop_cat
@[reassoc]
theorem μ_naturality₂ {m n m' n' : M} (f : m ⟶ m') (g : n ⟶ n') (X : C) :
    (F.map g).app ((F.obj m).obj X) ≫ (F.obj n').map ((F.map f).app X) ≫ (F.μ m' n').app X =
      (F.μ m n).app X ≫ (F.map (f ⊗ g)).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X

Next tactic:
have := congr_app (F.toLaxMonoidalFunctor.μ_natural f g) X
@[reassoc]
theorem μ_naturality₂ {m n m' n' : M} (f : m ⟶ m') (g : n ⟶ n') (X : C) :
    (F.map g).app ((F.obj m).obj X) ≫ (F.obj n').map ((F.map f).app X) ≫ (F.μ m' n').app X =
      (F.μ m n).app X ≫ (F.map (f ⊗ g)).app X := by
  have := congr_app (F.toLaxMonoidalFunctor.μ_natural f g) X
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
this :
  ((F.map f ⊗ F.map g) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n ≫ F.map (f ⊗ g)).app X
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X

Next tactic:
dsimp at this
@[reassoc]
theorem μ_naturality₂ {m n m' n' : M} (f : m ⟶ m') (g : n ⟶ n') (X : C) :
    (F.map g).app ((F.obj m).obj X) ≫ (F.obj n').map ((F.map f).app X) ≫ (F.μ m' n').app X =
      (F.μ m n).app X ≫ (F.map (f ⊗ g)).app X := by
  have := congr_app (F.toLaxMonoidalFunctor.μ_natural f g) X
  dsimp at this
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' n' : M
f : m ⟶ m'
g : n ⟶ n'
X : C
this :
  ((F.map g).app ((F.obj m).obj X) ≫ (F.obj n').map ((F.map f).app X)) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X
⊢ (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ g)).app X

Next tactic:
simpa using this
@[reassoc (attr := simp)]
theorem μ_naturalityₗ {m n m' : M} (f : m ⟶ m') (X : C) :
    (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X =
      (F.μ m n).app X ≫ (F.map (f ⊗ 𝟙 n)).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ 𝟙 n)).app X

Next tactic:
rw [← μ_naturality₂ F f (𝟙 n) X]
@[reassoc (attr := simp)]
theorem μ_naturalityₗ {m n m' : M} (f : m ⟶ m') (X : C) :
    (F.obj n).map ((F.map f).app X) ≫ (F.μ m' n).app X =
      (F.μ m n).app X ≫ (F.map (f ⊗ 𝟙 n)).app X := by
  rw [← μ_naturality₂ F f (𝟙 n) X]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X =
    (F.map (𝟙 n)).app ((F.obj m).obj X) ≫
      (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X

Next tactic:
simp
@[reassoc (attr := simp)]
theorem μ_naturalityᵣ {m n n' : M} (g : n ⟶ n') (X : C) :
    (F.map g).app ((F.obj m).obj X) ≫ (F.μ m n').app X =
      (F.μ m n).app X ≫ (F.map (𝟙 m ⊗ g)).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (𝟙 m ⊗ g)).app X

Next tactic:
rw [← μ_naturality₂ F (𝟙 m) g X]
@[reassoc (attr := simp)]
theorem μ_naturalityᵣ {m n n' : M} (g : n ⟶ n') (X : C) :
    (F.map g).app ((F.obj m).obj X) ≫ (F.μ m n').app X =
      (F.μ m n).app X ≫ (F.map (𝟙 m ⊗ g)).app X := by
  rw [← μ_naturality₂ F (𝟙 m) g X]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X =
    (F.map g).app ((F.obj m).obj X) ≫
      (F.obj n').map ((F.map (𝟙 m)).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n').app X

Next tactic:
simp
@[reassoc (attr := simp)]
theorem μ_inv_naturalityₗ {m n m' : M} (f : m ⟶ m') (X : C) :
    (F.μIso m n).inv.app X ≫ (F.obj n).map ((F.map f).app X) =
      (F.map (f ⊗ 𝟙 n)).app X ≫ (F.μIso m' n).inv.app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (MonoidalFunctor.μIso F m n).inv.app X ≫ (F.obj n).map ((F.map f).app X) =
    (F.map (f ⊗ 𝟙 n)).app X ≫ (MonoidalFunctor.μIso F m' n).inv.app X

Next tactic:
rw [← IsIso.comp_inv_eq, Category.assoc, ← IsIso.eq_inv_comp]
@[reassoc (attr := simp)]
theorem μ_inv_naturalityₗ {m n m' : M} (f : m ⟶ m') (X : C) :
    (F.μIso m n).inv.app X ≫ (F.obj n).map ((F.map f).app X) =
      (F.map (f ⊗ 𝟙 n)).app X ≫ (F.μIso m' n).inv.app X := by
  rw [← IsIso.comp_inv_eq, Category.assoc, ← IsIso.eq_inv_comp]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ inv ((MonoidalFunctor.μIso F m' n).inv.app X) =
    inv ((MonoidalFunctor.μIso F m n).inv.app X) ≫ (F.map (f ⊗ 𝟙 n)).app X

Next tactic:
simp
@[reassoc (attr := simp)]
theorem μ_inv_naturalityᵣ {m n n' : M} (g : n ⟶ n') (X : C) :
    (F.μIso m n).inv.app X ≫ (F.map g).app ((F.obj m).obj X) =
      (F.map (𝟙 m ⊗ g)).app X ≫ (F.μIso m n').inv.app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (MonoidalFunctor.μIso F m n).inv.app X ≫ (F.map g).app ((F.obj m).obj X) =
    (F.map (𝟙 m ⊗ g)).app X ≫ (MonoidalFunctor.μIso F m n').inv.app X

Next tactic:
rw [← IsIso.comp_inv_eq, Category.assoc, ← IsIso.eq_inv_comp]
@[reassoc (attr := simp)]
theorem μ_inv_naturalityᵣ {m n n' : M} (g : n ⟶ n') (X : C) :
    (F.μIso m n).inv.app X ≫ (F.map g).app ((F.obj m).obj X) =
      (F.map (𝟙 m ⊗ g)).app X ≫ (F.μIso m n').inv.app X := by
  rw [← IsIso.comp_inv_eq, Category.assoc, ← IsIso.eq_inv_comp]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n n' : M
g : n ⟶ n'
X : C
⊢ (F.map g).app ((F.obj m).obj X) ≫ inv ((MonoidalFunctor.μIso F m n').inv.app X) =
    inv ((MonoidalFunctor.μIso F m n).inv.app X) ≫ (F.map (𝟙 m ⊗ g)).app X

Next tactic:
simp
@[reassoc]
theorem left_unitality_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) ≫ (F.μ (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X = 𝟙 _ := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

Next tactic:
have := congr_app (F.toLaxMonoidalFunctor.left_unitality n) X
@[reassoc]
theorem left_unitality_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) ≫ (F.μ (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X = 𝟙 _ := by
  have := congr_app (F.toLaxMonoidalFunctor.left_unitality n) X
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  (λ_ (F.obj n)).hom.app X =
    ((F.ε ⊗ 𝟙 (F.obj n)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n ≫ F.map (λ_ n).hom).app X
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

Next tactic:
dsimp at this
@[reassoc]
theorem left_unitality_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) ≫ (F.μ (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X = 𝟙 _ := by
  have := congr_app (F.toLaxMonoidalFunctor.left_unitality n) X
  dsimp at this
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  𝟙 ((F.obj n).obj X) =
    (𝟙 ((F.obj n).obj X) ≫ (F.obj n).map (F.ε.app X)) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X
⊢ (F.obj n).map (F.ε.app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

Next tactic:
simpa using this.symm
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X

Next tactic:
refine' Eq.trans _ (Category.id_comp _)
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) ≫ (F.map (λ_ n).inv).app X ≫ (MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X

Next tactic:
rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map (F.ε.app X) ≫ inv ((MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X) ≫ inv ((F.map (λ_ n).inv).app X) =
    𝟙 ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X))

Next tactic:
convert left_unitality_app F n X
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
  convert left_unitality_app F n X
  · 

Proof state:
case h.e'_2.h.h.e'_7.h.h.e'_6
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((MonoidalFunctor.μIso F (𝟙_ M) n).inv.app X) = (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X

Next tactic:
simp
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_app (n : M) (X : C) :
    (F.obj n).map (F.ε.app X) = (F.map (λ_ n).inv).app X ≫ (F.μIso (𝟙_ M) n).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
  convert left_unitality_app F n X
  · simp
  · 

Proof state:
case h.e'_2.h.h.e'_7.h.h.e'_7.h
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X)) =
    ((F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) ⟶ (F.obj n).obj X)
e_5✝ : (F.obj n).obj ((𝟙_ (C ⥤ C)).obj X) = (F.obj n).obj X
⊢ inv ((F.map (λ_ n).inv).app X) = (F.map (λ_ n).hom).app X

Next tactic:
simp
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_inv_app (n : M) (X : C) :
    (F.obj n).map (F.εIso.inv.app X) = (F.μ (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map ((MonoidalFunctor.εIso F).inv.app X) =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X

Next tactic:
rw [← cancel_mono ((F.obj n).map (F.ε.app X)), ← Functor.map_comp]
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_ε_inv_app (n : M) (X : C) :
    (F.obj n).map (F.εIso.inv.app X) = (F.μ (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X := by
  rw [← cancel_mono ((F.obj n).map (F.ε.app X)), ← Functor.map_comp]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (F.obj n).map ((MonoidalFunctor.εIso F).inv.app X ≫ F.ε.app X) =
    ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) n).app X ≫ (F.map (λ_ n).hom).app X) ≫
      (F.obj n).map (F.ε.app X)

Next tactic:
simp
@[reassoc]
theorem right_unitality_app (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 _ := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

Next tactic:
have := congr_app (F.toLaxMonoidalFunctor.right_unitality n) X
@[reassoc]
theorem right_unitality_app (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 _ := by
  have := congr_app (F.toLaxMonoidalFunctor.right_unitality n) X
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  (ρ_ (F.obj n)).hom.app X =
    ((𝟙 (F.obj n) ⊗ F.ε) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M) ≫ F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

Next tactic:
dsimp at this
@[reassoc]
theorem right_unitality_app (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 _ := by
  have := congr_app (F.toLaxMonoidalFunctor.right_unitality n) X
  dsimp at this
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  𝟙 ((F.obj n).obj X) =
    (F.ε.app ((F.obj n).obj X) ≫ (F.obj (𝟙_ M)).map (𝟙 ((F.obj n).obj X))) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

Next tactic:
simpa using this.symm
@[simp]
theorem ε_app_obj (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (F.μIso n (𝟙_ M)).inv.app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (MonoidalFunctor.μIso F n (𝟙_ M)).inv.app X

Next tactic:
refine' Eq.trans _ (Category.id_comp _)
@[simp]
theorem ε_app_obj (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (F.μIso n (𝟙_ M)).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X)) ≫ (F.map (ρ_ n).inv).app X ≫ (MonoidalFunctor.μIso F n (𝟙_ M)).inv.app X

Next tactic:
rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
@[simp]
theorem ε_app_obj (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (F.μIso n (𝟙_ M)).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) ≫ inv ((MonoidalFunctor.μIso F n (𝟙_ M)).inv.app X) ≫ inv ((F.map (ρ_ n).inv).app X) =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

Next tactic:
convert right_unitality_app F n X using 1
@[simp]
theorem ε_app_obj (n : M) (X : C) :
    F.ε.app ((F.obj n).obj X) = (F.map (ρ_ n).inv).app X ≫ (F.μIso n (𝟙_ M)).inv.app X := by
  refine' Eq.trans _ (Category.id_comp _)
  rw [← Category.assoc, ← IsIso.comp_inv_eq, ← IsIso.comp_inv_eq, Category.assoc]
  convert right_unitality_app F n X using 1
  

Proof state:
case h.e'_2.h
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
e_1✝ :
  ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X) ⟶ (𝟙_ (C ⥤ C)).obj ((F.obj n).obj X)) =
    ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X) ⟶ (F.obj n).obj X)
⊢ F.ε.app ((F.obj n).obj X) ≫ inv ((MonoidalFunctor.μIso F n (𝟙_ M)).inv.app X) ≫ inv ((F.map (ρ_ n).inv).app X) =
    F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X

Next tactic:
simp
@[simp]
theorem ε_inv_app_obj (n : M) (X : C) :
    F.εIso.inv.app ((F.obj n).obj X) = (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (MonoidalFunctor.εIso F).inv.app ((F.obj n).obj X) =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X

Next tactic:
rw [← cancel_mono (F.ε.app ((F.obj n).obj X)), ε_inv_hom_app]
@[simp]
theorem ε_inv_app_obj (n : M) (X : C) :
    F.εIso.inv.app ((F.obj n).obj X) = (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X := by
  rw [← cancel_mono (F.ε.app ((F.obj n).obj X)), ε_inv_hom_app]
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ 𝟙 ((F.obj (𝟙_ M)).obj ((F.obj n).obj X)) =
    ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X) ≫
      F.ε.app ((F.obj n).obj X)

Next tactic:
simp
@[reassoc]
theorem associativity_app (m₁ m₂ m₃ : M) (X : C) :
    (F.obj m₃).map ((F.μ m₁ m₂).app X) ≫
        (F.μ (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
      (F.μ m₂ m₃).app ((F.obj m₁).obj X) ≫ (F.μ m₁ (m₂ ⊗ m₃)).app X := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X

Next tactic:
have := congr_app (F.toLaxMonoidalFunctor.associativity m₁ m₂ m₃) X