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

full_name: ModuleCat.braiding
code: /-- (implementation) the braiding for R-modules -/
def braiding (M N : ModuleCat.{u} R) : M ⊗ N ≅ N ⊗ M 
goal: M ⊗ N ≅ N ⊗ M

full_name: ModuleCat.MonoidalCategory.braiding_naturality
code: @[simp]
theorem braiding_naturality {X₁ X₂ Y₁ Y₂ : ModuleCat.{u} R} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    (f ⊗ g) ≫ (Y₁.braiding Y₂).hom = (X₁.braiding X₂).hom ≫ (g ⊗ f) 
goal: (f ⊗ g) ≫ (Y₁.braiding Y₂).hom = (X₁.braiding X₂).hom ≫ (g ⊗ f)

full_name: ModuleCat.MonoidalCategory.braiding_naturality_left
code: @[simp]
theorem braiding_naturality_left {X Y : ModuleCat R} (f : X ⟶ Y) (Z : ModuleCat R) :
    f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f 
goal: f ▷ Z ≫ (Y.braiding Z).hom = (X.braiding Z).hom ≫ Z ◁ f

full_name: ModuleCat.MonoidalCategory.braiding_naturality_right
code: @[simp]
theorem braiding_naturality_right (X : ModuleCat R) {Y Z : ModuleCat R} (f : Y ⟶ Z) :
    X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X 
goal: X ◁ f ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X

full_name: ModuleCat.MonoidalCategory.hexagon_forward
code: @[simp]
theorem hexagon_forward (X Y Z : ModuleCat.{u} R) :
    (α_ X Y Z).hom ≫ (braiding X _).hom ≫ (α_ Y Z X).hom =
      (braiding X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (braiding X Z).hom 
goal: (α_ X Y Z).hom ≫ (X.braiding (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
  (X.braiding Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (X.braiding Z).hom

full_name: ModuleCat.MonoidalCategory.hexagon_reverse
code: @[simp]
theorem hexagon_reverse (X Y Z : ModuleCat.{u} R) :
    (α_ X Y Z).inv ≫ (braiding _ Z).hom ≫ (α_ Z X Y).inv =
      X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y 
goal: (α_ X Y Z).inv ≫ ((X ⊗ Y).braiding Z).hom ≫ (α_ Z X Y).inv =
  X ◁ (Y.braiding Z).hom ≫ (α_ X Z Y).inv ≫ (X.braiding Z).hom ▷ Y

full_name: ModuleCat.MonoidalCategory.symmetricCategory
code: /-- The symmetric monoidal structure on `Module R`. -/
instance symmetricCategory : SymmetricCategory (ModuleCat.{u} R) 
goal: CategoryTheory.SymmetricCategory (ModuleCat R)

full_name: ModuleCat.MonoidalCategory.braiding_hom_apply
code: @[simp]
theorem braiding_hom_apply {M N : ModuleCat.{u} R} (m : M) (n : N) :
    ((β_ M N).hom : M ⊗ N ⟶ N ⊗ M) (m ⊗ₜ n) = n ⊗ₜ m 
goal: (β_ M N).hom (m ⊗ₜ[R] n) = n ⊗ₜ[R] m

full_name: ModuleCat.MonoidalCategory.braiding_inv_apply
code: @[simp]
theorem braiding_inv_apply {M N : ModuleCat.{u} R} (m : M) (n : N) :
    ((β_ M N).inv : N ⊗ M ⟶ M ⊗ N) (n ⊗ₜ m) = m ⊗ₜ n 
goal: (β_ M N).inv (n ⊗ₜ[R] m) = m ⊗ₜ[R] n

full_name: ModuleCat.MonoidalCategory.tensor_μ_eq_tensorTensorTensorComm
code: theorem tensor_μ_eq_tensorTensorTensorComm {A B C D : ModuleCat R} :
    tensor_μ _ (A, B) (C, D) = (TensorProduct.tensorTensorTensorComm R A B C D).toLinearMap 
goal: CategoryTheory.tensor_μ (ModuleCat R) (A, B) (C, D) = ↑(TensorProduct.tensorTensorTensorComm R ↑A ↑B ↑C ↑D)

full_name: ModuleCat.MonoidalCategory.tensor_μ_apply
code: @[simp]
theorem tensor_μ_apply
    {A B C D : ModuleCat R} (x : A) (y : B) (z : C) (w : D) :
    tensor_μ _ (A, B) (C, D) ((x ⊗ₜ y) ⊗ₜ (z ⊗ₜ w)) = (x ⊗ₜ z) ⊗ₜ (y ⊗ₜ w) 
goal: (CategoryTheory.tensor_μ (ModuleCat R) (A, B) (C, D)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z ⊗ₜ[R] w) = (x ⊗ₜ[R] z) ⊗ₜ[R] y ⊗ₜ[R] w