File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

full_name: Submodule.mulMap
code: /-- If `M` and `N` are submodules in an algebra `S` over `R`, there is the natural `R`-linear map
`M ⊗[R] N →ₗ[R] S` induced by multiplication in `S`. -/
def mulMap : M ⊗[R] N →ₗ[R] S 
goal: ↥M ⊗[R] ↥N →ₗ[R] S

full_name: Submodule.mulMap_tmul
code: @[simp]
theorem mulMap_tmul (m : M) (n : N) : mulMap M N (m ⊗ₜ[R] n) = m.1 * n.1 
goal: (M.mulMap N) (m ⊗ₜ[R] n) = ↑m * ↑n

full_name: Submodule.mulMap_op
code: theorem mulMap_op :
    mulMap (equivOpposite.symm (MulOpposite.op M)) (equivOpposite.symm (MulOpposite.op N)) =
    (MulOpposite.opLinearEquiv R).toLinearMap ∘ₗ mulMap N M ∘ₗ
    (TensorProduct.congr
      (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm M)
      (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm N) ≪≫ₗ
    TensorProduct.comm R M N).toLinearMap 
goal: (Submodule.equivOpposite.symm (MulOpposite.op M)).mulMap (Submodule.equivOpposite.symm (MulOpposite.op N)) =
  ↑(MulOpposite.opLinearEquiv R) ∘ₗ
    N.mulMap M ∘ₗ
      ↑(TensorProduct.congr ((MulOpposite.opLinearEquiv R).symm.ofSubmodule' M)
            ((MulOpposite.opLinearEquiv R).symm.ofSubmodule' N) ≪≫ₗ
          TensorProduct.comm R ↥M ↥N)

full_name: Submodule.mulMap_comm_of_commute
code: theorem mulMap_comm_of_commute (hc : ∀ (m : M) (n : N), Commute m.1 n.1) :
    mulMap N M = mulMap M N ∘ₗ TensorProduct.comm R N M 
goal: N.mulMap M = M.mulMap N ∘ₗ ↑(TensorProduct.comm R ↥N ↥M)

full_name: Submodule.mulMap_comp_rTensor
code: theorem mulMap_comp_rTensor {M' : Submodule R S} (hM : M' ≤ M) :
    mulMap M N ∘ₗ (inclusion hM).rTensor N = mulMap M' N 
goal: M.mulMap N ∘ₗ LinearMap.rTensor (↥N) (Submodule.inclusion hM) = M'.mulMap N

full_name: Submodule.mulMap_comp_lTensor
code: theorem mulMap_comp_lTensor {N' : Submodule R S} (hN : N' ≤ N) :
    mulMap M N ∘ₗ (inclusion hN).lTensor M = mulMap M N' 
goal: M.mulMap N ∘ₗ LinearMap.lTensor (↥M) (Submodule.inclusion hN) = M.mulMap N'

full_name: Submodule.mulMap_comp_map_inclusion
code: theorem mulMap_comp_map_inclusion {M' N' : Submodule R S} (hM : M' ≤ M) (hN : N' ≤ N) :
    mulMap M N ∘ₗ TensorProduct.map (inclusion hM) (inclusion hN) = mulMap M' N' 
goal: M.mulMap N ∘ₗ TensorProduct.map (Submodule.inclusion hM) (Submodule.inclusion hN) = M'.mulMap N'

full_name: Submodule.mulMap_eq_mul'_comp_mapIncl
code: theorem mulMap_eq_mul'_comp_mapIncl : mulMap M N = .mul' R S ∘ₗ TensorProduct.mapIncl M N 
goal: M.mulMap N = LinearMap.mul' R S ∘ₗ TensorProduct.mapIncl M N

full_name: Submodule.mulMap_range
code: theorem mulMap_range : LinearMap.range (mulMap M N) = M * N 
goal: LinearMap.range (M.mulMap N) = M * N

full_name: Submodule.mulMap'
code: /-- If `M` and `N` are submodules in an algebra `S` over `R`, there is the natural `R`-linear map
`M ⊗[R] N →ₗ[R] M * N` induced by multiplication in `S`,
which is surjective (`Submodule.mulMap'_surjective`). -/
def mulMap' : M ⊗[R] N →ₗ[R] ↥(M * N) 
goal: ↥M ⊗[R] ↥N →ₗ[R] ↥(M * N)

full_name: Submodule.val_mulMap'_tmul
code: @[simp]
theorem val_mulMap'_tmul (m : M) (n : N) : (mulMap' M N (m ⊗ₜ[R] n) : S) = m.1 * n.1 
goal: ↑((M.mulMap' N) (m ⊗ₜ[R] n)) = ↑m * ↑n

full_name: Submodule.mulMap'_surjective
code: theorem mulMap'_surjective : Function.Surjective (mulMap' M N) 
goal: Function.Surjective ⇑(M.mulMap' N)

full_name: Submodule.lTensorOne'
code: /-- If `N` is a submodule in an algebra `S` over `R`, there is the natural `R`-linear map
`i(R) ⊗[R] N →ₗ[R] N` induced by multiplication in `S`, here `i : R → S` is the structure map.
This is promoted to an isomorphism of `R`-modules as `Submodule.lTensorOne`. Use that instead. -/
def lTensorOne' : (⊥ : Subalgebra R S) ⊗[R] N →ₗ[R] N 
goal: ↥⊥ ⊗[R] ↥N →ₗ[R] ↥N

full_name: Submodule.lTensorOne'_tmul
code: @[simp]
theorem lTensorOne'_tmul (y : R) (n : N) :
    N.lTensorOne' (algebraMap R _ y ⊗ₜ[R] n) = y • n 
goal: N.lTensorOne' ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = y • n

full_name: Submodule.lTensorOne'_one_tmul
code: @[simp]
theorem lTensorOne'_one_tmul (n : N) : N.lTensorOne' (1 ⊗ₜ[R] n) = n 
goal: N.lTensorOne' (1 ⊗ₜ[R] n) = n

full_name: Submodule.lTensorOne
code: /-- If `N` is a submodule in an algebra `S` over `R`,
there is the natural isomorphism of `R`-modules between
`i(R) ⊗[R] N` and `N` induced by multiplication in `S`, here `i : R → S` is the structure map.
This generalizes `TensorProduct.lid` as `i(R)` is not necessarily isomorphic to `R`. -/
def lTensorOne : (⊥ : Subalgebra R S) ⊗[R] N ≃ₗ[R] N 
goal: ↥⊥ ⊗[R] ↥N ≃ₗ[R] ↥N

full_name: Submodule.lTensorOne_tmul
code: @[simp]
theorem lTensorOne_tmul (y : R) (n : N) : N.lTensorOne (algebraMap R _ y ⊗ₜ[R] n) = y • n 
goal: N.lTensorOne ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = y • n

full_name: Submodule.lTensorOne_one_tmul
code: @[simp]
theorem lTensorOne_one_tmul (n : N) : N.lTensorOne (1 ⊗ₜ[R] n) = n 
goal: N.lTensorOne (1 ⊗ₜ[R] n) = n

full_name: Submodule.lTensorOne_symm_apply
code: @[simp]
theorem lTensorOne_symm_apply (n : N) : N.lTensorOne.symm n = 1 ⊗ₜ[R] n 
goal: N.lTensorOne.symm n = 1 ⊗ₜ[R] n

full_name: Submodule.mulMap_one_left_eq
code: theorem mulMap_one_left_eq : mulMap 1 N = N.subtype ∘ₗ N.lTensorOne.toLinearMap 
goal: Submodule.mulMap 1 N = N.subtype ∘ₗ ↑N.lTensorOne

full_name: Submodule.rTensorOne'
code: /-- If `M` is a submodule in an algebra `S` over `R`, there is the natural `R`-linear map
`M ⊗[R] i(R) →ₗ[R] M` induced by multiplication in `S`, here `i : R → S` is the structure map.
This is promoted to an isomorphism of `R`-modules as `Submodule.rTensorOne`. Use that instead. -/
def rTensorOne' : M ⊗[R] (⊥ : Subalgebra R S) →ₗ[R] M 
goal: ↥M ⊗[R] ↥⊥ →ₗ[R] ↥M

full_name: Submodule.rTensorOne'_tmul
code: @[simp]
theorem rTensorOne'_tmul (y : R) (m : M) :
    M.rTensorOne' (m ⊗ₜ[R] algebraMap R _ y) = y • m 
goal: M.rTensorOne' (m ⊗ₜ[R] (algebraMap R ↥⊥) y) = y • m

full_name: Submodule.rTensorOne'_tmul_one
code: @[simp]
theorem rTensorOne'_tmul_one (m : M) : M.rTensorOne' (m ⊗ₜ[R] 1) = m 
goal: M.rTensorOne' (m ⊗ₜ[R] 1) = m

full_name: Submodule.rTensorOne
code: /-- If `M` is a submodule in an algebra `S` over `R`,
there is the natural isomorphism of `R`-modules between
`M ⊗[R] i(R)` and `M` induced by multiplication in `S`, here `i : R → S` is the structure map.
This generalizes `TensorProduct.rid` as `i(R)` is not necessarily isomorphic to `R`. -/
def rTensorOne : M ⊗[R] (⊥ : Subalgebra R S) ≃ₗ[R] M 
goal: ↥M ⊗[R] ↥⊥ ≃ₗ[R] ↥M

full_name: Submodule.rTensorOne_tmul
code: @[simp]
theorem rTensorOne_tmul (y : R) (m : M) : M.rTensorOne (m ⊗ₜ[R] algebraMap R _ y) = y • m 
goal: M.rTensorOne (m ⊗ₜ[R] (algebraMap R ↥⊥) y) = y • m

full_name: Submodule.rTensorOne_tmul_one
code: @[simp]
theorem rTensorOne_tmul_one (m : M) : M.rTensorOne (m ⊗ₜ[R] 1) = m 
goal: M.rTensorOne (m ⊗ₜ[R] 1) = m

full_name: Submodule.rTensorOne_symm_apply
code: @[simp]
theorem rTensorOne_symm_apply (m : M) : M.rTensorOne.symm m = m ⊗ₜ[R] 1 
goal: M.rTensorOne.symm m = m ⊗ₜ[R] 1

full_name: Submodule.mulMap_one_right_eq
code: theorem mulMap_one_right_eq : mulMap M 1 = M.subtype ∘ₗ M.rTensorOne.toLinearMap 
goal: M.mulMap 1 = M.subtype ∘ₗ ↑M.rTensorOne

full_name: Submodule.comm_trans_lTensorOne
code: @[simp]
theorem comm_trans_lTensorOne :
    (TensorProduct.comm R _ _).trans M.lTensorOne = M.rTensorOne 
goal: TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne = M.rTensorOne

full_name: Submodule.comm_trans_rTensorOne
code: @[simp]
theorem comm_trans_rTensorOne :
    (TensorProduct.comm R _ _).trans M.rTensorOne = M.lTensorOne 
goal: TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne = M.lTensorOne

full_name: Submodule.mulLeftMap_eq_mulMap_comp
code: theorem mulLeftMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (m : ι → M) :
    mulLeftMap N m = mulMap M N ∘ₗ LinearMap.rTensor N (Finsupp.total ι M R m) ∘ₗ
      (TensorProduct.finsuppScalarLeft R N ι).symm.toLinearMap 
goal: Submodule.mulLeftMap N m =
  M.mulMap N ∘ₗ LinearMap.rTensor (↥N) (Finsupp.total ι (↥M) R m) ∘ₗ ↑(TensorProduct.finsuppScalarLeft R (↥N) ι).symm

full_name: Submodule.mulRightMap_eq_mulMap_comp
code: theorem mulRightMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (n : ι → N) :
    mulRightMap M n = mulMap M N ∘ₗ LinearMap.lTensor M (Finsupp.total ι N R n) ∘ₗ
      (TensorProduct.finsuppScalarRight R M ι).symm.toLinearMap 
goal: M.mulRightMap n =
  M.mulMap N ∘ₗ LinearMap.lTensor (↥M) (Finsupp.total ι (↥N) R n) ∘ₗ ↑(TensorProduct.finsuppScalarRight R (↥M) ι).symm

full_name: Submodule.mulMap_comm
code: theorem mulMap_comm : mulMap N M = (mulMap M N).comp (TensorProduct.comm R N M).toLinearMap 
goal: N.mulMap M = M.mulMap N ∘ₗ ↑(TensorProduct.comm R ↥N ↥M)