# The tensor product of R-algebras #

This file provides results about the multiplicative structure on A ⊗[R] B when R is a commutative (semi)ring and A and B are both R-algebras. On these tensor products, multiplication is characterized by (a₁ ⊗ₜ b₁) * (a₂ ⊗ₜ b₂) = (a₁ * a₂) ⊗ₜ (b₁ * b₂).

## References #

### The base-change of a linear map of R-modules to a linear map of A-modules #

noncomputable def LinearMap.baseChange {R : Type u_1} (A : Type u_2) {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] (f : M →ₗ[R] N) :

baseChange A f for f : M →ₗ[R] N is the A-linear map A ⊗[R] M →ₗ[A] A ⊗[R] N.

This "base change" operation is also known as "extension of scalars".

Equations
Instances For
@[simp]
theorem LinearMap.baseChange_tmul {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] (f : M →ₗ[R] N) (a : A) (x : M) :
(a ⊗ₜ[R] x) = a ⊗ₜ[R] f x
theorem LinearMap.baseChange_eq_ltensor {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] (f : M →ₗ[R] N) :
=
@[simp]
theorem LinearMap.baseChange_add {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] (f : M →ₗ[R] N) (g : M →ₗ[R] N) :
@[simp]
theorem LinearMap.baseChange_zero {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] :
@[simp]
theorem LinearMap.baseChange_smul {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [] [Algebra R A] [] [] [Module R M] [Module R N] (r : R) (f : M →ₗ[R] N) :
@[simp]
theorem LinearMap.baseChange_id {R : Type u_1} {A : Type u_2} {M : Type u_4} [] [] [Algebra R A] [] [Module R M] :
LinearMap.baseChange A LinearMap.id = LinearMap.id
theorem LinearMap.baseChange_comp {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} {P : Type u_6} [] [] [Algebra R A] [] [] [] [Module R M] [Module R N] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
LinearMap.baseChange A (g ∘ₗ f) = ∘ₗ
@[simp]
theorem LinearMap.baseChange_one (R : Type u_1) {A : Type u_2} (M : Type u_4) [] [] [Algebra R A] [] [Module R M] :
theorem LinearMap.baseChange_mul {R : Type u_1} {A : Type u_2} {M : Type u_4} [] [] [Algebra R A] [] [Module R M] (f : ) (g : ) :
noncomputable def LinearMap.baseChangeHom (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_5) [] [] [Algebra R A] [] [] [Module R M] [Module R N] :

baseChange as a linear map.

When M = N, this is true more strongly as Module.End.baseChangeHom.

Equations
• = { toFun := , map_add' := , map_smul' := }
Instances For
@[simp]
theorem LinearMap.baseChangeHom_apply (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_5) [] [] [Algebra R A] [] [] [Module R M] [Module R N] (f : M →ₗ[R] N) :
noncomputable def Module.End.baseChangeHom (R : Type u_1) (A : Type u_2) (M : Type u_4) [] [] [Algebra R A] [] [Module R M] :

baseChange as an AlgHom.

Equations
Instances For
@[simp]
theorem Module.End.baseChangeHom_apply_apply (R : Type u_1) (A : Type u_2) (M : Type u_4) [] [] [Algebra R A] [] [Module R M] (a : ) :
∀ (a_1 : ), ( a) a_1 = (TensorProduct.liftAux (R ({ toFun := fun (h : M →ₗ[R] ) => h ∘ₗ a, map_add' := , map_smul' := } ∘ₗ ))) a_1
theorem LinearMap.baseChange_pow (R : Type u_1) (A : Type u_2) (M : Type u_4) [] [] [Algebra R A] [] [Module R M] (f : ) (n : ) :
@[simp]
theorem LinearMap.baseChange_sub {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [Ring A] [Algebra R A] [] [Module R M] [] [Module R N] (f : M →ₗ[R] N) (g : M →ₗ[R] N) :
@[simp]
theorem LinearMap.baseChange_neg {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [] [Ring A] [Algebra R A] [] [Module R M] [] [Module R N] (f : M →ₗ[R] N) :
noncomputable def LinearMap.liftBaseChangeEquiv {R : Type u_1} {M : Type u_2} {N : Type u_3} (A : Type u_4) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] :

If M is an R-module and N is an A-module, then A-linear maps A ⊗[R] M →ₗ[A] N correspond to R linear maps M →ₗ[R] N by composing with M → A ⊗ M, x ↦ 1 ⊗ x.

Equations
Instances For
@[reducible, inline]
noncomputable abbrev LinearMap.liftBaseChange {R : Type u_1} {M : Type u_2} {N : Type u_3} (A : Type u_4) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] (l : M →ₗ[R] N) :

If N is an A module, we may lift a linear map M →ₗ[R] N to A ⊗[R] M →ₗ[A] N

Equations
Instances For
@[simp]
theorem LinearMap.liftBaseChange_tmul {R : Type u_1} {M : Type u_2} {N : Type u_3} (A : Type u_4) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] (l : M →ₗ[R] N) (x : A) (y : M) :
(x ⊗ₜ[R] y) = x l y
theorem LinearMap.liftBaseChange_one_tmul {R : Type u_1} {M : Type u_2} {N : Type u_3} (A : Type u_4) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] (l : M →ₗ[R] N) (y : M) :
(1 ⊗ₜ[R] y) = l y
@[simp]
theorem LinearMap.liftBaseChangeEquiv_symm_apply {R : Type u_4} {M : Type u_2} {N : Type u_3} (A : Type u_1) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] (l : →ₗ[A] N) (x : M) :
(.symm l) x = l (1 ⊗ₜ[R] x)
theorem LinearMap.liftBaseChange_comp {R : Type u_3} {M : Type u_4} {N : Type u_5} (A : Type u_2) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] {P : Type u_1} [] [Module A P] [Module R P] [] (l : M →ₗ[R] N) (l' : N →ₗ[A] P) :
l' ∘ₗ = LinearMap.liftBaseChange A (R l' ∘ₗ l)
@[simp]
theorem LinearMap.range_liftBaseChange {R : Type u_1} {M : Type u_2} {N : Type u_3} (A : Type u_4) [] [] [Algebra R A] [] [] [Module R M] [Module R N] [Module A N] [] (l : M →ₗ[R] N) :

### The R-algebra structure on A ⊗[R] B#

noncomputable instance Algebra.TensorProduct.instOneTensorProduct {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] :
Equations
• Algebra.TensorProduct.instOneTensorProduct = { one := 1 ⊗ₜ[R] 1 }
theorem Algebra.TensorProduct.one_def {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] :
1 = 1 ⊗ₜ[R] 1
noncomputable instance Algebra.TensorProduct.instAddCommMonoidWithOne {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] :
Equations
theorem Algebra.TensorProduct.natCast_def {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] (n : ) :
n = n ⊗ₜ[R] 1
theorem Algebra.TensorProduct.natCast_def' {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] (n : ) :
n = 1 ⊗ₜ[R] n
@[irreducible]
noncomputable def Algebra.TensorProduct.mul {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] :

(Implementation detail) The multiplication map on A ⊗[R] B, as an R-bilinear map.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.mul_apply {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] (a₁ : A) (a₂ : A) (b₁ : B) (b₂ : B) :
(Algebra.TensorProduct.mul (a₁ ⊗ₜ[R] b₁)) (a₂ ⊗ₜ[R] b₂) = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)
noncomputable instance Algebra.TensorProduct.instMul {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instMul = { mul := fun (a b : ) => (Algebra.TensorProduct.mul a) b }
@[simp]
theorem Algebra.TensorProduct.tmul_mul_tmul {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] (a₁ : A) (a₂ : A) (b₁ : B) (b₂ : B) :
a₁ ⊗ₜ[R] b₁ * a₂ ⊗ₜ[R] b₂ = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)
theorem SemiconjBy.tmul {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] {a₁ : A} {a₂ : A} {a₃ : A} {b₁ : B} {b₂ : B} {b₃ : B} (ha : SemiconjBy a₁ a₂ a₃) (hb : SemiconjBy b₁ b₂ b₃) :
SemiconjBy (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) (a₃ ⊗ₜ[R] b₃)
theorem Commute.tmul {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] {a₁ : A} {a₂ : A} {b₁ : B} {b₂ : B} (ha : Commute a₁ a₂) (hb : Commute b₁ b₂) :
Commute (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂)
noncomputable instance Algebra.TensorProduct.instNonUnitalNonAssocSemiring {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonUnitalNonAssocSemiring =
@[instance 100]
noncomputable instance Algebra.TensorProduct.isScalarTower_right {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] [] [] [] [] :
Equations
• =
@[instance 100]
noncomputable instance Algebra.TensorProduct.sMulCommClass_right {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] [] [] [] [] :
Equations
• =
theorem Algebra.TensorProduct.one_mul {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Module R A] [] [] [] [Module R B] [] [] (x : ) :
(Algebra.TensorProduct.mul (1 ⊗ₜ[R] 1)) x = x
theorem Algebra.TensorProduct.mul_one {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Module R A] [] [] [] [Module R B] [] [] (x : ) :
(Algebra.TensorProduct.mul x) (1 ⊗ₜ[R] 1) = x
noncomputable instance Algebra.TensorProduct.instNonAssocSemiring {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Module R A] [] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonAssocSemiring =
theorem Algebra.TensorProduct.mul_assoc {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] (x : ) (y : ) (z : ) :
(Algebra.TensorProduct.mul ((Algebra.TensorProduct.mul x) y)) z = (Algebra.TensorProduct.mul x) ((Algebra.TensorProduct.mul y) z)
noncomputable instance Algebra.TensorProduct.instNonUnitalSemiring {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonUnitalSemiring =
noncomputable instance Algebra.TensorProduct.instSemiring {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :
Equations
• Algebra.TensorProduct.instSemiring = Semiring.mk npowRec
@[simp]
theorem Algebra.TensorProduct.tmul_pow {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (a : A) (b : B) (k : ) :
a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)
noncomputable def Algebra.TensorProduct.includeLeftRingHom {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :

The ring morphism A →+* A ⊗[R] B sending a to a ⊗ₜ 1.

Equations
• Algebra.TensorProduct.includeLeftRingHom = { toFun := fun (a : A) => a ⊗ₜ[R] 1, map_one' := , map_mul' := , map_zero' := , map_add' := }
Instances For
@[simp]
theorem Algebra.TensorProduct.includeLeftRingHom_apply {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (a : A) :
Algebra.TensorProduct.includeLeftRingHom a = a ⊗ₜ[R] 1
noncomputable instance Algebra.TensorProduct.leftAlgebra {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra S A] [] :
Equations
• Algebra.TensorProduct.leftAlgebra = Algebra.mk (Algebra.TensorProduct.includeLeftRingHom.comp (algebraMap S A))
noncomputable instance Algebra.TensorProduct.instAlgebra {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :

The tensor product of two R-algebras is an R-algebra.

Equations
• Algebra.TensorProduct.instAlgebra = inferInstance
@[simp]
theorem Algebra.TensorProduct.algebraMap_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra S A] [] (r : S) :
(algebraMap S (TensorProduct R A B)) r = (algebraMap S A) r ⊗ₜ[R] 1
theorem Algebra.TensorProduct.algebraMap_apply' {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (r : R) :
(algebraMap R (TensorProduct R A B)) r = 1 ⊗ₜ[R] (algebraMap R B) r
noncomputable def Algebra.TensorProduct.includeLeft {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra S A] [] :

The R-algebra morphism A →ₐ[R] A ⊗[R] B sending a to a ⊗ₜ 1.

Equations
• Algebra.TensorProduct.includeLeft = { toRingHom := Algebra.TensorProduct.includeLeftRingHom, commutes' := }
Instances For
@[simp]
theorem Algebra.TensorProduct.includeLeft_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra S A] [] (a : A) :
Algebra.TensorProduct.includeLeft a = a ⊗ₜ[R] 1
noncomputable def Algebra.TensorProduct.includeRight {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :

The algebra morphism B →ₐ[R] A ⊗[R] B sending b to 1 ⊗ₜ b.

Equations
• Algebra.TensorProduct.includeRight = { toFun := fun (b : B) => 1 ⊗ₜ[R] b, map_one' := , map_mul' := , map_zero' := , map_add' := , commutes' := }
Instances For
@[simp]
theorem Algebra.TensorProduct.includeRight_apply {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (b : B) :
Algebra.TensorProduct.includeRight b = 1 ⊗ₜ[R] b
theorem Algebra.TensorProduct.includeLeftRingHom_comp_algebraMap {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :
Algebra.TensorProduct.includeLeftRingHom.comp (algebraMap R A) = Algebra.TensorProduct.includeRight.comp (algebraMap R B)
theorem Algebra.TensorProduct.ext_iff {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] [] [Algebra S A] [Algebra R S] [Algebra S C] [] [] {f : →ₐ[S] C} {g : →ₐ[S] C} :
f = g f.comp Algebra.TensorProduct.includeLeft = g.comp Algebra.TensorProduct.includeLeft .comp Algebra.TensorProduct.includeRight = .comp Algebra.TensorProduct.includeRight
theorem Algebra.TensorProduct.ext {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] [] [Algebra S A] [Algebra R S] [Algebra S C] [] [] ⦃f : →ₐ[S] C ⦃g : →ₐ[S] C (ha : f.comp Algebra.TensorProduct.includeLeft = g.comp Algebra.TensorProduct.includeLeft) (hb : .comp Algebra.TensorProduct.includeRight = .comp Algebra.TensorProduct.includeRight) :
f = g

A version of TensorProduct.ext for AlgHom.

Using this as the @[ext] lemma instead of Algebra.TensorProduct.ext' allows ext to apply lemmas specific to A →ₐ[S] _ and B →ₐ[R] _; notably this allows recursion into nested tensor products of algebras.

See note [partially-applied ext lemmas].

theorem Algebra.TensorProduct.ext' {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] [] [Algebra S A] [Algebra R S] [Algebra S C] [] [] {g : →ₐ[S] C} {h : →ₐ[S] C} (H : ∀ (a : A) (b : B), g (a ⊗ₜ[R] b) = h (a ⊗ₜ[R] b)) :
g = h
noncomputable instance Algebra.TensorProduct.instAddCommGroupWithOne {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] :
Equations
theorem Algebra.TensorProduct.intCast_def {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [Module R B] (z : ) :
z = z ⊗ₜ[R] 1
noncomputable instance Algebra.TensorProduct.instNonUnitalNonAssocRing {R : Type uR} {A : Type uA} {B : Type uB} [] [Module R A] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonUnitalNonAssocRing =
noncomputable instance Algebra.TensorProduct.instNonAssocRing {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Module R A] [] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonAssocRing = NonAssocRing.mk
noncomputable instance Algebra.TensorProduct.instNonUnitalRing {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Module R A] [] [] [] [Module R B] [] [] :
Equations
• Algebra.TensorProduct.instNonUnitalRing =
noncomputable instance Algebra.TensorProduct.instCommSemiring {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :
Equations
• Algebra.TensorProduct.instCommSemiring =
noncomputable instance Algebra.TensorProduct.instRing {R : Type uR} {A : Type uA} {B : Type uB} [] [Ring A] [Algebra R A] [Ring B] [Algebra R B] :
Equations
• Algebra.TensorProduct.instRing = Ring.mk SubNegMonoid.zsmul
theorem Algebra.TensorProduct.intCast_def' {R : Type uR} {A : Type uA} {B : Type uB} [] [Ring A] [Algebra R A] [Ring B] [Algebra R B] (z : ) :
z = 1 ⊗ₜ[R] z
noncomputable instance Algebra.TensorProduct.instCommRing {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :
Equations
• Algebra.TensorProduct.instCommRing =
@[reducible, inline]
noncomputable abbrev Algebra.TensorProduct.rightAlgebra {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :

S ⊗[R] T has a T-algebra structure. This is not a global instance or else the action of S on S ⊗[R] S would be ambiguous.

Equations
• Algebra.TensorProduct.rightAlgebra = Algebra.TensorProduct.includeRight.toAlgebra
Instances For
noncomputable instance Algebra.TensorProduct.right_isScalarTower {R : Type uR} {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] :
Equations
• =

We now build the structure maps for the symmetric monoidal category of R-algebras.

noncomputable def Algebra.TensorProduct.algHomOfLinearMapTensorProduct {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] (f : →ₗ[S] C) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) = f (a₁ ⊗ₜ[R] b₁) * f (a₂ ⊗ₜ[R] b₂)) (h_one : f (1 ⊗ₜ[R] 1) = 1) :

Build an algebra morphism from a linear map out of a tensor product, and evidence that on pure tensors, it preserves multiplication and the identity.

Note that we state h_one using 1 ⊗ₜ[R] 1 instead of 1 so that lemmas about f applied to pure tensors can be directly applied by the caller (without needing TensorProduct.one_def).

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.algHomOfLinearMapTensorProduct_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] (f : →ₗ[S] C) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) = f (a₁ ⊗ₜ[R] b₁) * f (a₂ ⊗ₜ[R] b₂)) (h_one : f (1 ⊗ₜ[R] 1) = 1) (x : ) :
noncomputable def Algebra.TensorProduct.algEquivOfLinearEquivTensorProduct {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] (f : ≃ₗ[S] C) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) = f (a₁ ⊗ₜ[R] b₁) * f (a₂ ⊗ₜ[R] b₂)) (h_one : f (1 ⊗ₜ[R] 1) = 1) :

Build an algebra equivalence from a linear equivalence out of a tensor product, and evidence that on pure tensors, it preserves multiplication and the identity.

Note that we state h_one using 1 ⊗ₜ[R] 1 instead of 1 so that lemmas about f applied to pure tensors can be directly applied by the caller (without needing TensorProduct.one_def).

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Algebra.TensorProduct.algEquivOfLinearEquivTensorProduct_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] (f : ≃ₗ[S] C) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) = f (a₁ ⊗ₜ[R] b₁) * f (a₂ ⊗ₜ[R] b₂)) (h_one : f (1 ⊗ₜ[R] 1) = 1) (x : ) :
x = f x
noncomputable def Algebra.TensorProduct.algEquivOfLinearEquivTripleTensorProduct {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R A] [] [Algebra R B] [] [] [Algebra R D] [Algebra R C] (f : TensorProduct R (TensorProduct R A B) C ≃ₗ[R] D) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C), f (((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) ⊗ₜ[R] (c₁ * c₂)) = f ((a₁ ⊗ₜ[R] b₁) ⊗ₜ[R] c₁) * f ((a₂ ⊗ₜ[R] b₂) ⊗ₜ[R] c₂)) (h_one : f ((1 ⊗ₜ[R] 1) ⊗ₜ[R] 1) = 1) :

Build an algebra equivalence from a linear equivalence out of a triple tensor product, and evidence of multiplicativity on pure tensors.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.algEquivOfLinearEquivTripleTensorProduct_apply {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R A] [] [Algebra R B] [] [] [Algebra R D] [Algebra R C] (f : TensorProduct R (TensorProduct R A B) C ≃ₗ[R] D) (h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C), f (((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) ⊗ₜ[R] (c₁ * c₂)) = f ((a₁ ⊗ₜ[R] b₁) ⊗ₜ[R] c₁) * f ((a₂ ⊗ₜ[R] b₂) ⊗ₜ[R] c₂)) (h_one : f ((1 ⊗ₜ[R] 1) ⊗ₜ[R] 1) = 1) (x : TensorProduct R (TensorProduct R A B) C) :
x = f x
noncomputable def Algebra.TensorProduct.lift {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ (x : A) (y : B), Commute (f x) (g y)) :

The forward direction of the universal property of tensor products of algebras; any algebra morphism from the tensor product can be factored as the product of two algebra morphisms that commute.

See Algebra.TensorProduct.liftEquiv for the fact that every morphism factors this way.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Algebra.TensorProduct.lift_tmul {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ (x : A) (y : B), Commute (f x) (g y)) (a : A) (b : B) :
(Algebra.TensorProduct.lift f g hfg) (a ⊗ₜ[R] b) = f a * g b
@[simp]
theorem Algebra.TensorProduct.lift_includeLeft_includeRight {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] :
Algebra.TensorProduct.lift Algebra.TensorProduct.includeLeft Algebra.TensorProduct.includeRight = AlgHom.id S (TensorProduct R A B)
@[simp]
theorem Algebra.TensorProduct.lift_comp_includeLeft {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ (x : A) (y : B), Commute (f x) (g y)) :
(Algebra.TensorProduct.lift f g hfg).comp Algebra.TensorProduct.includeLeft = f
@[simp]
theorem Algebra.TensorProduct.lift_comp_includeRight {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ (x : A) (y : B), Commute (f x) (g y)) :
(AlgHom.restrictScalars R (Algebra.TensorProduct.lift f g hfg)).comp Algebra.TensorProduct.includeRight = g
noncomputable def Algebra.TensorProduct.liftEquiv {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] :
{ fg : (A →ₐ[S] C) × (B →ₐ[R] C) // ∀ (x : A) (y : B), Commute (fg.1 x) (fg.2 y) } ( →ₐ[S] C)

The universal property of the tensor product of algebras.

Pairs of algebra morphisms that commute are equivalent to algebra morphisms from the tensor product.

This is Algebra.TensorProduct.lift as an equivalence.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Algebra.TensorProduct.liftEquiv_symm_apply_coe {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (f' : →ₐ[S] C) :
(Algebra.TensorProduct.liftEquiv.symm f') = (f'.comp Algebra.TensorProduct.includeLeft, .comp Algebra.TensorProduct.includeRight)
@[simp]
theorem Algebra.TensorProduct.liftEquiv_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra S C] [Algebra R C] [] (fg : { fg : (A →ₐ[S] C) × (B →ₐ[R] C) // ∀ (x : A) (y : B), Commute (fg.1 x) (fg.2 y) }) :
Algebra.TensorProduct.liftEquiv fg = Algebra.TensorProduct.lift (↑fg).1 (↑fg).2
noncomputable def Algebra.TensorProduct.lid (R : Type uR) (A : Type uA) [] [] [Algebra R A] :

The base ring is a left identity for the tensor product of algebra, up to algebra isomorphism.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.lid_toLinearEquiv (R : Type uR) (A : Type uA) [] [] [Algebra R A] :
.toLinearEquiv =
@[simp]
theorem Algebra.TensorProduct.lid_tmul {R : Type uR} {A : Type uA} [] [] [Algebra R A] (r : R) (a : A) :
(r ⊗ₜ[R] a) = r a
@[simp]
theorem Algebra.TensorProduct.lid_symm_apply (R : Type uR) {A : Type uA} [] [] [Algebra R A] (a : A) :
.symm a = 1 ⊗ₜ[R] a
noncomputable def Algebra.TensorProduct.rid (R : Type uR) (S : Type uS) (A : Type uA) [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] :

The base ring is a right identity for the tensor product of algebra, up to algebra isomorphism.

Note that if A is commutative this can be instantiated with S = A.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.rid_toLinearEquiv (R : Type uR) (S : Type uS) (A : Type uA) [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] :
.toLinearEquiv =
@[simp]
theorem Algebra.TensorProduct.rid_tmul {R : Type uR} (S : Type uS) {A : Type uA} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] (r : R) (a : A) :
(a ⊗ₜ[R] r) = r a
@[simp]
theorem Algebra.TensorProduct.rid_symm_apply (R : Type uR) (S : Type uS) {A : Type uA} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] (a : A) :
.symm a = a ⊗ₜ[R] 1
noncomputable def Algebra.TensorProduct.comm (R : Type uR) (A : Type uA) (B : Type uB) [] [] [Algebra R A] [] [Algebra R B] :

The tensor product of R-algebras is commutative, up to algebra isomorphism.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.comm_toLinearEquiv (R : Type uR) (A : Type uA) (B : Type uB) [] [] [Algebra R A] [] [Algebra R B] :
.toLinearEquiv =
@[simp]
theorem Algebra.TensorProduct.comm_tmul (R : Type uR) {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (a : A) (b : B) :
(a ⊗ₜ[R] b) = b ⊗ₜ[R] a
@[simp]
theorem Algebra.TensorProduct.comm_symm_tmul (R : Type uR) {A : Type uA} {B : Type uB} [] [] [Algebra R A] [] [Algebra R B] (a : A) (b : B) :
.symm (b ⊗ₜ[R] a) = a ⊗ₜ[R] b
theorem Algebra.TensorProduct.comm_symm (R : Type uR) (A : Type uA) (B : Type uB) [] [] [Algebra R A] [] [Algebra R B] :
.symm =
theorem Algebra.TensorProduct.adjoin_tmul_eq_top (R : Type uR) (A : Type uA) (B : Type uB) [] [] [Algebra R A] [] [Algebra R B] :
Algebra.adjoin R {t : | ∃ (a : A) (b : B), a ⊗ₜ[R] b = t} =
theorem Algebra.TensorProduct.assoc_aux_1 {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] (a₁ : A) (a₂ : A) (b₁ : B) (b₂ : B) (c₁ : C) (c₂ : C) :
(TensorProduct.assoc R A B C) (((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) ⊗ₜ[R] (c₁ * c₂)) = (TensorProduct.assoc R A B C) ((a₁ ⊗ₜ[R] b₁) ⊗ₜ[R] c₁) * (TensorProduct.assoc R A B C) ((a₂ ⊗ₜ[R] b₂) ⊗ₜ[R] c₂)
theorem Algebra.TensorProduct.assoc_aux_2 {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] :
(TensorProduct.assoc R A B C) ((1 ⊗ₜ[R] 1) ⊗ₜ[R] 1) = 1
noncomputable def Algebra.TensorProduct.assoc (R : Type uR) (A : Type uA) (B : Type uB) (C : Type uC) [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] :

The associator for tensor product of R-algebras, as an algebra isomorphism.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.assoc_toLinearEquiv (R : Type uR) (A : Type uA) (B : Type uB) (C : Type uC) [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] :
.toLinearEquiv =
@[simp]
theorem Algebra.TensorProduct.assoc_tmul (R : Type uR) {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] (a : A) (b : B) (c : C) :
((a ⊗ₜ[R] b) ⊗ₜ[R] c) = a ⊗ₜ[R] b ⊗ₜ[R] c
@[simp]
theorem Algebra.TensorProduct.assoc_symm_tmul (R : Type uR) {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] (a : A) (b : B) (c : C) :
.symm (a ⊗ₜ[R] b ⊗ₜ[R] c) = (a ⊗ₜ[R] b) ⊗ₜ[R] c
noncomputable def Algebra.TensorProduct.map {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[S] B) (g : C →ₐ[R] D) :

The tensor product of a pair of algebra morphisms.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.map_tmul {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[S] B) (g : C →ₐ[R] D) (a : A) (c : C) :
(a ⊗ₜ[R] c) = f a ⊗ₜ[R] g c
@[simp]
theorem Algebra.TensorProduct.map_id {R : Type uR} {S : Type uS} {A : Type uA} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R C] :
theorem Algebra.TensorProduct.map_comp {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} {E : Type uE} {F : Type uF} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] [] [Algebra R E] [] [Algebra R F] [Algebra S C] [] (f₂ : B →ₐ[S] C) (f₁ : A →ₐ[S] B) (g₂ : E →ₐ[R] F) (g₁ : D →ₐ[R] E) :
Algebra.TensorProduct.map (f₂.comp f₁) (g₂.comp g₁) = .comp
@[simp]
theorem Algebra.TensorProduct.map_comp_includeLeft {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[S] B) (g : C →ₐ[R] D) :
.comp Algebra.TensorProduct.includeLeft = Algebra.TensorProduct.includeLeft.comp f
@[simp]
theorem Algebra.TensorProduct.map_restrictScalars_comp_includeRight {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[S] B) (g : C →ₐ[R] D) :
.comp Algebra.TensorProduct.includeRight = Algebra.TensorProduct.includeRight.comp g
@[simp]
theorem Algebra.TensorProduct.map_comp_includeRight {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
.comp Algebra.TensorProduct.includeRight = Algebra.TensorProduct.includeRight.comp g
theorem Algebra.TensorProduct.map_range {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R A] [] [Algebra R B] [] [Algebra R C] [] [Algebra R D] (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
.range = (Algebra.TensorProduct.includeLeft.comp f).range (Algebra.TensorProduct.includeRight.comp g).range
noncomputable def Algebra.TensorProduct.congr {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) :

Construct an isomorphism between tensor products of an S-algebra with an R-algebra from S- and R- isomorphisms between the tensor factors.

Equations
Instances For
@[simp]
theorem Algebra.TensorProduct.congr_toLinearEquiv {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) :
.toLinearEquiv = TensorProduct.AlgebraTensorModule.congr f.toLinearEquiv g.toLinearEquiv
@[simp]
theorem Algebra.TensorProduct.congr_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) (x : ) :
x = x
@[simp]
theorem Algebra.TensorProduct.congr_symm_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) (x : ) :
.symm x = (Algebra.TensorProduct.map f.symm g.symm) x
@[simp]
theorem Algebra.TensorProduct.congr_refl {R : Type uR} {S : Type uS} {A : Type uA} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R C] :
Algebra.TensorProduct.congr AlgEquiv.refl AlgEquiv.refl = AlgEquiv.refl
theorem Algebra.TensorProduct.congr_trans {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} {E : Type uE} {F : Type uF} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] [] [Algebra R E] [] [Algebra R F] [Algebra S C] [] (f₁ : A ≃ₐ[S] B) (f₂ : B ≃ₐ[S] C) (g₁ : D ≃ₐ[R] E) (g₂ : E ≃ₐ[R] F) :
Algebra.TensorProduct.congr (f₁.trans f₂) (g₁.trans g₂) = .trans
theorem Algebra.TensorProduct.congr_symm {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [Algebra S B] [] [] [Algebra R C] [] [Algebra R D] (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) :
Algebra.TensorProduct.congr f.symm g.symm = .symm
@[reducible, inline]
noncomputable abbrev Algebra.TensorProduct.productLeftAlgHom {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} [] [] [Algebra R S] [] [Algebra R A] [Algebra S A] [] [] [Algebra R B] [] [Algebra R C] [Algebra S C] [] (f : A →ₐ[S] C) (g : B →ₐ[R] C) :

If A, B, C are R-algebras, A and C are also S-algebras (forming a tower as ·/S/R), then the product map of f : A →ₐ[S] C and g : B →ₐ[R] C is an S-algebra homomorphism.

This is just a special case of Algebra.TensorProduct.lift for when C is commutative.

Equations
Instances For
noncomputable def Algebra.TensorProduct.lmul' (R : Type uR) {S : Type uS} [] [] [Algebra R S] :

LinearMap.mul' is an AlgHom on commutative rings.

Equations
Instances For
theorem Algebra.TensorProduct.lmul'_toLinearMap {R : Type uR} {S : Type uS} [] [] [Algebra R S] :
.toLinearMap =
@[simp]
theorem Algebra.TensorProduct.lmul'_apply_tmul {R : Type uR} {S : Type uS} [] [] [Algebra R S] (a : S) (b : S) :
(a ⊗ₜ[R] b) = a * b
@[simp]
theorem Algebra.TensorProduct.lmul'_comp_includeLeft {R : Type uR} {S : Type uS} [] [] [Algebra R S] :
.comp Algebra.TensorProduct.includeLeft =
@[simp]
theorem Algebra.TensorProduct.lmul'_comp_includeRight {R : Type uR} {S : Type uS} [] [] [Algebra R S] :
.comp Algebra.TensorProduct.includeRight =
noncomputable def Algebra.TensorProduct.productMap {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) :

If S is commutative, for a pair of morphisms f : A →ₐ[R] S, g : B →ₐ[R] S, We obtain a map A ⊗[R] B →ₐ[R] S that commutes with f, g via a ⊗ b ↦ f(a) * g(b).

This is a special case of Algebra.TensorProduct.productLeftAlgHom for when the two base rings are the same.

Equations
Instances For
theorem Algebra.TensorProduct.productMap_eq_comp_map {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) :
@[simp]
theorem Algebra.TensorProduct.productMap_apply_tmul {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) (a : A) (b : B) :
(a ⊗ₜ[R] b) = f a * g b
theorem Algebra.TensorProduct.productMap_left_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) (a : A) :
(a ⊗ₜ[R] 1) = f a
@[simp]
theorem Algebra.TensorProduct.productMap_left {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) :
.comp Algebra.TensorProduct.includeLeft = f
theorem Algebra.TensorProduct.productMap_right_apply {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) (b : B) :
(1 ⊗ₜ[R] b) = g b
@[simp]
theorem Algebra.TensorProduct.productMap_right {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) :
.comp Algebra.TensorProduct.includeRight = g
theorem Algebra.TensorProduct.productMap_range {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [] [] [] [] [Algebra R A] [Algebra R B] [Algebra R S] (f : A →ₐ[R] S) (g : B →ₐ[R] S) :
.range = f.range g.range
noncomputable def Algebra.TensorProduct.basisAux {R : Type uR} (A : Type uA) {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) :

Given an R-algebra A and an R-basis of M, this is an R-linear isomorphism A ⊗[R] M ≃ (ι →₀ A) (which is in fact A-linear).

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem Algebra.TensorProduct.basisAux_tmul {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (a : A) (m : M) :
(a ⊗ₜ[R] m) = a Finsupp.mapRange (algebraMap R A) (b.repr m)
theorem Algebra.TensorProduct.basisAux_map_smul {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (a : A) (x : ) :
(a x) = a
noncomputable def Algebra.TensorProduct.basis {R : Type uR} (A : Type uA) {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) :
Basis ι A (TensorProduct R A M)

Given a R-algebra A, this is the A-basis of A ⊗[R] M induced by a R-basis of M.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Algebra.TensorProduct.basis_repr_tmul {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (a : A) (m : M) :
.repr (a ⊗ₜ[R] m) = a Finsupp.mapRange (algebraMap R A) (b.repr m)
theorem Algebra.TensorProduct.basis_repr_symm_apply {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (a : A) (i : ι) :
.repr.symm (Finsupp.single i a) = a ⊗ₜ[R] b.repr.symm (Finsupp.single i 1)
@[simp]
theorem Algebra.TensorProduct.basis_apply {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (i : ι) :
i = 1 ⊗ₜ[R] b i
theorem Algebra.TensorProduct.basis_repr_symm_apply' {R : Type uR} {A : Type uA} {M : Type uM} {ι : Type uι} [] [] [Algebra R A] [] [Module R M] (b : Basis ι R M) (a : A) (i : ι) :
a i = a ⊗ₜ[R] b i
theorem Basis.baseChange_linearMap {R : Type uR} {M : Type uM} {ι : Type uι} [] [] [Module R M] [] {ι' : Type u_1} {N : Type u_2} [Fintype ι'] [] [] [Module R N] (A : Type u_3) [] [Algebra R A] (b : Basis ι R M) (b' : Basis ι' R N) (ij : ι × ι') :
LinearMap.baseChange A ((b'.linearMap b) ij) = (.linearMap ) ij
theorem Basis.baseChange_end {R : Type uR} {M : Type uM} {ι : Type uι} [] [] [Module R M] [] (A : Type u_3) [] [Algebra R A] [] (b : Basis ι R M) (ij : ι × ι) :
LinearMap.baseChange A (b.end ij) = .end ij
noncomputable instance Algebra.TensorProduct.instFreeTensorProduct (R : Type u_1) (A : Type u_2) (M : Type u_3) [] [] [Module R M] [] [] [Algebra R A] :
Equations
• =
@[simp]
theorem LinearMap.toMatrix_baseChange {R : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {ι : Type u_4} {ι₂ : Type u_5} (A : Type u_6) [] [Finite ι₂] [] [] [] [Algebra R A] [] [Module R M₁] [] [Module R M₂] (f : M₁ →ₗ[R] M₂) (b₁ : Basis ι R M₁) (b₂ : Basis ι₂ R M₂) :
= ((LinearMap.toMatrix b₁ b₂) f).map (algebraMap R A)
noncomputable def LinearMap.tensorProduct (R : Type u_1) (A : Type u_2) (M : Type u_3) (N : Type u_4) [] [] [Algebra R A] [] [Module R M] [] [Module R N] :

The natural linear map $A ⊗ \text{Hom}_R(M, N) → \text{Hom}_A (M_A, N_A)$, where $M_A$ and $N_A$ are the respective modules over $A$ obtained by extension of scalars.

See LinearMap.tensorProductEnd for this map specialized to endomorphisms, and bundled as A-algebra homomorphism.

Equations
Instances For
@[simp]
theorem LinearMap.tensorProduct_apply (R : Type u_1) (A : Type u_2) (M : Type u_3) (N : Type u_4) [] [] [Algebra R A] [] [Module R M] [] [Module R N] :
∀ (a : TensorProduct R A (M →ₗ[R] N)), (LinearMap.tensorProduct R A M N) a = (TensorProduct.liftAux (R { toFun := fun (a : A) => a , map_add' := , map_smul' := })) a
noncomputable def LinearMap.tensorProductEnd (R : Type u_1) (A : Type u_2) (M : Type u_3) [] [] [Algebra R A] [] [Module R M] :

The natural A-algebra homomorphism $A ⊗ (\text{End}_R M) → \text{End}_A (A ⊗ M)$, where M is an R-module, and A an R-algebra.

Equations
Instances For
@[simp]
theorem LinearMap.tensorProductEnd_apply (R : Type u_1) (A : Type u_2) (M : Type u_3) [] [] [Algebra R A] [] [Module R M] (a : TensorProduct R A (Module.End R M)) :
a = (TensorProduct.liftAux (R { toFun := fun (a : A) => a , map_add' := , map_smul' := })) a
noncomputable def Module.endTensorEndAlgHom {R : Type u_1} {S : Type u_2} {A : Type u_3} {M : Type u_4} {N : Type u_5} [] [] [] [] [] [Algebra R S] [Algebra S A] [Algebra R A] [Module R M] [Module S M] [Module A M] [Module R N] [] [] [] :

The algebra homomorphism from End M ⊗ End N to End (M ⊗ N) sending f ⊗ₜ g to the TensorProduct.map f g, the tensor product of the two maps.

This is an AlgHom version of TensorProduct.AlgebraTensorModule.homTensorHomMap. Like that definition, this is generalized across many different rings; namely a tower of algebras A/S/R.

Equations
• Module.endTensorEndAlgHom =
Instances For
theorem Module.endTensorEndAlgHom_apply {R : Type u_1} {S : Type u_2} {A : Type u_3} {M : Type u_4} {N : Type u_5} [] [] [] [] [] [Algebra R S] [Algebra S A] [Algebra R A] [Module R M] [Module S M] [Module A M] [Module R N] [] [] [] (f : ) (g : ) :
Module.endTensorEndAlgHom (f ⊗ₜ[R] g) =
theorem Subalgebra.finite_sup {K : Type u_1} {L : Type u_2} [] [] [Algebra K L] (E1 : ) (E2 : ) [Module.Finite K { x : L // x E1 }] [Module.Finite K { x : L // x E2 }] :
Module.Finite K { x : L // x E1 E2 }
noncomputable def TensorProduct.Algebra.moduleAux {R : Type u_1} {A : Type u_2} {B : Type u_3} {M : Type u_4} [] [] [Module R M] [] [] [Module A M] [Module B M] [Algebra R A] [Algebra R B] [] [] :

An auxiliary definition, used for constructing the Module (A ⊗[R] B) M in TensorProduct.Algebra.module below.

Equations
Instances For
theorem TensorProduct.Algebra.moduleAux_apply {R : Type u_1} {A : Type u_2} {B : Type u_3} {M : Type u_4} [] [] [Module R M] [] [] [Module A M] [Module B M] [Algebra R A] [Algebra R B] [] [] (a : A) (b : B) (m : M) :
(TensorProduct.Algebra.moduleAux (a ⊗ₜ[R] b)) m = a b m
noncomputable def TensorProduct.Algebra.module {R : Type u_1} {A : Type u_2} {B : Type u_3} {M : Type u_4} [] [] [Module R M] [] [] [Module A M] [Module B M] [Algebra R A] [Algebra R B] [] [] [] :

If M is a representation of two different R-algebras A and B whose actions commute, then it is a representation the R-algebra A ⊗[R] B.

An important example arises from a semiring S; allowing S to act on itself via left and right multiplication, the roles of R, A, B, M are played by , S, Sᵐᵒᵖ, S. This example is important because a submodule of S as a Module over S ⊗[ℕ] Sᵐᵒᵖ is a two-sided ideal.

NB: This is not an instance because in the case B = A and M = A ⊗[R] A we would have a diamond of smul actions. Furthermore, this would not be a mere definitional diamond but a true mathematical diamond in which A ⊗[R] A had two distinct scalar actions on itself: one from its multiplication, and one from this would-be instance. Arguably we could live with this but in any case the real fix is to address the ambiguity in notation, probably along the lines outlined here: https://leanprover.zulipchat.com/#narrow/stream/144837-PR-reviews/topic/.234773.20base.20change/near/240929258

Equations
• TensorProduct.Algebra.module =
Instances For
theorem TensorProduct.Algebra.smul_def {R : Type u_1} {A : Type u_2} {B : Type u_3} {M : Type u_4} [] [] [Module R M] [] [] [Module A M] [Module B M] [Algebra R A] [Algebra R B] [] [] [] (a : A) (b : B) (m : M) :
a ⊗ₜ[R] b m = a b m