File: Mathlib/LinearAlgebra/TensorProduct/Tower.lean

full_name: TensorProduct.AlgebraTensorModule.smul_eq_lsmul_rTensor
code: theorem smul_eq_lsmul_rTensor (a : A) (x : M ⊗[R] N) : a • x = (lsmul R R M a).rTensor N x 
goal: a • x = (LinearMap.rTensor N ((Algebra.lsmul R R M) a)) x

full_name: TensorProduct.AlgebraTensorModule.curry
code: /-- Heterobasic version of `TensorProduct.curry`:

Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. -/
@[simps]
nonrec def curry (f : M ⊗[R] N →ₗ[A] P) : M →ₗ[A] N →ₗ[R] P 
goal: M →ₗ[A] N →ₗ[R] P

full_name: TensorProduct.AlgebraTensorModule.curry_apply
code: /-- Heterobasic version of `TensorProduct.curry`:

Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. -/
@[simps]
nonrec def curry (f : M ⊗[R] N →ₗ[A] P) : M →ₗ[A] N →ₗ[R] P 
goal: (TensorProduct.AlgebraTensorModule.curry f) a = (TensorProduct.curry (↑R f)) a

full_name: TensorProduct.AlgebraTensorModule.restrictScalars_curry
code: theorem restrictScalars_curry (f : M ⊗[R] N →ₗ[A] P) :
    restrictScalars R (curry f) = TensorProduct.curry (f.restrictScalars R) 
goal: ↑R (TensorProduct.AlgebraTensorModule.curry f) = TensorProduct.curry (↑R f)

full_name: TensorProduct.AlgebraTensorModule.curry_injective
code: /-- Just as `TensorProduct.ext` is marked `ext` instead of `TensorProduct.ext'`, this is
a better `ext` lemma than `TensorProduct.AlgebraTensorModule.ext` below.

See note [partially-applied ext lemmas]. -/
@[ext high]
nonrec theorem curry_injective : Function.Injective (curry : (M ⊗ N →ₗ[A] P) → M →ₗ[A] N →ₗ[R] P) 
goal: Function.Injective TensorProduct.AlgebraTensorModule.curry

full_name: TensorProduct.AlgebraTensorModule.ext
code: theorem ext {g h : M ⊗[R] N →ₗ[A] P} (H : ∀ x y, g (x ⊗ₜ y) = h (x ⊗ₜ y)) : g = h 
goal: g = h

full_name: TensorProduct.AlgebraTensorModule.lift
code: /-- Heterobasic version of `TensorProduct.lift`:

Constructing a linear map `M ⊗[R] N →[A] P` given a bilinear map `M →[A] N →[R] P` with the
property that its composition with the canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is
the given bilinear map `M →[A] N →[R] P`. -/
nonrec def lift (f : M →ₗ[A] N →ₗ[R] P) : M ⊗[R] N →ₗ[A] P 
goal: TensorProduct R M N →ₗ[A] P

full_name: TensorProduct.AlgebraTensorModule.lift_apply
code: @[simp]
theorem lift_apply (f : M →ₗ[A] N →ₗ[R] P) (a : M ⊗[R] N) :
    AlgebraTensorModule.lift f a = TensorProduct.lift (LinearMap.restrictScalars R f) a 
goal: (TensorProduct.AlgebraTensorModule.lift f) a = (TensorProduct.lift (↑R f)) a

full_name: TensorProduct.AlgebraTensorModule.lift_tmul
code: @[simp]
theorem lift_tmul (f : M →ₗ[A] N →ₗ[R] P) (x : M) (y : N) : lift f (x ⊗ₜ y) = f x y 
goal: (TensorProduct.AlgebraTensorModule.lift f) (x ⊗ₜ[R] y) = (f x) y

full_name: TensorProduct.AlgebraTensorModule.uncurry_apply
code: /-- Heterobasic version of `TensorProduct.uncurry`:

Linearly constructing a linear map `M ⊗[R] N →[A] P` given a bilinear map `M →[A] N →[R] P`
with the property that its composition with the canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is
the given bilinear map `M →[A] N →[R] P`. -/
@[simps]
def uncurry : (M →ₗ[A] N →ₗ[R] P) →ₗ[B] M ⊗[R] N →ₗ[A] P 
goal: (TensorProduct.AlgebraTensorModule.uncurry R A B M N P) f = TensorProduct.AlgebraTensorModule.lift f

full_name: TensorProduct.AlgebraTensorModule.uncurry
code: /-- Heterobasic version of `TensorProduct.uncurry`:

Linearly constructing a linear map `M ⊗[R] N →[A] P` given a bilinear map `M →[A] N →[R] P`
with the property that its composition with the canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is
the given bilinear map `M →[A] N →[R] P`. -/
@[simps]
def uncurry : (M →ₗ[A] N →ₗ[R] P) →ₗ[B] M ⊗[R] N →ₗ[A] P 
goal: (M →ₗ[A] N →ₗ[R] P) →ₗ[B] TensorProduct R M N →ₗ[A] P

full_name: TensorProduct.AlgebraTensorModule.lcurry_apply
code: /-- Heterobasic version of `TensorProduct.lcurry`:

Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. -/
@[simps]
def lcurry : (M ⊗[R] N →ₗ[A] P) →ₗ[B] M →ₗ[A] N →ₗ[R] P 
goal: (TensorProduct.AlgebraTensorModule.lcurry R A B M N P) f = TensorProduct.AlgebraTensorModule.curry f

full_name: TensorProduct.AlgebraTensorModule.lcurry
code: /-- Heterobasic version of `TensorProduct.lcurry`:

Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. -/
@[simps]
def lcurry : (M ⊗[R] N →ₗ[A] P) →ₗ[B] M →ₗ[A] N →ₗ[R] P 
goal: (TensorProduct R M N →ₗ[A] P) →ₗ[B] M →ₗ[A] N →ₗ[R] P

full_name: TensorProduct.AlgebraTensorModule.lift.equiv
code: /-- Heterobasic version of `TensorProduct.lift.equiv`:

A linear equivalence constructing a linear map `M ⊗[R] N →[A] P` given a
bilinear map `M →[A] N →[R] P` with the property that its composition with the
canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is the given bilinear map `M →[A] N →[R] P`. -/
def lift.equiv : (M →ₗ[A] N →ₗ[R] P) ≃ₗ[B] M ⊗[R] N →ₗ[A] P 
goal: (M →ₗ[A] N →ₗ[R] P) ≃ₗ[B] TensorProduct R M N →ₗ[A] P

full_name: TensorProduct.AlgebraTensorModule.mk
code: /-- Heterobasic version of `TensorProduct.mk`:

The canonical bilinear map `M →[A] N →[R] M ⊗[R] N`. -/
@[simps! apply]
nonrec def mk : M →ₗ[A] N →ₗ[R] M ⊗[R] N 
goal: M →ₗ[A] N →ₗ[R] TensorProduct R M N

full_name: TensorProduct.AlgebraTensorModule.mk_apply
code: /-- Heterobasic version of `TensorProduct.mk`:

The canonical bilinear map `M →[A] N →[R] M ⊗[R] N`. -/
@[simps! apply]
nonrec def mk : M →ₗ[A] N →ₗ[R] M ⊗[R] N 
goal: (TensorProduct.AlgebraTensorModule.mk R A M N) m = { toFun := fun x => m ⊗ₜ[R] x, map_add' := ⋯, map_smul' := ⋯ }

full_name: TensorProduct.AlgebraTensorModule.map
code: /-- Heterobasic version of `TensorProduct.map` -/
def map (f : M →ₗ[A] P) (g : N →ₗ[R] Q) : M ⊗[R] N →ₗ[A] P ⊗[R] Q 
goal: TensorProduct R M N →ₗ[A] TensorProduct R P Q

full_name: TensorProduct.AlgebraTensorModule.map_tmul
code: @[simp] theorem map_tmul (f : M →ₗ[A] P) (g : N →ₗ[R] Q) (m : M) (n : N) :
    map f g (m ⊗ₜ n) = f m ⊗ₜ g n 
goal: (TensorProduct.AlgebraTensorModule.map f g) (m ⊗ₜ[R] n) = f m ⊗ₜ[R] g n

full_name: TensorProduct.AlgebraTensorModule.map_id
code: @[simp]
theorem map_id : map (id : M →ₗ[A] M) (id : N →ₗ[R] N) = .id 
goal: TensorProduct.AlgebraTensorModule.map LinearMap.id LinearMap.id = LinearMap.id

full_name: TensorProduct.AlgebraTensorModule.map_comp
code: theorem map_comp (f₂ : P →ₗ[A] P') (f₁ : M →ₗ[A] P) (g₂ : Q →ₗ[R] Q') (g₁ : N →ₗ[R] Q) :
    map (f₂.comp f₁) (g₂.comp g₁) = (map f₂ g₂).comp (map f₁ g₁) 
goal: TensorProduct.AlgebraTensorModule.map (f₂ ∘ₗ f₁) (g₂ ∘ₗ g₁) =
  TensorProduct.AlgebraTensorModule.map f₂ g₂ ∘ₗ TensorProduct.AlgebraTensorModule.map f₁ g₁

full_name: TensorProduct.AlgebraTensorModule.map_one
code: @[simp]
protected theorem map_one : map (1 : M →ₗ[A] M) (1 : N →ₗ[R] N) = 1 
goal: TensorProduct.AlgebraTensorModule.map 1 1 = 1

full_name: TensorProduct.AlgebraTensorModule.map_mul
code: protected theorem map_mul (f₁ f₂ : M →ₗ[A] M) (g₁ g₂ : N →ₗ[R] N) :
    map (f₁ * f₂) (g₁ * g₂) = map f₁ g₁ * map f₂ g₂ 
goal: TensorProduct.AlgebraTensorModule.map (f₁ * f₂) (g₁ * g₂) =
  TensorProduct.AlgebraTensorModule.map f₁ g₁ * TensorProduct.AlgebraTensorModule.map f₂ g₂

full_name: TensorProduct.AlgebraTensorModule.map_add_left
code: theorem map_add_left (f₁ f₂ : M →ₗ[A] P) (g : N →ₗ[R] Q) :
    map (f₁ + f₂) g = map f₁ g + map f₂ g 
goal: TensorProduct.AlgebraTensorModule.map (f₁ + f₂) g =
  TensorProduct.AlgebraTensorModule.map f₁ g + TensorProduct.AlgebraTensorModule.map f₂ g

full_name: TensorProduct.AlgebraTensorModule.map_add_right
code: theorem map_add_right (f : M →ₗ[A] P) (g₁ g₂ : N →ₗ[R] Q) :
    map f (g₁ + g₂) = map f g₁ + map f g₂ 
goal: TensorProduct.AlgebraTensorModule.map f (g₁ + g₂) =
  TensorProduct.AlgebraTensorModule.map f g₁ + TensorProduct.AlgebraTensorModule.map f g₂

full_name: TensorProduct.AlgebraTensorModule.map_smul_right
code: theorem map_smul_right (r : R) (f : M →ₗ[A] P) (g : N →ₗ[R] Q) : map f (r • g) = r • map f g 
goal: TensorProduct.AlgebraTensorModule.map f (r • g) = r • TensorProduct.AlgebraTensorModule.map f g

full_name: TensorProduct.AlgebraTensorModule.map_smul_left
code: theorem map_smul_left (b : B) (f : M →ₗ[A] P) (g : N →ₗ[R] Q) : map (b • f) g = b • map f g 
goal: TensorProduct.AlgebraTensorModule.map (b • f) g = b • TensorProduct.AlgebraTensorModule.map f g

full_name: TensorProduct.AlgebraTensorModule.mapBilinear
code: /-- Heterobasic version of `TensorProduct.map_bilinear` -/
def mapBilinear : (M →ₗ[A] P) →ₗ[B] (N →ₗ[R] Q) →ₗ[R] (M ⊗[R] N →ₗ[A] P ⊗[R] Q) 
goal: (M →ₗ[A] P) →ₗ[B] (N →ₗ[R] Q) →ₗ[R] TensorProduct R M N →ₗ[A] TensorProduct R P Q

full_name: TensorProduct.AlgebraTensorModule.mapBilinear_apply
code: @[simp]
theorem mapBilinear_apply (f : M →ₗ[A] P) (g : N →ₗ[R] Q) :
    mapBilinear R A B M N P Q f g = map f g 
goal: ((TensorProduct.AlgebraTensorModule.mapBilinear R A B M N P Q) f) g = TensorProduct.AlgebraTensorModule.map f g

full_name: TensorProduct.AlgebraTensorModule.homTensorHomMap
code: /-- Heterobasic version of `TensorProduct.homTensorHomMap` -/
def homTensorHomMap : ((M →ₗ[A] P) ⊗[R] (N →ₗ[R] Q)) →ₗ[B] (M ⊗[R] N →ₗ[A] P ⊗[R] Q) 
goal: TensorProduct R (M →ₗ[A] P) (N →ₗ[R] Q) →ₗ[B] TensorProduct R M N →ₗ[A] TensorProduct R P Q

full_name: TensorProduct.AlgebraTensorModule.homTensorHomMap_apply
code: @[simp] theorem homTensorHomMap_apply (f : M →ₗ[A] P) (g : N →ₗ[R] Q) :
    homTensorHomMap R A B M N P Q (f ⊗ₜ g) = map f g 
goal: (TensorProduct.AlgebraTensorModule.homTensorHomMap R A B M N P Q) (f ⊗ₜ[R] g) =
  TensorProduct.AlgebraTensorModule.map f g

full_name: TensorProduct.AlgebraTensorModule.congr
code: /-- Heterobasic version of `TensorProduct.congr` -/
def congr (f : M ≃ₗ[A] P) (g : N ≃ₗ[R] Q) : (M ⊗[R] N) ≃ₗ[A] (P ⊗[R] Q) 
goal: TensorProduct R M N ≃ₗ[A] TensorProduct R P Q

full_name: TensorProduct.AlgebraTensorModule.congr_refl
code: @[simp]
theorem congr_refl : congr (.refl A M) (.refl R N) = .refl A _ 
goal: TensorProduct.AlgebraTensorModule.congr (LinearEquiv.refl A M) (LinearEquiv.refl R N) =
  LinearEquiv.refl A (TensorProduct R M N)

full_name: TensorProduct.AlgebraTensorModule.congr_trans
code: theorem congr_trans (f₁ : M ≃ₗ[A] P) (f₂ : P ≃ₗ[A] P') (g₁ : N ≃ₗ[R] Q) (g₂ : Q ≃ₗ[R] Q') :
    congr (f₁.trans f₂) (g₁.trans g₂) = (congr f₁ g₁).trans (congr f₂ g₂) 
goal: TensorProduct.AlgebraTensorModule.congr (f₁ ≪≫ₗ f₂) (g₁ ≪≫ₗ g₂) =
  TensorProduct.AlgebraTensorModule.congr f₁ g₁ ≪≫ₗ TensorProduct.AlgebraTensorModule.congr f₂ g₂

full_name: TensorProduct.AlgebraTensorModule.congr_symm
code: theorem congr_symm (f : M ≃ₗ[A] P) (g : N ≃ₗ[R] Q) : congr f.symm g.symm = (congr f g).symm 
goal: TensorProduct.AlgebraTensorModule.congr f.symm g.symm = (TensorProduct.AlgebraTensorModule.congr f g).symm

full_name: TensorProduct.AlgebraTensorModule.congr_one
code: @[simp]
theorem congr_one : congr (1 : M ≃ₗ[A] M) (1 : N ≃ₗ[R] N) = 1 
goal: TensorProduct.AlgebraTensorModule.congr 1 1 = 1

full_name: TensorProduct.AlgebraTensorModule.congr_mul
code: theorem congr_mul (f₁ f₂ : M ≃ₗ[A] M) (g₁ g₂ : N ≃ₗ[R] N) :
    congr (f₁ * f₂) (g₁ * g₂) = congr f₁ g₁ * congr f₂ g₂ 
goal: TensorProduct.AlgebraTensorModule.congr (f₁ * f₂) (g₁ * g₂) =
  TensorProduct.AlgebraTensorModule.congr f₁ g₁ * TensorProduct.AlgebraTensorModule.congr f₂ g₂

full_name: TensorProduct.AlgebraTensorModule.congr_tmul
code: @[simp] theorem congr_tmul (f : M ≃ₗ[A] P) (g : N ≃ₗ[R] Q) (m : M) (n : N) :
    congr f g (m ⊗ₜ n) = f m ⊗ₜ g n 
goal: (TensorProduct.AlgebraTensorModule.congr f g) (m ⊗ₜ[R] n) = f m ⊗ₜ[R] g n

full_name: TensorProduct.AlgebraTensorModule.congr_symm_tmul
code: @[simp] theorem congr_symm_tmul (f : M ≃ₗ[A] P) (g : N ≃ₗ[R] Q) (p : P) (q : Q) :
    (congr f g).symm (p ⊗ₜ q) = f.symm p ⊗ₜ g.symm q 
goal: (TensorProduct.AlgebraTensorModule.congr f g).symm (p ⊗ₜ[R] q) = f.symm p ⊗ₜ[R] g.symm q

full_name: TensorProduct.AlgebraTensorModule.rid
code: /-- Heterobasic version of `TensorProduct.rid`. -/
protected def rid : M ⊗[R] R ≃ₗ[A] M 
goal: TensorProduct R M R ≃ₗ[A] M

full_name: TensorProduct.AlgebraTensorModule.rid_eq_rid
code: theorem rid_eq_rid : AlgebraTensorModule.rid R R M = TensorProduct.rid R M 
goal: TensorProduct.AlgebraTensorModule.rid R R M = TensorProduct.rid R M

full_name: TensorProduct.AlgebraTensorModule.rid_tmul
code: @[simp]
theorem rid_tmul (r : R) (m : M) : AlgebraTensorModule.rid R A M (m ⊗ₜ r) = r • m 
goal: (TensorProduct.AlgebraTensorModule.rid R A M) (m ⊗ₜ[R] r) = r • m

full_name: TensorProduct.AlgebraTensorModule.rid_symm_apply
code: @[simp]
theorem rid_symm_apply (m : M) : (AlgebraTensorModule.rid R A M).symm m = m ⊗ₜ 1 
goal: (TensorProduct.AlgebraTensorModule.rid R A M).symm m = m ⊗ₜ[R] 1

full_name: TensorProduct.AlgebraTensorModule.assoc
code: /-- Heterobasic version of `TensorProduct.assoc`:

`B`-linear equivalence between `(M ⊗[A] P) ⊗[R] Q` and `M ⊗[A] (P ⊗[R] Q)`.

Note this is especially useful with `A = R` (where it is a "more linear" version of
`TensorProduct.assoc`), or with `B = A`. -/
def assoc : (M ⊗[A] P) ⊗[R] Q ≃ₗ[B] M ⊗[A] (P ⊗[R] Q) 
goal: TensorProduct R (TensorProduct A M P) Q ≃ₗ[B] TensorProduct A M (TensorProduct R P Q)

full_name: TensorProduct.AlgebraTensorModule.assoc_tmul
code: @[simp]
theorem assoc_tmul (m : M) (p : P) (q : Q) :
    assoc R A B M P Q ((m ⊗ₜ p) ⊗ₜ q) = m ⊗ₜ (p ⊗ₜ q) 
goal: (TensorProduct.AlgebraTensorModule.assoc R A B M P Q) ((m ⊗ₜ[A] p) ⊗ₜ[R] q) = m ⊗ₜ[A] p ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.assoc_symm_tmul
code: @[simp]
theorem assoc_symm_tmul (m : M) (p : P) (q : Q) :
    (assoc R A B M P Q).symm (m ⊗ₜ (p ⊗ₜ q)) = (m ⊗ₜ p) ⊗ₜ q 
goal: (TensorProduct.AlgebraTensorModule.assoc R A B M P Q).symm (m ⊗ₜ[A] p ⊗ₜ[R] q) = (m ⊗ₜ[A] p) ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.cancelBaseChange
code: /-- `B`-linear equivalence between `M ⊗[A] (A ⊗[R] N)` and `M ⊗[R] N`.
In particular useful with `B = A`. -/
def cancelBaseChange : M ⊗[A] (A ⊗[R] N) ≃ₗ[B] M ⊗[R] N 
goal: TensorProduct A M (TensorProduct R A N) ≃ₗ[B] TensorProduct R M N

full_name: TensorProduct.AlgebraTensorModule.cancelBaseChange_tmul
code: @[simp]
theorem cancelBaseChange_tmul (m : M) (n : N) (a : A) :
    cancelBaseChange R A B M N (m ⊗ₜ (a ⊗ₜ n)) = (a • m) ⊗ₜ n 
goal: (TensorProduct.AlgebraTensorModule.cancelBaseChange R A B M N) (m ⊗ₜ[A] a ⊗ₜ[R] n) = (a • m) ⊗ₜ[R] n

full_name: TensorProduct.AlgebraTensorModule.cancelBaseChange_symm_tmul
code: @[simp]
theorem cancelBaseChange_symm_tmul (m : M) (n : N) :
    (cancelBaseChange R A B M N).symm (m ⊗ₜ n) = m ⊗ₜ (1 ⊗ₜ n) 
goal: (TensorProduct.AlgebraTensorModule.cancelBaseChange R A B M N).symm (m ⊗ₜ[R] n) = m ⊗ₜ[A] 1 ⊗ₜ[R] n

full_name: TensorProduct.AlgebraTensorModule.leftComm
code: /-- Heterobasic version of `TensorProduct.leftComm` -/
def leftComm : M ⊗[A] (P ⊗[R] Q) ≃ₗ[A] P ⊗[A] (M ⊗[R] Q) 
goal: TensorProduct A M (TensorProduct R P Q) ≃ₗ[A] TensorProduct A P (TensorProduct R M Q)

full_name: TensorProduct.AlgebraTensorModule.leftComm_tmul
code: @[simp]
theorem leftComm_tmul (m : M) (p : P) (q : Q) :
    leftComm R A M P Q (m ⊗ₜ (p ⊗ₜ q)) = p ⊗ₜ (m ⊗ₜ q) 
goal: (TensorProduct.AlgebraTensorModule.leftComm R A M P Q) (m ⊗ₜ[A] p ⊗ₜ[R] q) = p ⊗ₜ[A] m ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.leftComm_symm_tmul
code: @[simp]
theorem leftComm_symm_tmul (m : M) (p : P) (q : Q) :
    (leftComm R A M P Q).symm (p ⊗ₜ (m ⊗ₜ q)) = m ⊗ₜ (p ⊗ₜ q) 
goal: (TensorProduct.AlgebraTensorModule.leftComm R A M P Q).symm (p ⊗ₜ[A] m ⊗ₜ[R] q) = m ⊗ₜ[A] p ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.rightComm
code: /-- A tensor product analogue of `mul_right_comm`. -/
def rightComm : (M ⊗[A] P) ⊗[R] Q ≃ₗ[A] (M ⊗[R] Q) ⊗[A] P 
goal: TensorProduct R (TensorProduct A M P) Q ≃ₗ[A] TensorProduct A (TensorProduct R M Q) P

full_name: TensorProduct.AlgebraTensorModule.rightComm_tmul
code: @[simp]
theorem rightComm_tmul (m : M) (p : P) (q : Q) :
    rightComm R A M P Q ((m ⊗ₜ p) ⊗ₜ q) = (m ⊗ₜ q) ⊗ₜ p 
goal: (TensorProduct.AlgebraTensorModule.rightComm R A M P Q) ((m ⊗ₜ[A] p) ⊗ₜ[R] q) = (m ⊗ₜ[R] q) ⊗ₜ[A] p

full_name: TensorProduct.AlgebraTensorModule.rightComm_symm_tmul
code: @[simp]
theorem rightComm_symm_tmul (m : M) (p : P) (q : Q) :
    (rightComm R A M P Q).symm ((m ⊗ₜ q) ⊗ₜ p) = (m ⊗ₜ p) ⊗ₜ q 
goal: (TensorProduct.AlgebraTensorModule.rightComm R A M P Q).symm ((m ⊗ₜ[R] q) ⊗ₜ[A] p) = (m ⊗ₜ[A] p) ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.tensorTensorTensorComm
code: /-- Heterobasic version of `tensorTensorTensorComm`. -/
def tensorTensorTensorComm :
    (M ⊗[R] N) ⊗[A] (P ⊗[R] Q) ≃ₗ[A] (M ⊗[A] P) ⊗[R] (N ⊗[R] Q) 
goal: TensorProduct A (TensorProduct R M N) (TensorProduct R P Q) ≃ₗ[A]
  TensorProduct R (TensorProduct A M P) (TensorProduct R N Q)

full_name: TensorProduct.AlgebraTensorModule.tensorTensorTensorComm_tmul
code: @[simp]
theorem tensorTensorTensorComm_tmul (m : M) (n : N) (p : P) (q : Q) :
    tensorTensorTensorComm R A M N P Q ((m ⊗ₜ n) ⊗ₜ (p ⊗ₜ q)) = (m ⊗ₜ p) ⊗ₜ (n ⊗ₜ q) 
goal: (TensorProduct.AlgebraTensorModule.tensorTensorTensorComm R A M N P Q) ((m ⊗ₜ[R] n) ⊗ₜ[A] p ⊗ₜ[R] q) =
  (m ⊗ₜ[A] p) ⊗ₜ[R] n ⊗ₜ[R] q

full_name: TensorProduct.AlgebraTensorModule.tensorTensorTensorComm_symm_tmul
code: @[simp]
theorem tensorTensorTensorComm_symm_tmul (m : M) (n : N) (p : P) (q : Q) :
    (tensorTensorTensorComm R A M N P Q).symm ((m ⊗ₜ p) ⊗ₜ (n ⊗ₜ q)) = (m ⊗ₜ n) ⊗ₜ (p ⊗ₜ q) 
goal: (TensorProduct.AlgebraTensorModule.tensorTensorTensorComm R A M N P Q).symm ((m ⊗ₜ[A] p) ⊗ₜ[R] n ⊗ₜ[R] q) =
  (m ⊗ₜ[R] n) ⊗ₜ[A] p ⊗ₜ[R] q

full_name: Submodule.baseChange
code: /-- If `A` is an `R`-algebra, any `R`-submodule `p` of an `R`-module `M` may be pushed forward to
an `A`-submodule of `A ⊗ M`.

This "base change" operation is also known as "extension of scalars". -/
def baseChange : Submodule A (A ⊗[R] M) 
goal: Submodule A (TensorProduct R A M)

full_name: Submodule.baseChange_bot
code: @[simp]
lemma baseChange_bot : (⊥ : Submodule R M).baseChange A = ⊥ 
goal: Submodule.baseChange A ⊥ = ⊥

full_name: Submodule.baseChange_top
code: @[simp]
lemma baseChange_top : (⊤ : Submodule R M).baseChange A = ⊤ 
goal: Submodule.baseChange A ⊤ = ⊤

full_name: Submodule.tmul_mem_baseChange_of_mem
code: lemma tmul_mem_baseChange_of_mem (a : A) {m : M} (hm : m ∈ p) :
    a ⊗ₜ[R] m ∈ p.baseChange A 
goal: a ⊗ₜ[R] m ∈ Submodule.baseChange A p

full_name: Submodule.baseChange_span
code: @[simp]
lemma baseChange_span (s : Set M) :
    (span R s).baseChange A = span A (TensorProduct.mk R A M 1 '' s) 
goal: Submodule.baseChange A (Submodule.span R s) = Submodule.span A (⇑((TensorProduct.mk R A M) 1) '' s)