File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

full_name: ModuleCat.MonoidalCategory.tensorObj
code: /-- (implementation) tensor product of R-modules -/
def tensorObj (M N : ModuleCat R) : ModuleCat R 
goal: ModuleCat R

full_name: ModuleCat.MonoidalCategory.tensorHom
code: /-- (implementation) tensor product of morphisms R-modules -/
def tensorHom {M N M' N' : ModuleCat R} (f : M ⟶ N) (g : M' ⟶ N') :
    tensorObj M M' ⟶ tensorObj N N' 
goal: ModuleCat.MonoidalCategory.tensorObj M M' ⟶ ModuleCat.MonoidalCategory.tensorObj N N'

full_name: ModuleCat.MonoidalCategory.whiskerLeft
code: /-- (implementation) left whiskering for R-modules -/
def whiskerLeft (M : ModuleCat R) {N₁ N₂ : ModuleCat R} (f : N₁ ⟶ N₂) :
    tensorObj M N₁ ⟶ tensorObj M N₂ 
goal: ModuleCat.MonoidalCategory.tensorObj M N₁ ⟶ ModuleCat.MonoidalCategory.tensorObj M N₂

full_name: ModuleCat.MonoidalCategory.whiskerRight
code: /-- (implementation) right whiskering for R-modules -/
def whiskerRight {M₁ M₂ : ModuleCat R} (f : M₁ ⟶ M₂) (N : ModuleCat R) :
    tensorObj M₁ N ⟶ tensorObj M₂ N 
goal: ModuleCat.MonoidalCategory.tensorObj M₁ N ⟶ ModuleCat.MonoidalCategory.tensorObj M₂ N

full_name: ModuleCat.MonoidalCategory.tensor_id
code: theorem tensor_id (M N : ModuleCat R) : tensorHom (𝟙 M) (𝟙 N) = 𝟙 (ModuleCat.of R (M ⊗ N)) 
goal: ModuleCat.MonoidalCategory.tensorHom (𝟙 M) (𝟙 N) = 𝟙 (ModuleCat.of R (TensorProduct R ↑M ↑N))

full_name: ModuleCat.MonoidalCategory.tensor_comp
code: theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁)
    (g₂ : Y₂ ⟶ Z₂) : tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom f₁ f₂ ≫ tensorHom g₁ g₂ 
goal: ModuleCat.MonoidalCategory.tensorHom (f₁ ≫ g₁) (f₂ ≫ g₂) =
  ModuleCat.MonoidalCategory.tensorHom f₁ f₂ ≫ ModuleCat.MonoidalCategory.tensorHom g₁ g₂

full_name: ModuleCat.MonoidalCategory.associator
code: /-- (implementation) the associator for R-modules -/
def associator (M : ModuleCat.{v} R) (N : ModuleCat.{w} R) (K : ModuleCat.{x} R) :
    tensorObj (tensorObj M N) K ≅ tensorObj M (tensorObj N K) 
goal: ModuleCat.MonoidalCategory.tensorObj (ModuleCat.MonoidalCategory.tensorObj M N) K ≅
  ModuleCat.MonoidalCategory.tensorObj M (ModuleCat.MonoidalCategory.tensorObj N K)

full_name: ModuleCat.MonoidalCategory.leftUnitor
code: /-- (implementation) the left unitor for R-modules -/
def leftUnitor (M : ModuleCat.{u} R) : ModuleCat.of R (R ⊗[R] M) ≅ M 
goal: ModuleCat.of R (TensorProduct R R ↑M) ≅ M

full_name: ModuleCat.MonoidalCategory.rightUnitor
code: /-- (implementation) the right unitor for R-modules -/
def rightUnitor (M : ModuleCat.{u} R) : ModuleCat.of R (M ⊗[R] R) ≅ M 
goal: ModuleCat.of R (TensorProduct R (↑M) R) ≅ M

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorObj
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory.tensorObj M N = ModuleCat.MonoidalCategory.tensorObj M N

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorUnit
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: 𝟙_ (ModuleCat R) = ModuleCat.of R R

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_rightUnitor
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory.rightUnitor M = ModuleCat.MonoidalCategory.rightUnitor M

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_tensorHom
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: ∀ {X₁ Y₁ X₂ Y₂ : ModuleCat R} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
  CategoryTheory.MonoidalCategory.tensorHom f g = TensorProduct.map f g

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategoryStruct (ModuleCat R)

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_whiskerRight
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: ∀ {X₁ X₂ : ModuleCat R} (f : X₁ ⟶ X₂) (N : ModuleCat R),
  CategoryTheory.MonoidalCategory.whiskerRight f N = ModuleCat.MonoidalCategory.whiskerRight f N

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_whiskerLeft
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory.whiskerLeft M f = ModuleCat.MonoidalCategory.whiskerLeft M f

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_leftUnitor
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory.leftUnitor M = ModuleCat.MonoidalCategory.leftUnitor M

full_name: ModuleCat.MonoidalCategory.instMonoidalCategoryStruct_associator
code: @[simps (config := .lemmasOnly)]
instance instMonoidalCategoryStruct : MonoidalCategoryStruct (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory.associator M N K = ModuleCat.MonoidalCategory.associator M N K

full_name: _private.Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic.0.ModuleCat.MonoidalCategory.associator_naturality_aux
code: private theorem associator_naturality_aux {X₁ X₂ X₃ : Type*} [AddCommMonoid X₁] [AddCommMonoid X₂]
    [AddCommMonoid X₃] [Module R X₁] [Module R X₂] [Module R X₃] {Y₁ Y₂ Y₃ : Type*}
    [AddCommMonoid Y₁] [AddCommMonoid Y₂] [AddCommMonoid Y₃] [Module R Y₁] [Module R Y₂]
    [Module R Y₃] (f₁ : X₁ →ₗ[R] Y₁) (f₂ : X₂ →ₗ[R] Y₂) (f₃ : X₃ →ₗ[R] Y₃) :
    ↑(assoc R Y₁ Y₂ Y₃) ∘ₗ map (map f₁ f₂) f₃ = map f₁ (map f₂ f₃) ∘ₗ ↑(assoc R X₁ X₂ X₃) 
goal: ↑(TensorProduct.assoc R Y₁ Y₂ Y₃) ∘ₗ TensorProduct.map (TensorProduct.map f₁ f₂) f₃ =
  TensorProduct.map f₁ (TensorProduct.map f₂ f₃) ∘ₗ ↑(TensorProduct.assoc R X₁ X₂ X₃)

full_name: _private.Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic.0.ModuleCat.MonoidalCategory.pentagon_aux
code: private theorem pentagon_aux (W X Y Z : Type*) [AddCommMonoid W] [AddCommMonoid X]
    [AddCommMonoid Y] [AddCommMonoid Z] [Module R W] [Module R X] [Module R Y] [Module R Z] :
    (((assoc R X Y Z).toLinearMap.lTensor W).comp
            (assoc R W (X ⊗[R] Y) Z).toLinearMap).comp
        ((assoc R W X Y).toLinearMap.rTensor Z) =
      (assoc R W X (Y ⊗[R] Z)).toLinearMap.comp (assoc R (W ⊗[R] X) Y Z).toLinearMap 
goal: (LinearMap.lTensor W ↑(TensorProduct.assoc R X Y Z) ∘ₗ ↑(TensorProduct.assoc R W (TensorProduct R X Y) Z)) ∘ₗ
    LinearMap.rTensor Z ↑(TensorProduct.assoc R W X Y) =
  ↑(TensorProduct.assoc R W X (TensorProduct R Y Z)) ∘ₗ ↑(TensorProduct.assoc R (TensorProduct R W X) Y Z)

full_name: ModuleCat.MonoidalCategory.associator_naturality
code: theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
    (f₃ : X₃ ⟶ Y₃) :
    tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
      (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃) 
goal: ModuleCat.MonoidalCategory.tensorHom (ModuleCat.MonoidalCategory.tensorHom f₁ f₂) f₃ ≫
    (ModuleCat.MonoidalCategory.associator Y₁ Y₂ Y₃).hom =
  (ModuleCat.MonoidalCategory.associator X₁ X₂ X₃).hom ≫
    ModuleCat.MonoidalCategory.tensorHom f₁ (ModuleCat.MonoidalCategory.tensorHom f₂ f₃)

full_name: ModuleCat.MonoidalCategory.pentagon
code: theorem pentagon (W X Y Z : ModuleCat R) :
    whiskerRight (associator W X Y).hom Z ≫
        (associator W (tensorObj X Y) Z).hom ≫ whiskerLeft W (associator X Y Z).hom =
      (associator (tensorObj W X) Y Z).hom ≫ (associator W X (tensorObj Y Z)).hom 
goal: ModuleCat.MonoidalCategory.whiskerRight (ModuleCat.MonoidalCategory.associator W X Y).hom Z ≫
    (ModuleCat.MonoidalCategory.associator W (ModuleCat.MonoidalCategory.tensorObj X Y) Z).hom ≫
      ModuleCat.MonoidalCategory.whiskerLeft W (ModuleCat.MonoidalCategory.associator X Y Z).hom =
  (ModuleCat.MonoidalCategory.associator (ModuleCat.MonoidalCategory.tensorObj W X) Y Z).hom ≫
    (ModuleCat.MonoidalCategory.associator W X (ModuleCat.MonoidalCategory.tensorObj Y Z)).hom

full_name: ModuleCat.MonoidalCategory.leftUnitor_naturality
code: theorem leftUnitor_naturality {M N : ModuleCat R} (f : M ⟶ N) :
    tensorHom (𝟙 (ModuleCat.of R R)) f ≫ (leftUnitor N).hom = (leftUnitor M).hom ≫ f 
goal: ModuleCat.MonoidalCategory.tensorHom (𝟙 (ModuleCat.of R R)) f ≫ (ModuleCat.MonoidalCategory.leftUnitor N).hom =
  (ModuleCat.MonoidalCategory.leftUnitor M).hom ≫ f

full_name: ModuleCat.MonoidalCategory.rightUnitor_naturality
code: theorem rightUnitor_naturality {M N : ModuleCat R} (f : M ⟶ N) :
    tensorHom f (𝟙 (ModuleCat.of R R)) ≫ (rightUnitor N).hom = (rightUnitor M).hom ≫ f 
goal: ModuleCat.MonoidalCategory.tensorHom f (𝟙 (ModuleCat.of R R)) ≫ (ModuleCat.MonoidalCategory.rightUnitor N).hom =
  (ModuleCat.MonoidalCategory.rightUnitor M).hom ≫ f

full_name: ModuleCat.MonoidalCategory.triangle
code: theorem triangle (M N : ModuleCat.{u} R) :
    (associator M (ModuleCat.of R R) N).hom ≫ tensorHom (𝟙 M) (leftUnitor N).hom =
      tensorHom (rightUnitor M).hom (𝟙 N) 
goal: (ModuleCat.MonoidalCategory.associator M (ModuleCat.of R R) N).hom ≫
    ModuleCat.MonoidalCategory.tensorHom (𝟙 M) (ModuleCat.MonoidalCategory.leftUnitor N).hom =
  ModuleCat.MonoidalCategory.tensorHom (ModuleCat.MonoidalCategory.rightUnitor M).hom (𝟙 N)

full_name: ModuleCat.monoidalCategory
code: instance monoidalCategory : MonoidalCategory (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory (ModuleCat R)

full_name: ModuleCat.instCommRingCarrierTensorUnit
code: /-- Remind ourselves that the monoidal unit, being just `R`, is still a commutative ring. -/
instance : CommRing ((𝟙_ (ModuleCat.{u} R) : ModuleCat.{u} R) : Type u) 
goal: CommRing ↑(𝟙_ (ModuleCat R))

full_name: ModuleCat.MonoidalCategory.hom_apply
code: @[simp]
theorem hom_apply {K L M N : ModuleCat.{u} R} (f : K ⟶ L) (g : M ⟶ N) (k : K) (m : M) :
    (f ⊗ g) (k ⊗ₜ m) = f k ⊗ₜ g m 
goal: (CategoryTheory.MonoidalCategory.tensorHom f g) (k ⊗ₜ[R] m) = f k ⊗ₜ[R] g m

full_name: ModuleCat.MonoidalCategory.whiskerLeft_apply
code: @[simp]
theorem whiskerLeft_apply (L : ModuleCat.{u} R) {M N : ModuleCat.{u} R} (f : M ⟶ N)
    (l : L) (m : M) :
    (L ◁ f) (l ⊗ₜ m) = l ⊗ₜ f m 
goal: (CategoryTheory.MonoidalCategory.whiskerLeft L f) (l ⊗ₜ[R] m) = l ⊗ₜ[R] f m

full_name: ModuleCat.MonoidalCategory.whiskerRight_apply
code: @[simp]
theorem whiskerRight_apply {L M : ModuleCat.{u} R} (f : L ⟶ M) (N : ModuleCat.{u} R)
    (l : L) (n : N) :
    (f ▷ N) (l ⊗ₜ n) = f l ⊗ₜ n 
goal: (CategoryTheory.MonoidalCategory.whiskerRight f N) (l ⊗ₜ[R] n) = f l ⊗ₜ[R] n

full_name: ModuleCat.MonoidalCategory.leftUnitor_hom_apply
code: @[simp]
theorem leftUnitor_hom_apply {M : ModuleCat.{u} R} (r : R) (m : M) :
    ((λ_ M).hom : 𝟙_ (ModuleCat R) ⊗ M ⟶ M) (r ⊗ₜ[R] m) = r • m 
goal: (CategoryTheory.MonoidalCategory.leftUnitor M).hom (r ⊗ₜ[R] m) = r • m

full_name: ModuleCat.MonoidalCategory.leftUnitor_inv_apply
code: @[simp]
theorem leftUnitor_inv_apply {M : ModuleCat.{u} R} (m : M) :
    ((λ_ M).inv : M ⟶ 𝟙_ (ModuleCat.{u} R) ⊗ M) m = 1 ⊗ₜ[R] m 
goal: (CategoryTheory.MonoidalCategory.leftUnitor M).inv m = 1 ⊗ₜ[R] m

full_name: ModuleCat.MonoidalCategory.rightUnitor_hom_apply
code: @[simp]
theorem rightUnitor_hom_apply {M : ModuleCat.{u} R} (m : M) (r : R) :
    ((ρ_ M).hom : M ⊗ 𝟙_ (ModuleCat R) ⟶ M) (m ⊗ₜ r) = r • m 
goal: (CategoryTheory.MonoidalCategory.rightUnitor M).hom (m ⊗ₜ[R] r) = r • m

full_name: ModuleCat.MonoidalCategory.rightUnitor_inv_apply
code: @[simp]
theorem rightUnitor_inv_apply {M : ModuleCat.{u} R} (m : M) :
    ((ρ_ M).inv : M ⟶ M ⊗ 𝟙_ (ModuleCat.{u} R)) m = m ⊗ₜ[R] 1 
goal: (CategoryTheory.MonoidalCategory.rightUnitor M).inv m = m ⊗ₜ[R] 1

full_name: ModuleCat.MonoidalCategory.associator_hom_apply
code: @[simp]
theorem associator_hom_apply {M N K : ModuleCat.{u} R} (m : M) (n : N) (k : K) :
    ((α_ M N K).hom : (M ⊗ N) ⊗ K ⟶ M ⊗ N ⊗ K) (m ⊗ₜ n ⊗ₜ k) = m ⊗ₜ (n ⊗ₜ k) 
goal: (CategoryTheory.MonoidalCategory.associator M N K).hom ((m ⊗ₜ[R] n) ⊗ₜ[R] k) = m ⊗ₜ[R] n ⊗ₜ[R] k

full_name: ModuleCat.MonoidalCategory.associator_inv_apply
code: @[simp]
theorem associator_inv_apply {M N K : ModuleCat.{u} R} (m : M) (n : N) (k : K) :
    ((α_ M N K).inv : M ⊗ N ⊗ K ⟶ (M ⊗ N) ⊗ K) (m ⊗ₜ (n ⊗ₜ k)) = m ⊗ₜ n ⊗ₜ k 
goal: (CategoryTheory.MonoidalCategory.associator M N K).inv (m ⊗ₜ[R] n ⊗ₜ[R] k) = (m ⊗ₜ[R] n) ⊗ₜ[R] k

full_name: ModuleCat.instMonoidalPreadditive
code: instance : MonoidalPreadditive (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalPreadditive (ModuleCat R)

full_name: ModuleCat.instMonoidalLinear
code: instance : MonoidalLinear R (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalLinear R (ModuleCat R)