File: Mathlib/CategoryTheory/Monoidal/End.lean

full_name: CategoryTheory.endofunctorMonoidalCategory
code: /-- The category of endofunctors of any category is a monoidal category,
with tensor product given by composition of functors
(and horizontal composition of natural transformations).
-/
def endofunctorMonoidalCategory : MonoidalCategory (C ⥤ C) 
goal: CategoryTheory.MonoidalCategory (CategoryTheory.Functor C C)

full_name: CategoryTheory.endofunctorMonoidalCategory_tensorUnit_obj
code: @[simp] theorem endofunctorMonoidalCategory_tensorUnit_obj (X : C) :
    (𝟙_ (C ⥤ C)).obj X = X 
goal: (𝟙_ (CategoryTheory.Functor C C)).obj X = X

full_name: CategoryTheory.endofunctorMonoidalCategory_tensorUnit_map
code: @[simp] theorem endofunctorMonoidalCategory_tensorUnit_map {X Y : C} (f : X ⟶ Y) :
    (𝟙_ (C ⥤ C)).map f = f 
goal: (𝟙_ (CategoryTheory.Functor C C)).map f = f

full_name: CategoryTheory.endofunctorMonoidalCategory_tensorObj_obj
code: @[simp] theorem endofunctorMonoidalCategory_tensorObj_obj (F G : C ⥤ C) (X : C) :
    (F ⊗ G).obj X = G.obj (F.obj X) 
goal: (CategoryTheory.MonoidalCategory.tensorObj F G).obj X = G.obj (F.obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_tensorObj_map
code: @[simp] theorem endofunctorMonoidalCategory_tensorObj_map (F G : C ⥤ C) {X Y : C} (f : X ⟶ Y) :
    (F ⊗ G).map f = G.map (F.map f) 
goal: (CategoryTheory.MonoidalCategory.tensorObj F G).map f = G.map (F.map f)

full_name: CategoryTheory.endofunctorMonoidalCategory_tensorMap_app
code: @[simp] theorem endofunctorMonoidalCategory_tensorMap_app
    {F G H K : C ⥤ C} {α : F ⟶ G} {β : H ⟶ K} (X : C) :
    (α ⊗ β).app X = β.app (F.obj X) ≫ K.map (α.app X) 
goal: (CategoryTheory.MonoidalCategory.tensorHom α β).app X =
  CategoryTheory.CategoryStruct.comp (β.app (F.obj X)) (K.map (α.app X))

full_name: CategoryTheory.endofunctorMonoidalCategory_whiskerLeft_app
code: @[simp] theorem endofunctorMonoidalCategory_whiskerLeft_app
    {F H K : C ⥤ C} {β : H ⟶ K} (X : C) :
    (F ◁ β).app X = β.app (F.obj X) 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft F β).app X = β.app (F.obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_whiskerRight_app
code: @[simp] theorem endofunctorMonoidalCategory_whiskerRight_app
    {F G H : C ⥤ C} {α : F ⟶ G} (X : C) :
    (α ▷ H).app X = H.map (α.app X) 
goal: (CategoryTheory.MonoidalCategory.whiskerRight α H).app X = H.map (α.app X)

full_name: CategoryTheory.endofunctorMonoidalCategory_associator_hom_app
code: @[simp] theorem endofunctorMonoidalCategory_associator_hom_app (F G H : C ⥤ C) (X : C) :
  (α_ F G H).hom.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.associator F G H).hom.app X =
  CategoryTheory.CategoryStruct.id
    ((CategoryTheory.MonoidalCategory.tensorObj (CategoryTheory.MonoidalCategory.tensorObj F G) H).obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_associator_inv_app
code: @[simp] theorem endofunctorMonoidalCategory_associator_inv_app (F G H : C ⥤ C) (X : C) :
  (α_ F G H).inv.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.associator F G H).inv.app X =
  CategoryTheory.CategoryStruct.id
    ((CategoryTheory.MonoidalCategory.tensorObj F (CategoryTheory.MonoidalCategory.tensorObj G H)).obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_leftUnitor_hom_app
code: @[simp] theorem endofunctorMonoidalCategory_leftUnitor_hom_app (F : C ⥤ C) (X : C) :
  (λ_ F).hom.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.leftUnitor F).hom.app X =
  CategoryTheory.CategoryStruct.id
    ((CategoryTheory.MonoidalCategory.tensorObj (𝟙_ (CategoryTheory.Functor C C)) F).obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_leftUnitor_inv_app
code: @[simp] theorem endofunctorMonoidalCategory_leftUnitor_inv_app (F : C ⥤ C) (X : C) :
  (λ_ F).inv.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.leftUnitor F).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_rightUnitor_hom_app
code: @[simp] theorem endofunctorMonoidalCategory_rightUnitor_hom_app (F : C ⥤ C) (X : C) :
  (ρ_ F).hom.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.rightUnitor F).hom.app X =
  CategoryTheory.CategoryStruct.id
    ((CategoryTheory.MonoidalCategory.tensorObj F (𝟙_ (CategoryTheory.Functor C C))).obj X)

full_name: CategoryTheory.endofunctorMonoidalCategory_rightUnitor_inv_app
code: @[simp] theorem endofunctorMonoidalCategory_rightUnitor_inv_app (F : C ⥤ C) (X : C) :
  (ρ_ F).inv.app X = 𝟙 _ 
goal: (CategoryTheory.MonoidalCategory.rightUnitor F).inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.tensoringRightMonoidal_toLaxMonoidalFunctor_μ_app
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: ∀ (X_1 : C),
  ((CategoryTheory.tensoringRightMonoidal C).μ X Y).app X_1 = (CategoryTheory.MonoidalCategory.associator X_1 X Y).hom

full_name: CategoryTheory.tensoringRightMonoidal
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: CategoryTheory.MonoidalFunctor C (CategoryTheory.Functor C C)

full_name: CategoryTheory.tensoringRightMonoidal_toLaxMonoidalFunctor_ε_app
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: (CategoryTheory.tensoringRightMonoidal C).ε.app X = (CategoryTheory.MonoidalCategory.rightUnitor X).inv

full_name: CategoryTheory.tensoringRightMonoidal_toLaxMonoidalFunctor_toFunctor_obj_obj
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: ((CategoryTheory.tensoringRightMonoidal C).obj k).obj j = CategoryTheory.MonoidalCategory.tensorObj j k

full_name: CategoryTheory.tensoringRightMonoidal_toLaxMonoidalFunctor_toFunctor_obj_map
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.tensoringRightMonoidal C).obj k).map f = CategoryTheory.MonoidalCategory.whiskerRight f k

full_name: CategoryTheory.tensoringRightMonoidal_toLaxMonoidalFunctor_toFunctor_map_app
code: /-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C) 
goal: ∀ {X Y : C} (f : X ⟶ Y) (j : C),
  ((CategoryTheory.tensoringRightMonoidal C).map f).app j = CategoryTheory.MonoidalCategory.whiskerLeft j f

full_name: CategoryTheory.μ_hom_inv_app
code: @[reassoc (attr := simp)]
theorem μ_hom_inv_app (i j : M) (X : C) : (F.μ i j).app X ≫ (F.μIso i j).inv.app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((F.μ i j).app X) ((F.μIso i j).inv.app X) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.MonoidalCategory.tensorObj (F.obj i) (F.obj j)).obj X)

full_name: CategoryTheory.μ_inv_hom_app
code: @[reassoc (attr := simp)]
theorem μ_inv_hom_app (i j : M) (X : C) : (F.μIso i j).inv.app X ≫ (F.μ i j).app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((F.μIso i j).inv.app X) ((F.μ i j).app X) =
  CategoryTheory.CategoryStruct.id ((F.obj (CategoryTheory.MonoidalCategory.tensorObj i j)).obj X)

full_name: CategoryTheory.ε_hom_inv_app
code: @[reassoc (attr := simp)]
theorem ε_hom_inv_app (X : C) : F.ε.app X ≫ F.εIso.inv.app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.ε.app X) (F.εIso.inv.app X) =
  CategoryTheory.CategoryStruct.id ((𝟙_ (CategoryTheory.Functor C C)).obj X)

full_name: CategoryTheory.ε_inv_hom_app
code: @[reassoc (attr := simp)]
theorem ε_inv_hom_app (X : C) : F.εIso.inv.app X ≫ F.ε.app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.εIso.inv.app X) (F.ε.app X) =
  CategoryTheory.CategoryStruct.id ((F.obj (𝟙_ M)).obj X)

full_name: CategoryTheory.ε_naturality
code: @[reassoc (attr := simp)]
theorem ε_naturality {X Y : C} (f : X ⟶ Y) : F.ε.app X ≫ (F.obj (𝟙_ M)).map f = f ≫ F.ε.app Y 
goal: CategoryTheory.CategoryStruct.comp (F.ε.app X) ((F.obj (𝟙_ M)).map f) = CategoryTheory.CategoryStruct.comp f (F.ε.app Y)

full_name: CategoryTheory.ε_inv_naturality
code: @[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 
goal: CategoryTheory.CategoryStruct.comp (F.εIso.inv.app X) ((𝟙_ (CategoryTheory.Functor C C)).map f) =
  CategoryTheory.CategoryStruct.comp (F.εIso.inv.app X) f

full_name: CategoryTheory.μ_naturality
code: @[reassoc (attr := simp)]
theorem μ_naturality {m n : M} {X Y : C} (f : X ⟶ Y) :
    (F.obj n).map ((F.obj m).map f) ≫ (F.μ m n).app Y = (F.μ m n).app X ≫ (F.obj _).map f 
goal: CategoryTheory.CategoryStruct.comp ((F.obj n).map ((F.obj m).map f)) ((F.μ m n).app Y) =
  CategoryTheory.CategoryStruct.comp ((F.μ m n).app X) ((F.obj (CategoryTheory.MonoidalCategory.tensorObj m n)).map f)

full_name: CategoryTheory.μ_inv_naturality
code: @[reassoc]
theorem μ_inv_naturality {m n : M} {X Y : C} (f : X ⟶ Y) :
    (F.μIso m n).inv.app X ≫ (F.obj n).map ((F.obj m).map f) =
      (F.obj _).map f ≫ (F.μIso m n).inv.app Y 
goal: CategoryTheory.CategoryStruct.comp ((F.μIso m n).inv.app X) ((F.obj n).map ((F.obj m).map f)) =
  CategoryTheory.CategoryStruct.comp ((F.obj (CategoryTheory.MonoidalCategory.tensorObj m n)).map f)
    ((F.μIso m n).inv.app Y)

full_name: CategoryTheory.μ_naturality₂
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.map g).app ((F.obj m).obj X))
    (CategoryTheory.CategoryStruct.comp ((F.obj n').map ((F.map f).app X)) ((F.μ m' n').app X)) =
  CategoryTheory.CategoryStruct.comp ((F.μ m n).app X) ((F.map (CategoryTheory.MonoidalCategory.tensorHom f g)).app X)

full_name: CategoryTheory.μ_naturalityₗ
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.obj n).map ((F.map f).app X)) ((F.μ m' n).app X) =
  CategoryTheory.CategoryStruct.comp ((F.μ m n).app X)
    ((F.map (CategoryTheory.MonoidalCategory.whiskerRight f n)).app X)

full_name: CategoryTheory.μ_naturalityᵣ
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.map g).app ((F.obj m).obj X)) ((F.μ m n').app X) =
  CategoryTheory.CategoryStruct.comp ((F.μ m n).app X) ((F.map (CategoryTheory.MonoidalCategory.whiskerLeft m g)).app X)

full_name: CategoryTheory.μ_inv_naturalityₗ
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.μIso m n).inv.app X) ((F.obj n).map ((F.map f).app X)) =
  CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.whiskerRight f n)).app X)
    ((F.μIso m' n).inv.app X)

full_name: CategoryTheory.μ_inv_naturalityᵣ
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.μIso m n).inv.app X) ((F.map g).app ((F.obj m).obj X)) =
  CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.whiskerLeft m g)).app X)
    ((F.μIso m n').inv.app X)

full_name: CategoryTheory.left_unitality_app
code: @[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 = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((F.obj n).map (F.ε.app X))
    (CategoryTheory.CategoryStruct.comp ((F.μ (𝟙_ M) n).app X)
      ((F.map (CategoryTheory.MonoidalCategory.leftUnitor n).hom).app X)) =
  CategoryTheory.CategoryStruct.id ((F.obj n).obj ((𝟙_ (CategoryTheory.Functor C C)).obj X))

full_name: CategoryTheory.obj_ε_app
code: @[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 
goal: (F.obj n).map (F.ε.app X) =
  CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.leftUnitor n).inv).app X)
    ((F.μIso (𝟙_ M) n).inv.app X)

full_name: CategoryTheory.obj_ε_inv_app
code: @[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 
goal: (F.obj n).map (F.εIso.inv.app X) =
  CategoryTheory.CategoryStruct.comp ((F.μ (𝟙_ M) n).app X)
    ((F.map (CategoryTheory.MonoidalCategory.leftUnitor n).hom).app X)

full_name: CategoryTheory.right_unitality_app
code: @[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 = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.ε.app ((F.obj n).obj X))
    (CategoryTheory.CategoryStruct.comp ((F.μ n (𝟙_ M)).app X)
      ((F.map (CategoryTheory.MonoidalCategory.rightUnitor n).hom).app X)) =
  CategoryTheory.CategoryStruct.id ((𝟙_ (CategoryTheory.Functor C C)).obj ((F.obj n).obj X))

full_name: CategoryTheory.ε_app_obj
code: @[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 
goal: F.ε.app ((F.obj n).obj X) =
  CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.rightUnitor n).inv).app X)
    ((F.μIso n (𝟙_ M)).inv.app X)

full_name: CategoryTheory.ε_inv_app_obj
code: @[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 
goal: F.εIso.inv.app ((F.obj n).obj X) =
  CategoryTheory.CategoryStruct.comp ((F.μ n (𝟙_ M)).app X)
    ((F.map (CategoryTheory.MonoidalCategory.rightUnitor n).hom).app X)

full_name: CategoryTheory.associativity_app
code: @[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 
goal: CategoryTheory.CategoryStruct.comp ((F.obj m₃).map ((F.μ m₁ m₂).app X))
    (CategoryTheory.CategoryStruct.comp ((F.μ (CategoryTheory.MonoidalCategory.tensorObj m₁ m₂) m₃).app X)
      ((F.map (CategoryTheory.MonoidalCategory.associator m₁ m₂ m₃).hom).app X)) =
  CategoryTheory.CategoryStruct.comp ((F.μ m₂ m₃).app ((F.obj m₁).obj X))
    ((F.μ m₁ (CategoryTheory.MonoidalCategory.tensorObj m₂ m₃)).app X)

full_name: CategoryTheory.obj_μ_app
code: @[reassoc (attr := simp, nolint simpNF)]
theorem obj_μ_app (m₁ m₂ m₃ : M) (X : C) :
    (F.obj m₃).map ((F.μ m₁ m₂).app X) =
      (F.μ m₂ m₃).app ((F.obj m₁).obj X) ≫
        (F.μ m₁ (m₂ ⊗ m₃)).app X ≫
          (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (F.μIso (m₁ ⊗ m₂) m₃).inv.app X 
goal: (F.obj m₃).map ((F.μ m₁ m₂).app X) =
  CategoryTheory.CategoryStruct.comp ((F.μ m₂ m₃).app ((F.obj m₁).obj X))
    (CategoryTheory.CategoryStruct.comp ((F.μ m₁ (CategoryTheory.MonoidalCategory.tensorObj m₂ m₃)).app X)
      (CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.associator m₁ m₂ m₃).inv).app X)
        ((F.μIso (CategoryTheory.MonoidalCategory.tensorObj m₁ m₂) m₃).inv.app X)))

full_name: CategoryTheory.obj_μ_inv_app
code: @[reassoc (attr := simp, nolint simpNF)]
theorem obj_μ_inv_app (m₁ m₂ m₃ : M) (X : C) :
    (F.obj m₃).map ((F.μIso m₁ m₂).inv.app X) =
      (F.μ (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫
          (F.μIso m₁ (m₂ ⊗ m₃)).inv.app X ≫ (F.μIso m₂ m₃).inv.app ((F.obj m₁).obj X) 
goal: (F.obj m₃).map ((F.μIso m₁ m₂).inv.app X) =
  CategoryTheory.CategoryStruct.comp ((F.μ (CategoryTheory.MonoidalCategory.tensorObj m₁ m₂) m₃).app X)
    (CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.associator m₁ m₂ m₃).hom).app X)
      (CategoryTheory.CategoryStruct.comp ((F.μIso m₁ (CategoryTheory.MonoidalCategory.tensorObj m₂ m₃)).inv.app X)
        ((F.μIso m₂ m₃).inv.app ((F.obj m₁).obj X))))

full_name: CategoryTheory.obj_zero_map_μ_app
code: @[reassoc (attr := simp)]
theorem obj_zero_map_μ_app {m : M} {X Y : C} (f : X ⟶ (F.obj m).obj Y) :
    (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app _ =
    F.εIso.inv.app _ ≫ f ≫ (F.map (ρ_ m).inv).app _ 
goal: CategoryTheory.CategoryStruct.comp ((F.obj (𝟙_ M)).map f) ((F.μ m (𝟙_ M)).app Y) =
  CategoryTheory.CategoryStruct.comp (F.εIso.inv.app X)
    (CategoryTheory.CategoryStruct.comp f ((F.map (CategoryTheory.MonoidalCategory.rightUnitor m).inv).app Y))

full_name: CategoryTheory.obj_μ_zero_app
code: @[simp]
theorem obj_μ_zero_app (m₁ m₂ : M) (X : C) :
    (F.μ (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫ (F.μ m₁ (𝟙_ M ⊗ m₂)).app X ≫
    (F.map (α_ m₁ (𝟙_ M) m₂).inv).app X ≫ (F.μIso (m₁ ⊗ 𝟙_ M) m₂).inv.app X =
    (F.μ (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫
    (F.map (λ_ m₂).hom).app ((F.obj m₁).obj X) ≫ (F.obj m₂).map ((F.map (ρ_ m₁).inv).app X) 
goal: CategoryTheory.CategoryStruct.comp ((F.μ (𝟙_ M) m₂).app ((F.obj m₁).obj X))
    (CategoryTheory.CategoryStruct.comp ((F.μ m₁ (CategoryTheory.MonoidalCategory.tensorObj (𝟙_ M) m₂)).app X)
      (CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategory.associator m₁ (𝟙_ M) m₂).inv).app X)
        ((F.μIso (CategoryTheory.MonoidalCategory.tensorObj m₁ (𝟙_ M)) m₂).inv.app X))) =
  CategoryTheory.CategoryStruct.comp ((F.μ (𝟙_ M) m₂).app ((F.obj m₁).obj X))
    (CategoryTheory.CategoryStruct.comp
      ((F.map (CategoryTheory.MonoidalCategory.leftUnitor m₂).hom).app ((F.obj m₁).obj X))
      ((F.obj m₂).map ((F.map (CategoryTheory.MonoidalCategory.rightUnitor m₁).inv).app X)))

full_name: CategoryTheory.unitOfTensorIsoUnit
code: /-- If `m ⊗ n ≅ 𝟙_M`, then `F.obj m` is a left inverse of `F.obj n`. -/
@[simps!]
noncomputable def unitOfTensorIsoUnit (m n : M) (h : m ⊗ n ≅ 𝟙_ M) : F.obj m ⋙ F.obj n ≅ 𝟭 C 
goal: (F.obj m).comp (F.obj n) ≅ CategoryTheory.Functor.id C

full_name: CategoryTheory.unitOfTensorIsoUnit_hom_app
code: /-- If `m ⊗ n ≅ 𝟙_M`, then `F.obj m` is a left inverse of `F.obj n`. -/
@[simps!]
noncomputable def unitOfTensorIsoUnit (m n : M) (h : m ⊗ n ≅ 𝟙_ M) : F.obj m ⋙ F.obj n ≅ 𝟭 C 
goal: (CategoryTheory.unitOfTensorIsoUnit F m n h).hom.app X =
  CategoryTheory.CategoryStruct.comp ((F.μ m n).app X)
    (CategoryTheory.CategoryStruct.comp ((F.map h.hom).app X) (F.εIso.inv.app X))

full_name: CategoryTheory.unitOfTensorIsoUnit_inv_app
code: /-- If `m ⊗ n ≅ 𝟙_M`, then `F.obj m` is a left inverse of `F.obj n`. -/
@[simps!]
noncomputable def unitOfTensorIsoUnit (m n : M) (h : m ⊗ n ≅ 𝟙_ M) : F.obj m ⋙ F.obj n ≅ 𝟭 C 
goal: (CategoryTheory.unitOfTensorIsoUnit F m n h).inv.app X =
  CategoryTheory.CategoryStruct.comp (F.ε.app X)
    (CategoryTheory.CategoryStruct.comp ((F.map h.inv).app X) ((F.μIso m n).inv.app X))

full_name: CategoryTheory.equivOfTensorIsoUnit_inverse
code: /-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C 
goal: (CategoryTheory.equivOfTensorIsoUnit F m n h₁ h₂ H).inverse = F.obj n

full_name: CategoryTheory.equivOfTensorIsoUnit
code: /-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C 
goal: C ≌ C

full_name: CategoryTheory.equivOfTensorIsoUnit_functor
code: /-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C 
goal: (CategoryTheory.equivOfTensorIsoUnit F m n h₁ h₂ H).functor = F.obj m

full_name: CategoryTheory.equivOfTensorIsoUnit_counitIso
code: /-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C 
goal: (CategoryTheory.equivOfTensorIsoUnit F m n h₁ h₂ H).counitIso = CategoryTheory.unitOfTensorIsoUnit F n m h₂

full_name: CategoryTheory.equivOfTensorIsoUnit_unitIso
code: /-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C 
goal: (CategoryTheory.equivOfTensorIsoUnit F m n h₁ h₂ H).unitIso = (CategoryTheory.unitOfTensorIsoUnit F m n h₁).symm