File: Mathlib/CategoryTheory/Monoidal/FunctorCategory.lean

full_name: CategoryTheory.Monoidal.FunctorCategory.tensorObj_obj
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.)
Tensor product of functors `C ⥤ D`, when `D` is monoidal.
 -/
@[simps]
def tensorObj : C ⥤ D 
goal: (CategoryTheory.Monoidal.FunctorCategory.tensorObj F G).obj X = F.obj X ⊗ G.obj X

full_name: CategoryTheory.Monoidal.FunctorCategory.tensorObj_map
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.)
Tensor product of functors `C ⥤ D`, when `D` is monoidal.
 -/
@[simps]
def tensorObj : C ⥤ D 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Monoidal.FunctorCategory.tensorObj F G).map f = F.map f ⊗ G.map f

full_name: CategoryTheory.Monoidal.FunctorCategory.tensorObj
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.)
Tensor product of functors `C ⥤ D`, when `D` is monoidal.
 -/
@[simps]
def tensorObj : C ⥤ D 
goal: C ⥤ D

full_name: CategoryTheory.Monoidal.FunctorCategory.tensorHom_app
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.)
Tensor product of natural transformations into `D`, when `D` is monoidal.
-/
@[simps]
def tensorHom : tensorObj F F' ⟶ tensorObj G G' 
goal: (CategoryTheory.Monoidal.FunctorCategory.tensorHom α β).app X = α.app X ⊗ β.app X

full_name: CategoryTheory.Monoidal.FunctorCategory.tensorHom
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.)
Tensor product of natural transformations into `D`, when `D` is monoidal.
-/
@[simps]
def tensorHom : tensorObj F F' ⟶ tensorObj G G' 
goal: CategoryTheory.Monoidal.FunctorCategory.tensorObj F F' ⟶ CategoryTheory.Monoidal.FunctorCategory.tensorObj G G'

full_name: CategoryTheory.Monoidal.FunctorCategory.whiskerLeft
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.) -/
@[simps]
def whiskerLeft (F) (β : F' ⟶ G') : tensorObj F F' ⟶ tensorObj F G' 
goal: CategoryTheory.Monoidal.FunctorCategory.tensorObj F F' ⟶ CategoryTheory.Monoidal.FunctorCategory.tensorObj F G'

full_name: CategoryTheory.Monoidal.FunctorCategory.whiskerLeft_app
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.) -/
@[simps]
def whiskerLeft (F) (β : F' ⟶ G') : tensorObj F F' ⟶ tensorObj F G' 
goal: (CategoryTheory.Monoidal.FunctorCategory.whiskerLeft F β).app X = F.obj X ◁ β.app X

full_name: CategoryTheory.Monoidal.FunctorCategory.whiskerRight_app
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.) -/
@[simps]
def whiskerRight (F') : tensorObj F F' ⟶ tensorObj G F' 
goal: (CategoryTheory.Monoidal.FunctorCategory.whiskerRight α F').app X = α.app X ▷ F'.obj X

full_name: CategoryTheory.Monoidal.FunctorCategory.whiskerRight
code: /-- (An auxiliary definition for `functorCategoryMonoidal`.) -/
@[simps]
def whiskerRight (F') : tensorObj F F' ⟶ tensorObj G F' 
goal: CategoryTheory.Monoidal.FunctorCategory.tensorObj F F' ⟶ CategoryTheory.Monoidal.FunctorCategory.tensorObj G F'

full_name: CategoryTheory.Monoidal.functorCategoryMonoidalStruct
code: /-- When `C` is any category, and `D` is a monoidal category,
the functor category `C ⥤ D` has a natural pointwise monoidal structure,
where `(F ⊗ G).obj X = F.obj X ⊗ G.obj X`.
-/
instance functorCategoryMonoidalStruct : MonoidalCategoryStruct (C ⥤ D) 
goal: CategoryTheory.MonoidalCategoryStruct (C ⥤ D)

full_name: CategoryTheory.Monoidal.tensorUnit_obj
code: @[simp]
theorem tensorUnit_obj {X} : (𝟙_ (C ⥤ D)).obj X = 𝟙_ D 
goal: (𝟙_ (C ⥤ D)).obj X = 𝟙_ D

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

full_name: CategoryTheory.Monoidal.tensorObj_obj
code: @[simp]
theorem tensorObj_obj {F G : C ⥤ D} {X} : (F ⊗ G).obj X = F.obj X ⊗ G.obj X 
goal: (F ⊗ G).obj X = F.obj X ⊗ G.obj X

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

full_name: CategoryTheory.Monoidal.tensorHom_app
code: @[simp]
theorem tensorHom_app {F G F' G' : C ⥤ D} {α : F ⟶ G} {β : F' ⟶ G'} {X} :
    (α ⊗ β).app X = α.app X ⊗ β.app X 
goal: (α ⊗ β).app X = α.app X ⊗ β.app X

full_name: CategoryTheory.Monoidal.whiskerLeft_app
code: @[simp]
theorem whiskerLeft_app {F F' G' : C ⥤ D} {β : F' ⟶ G'} {X} :
    (F ◁ β).app X = F.obj X ◁ β.app X 
goal: (F ◁ β).app X = F.obj X ◁ β.app X

full_name: CategoryTheory.Monoidal.whiskerRight_app
code: @[simp]
theorem whiskerRight_app {F G F' : C ⥤ D} {α : F ⟶ G} {X} :
    (α ▷ F').app X = α.app X ▷ F'.obj X 
goal: (α ▷ F').app X = α.app X ▷ F'.obj X

full_name: CategoryTheory.Monoidal.leftUnitor_hom_app
code: @[simp]
theorem leftUnitor_hom_app {F : C ⥤ D} {X} :
    ((λ_ F).hom : 𝟙_ _ ⊗ F ⟶ F).app X = (λ_ (F.obj X)).hom 
goal: (λ_ F).hom.app X = (λ_ (F.obj X)).hom

full_name: CategoryTheory.Monoidal.leftUnitor_inv_app
code: @[simp]
theorem leftUnitor_inv_app {F : C ⥤ D} {X} :
    ((λ_ F).inv : F ⟶ 𝟙_ _ ⊗ F).app X = (λ_ (F.obj X)).inv 
goal: (λ_ F).inv.app X = (λ_ (F.obj X)).inv

full_name: CategoryTheory.Monoidal.rightUnitor_hom_app
code: @[simp]
theorem rightUnitor_hom_app {F : C ⥤ D} {X} :
    ((ρ_ F).hom : F ⊗ 𝟙_ _ ⟶ F).app X = (ρ_ (F.obj X)).hom 
goal: (ρ_ F).hom.app X = (ρ_ (F.obj X)).hom

full_name: CategoryTheory.Monoidal.rightUnitor_inv_app
code: @[simp]
theorem rightUnitor_inv_app {F : C ⥤ D} {X} :
    ((ρ_ F).inv : F ⟶ F ⊗ 𝟙_ _).app X = (ρ_ (F.obj X)).inv 
goal: (ρ_ F).inv.app X = (ρ_ (F.obj X)).inv

full_name: CategoryTheory.Monoidal.associator_hom_app
code: @[simp]
theorem associator_hom_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).hom : (F ⊗ G) ⊗ H ⟶ F ⊗ G ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).hom 
goal: (α_ F G H).hom.app X = (α_ (F.obj X) (G.obj X) (H.obj X)).hom

full_name: CategoryTheory.Monoidal.associator_inv_app
code: @[simp]
theorem associator_inv_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).inv : F ⊗ G ⊗ H ⟶ (F ⊗ G) ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).inv 
goal: (α_ F G H).inv.app X = (α_ (F.obj X) (G.obj X) (H.obj X)).inv

full_name: CategoryTheory.Monoidal.functorCategoryMonoidal
code: /-- When `C` is any category, and `D` is a monoidal category,
the functor category `C ⥤ D` has a natural pointwise monoidal structure,
where `(F ⊗ G).obj X = F.obj X ⊗ G.obj X`.
-/
instance functorCategoryMonoidal : MonoidalCategory (C ⥤ D) 
goal: CategoryTheory.MonoidalCategory (C ⥤ D)

full_name: CategoryTheory.Monoidal.functorCategoryBraided
code: /-- When `C` is any category, and `D` is a braided monoidal category,
the natural pointwise monoidal structure on the functor category `C ⥤ D`
is also braided.
-/
instance functorCategoryBraided : BraidedCategory (C ⥤ D) 
goal: CategoryTheory.BraidedCategory (C ⥤ D)

full_name: CategoryTheory.Monoidal.functorCategorySymmetric
code: /-- When `C` is any category, and `D` is a symmetric monoidal category,
the natural pointwise monoidal structure on the functor category `C ⥤ D`
is also symmetric.
-/
instance functorCategorySymmetric : SymmetricCategory (C ⥤ D) 
goal: CategoryTheory.SymmetricCategory (C ⥤ D)