fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
map_comp
(f₂ : C →ₐ[S] E) (f₁ : A →ₐ[S] C) (g₂ : D →ₐ[R] F) (g₁ : B →ₐ[R] D) :
map (f₂.comp f₁) (g₂.comp g₁) = (map f₂ g₂).comp (map f₁ g₁) :=
ext (AlgHom.ext fun _ => rfl) (AlgHom.ext fun _ => rfl) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_comp | null |
map_id_comp (g₂ : D →ₐ[R] F) (g₁ : B →ₐ[R] D) :
map (AlgHom.id S A) (g₂.comp g₁) = (map (AlgHom.id S A) g₂).comp (map (AlgHom.id S A) g₁) :=
ext (AlgHom.ext fun _ => rfl) (AlgHom.ext fun _ => rfl) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_id_comp | null |
map_comp_id
(f₂ : C →ₐ[S] E) (f₁ : A →ₐ[S] C) :
map (f₂.comp f₁) (AlgHom.id R E) = (map f₂ (AlgHom.id R E)).comp (map f₁ (AlgHom.id R E)) :=
ext (AlgHom.ext fun _ => rfl) (AlgHom.ext fun _ => rfl)
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_comp_id | null |
map_comp_includeLeft (f : A →ₐ[S] C) (g : B →ₐ[R] D) :
(map f g).comp includeLeft = includeLeft.comp f :=
AlgHom.ext <| by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_comp_includeLeft | null |
map_restrictScalars_comp_includeRight (f : A →ₐ[S] C) (g : B →ₐ[R] D) :
((map f g).restrictScalars R).comp includeRight = includeRight.comp g :=
AlgHom.ext <| by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_restrictScalars_comp_includeRight | null |
map_comp_includeRight (f : A →ₐ[R] C) (g : B →ₐ[R] D) :
(map f g).comp includeRight = includeRight.comp g :=
map_restrictScalars_comp_includeRight f g | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_comp_includeRight | null |
map_range (f : A →ₐ[R] C) (g : B →ₐ[R] D) :
(map f g).range = (includeLeft.comp f).range ⊔ (includeRight.comp g).range := by
apply le_antisymm
· rw [← map_top, ← adjoin_tmul_eq_top, ← adjoin_image, adjoin_le_iff]
rintro _ ⟨_, ⟨a, b, rfl⟩, rfl⟩
rw [map_tmul, ← mul_one (f a), ← one_mul (g b), ← tmul_mul_tmul]
exact mul_mem_sup (AlgHom.mem_range_self _ a) (AlgHom.mem_range_self _ b)
· rw [← map_comp_includeLeft f g, ← map_comp_includeRight f g]
exact sup_le (AlgHom.range_comp_le_range _ _) (AlgHom.range_comp_le_range _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | map_range | null |
comm_comp_map (f : A →ₐ[R] C) (g : B →ₐ[R] D) :
(TensorProduct.comm R C D : C ⊗[R] D →ₐ[R] D ⊗[R] C).comp (Algebra.TensorProduct.map f g) =
(Algebra.TensorProduct.map g f).comp (TensorProduct.comm R A B).toAlgHom := by
ext <;> rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | comm_comp_map | null |
comm_comp_map_apply (f : A →ₐ[R] C) (g : B →ₐ[R] D) (x) :
TensorProduct.comm R C D (Algebra.TensorProduct.map f g x) =
(Algebra.TensorProduct.map g f) (TensorProduct.comm R A B x) :=
congr($(comm_comp_map f g) x) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | comm_comp_map_apply | null |
congr (f : A ≃ₐ[S] C) (g : B ≃ₐ[R] D) : A ⊗[R] B ≃ₐ[S] C ⊗[R] D :=
AlgEquiv.ofAlgHom (map f g) (map f.symm g.symm)
(ext' fun b d => by simp) (ext' fun a c => by simp)
@[simp] theorem congr_toLinearEquiv (f : A ≃ₐ[S] C) (g : B ≃ₐ[R] D) :
(Algebra.TensorProduct.congr f g).toLinearEquiv =
TensorProduct.AlgebraTensorModule.congr f.toLinearEquiv g.toLinearEquiv := rfl
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr | Construct an isomorphism between tensor products of an S-algebra with an R-algebra
from S- and R- isomorphisms between the tensor factors. |
congr_apply (f : A ≃ₐ[S] C) (g : B ≃ₐ[R] D) (x) :
congr f g x = (map (f : A →ₐ[S] C) (g : B →ₐ[R] D)) x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr_apply | null |
congr_symm_apply (f : A ≃ₐ[S] C) (g : B ≃ₐ[R] D) (x) :
(congr f g).symm x = (map (f.symm : C →ₐ[S] A) (g.symm : D →ₐ[R] B)) x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr_symm_apply | null |
congr_refl : congr (.refl : A ≃ₐ[S] A) (.refl : B ≃ₐ[R] B) = .refl :=
AlgEquiv.coe_algHom_injective <| map_id | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr_refl | null |
congr_trans
(f₁ : A ≃ₐ[S] C) (f₂ : C ≃ₐ[S] E) (g₁ : B ≃ₐ[R] D) (g₂ : D ≃ₐ[R] F) :
congr (f₁.trans f₂) (g₁.trans g₂) = (congr f₁ g₁).trans (congr f₂ g₂) :=
AlgEquiv.coe_algHom_injective <| map_comp f₂.toAlgHom f₁.toAlgHom g₂.toAlgHom g₁.toAlgHom | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr_trans | null |
congr_symm (f : A ≃ₐ[S] C) (g : B ≃ₐ[R] D) : congr f.symm g.symm = (congr f g).symm := rfl
variable (R A B C) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | congr_symm | null |
leftComm : A ⊗[R] (B ⊗[R] C) ≃ₐ[R] B ⊗[R] (A ⊗[R] C) :=
(Algebra.TensorProduct.assoc R R A B C).symm.trans <|
(congr (Algebra.TensorProduct.comm R A B) .refl).trans <| TensorProduct.assoc R R B A C
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | leftComm | Tensor product of algebras analogue of `mul_left_comm`.
This is the algebra version of `TensorProduct.leftComm`. |
leftComm_tmul (m : A) (n : B) (p : C) :
leftComm R A B C (m ⊗ₜ (n ⊗ₜ p)) = n ⊗ₜ (m ⊗ₜ p) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | leftComm_tmul | null |
leftComm_symm_tmul (m : A) (n : B) (p : C) :
(leftComm R A B C).symm (n ⊗ₜ (m ⊗ₜ p)) = m ⊗ₜ (n ⊗ₜ p) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | leftComm_symm_tmul | null |
leftComm_toLinearEquiv : ↑(leftComm R A B C) = _root_.TensorProduct.leftComm R A B C :=
LinearEquiv.toLinearMap_injective (by ext; rfl)
variable [CommSemiring T] [Algebra R T] [Algebra T A] [IsScalarTower R T A] [SMulCommClass S T A]
[Algebra S T] [IsScalarTower S T A] [CommSemiring R'] [Algebra R R'] [Algebra R' T] [Algebra R' A]
[Algebra R' B] [IsScalarTower R R' A] [SMulCommClass S R' A] [SMulCommClass R' S A]
[IsScalarTower R' T A] [IsScalarTower R R' B]
variable (R R' S T A B C D) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | leftComm_toLinearEquiv | null |
tensorTensorTensorComm : A ⊗[R'] B ⊗[S] (C ⊗[R] D) ≃ₐ[T] A ⊗[S] C ⊗[R'] (B ⊗[R] D) :=
AlgEquiv.ofLinearEquiv (TensorProduct.AlgebraTensorModule.tensorTensorTensorComm R R' S T A B C D)
rfl (LinearMap.map_mul_iff _ |>.mpr <| by ext; simp)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorTensorTensorComm | Tensor product of algebras analogue of `mul_mul_mul_comm`.
This is the algebra version of `TensorProduct.AlgebraTensorModule.tensorTensorTensorComm`. |
tensorTensorTensorComm_tmul (m : A) (n : B) (p : C) (q : D) :
tensorTensorTensorComm R R' S T A B C D (m ⊗ₜ n ⊗ₜ (p ⊗ₜ q)) = m ⊗ₜ p ⊗ₜ (n ⊗ₜ q) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorTensorTensorComm_tmul | null |
tensorTensorTensorComm_symm_tmul (m : A) (n : C) (p : B) (q : D) :
(tensorTensorTensorComm R R' S T A B C D).symm (m ⊗ₜ n ⊗ₜ (p ⊗ₜ q)) = m ⊗ₜ p ⊗ₜ (n ⊗ₜ q) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorTensorTensorComm_symm_tmul | null |
tensorTensorTensorComm_symm :
(tensorTensorTensorComm R R' S T A B C D).symm = tensorTensorTensorComm R S R' T A C B D := by
ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorTensorTensorComm_symm | null |
tensorTensorTensorComm_toLinearEquiv :
(tensorTensorTensorComm R R' S T A B C D).toLinearEquiv =
TensorProduct.AlgebraTensorModule.tensorTensorTensorComm R R' S T A B C D := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorTensorTensorComm_toLinearEquiv | null |
toLinearEquiv_tensorTensorTensorComm :
(tensorTensorTensorComm R R R R A B C D).toLinearEquiv =
_root_.TensorProduct.tensorTensorTensorComm R A B C D := by
apply LinearEquiv.toLinearMap_injective
ext; simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | toLinearEquiv_tensorTensorTensorComm | null |
productLeftAlgHom (f : A →ₐ[S] C) (g : B →ₐ[R] C) : A ⊗[R] B →ₐ[S] C :=
lift f g (fun _ _ => Commute.all _ _) | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productLeftAlgHom | 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. |
tmul_one_eq_one_tmul (r : R) : algebraMap R A r ⊗ₜ[R] 1 = 1 ⊗ₜ algebraMap R B r := by
rw [Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one, smul_tmul] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tmul_one_eq_one_tmul | null |
closure_range_union_range_eq_top [CommRing R] [Ring A] [Ring B]
[Algebra R A] [Algebra R B] :
Subring.closure (Set.range (Algebra.TensorProduct.includeLeft : A →ₐ[R] A ⊗[R] B) ∪
Set.range Algebra.TensorProduct.includeRight) = ⊤ := by
rw [← top_le_iff]
rintro x -
induction x with
| zero => exact zero_mem _
| tmul x y =>
convert_to (Algebra.TensorProduct.includeLeftRingHom (R := R) x) *
(Algebra.TensorProduct.includeRight y) ∈ _
· simp
· exact mul_mem (Subring.subset_closure (.inl ⟨x, rfl⟩))
(Subring.subset_closure (.inr ⟨_, rfl⟩))
| add x y _ _ => exact add_mem ‹_› ‹_› | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | closure_range_union_range_eq_top | null |
lmul'' : S ⊗[R] S →ₐ[S] S :=
algHomOfLinearMapTensorProduct
{ __ := LinearMap.mul' R S
map_smul' := fun s x ↦ x.induction_on (by simp)
(fun _ _ ↦ by simp [TensorProduct.smul_tmul', mul_assoc])
fun x y hx hy ↦ by simp_all [mul_add] }
(fun a₁ a₂ b₁ b₂ => by simp [mul_mul_mul_comm]) <| by simp | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'' | `LinearMap.mul'` as an `AlgHom` over the algebra. |
lmul''_eq_lid_comp_mapOfCompatibleSMul :
lmul'' R = (TensorProduct.lid S S).toAlgHom.comp (mapOfCompatibleSMul' _ _ _ _) := by
ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul''_eq_lid_comp_mapOfCompatibleSMul | null |
lmul' : S ⊗[R] S →ₐ[R] S := (lmul'' R).restrictScalars R
variable {R} | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul' | `LinearMap.mul'` as an `AlgHom` over the base ring. |
lmul'_toLinearMap : (lmul' R : _ →ₐ[R] S).toLinearMap = LinearMap.mul' R S :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'_toLinearMap | null |
lmul'_apply_tmul (a b : S) : lmul' (S := S) R (a ⊗ₜ[R] b) = a * b :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'_apply_tmul | null |
lmul'_comp_includeLeft : (lmul' R : _ →ₐ[R] S).comp includeLeft = AlgHom.id R S :=
AlgHom.ext <| mul_one
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'_comp_includeLeft | null |
lmul'_comp_includeRight : (lmul' R : _ →ₐ[R] S).comp includeRight = AlgHom.id R S :=
AlgHom.ext <| one_mul | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'_comp_includeRight | null |
lmul'_comp_map (f : A →ₐ[R] S) (g : B →ₐ[R] S) :
(lmul' R).comp (map f g) = lift f g (fun _ _ ↦ .all _ _) := by ext <;> rfl
variable (R S) in | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmul'_comp_map | null |
lmulEquiv [CompatibleSMul R S S S] : S ⊗[R] S ≃ₐ[S] S :=
.ofAlgHom (lmul'' R) includeLeft lmul'_comp_includeLeft <| AlgHom.ext fun x ↦ x.induction_on
(by simp) (fun x y ↦ show (x * y) ⊗ₜ[R] 1 = x ⊗ₜ[R] y by
rw [mul_comm, ← smul_eq_mul, smul_tmul, smul_eq_mul, mul_one])
fun _ _ hx hy ↦ by simp_all [add_tmul] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmulEquiv | If multiplication by elements of S can switch between the two factors of `S ⊗[R] S`,
then `lmul''` is an isomorphism. |
lmulEquiv_eq_lidOfCompatibleSMul [CompatibleSMul R S S S] :
lmulEquiv R S = lidOfCompatibleSMul R S S :=
AlgEquiv.coe_algHom_injective <| by ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lmulEquiv_eq_lidOfCompatibleSMul | null |
productMap : A ⊗[R] B →ₐ[R] S := productLeftAlgHom f g | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap | 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. |
productMap_eq_comp_map : productMap f g = (lmul' R).comp (TensorProduct.map f g) := by
ext <;> rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_eq_comp_map | null |
productMap_apply_tmul (a : A) (b : B) : productMap f g (a ⊗ₜ b) = f a * g b := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_apply_tmul | null |
productMap_left_apply (a : A) : productMap f g (a ⊗ₜ 1) = f a := by
simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_left_apply | null |
productMap_left : (productMap f g).comp includeLeft = f :=
lift_comp_includeLeft _ _ (fun _ _ => Commute.all _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_left | null |
productMap_right_apply (b : B) :
productMap f g (1 ⊗ₜ b) = g b := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_right_apply | null |
productMap_right : (productMap f g).comp includeRight = g :=
lift_comp_includeRight _ _ (fun _ _ => Commute.all _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_right | null |
productMap_range : (productMap f g).range = f.range ⊔ g.range := by
rw [productMap_eq_comp_map, AlgHom.range_comp, map_range, map_sup, ← AlgHom.range_comp,
← AlgHom.range_comp,
← AlgHom.comp_assoc, ← AlgHom.comp_assoc, lmul'_comp_includeLeft, lmul'_comp_includeRight,
AlgHom.id_comp, AlgHom.id_comp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | productMap_range | null |
mk_one_injective_of_isScalarTower (M : Type*) [AddCommMonoid M]
[Module R M] [Module S M] [IsScalarTower R S M] :
Function.Injective (TensorProduct.mk R S M 1) := by
apply Function.RightInverse.injective (g := LinearMap.liftBaseChange S LinearMap.id)
intro m
simp | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | mk_one_injective_of_isScalarTower | If `M` is a `B`-module that is also an `A`-module, the canonical map
`M →ₗ[A] B ⊗[A] M` is injective. |
Algebra.baseChange_lmul {R B : Type*} [CommSemiring R] [Semiring B] [Algebra R B]
{A : Type*} [CommSemiring A] [Algebra R A] (f : B) :
(Algebra.lmul R B f).baseChange A = Algebra.lmul A (A ⊗[R] B) (1 ⊗ₜ f) := by
ext i
simp | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | Algebra.baseChange_lmul | null |
@[simps!]
tensorProduct : A ⊗[R] (M →ₗ[R] N) →ₗ[A] (A ⊗[R] M) →ₗ[A] (A ⊗[R] N) :=
TensorProduct.AlgebraTensorModule.lift <|
{ toFun := fun a ↦ a • baseChangeHom R A M N
map_add' := by simp only [add_smul, forall_true_iff]
map_smul' := by simp only [smul_assoc, RingHom.id_apply, forall_true_iff] } | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorProduct | 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. |
@[simps!]
tensorProductEnd : A ⊗[R] (End R M) →ₐ[A] End A (A ⊗[R] M) :=
Algebra.TensorProduct.algHomOfLinearMapTensorProduct
(LinearMap.tensorProduct R A M M)
(fun a b f g ↦ by
apply LinearMap.ext
intro x
simp only [tensorProduct, mul_comm a b, Module.End.mul_eq_comp,
TensorProduct.AlgebraTensorModule.lift_apply, TensorProduct.lift.tmul, coe_restrictScalars,
coe_mk, AddHom.coe_mk, mul_smul, smul_apply, baseChangeHom_apply, baseChange_comp,
comp_apply, Algebra.mul_smul_comm, Algebra.smul_mul_assoc])
(by
apply LinearMap.ext
intro x
simp only [tensorProduct, TensorProduct.AlgebraTensorModule.lift_apply,
TensorProduct.lift.tmul, coe_restrictScalars, coe_mk, AddHom.coe_mk, one_smul,
baseChangeHom_apply, baseChange_eq_ltensor, Module.End.one_eq_id,
lTensor_id, LinearMap.id_apply]) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tensorProductEnd | 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. |
endTensorEndAlgHom : End A M ⊗[R] End R N →ₐ[S] End A (M ⊗[R] N) :=
Algebra.TensorProduct.algHomOfLinearMapTensorProduct
(AlgebraTensorModule.homTensorHomMap R A S M N M N)
(fun _f₁ _f₂ _g₁ _g₂ => AlgebraTensorModule.ext fun _m _n => rfl)
(AlgebraTensorModule.ext fun _m _n => rfl) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | endTensorEndAlgHom | 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`. |
endTensorEndAlgHom_apply (f : End A M) (g : End R N) :
endTensorEndAlgHom (R := R) (S := S) (A := A) (M := M) (N := N) (f ⊗ₜ[R] g)
= AlgebraTensorModule.map f g :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | endTensorEndAlgHom_apply | null |
moduleAux : A ⊗[R] B →ₗ[R] M →ₗ[R] M :=
TensorProduct.lift
{ toFun := fun a => a • (Algebra.lsmul R R M : B →ₐ[R] Module.End R M).toLinearMap
map_add' := fun r t => by
ext
simp only [add_smul, LinearMap.add_apply]
map_smul' := fun n r => by
ext
simp only [RingHom.id_apply, LinearMap.smul_apply, smul_assoc] } | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | moduleAux | An auxiliary definition, used for constructing the `Module (A ⊗[R] B) M` in
`TensorProduct.Algebra.module` below. |
moduleAux_apply (a : A) (b : B) (m : M) : moduleAux (a ⊗ₜ[R] b) m = a • b • m :=
rfl
variable [SMulCommClass A B M] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | moduleAux_apply | null |
protected module : Module (A ⊗[R] B) M where
smul x m := moduleAux x m
zero_smul m := by simp only [(· • ·), map_zero, LinearMap.zero_apply]
smul_zero x := by simp only [(· • ·), map_zero]
smul_add x m₁ m₂ := by simp only [(· • ·), map_add]
add_smul x y m := by simp only [(· • ·), map_add, LinearMap.add_apply]
one_smul m := by
simp only [(· • ·), Algebra.TensorProduct.one_def]
simp only [moduleAux_apply, one_smul]
mul_smul x y m := by
refine TensorProduct.induction_on x ?_ ?_ ?_ <;> refine TensorProduct.induction_on y ?_ ?_ ?_
· simp only [(· • ·), mul_zero, map_zero, LinearMap.zero_apply]
· intro a b
simp only [(· • ·), zero_mul, map_zero, LinearMap.zero_apply]
· intro z w _ _
simp only [(· • ·), zero_mul, map_zero, LinearMap.zero_apply]
· intro a b
simp only [(· • ·), mul_zero, map_zero, LinearMap.zero_apply]
· intro a₁ b₁ a₂ b₂
simp only [(· • ·), Algebra.TensorProduct.tmul_mul_tmul]
simp only [moduleAux_apply, mul_smul, smul_comm a₁ b₂]
· intro z w hz hw a b
simp only [(· • ·)] at hz hw ⊢
simp only [moduleAux_apply, mul_add, LinearMap.map_add,
LinearMap.add_apply, moduleAux_apply, hz, hw]
· intro z w _ _
simp only [(· • ·), mul_zero, map_zero, LinearMap.zero_apply]
· intro a b z w hz hw
simp only [(· • ·)] at hz hw ⊢
simp only [LinearMap.map_add, add_mul, LinearMap.add_apply, hz, hw]
· intro u v _ _ z w hz hw
simp only [(· • ·)] at hz hw ⊢
simp only [add_mul, LinearMap.map_add, LinearMap.add_apply, hz, hw, add_add_add_comm]
attribute [local instance] TensorProduct.Algebra.module | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | module | 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 |
smul_def (a : A) (b : B) (m : M) : a ⊗ₜ[R] b • m = a • b • m :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | smul_def | null |
linearMap_comp_mul' :
Algebra.linearMap R (A ⊗[R] B) ∘ₗ LinearMap.mul' R R =
map (Algebra.linearMap R A) (Algebra.linearMap R B) := by
ext
simp only [AlgebraTensorModule.curry_apply, curry_apply, LinearMap.coe_restrictScalars, map_tmul,
Algebra.linearMap_apply, map_one, LinearMap.coe_comp, Function.comp_apply,
LinearMap.mul'_apply, mul_one, Algebra.TensorProduct.one_def] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | linearMap_comp_mul' | null |
Submodule.map_range_rTensor_subtype_lid {R Q} [CommSemiring R] [AddCommMonoid Q]
[Module R Q] {I : Submodule R R} :
(range <| rTensor Q I.subtype).map (TensorProduct.lid R Q) = I • ⊤ := by
rw [← map_top, ← map_coe_toLinearMap, ← Submodule.map_comp, map_top]
refine le_antisymm ?_ fun q h ↦ Submodule.smul_induction_on h
(fun r hr q _ ↦ ⟨⟨r, hr⟩ ⊗ₜ q, by simp⟩) (by simp +contextual [add_mem])
rintro _ ⟨t, rfl⟩
exact t.induction_on (by simp) (by simp +contextual [Submodule.smul_mem_smul])
(by simp +contextual [add_mem]) | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | Submodule.map_range_rTensor_subtype_lid | null |
TensorProduct.mk_surjective (h : Function.Surjective (algebraMap R S)) :
Function.Surjective (TensorProduct.mk R S M 1) := by
rw [← LinearMap.range_eq_top, ← top_le_iff, ← span_tmul_eq_top, Submodule.span_le]
rintro _ ⟨x, y, rfl⟩
obtain ⟨x, rfl⟩ := h x
rw [Algebra.algebraMap_eq_smul_one, smul_tmul]
exact ⟨x • y, rfl⟩
variable (S) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | TensorProduct.mk_surjective | null |
TensorProduct.flip_mk_surjective (h : Function.Surjective (algebraMap R T)) :
Function.Surjective ((TensorProduct.mk R S T).flip 1) := by
rw [← LinearMap.range_eq_top, ← top_le_iff, ← span_tmul_eq_top, Submodule.span_le]
rintro _ ⟨s, t, rfl⟩
obtain ⟨r, rfl⟩ := h t
rw [Algebra.algebraMap_eq_smul_one, ← smul_tmul]
exact ⟨r • s, rfl⟩
variable (T) in | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | TensorProduct.flip_mk_surjective | null |
Algebra.TensorProduct.includeRight_surjective (h : Function.Surjective (algebraMap R S)) :
Function.Surjective (includeRight : T →ₐ[R] S ⊗[R] T) :=
TensorProduct.mk_surjective _ _ _ h | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | Algebra.TensorProduct.includeRight_surjective | null |
Algebra.TensorProduct.includeLeft_surjective
(S A : Type*) [CommSemiring S] [Semiring A] [Algebra S A] [Algebra R A]
[SMulCommClass R S A] (h : Function.Surjective (algebraMap R T)) :
Function.Surjective (includeLeft : A →ₐ[S] A ⊗[R] T) :=
TensorProduct.flip_mk_surjective _ h | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | Algebra.TensorProduct.includeLeft_surjective | null |
@[simp]
TensorProduct.Algebra.mul'_comp_tensorTensorTensorComm :
LinearMap.mul' R (A ⊗[R] B) ∘ₗ tensorTensorTensorComm R A A B B =
map (LinearMap.mul' R A) (LinearMap.mul' R B) := by
ext
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | TensorProduct.Algebra.mul'_comp_tensorTensorTensorComm | null |
LinearMap.mul'_tensor :
mul' R (A ⊗[R] B) = map (mul' R A) (mul' R B) ∘ₗ tensorTensorTensorComm R A B A B :=
ext_fourfold' <| by simp | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | LinearMap.mul'_tensor | null |
LinearMap.mulLeft_tmul (a : A) (b : B) :
mulLeft R (a ⊗ₜ[R] b) = map (mulLeft R a) (mulLeft R b) := by
ext; simp | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | LinearMap.mulLeft_tmul | null |
LinearMap.mulRight_tmul (a : A) (b : B) :
mulRight R (a ⊗ₜ[R] b) = map (mulRight R a) (mulRight R b) := by
ext; simp | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | LinearMap.mulRight_tmul | null |
Submodule.FG.directedSystem :
DirectedSystem (ι := {P : Submodule R M // P.FG}) (F := fun P ↦ P.val)
(f := fun ⦃P Q⦄ (h : P ≤ Q) ↦ Submodule.inclusion h) where
map_self := fun _ _ ↦ rfl
map_map := fun _ _ _ _ _ _ ↦ rfl
variable (R M) in | instance | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.directedSystem | The directed system of finitely generated submodules of `M` |
noncomputable Submodule.FG.directLimit [DecidableEq {P : Submodule R M // P.FG}] :
Module.DirectLimit (ι := {P : Submodule R M // P.FG}) (G := fun P ↦ P.val)
(fun ⦃P Q⦄ (h : P ≤ Q) ↦ Submodule.inclusion h) ≃ₗ[R] M :=
LinearEquiv.ofBijective
(Module.DirectLimit.lift _ _ _ _ (fun P ↦ P.val.subtype) (fun _ _ _ _ ↦ rfl))
⟨Module.DirectLimit.lift_injective _ _ (fun P ↦ Submodule.injective_subtype P.val),
fun x ↦ ⟨Module.DirectLimit.of _ {P : Submodule R M // P.FG} _ _
⟨Submodule.span R {x}, Submodule.fg_span_singleton x⟩
⟨x, Submodule.mem_span_singleton_self x⟩,
by simp⟩⟩ | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.directLimit | Any module is the direct limit of its finitely generated submodules |
DirectedSystem.rTensor {ι : Type*} [Preorder ι] {F : ι → Type*}
[∀ i, AddCommMonoid (F i)] [∀ i, Module R (F i)] {f : ⦃i j : ι⦄ → i ≤ j → F i →ₗ[R] F j}
(D : DirectedSystem F (fun _ _ h ↦ f h)) :
DirectedSystem (fun i ↦ (F i) ⊗[R] N) (fun _ _ h ↦ rTensor N (f h)) where
map_self i t := by
rw [← id_apply (R := R) t]
apply DFunLike.congr_fun
ext m n
simp [D.map_self]
map_map {i j k} h h' t := by
rw [← comp_apply, ← rTensor_comp]
apply DFunLike.congr_fun
ext p n
simp [D.map_map] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | DirectedSystem.rTensor | Given a directed system of `R`-modules, tensoring it on the right gives a directed system |
Submodule.FG.rTensor.directedSystem :
DirectedSystem (ι := {P : Submodule R M // P.FG}) (fun P ↦ P.val ⊗[R] N)
(fun ⦃_ _⦄ h ↦ rTensor N (Submodule.inclusion h)) :=
Submodule.FG.directedSystem.rTensor R N | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.rTensor.directedSystem | When `P` ranges over finitely generated submodules of `M`,
the modules of the form `P ⊗[R] N` form a directed system. |
noncomputable Submodule.FG.rTensor.directLimit [DecidableEq {P : Submodule R M // P.FG}] :
Module.DirectLimit (R := R) (ι := {P : Submodule R M // P.FG}) (fun P ↦ P.val ⊗[R] N)
(fun ⦃P Q⦄ (h : P ≤ Q) ↦ (Submodule.inclusion h).rTensor N) ≃ₗ[R] M ⊗[R] N :=
(TensorProduct.directLimitLeft _ N).symm.trans ((Submodule.FG.directLimit R M).rTensor N) | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.rTensor.directLimit | A tensor product `M ⊗[R] N` is the direct limit of the modules `P ⊗[R] N`,
where `P` ranges over all finitely generated submodules of `M`, as a linear equivalence. |
Submodule.FG.rTensor.directLimit_apply [DecidableEq {P : Submodule R M // P.FG}]
{P : {P : Submodule R M // P.FG}} (u : P ⊗[R] N) :
(Submodule.FG.rTensor.directLimit R M N)
((Module.DirectLimit.of R {P : Submodule R M // P.FG} (fun P ↦ P.val ⊗[R] N)
(fun ⦃_ _⦄ h ↦ (Submodule.inclusion h).rTensor N) P) u)
= (rTensor N (Submodule.subtype P)) u := by
suffices (Submodule.FG.rTensor.directLimit R M N).toLinearMap.comp
(Module.DirectLimit.of R {P : Submodule R M // P.FG} (fun P ↦ P.val ⊗[R] N)
(fun _ _ hPQ ↦ rTensor N (Submodule.inclusion hPQ)) P)
= rTensor N (Submodule.subtype P.val) by
exact DFunLike.congr_fun this u
ext p n
simp [Submodule.FG.rTensor.directLimit, Submodule.FG.directLimit] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.rTensor.directLimit_apply | null |
Submodule.FG.rTensor.directLimit_apply' [DecidableEq {P : Submodule R M // P.FG}]
{P : Submodule R M} (hP : Submodule.FG P) (u : P ⊗[R] N) :
(Submodule.FG.rTensor.directLimit R M N)
((Module.DirectLimit.of R {P : Submodule R M // P.FG} (fun P ↦ P.val ⊗[R] N)
(fun ⦃_ _⦄ h ↦ rTensor N (Submodule.inclusion h)) ⟨P, hP⟩) u)
= (rTensor N (Submodule.subtype P)) u := by
apply Submodule.FG.rTensor.directLimit_apply | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.rTensor.directLimit_apply' | An alternative version to `Submodule.FG.rTensor.directLimit_apply`. |
DirectedSystem.lTensor {ι : Type*} [Preorder ι] {F : ι → Type*}
[∀ i, AddCommMonoid (F i)] [∀ i, Module R (F i)] {f : ⦃i j : ι⦄ → i ≤ j → F i →ₗ[R] F j}
(D : DirectedSystem F (fun _ _ h ↦ f h)) :
DirectedSystem (fun i ↦ M ⊗[R] (F i)) (fun _ _ h ↦ lTensor M (f h)) where
map_self i t := by
rw [← id_apply (R := R) t]
apply DFunLike.congr_fun
ext m n
simp [D.map_self]
map_map {i j k} h h' t := by
rw [← comp_apply, ← lTensor_comp]
apply DFunLike.congr_fun
ext p n
simp [D.map_map] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | DirectedSystem.lTensor | Given a directed system of `R`-modules, tensoring it on the left gives a directed system |
Submodule.FG.lTensor.directedSystem :
DirectedSystem (ι := {Q : Submodule R N // Q.FG}) (fun Q ↦ M ⊗[R] Q.val)
(fun _ _ hPQ ↦ lTensor M (Submodule.inclusion hPQ)) :=
Submodule.FG.directedSystem.lTensor R M | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.lTensor.directedSystem | When `Q` ranges over finitely generated submodules of `N`,
the modules of the form `M ⊗[R] Q` form a directed system. |
noncomputable Submodule.FG.lTensor.directLimit [DecidableEq {Q : Submodule R N // Q.FG}] :
Module.DirectLimit (R := R) (ι := {Q : Submodule R N // Q.FG}) (fun Q ↦ M ⊗[R] Q.val)
(fun _ _ hPQ ↦ (inclusion hPQ).lTensor M) ≃ₗ[R] M ⊗[R] N :=
(TensorProduct.directLimitRight _ M).symm.trans ((Submodule.FG.directLimit R N).lTensor M) | def | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.lTensor.directLimit | A tensor product `M ⊗[R] N` is the direct limit of the modules `M ⊗[R] Q`,
where `Q` ranges over all finitely generated submodules of `N`, as a linear equivalence. |
Submodule.FG.lTensor.directLimit_apply [DecidableEq {P : Submodule R N // P.FG}]
(Q : {Q : Submodule R N // Q.FG}) (u : M ⊗[R] Q.val) :
(Submodule.FG.lTensor.directLimit R M N)
((Module.DirectLimit.of R {Q : Submodule R N // Q.FG} (fun Q ↦ M ⊗[R] Q.val)
(fun _ _ hPQ ↦ (inclusion hPQ).lTensor M) Q) u)
= (lTensor M (Submodule.subtype Q.val)) u := by
suffices (Submodule.FG.lTensor.directLimit R M N).toLinearMap.comp
(Module.DirectLimit.of R {Q : Submodule R N // Q.FG} (fun Q ↦ M ⊗[R] Q.val)
(fun _ _ hPQ ↦ lTensor M (inclusion hPQ)) Q)
= lTensor M (Submodule.subtype Q.val) by
exact DFunLike.congr_fun this u
ext p n
simp [Submodule.FG.lTensor.directLimit, Submodule.FG.directLimit] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.lTensor.directLimit_apply | null |
Submodule.FG.lTensor.directLimit_apply' [DecidableEq {Q : Submodule R N // Q.FG}]
(Q : Submodule R N) (hQ : Q.FG) (u : M ⊗[R] Q) :
(Submodule.FG.lTensor.directLimit R M N)
((Module.DirectLimit.of R {Q : Submodule R N // Q.FG} (fun Q ↦ M ⊗[R] Q.val)
(fun _ _ hPQ ↦ lTensor M (inclusion hPQ)) ⟨Q, hQ⟩) u)
= (lTensor M (Submodule.subtype Q)) u :=
Submodule.FG.lTensor.directLimit_apply R M N ⟨Q, hQ⟩ u
variable {R M N} (u : M ⊗[R] N)
{P : Submodule R M} (hP : Submodule.FG P) {t : P ⊗[R] N}
{P' : Submodule R M} (hP' : Submodule.FG P') {t' : P' ⊗[R] N} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.FG.lTensor.directLimit_apply' | null |
TensorProduct.exists_of_fg :
∃ (P : Submodule R M), P.FG ∧ u ∈ range (rTensor N P.subtype) := by
classical
let ⟨P, t, ht⟩ := Module.DirectLimit.exists_of ((Submodule.FG.rTensor.directLimit R M N).symm u)
use P.val, P.property, t
rw [← Submodule.FG.rTensor.directLimit_apply, ht, LinearEquiv.apply_symm_apply]
include hP in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.exists_of_fg | null |
TensorProduct.eq_of_fg_of_subtype_eq {t' : P ⊗[R] N}
(h : rTensor N P.subtype t = rTensor N P.subtype t') :
∃ (Q : Submodule R M) (hPQ : P ≤ Q), Q.FG ∧
rTensor N (inclusion hPQ) t = rTensor N (inclusion hPQ) t' := by
classical
simp only [← Submodule.FG.rTensor.directLimit_apply' R M N hP, EmbeddingLike.apply_eq_iff_eq] at h
obtain ⟨Q, hPQ, h⟩ := Module.DirectLimit.exists_eq_of_of_eq h
use Q.val, Subtype.coe_le_coe.mpr hPQ, Q.property
include hP in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.eq_of_fg_of_subtype_eq | null |
TensorProduct.eq_zero_of_fg_of_subtype_eq_zero (h : rTensor N P.subtype t = 0) :
∃ (Q : Submodule R M) (hPQ : P ≤ Q), Q.FG ∧ rTensor N (inclusion hPQ) t = 0 := by
rw [← (rTensor N P.subtype).map_zero] at h
simpa only [map_zero] using TensorProduct.eq_of_fg_of_subtype_eq hP h
include hP hP' in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.eq_zero_of_fg_of_subtype_eq_zero | null |
TensorProduct.eq_of_fg_of_subtype_eq'
(h : rTensor N P.subtype t = rTensor N P'.subtype t') :
∃ (Q : Submodule R M) (hPQ : P ≤ Q) (hP'Q : P' ≤ Q), Q.FG ∧
rTensor N (inclusion hPQ) t = rTensor N (inclusion hP'Q) t' := by
simp only [← subtype_comp_inclusion _ _ (le_sup_left : _ ≤ P ⊔ P'),
← subtype_comp_inclusion _ _ (le_sup_right : _ ≤ P ⊔ P'),
rTensor_comp, coe_comp, Function.comp_apply] at h
let ⟨Q, hQ_le, hQ, h⟩ := TensorProduct.eq_of_fg_of_subtype_eq (hP.sup hP') h
use Q, le_trans le_sup_left hQ_le, le_trans le_sup_right hQ_le, hQ
simpa [← comp_apply, ← rTensor_comp] using h | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.eq_of_fg_of_subtype_eq' | null |
TensorProduct.Algebra.exists_of_fg :
∃ (A : Subalgebra R S), Subalgebra.FG A ∧ u ∈ range (rTensor N A.val.toLinearMap) := by
obtain ⟨P, ⟨s, hs⟩, hu⟩ := TensorProduct.exists_of_fg u
use Algebra.adjoin R s, Subalgebra.fg_adjoin_finset _
have : P ≤ (Algebra.adjoin R (s : Set S)).toSubmodule := by
simp only [← hs, span_le, Subalgebra.coe_toSubmodule]
exact Algebra.subset_adjoin
rw [← subtype_comp_inclusion P _ this, rTensor_comp] at hu
exact range_comp_le_range _ _ hu
include hA in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.Algebra.exists_of_fg | null |
TensorProduct.Algebra.eq_of_fg_of_subtype_eq
(h : rTensor N A.val.toLinearMap t = rTensor N A.val.toLinearMap t') :
∃ (B : Subalgebra R S) (hAB : A ≤ B), Subalgebra.FG B
∧ rTensor N (Subalgebra.inclusion hAB).toLinearMap t
= LinearMap.rTensor N (Subalgebra.inclusion hAB).toLinearMap t' := by
classical
let ⟨P, hP, u, hu⟩ := TensorProduct.exists_of_fg t
let ⟨P', hP', u', hu'⟩ := TensorProduct.exists_of_fg t'
let P₁ := Submodule.map A.toSubmodule.subtype (P ⊔ P')
have hP₁ : Submodule.FG P₁ := Submodule.FG.map _ (Submodule.FG.sup hP hP')
let j : P →ₗ[R] P₁ := (Subalgebra.toSubmodule A).subtype.restrict
(fun p hp ↦ by
simp only [coe_subtype, Submodule.map_sup, P₁]
exact Submodule.mem_sup_left ⟨p, hp, rfl⟩)
let j' : P' →ₗ[R] P₁ := (Subalgebra.toSubmodule A).subtype.restrict
(fun p hp ↦ by
simp only [coe_subtype, Submodule.map_sup, P₁]
exact Submodule.mem_sup_right ⟨p, hp, rfl⟩)
set u₁ := rTensor N j u with hu₁
set u'₁ := rTensor N j' u' with hu'₁
have : rTensor N P₁.subtype u₁ = rTensor N P₁.subtype u'₁ := by
rw [hu₁, hu'₁]
simp only [← comp_apply, ← rTensor_comp]
have hj₁ : P₁.subtype ∘ₗ j = A.val.toLinearMap ∘ₗ P.subtype := rfl
have hj'₁ : P₁.subtype ∘ₗ j' = A.val.toLinearMap ∘ₗ P'.subtype := rfl
rw [hj₁, hj'₁]
simp only [rTensor_comp, comp_apply]
rw [hu, hu', h]
let ⟨P'₁, hP₁_le, hP'₁, h⟩ := TensorProduct.eq_of_fg_of_subtype_eq hP₁ this
let ⟨s, hs⟩ := hP'₁
let ⟨w, hw⟩ := hA
let B := Algebra.adjoin R ((s ∪ w : Finset S) : Set S)
have hBA : A ≤ B := by
simp only [B, ← hw]
apply Algebra.adjoin_mono
simp only [Finset.coe_union, Set.subset_union_right]
use B, hBA, Subalgebra.fg_adjoin_finset _
rw [← hu, ← hu']
simp only [← comp_apply, ← rTensor_comp]
have hP'₁_le : P'₁ ≤ B.toSubmodule := by
simp only [← hs, Finset.coe_union, Submodule.span_le, Subalgebra.coe_toSubmodule, B]
exact subset_trans Set.subset_union_left Algebra.subset_adjoin
have k : (Subalgebra.inclusion hBA).toLinearMap ∘ₗ P.subtype
= inclusion hP'₁_le ∘ₗ inclusion hP₁_le ∘ₗ j := by ext; rfl
have k' : (Subalgebra.inclusion hBA).toLinearMap ∘ₗ P'.subtype
= inclusion hP'₁_le ∘ₗ inclusion hP₁_le ∘ₗ j' := by ext; rfl
rw [k, k']
simp only [rTensor_comp, comp_apply]
rw [← hu₁, ← hu'₁, h]
include hA hA' in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.Algebra.eq_of_fg_of_subtype_eq | null |
TensorProduct.Algebra.eq_of_fg_of_subtype_eq' {t' : A' ⊗[R] N}
(h : rTensor N A.val.toLinearMap t = rTensor N A'.val.toLinearMap t') :
∃ (B : Subalgebra R S) (hAB : A ≤ B) (hA'B : A' ≤ B), Subalgebra.FG B
∧ rTensor N (Subalgebra.inclusion hAB).toLinearMap t
= rTensor N (Subalgebra.inclusion hA'B).toLinearMap t' := by
have hj : (A ⊔ A').val.comp (Subalgebra.inclusion le_sup_left) = A.val := by ext; rfl
have hj' : (A ⊔ A').val.comp (Subalgebra.inclusion le_sup_right) = A'.val := by ext; rfl
simp only [← hj, ← hj', AlgHom.comp_toLinearMap, rTensor_comp, comp_apply] at h
let ⟨B, hB_le, hB, h⟩ := TensorProduct.Algebra.eq_of_fg_of_subtype_eq
(Subalgebra.FG.sup hA hA') h
use B, le_trans le_sup_left hB_le, le_trans le_sup_right hB_le, hB
simpa only [← rTensor_comp, ← comp_apply] using h | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | TensorProduct.Algebra.eq_of_fg_of_subtype_eq' | null |
Submodule.exists_fg_of_baseChange_eq_zero
(f : M →ₗ[R] N) {t : S ⊗[R] M} (ht : f.baseChange S t = 0) :
∃ (A : Subalgebra R S) (_ : A.FG) (u : A ⊗[R] M),
f.baseChange A u = 0 ∧ A.val.toLinearMap.rTensor M u = t := by
classical
obtain ⟨A, hA, ht_memA⟩ := TensorProduct.Algebra.exists_of_fg t
obtain ⟨u, hu⟩ := _root_.id ht_memA
have := TensorProduct.Algebra.eq_of_fg_of_subtype_eq hA (t := f.baseChange _ u) (t' := 0)
simp only [map_zero, exists_and_left] at this
have hu' : (A.val.toLinearMap.rTensor N) (f.baseChange (↥A) u) = 0 := by
rw [← ht, ← hu, rTensor_baseChange]
obtain ⟨B, hB, hAB, hu'⟩ := this hu'
use B, hB, rTensor M (Subalgebra.inclusion hAB).toLinearMap u
constructor
· rw [← rTensor_baseChange, hu']
· rw [← comp_apply, ← rTensor_comp, ← hu]
congr | theorem | RingTheory | [
"Mathlib.LinearAlgebra.TensorProduct.DirectLimit",
"Mathlib.LinearAlgebra.TensorProduct.Tower",
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/TensorProduct/DirectLimitFG.lean | Submodule.exists_fg_of_baseChange_eq_zero | Lift an element that maps to 0 |
exists_fg_le_eq_rTensor_subtype (x : N ⊗ M) :
∃ (J : Submodule R N) (_ : J.FG) (y : J ⊗ M), x = rTensor M J.subtype y := by
induction x with
| zero => exact ⟨⊥, fg_bot, 0, rfl⟩
| tmul i m => exact ⟨R ∙ i, fg_span_singleton i, ⟨i, mem_span_singleton_self _⟩ ⊗ₜ[R] m, rfl⟩
| add x₁ x₂ ihx₁ ihx₂ =>
obtain ⟨J₁, fg₁, y₁, rfl⟩ := ihx₁
obtain ⟨J₂, fg₂, y₂, rfl⟩ := ihx₂
refine ⟨J₁ ⊔ J₂, fg₁.sup fg₂,
rTensor M (J₁.inclusion le_sup_left) y₁ + rTensor M (J₂.inclusion le_sup_right) y₂, ?_⟩
rw [map_add, ← rTensor_comp_apply, ← rTensor_comp_apply]
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | exists_fg_le_eq_rTensor_subtype | Every `x : N ⊗ M` is the image of some `y : J ⊗ M`, where `J` is a finitely generated
submodule of `N`, under the tensor product of the inclusion `J → N` and the identity `M → M`. |
exists_fg_le_subset_range_rTensor_subtype (s : Set (N ⊗[R] M)) (hs : s.Finite) :
∃ (J : Submodule R N) (_ : J.FG), s ⊆ LinearMap.range (rTensor M J.subtype) := by
choose J fg y eq using exists_fg_le_eq_rTensor_subtype (R := R) (M := M) (N := N)
rw [← Set.finite_coe_iff] at hs
refine ⟨⨆ x : s, J x, fg_iSup _ fun _ ↦ fg _, fun x hx ↦
⟨rTensor M (inclusion <| le_iSup _ ⟨x, hx⟩) (y x), .trans ?_ (eq x).symm⟩⟩
rw [← comp_apply, ← rTensor_comp]; rfl
open TensorProduct LinearMap | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | exists_fg_le_subset_range_rTensor_subtype | null |
exists_fg_le_eq_rTensor_inclusion (x : I ⊗ M) :
∃ (J : Submodule R N) (_ : J.FG) (hle : J ≤ I) (y : J ⊗ M),
x = rTensor M (J.inclusion hle) y := by
obtain ⟨J, fg, y, rfl⟩ := exists_fg_le_eq_rTensor_subtype x
refine ⟨J.map I.subtype, fg.map _, I.map_subtype_le J, rTensor M (I.subtype.submoduleMap J) y, ?_⟩
rw [← LinearMap.rTensor_comp_apply]; rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | exists_fg_le_eq_rTensor_inclusion | Every `x : I ⊗ M` is the image of some `y : J ⊗ M`, where `J ≤ I` is finitely generated,
under the tensor product of `J.inclusion ‹J ≤ I› : J → I` and the identity `M → M`. |
exists_fg_le_subset_range_rTensor_inclusion (s : Set (I ⊗[R] M)) (hs : s.Finite) :
∃ (J : Submodule R N) (_ : J.FG) (hle : J ≤ I),
s ⊆ LinearMap.range (rTensor M (J.inclusion hle)) := by
choose J fg hle y eq using exists_fg_le_eq_rTensor_inclusion (M := M) (I := I)
rw [← Set.finite_coe_iff] at hs
refine ⟨⨆ x : s, J x, fg_iSup _ fun _ ↦ fg _, iSup_le fun _ ↦ hle _, fun x hx ↦
⟨rTensor M (inclusion <| le_iSup _ ⟨x, hx⟩) (y x), .trans ?_ (eq x).symm⟩⟩
rw [← comp_apply, ← rTensor_comp]; rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | exists_fg_le_subset_range_rTensor_inclusion | null |
Module.Finite.base_change [CommSemiring R] [Semiring A] [Algebra R A] [AddCommMonoid M]
[Module R M] [h : Module.Finite R M] : Module.Finite A (TensorProduct R A M) := by
classical
obtain ⟨s, hs⟩ := h.fg_top
refine ⟨⟨s.image (TensorProduct.mk R A M 1), eq_top_iff.mpr ?_⟩⟩
rintro x -
induction x with
| zero => exact zero_mem _
| tmul x y =>
rw [Finset.coe_image, ← Submodule.span_span_of_tower R, Submodule.span_image, hs,
Submodule.map_top, LinearMap.coe_range, ← mul_one x, ← smul_eq_mul,
← TensorProduct.smul_tmul']
exact Submodule.smul_mem _ x (Submodule.subset_span <| Set.mem_range_self y)
| add x y hx hy => exact Submodule.add_mem _ hx hy | instance | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | Module.Finite.base_change | null |
Module.Finite.tensorProduct [CommSemiring R] [AddCommMonoid M] [Module R M]
[AddCommMonoid N] [Module R N] [hM : Module.Finite R M] [hN : Module.Finite R N] :
Module.Finite R (TensorProduct R M N) where
fg_top := (TensorProduct.map₂_mk_top_top_eq_top R M N).subst (hM.fg_top.map₂ _ hN.fg_top) | instance | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | Module.Finite.tensorProduct | null |
Module.exists_isPrincipal_quotient_of_finite :
∃ N : Submodule R M, N ≠ ⊤ ∧ Submodule.IsPrincipal (⊤ : Submodule R (M ⧸ N)) := by
obtain ⟨n, f, hf⟩ := @Module.Finite.exists_fin R M _ _ _ _
let s := { m : ℕ | Submodule.span R (f '' (Fin.val ⁻¹' (Set.Iio m))) ≠ ⊤ }
have hns : ∀ x ∈ s, x < n := by
refine fun x hx ↦ lt_iff_not_ge.mpr fun e ↦ ?_
have : (Fin.val ⁻¹' Set.Iio x : Set (Fin n)) = Set.univ := by ext y; simpa using y.2.trans_le e
simp [s, this, hf] at hx
have hs₁ : s.Nonempty := ⟨0, by simp [s]⟩
have hs₂ : BddAbove s := ⟨n, fun x hx ↦ (hns x hx).le⟩
have hs := Nat.sSup_mem hs₁ hs₂
refine ⟨_, hs, ⟨⟨Submodule.mkQ _ (f ⟨_, hns _ hs⟩), ?_⟩⟩⟩
have := not_not.mp (notMem_of_csSup_lt (Order.lt_succ _) hs₂)
rw [← Set.image_singleton, ← Submodule.map_span,
← (Submodule.comap_injective_of_surjective (Submodule.mkQ_surjective _)).eq_iff,
Submodule.comap_map_eq, Submodule.ker_mkQ, Submodule.comap_top, ← this, ← Submodule.span_union,
Order.Iio_succ_eq_insert (sSup s), ← Set.union_singleton, Set.preimage_union, Set.image_union,
← @Set.image_singleton _ _ f, Set.union_comm]
congr!
ext
simp [Fin.ext_iff] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | Module.exists_isPrincipal_quotient_of_finite | null |
Module.exists_surjective_quotient_of_finite :
∃ (I : Ideal R) (f : M →ₗ[R] R ⧸ I), I ≠ ⊤ ∧ Function.Surjective f := by
obtain ⟨N, hN, ⟨x, hx⟩⟩ := Module.exists_isPrincipal_quotient_of_finite R M
let f := (LinearMap.toSpanSingleton R _ x).quotKerEquivOfSurjective
(by rw [← LinearMap.range_eq_top, ← LinearMap.span_singleton_eq_range, hx])
refine ⟨_, f.symm.toLinearMap.comp N.mkQ, fun e ↦ ?_, f.symm.surjective.comp N.mkQ_surjective⟩
obtain rfl : x = 0 := by simpa using LinearMap.congr_fun (LinearMap.ker_eq_top.mp e) 1
rw [ne_eq, ← Submodule.subsingleton_quotient_iff_eq_top, ← not_nontrivial_iff_subsingleton,
not_not] at hN
simp at hx
open TensorProduct | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | Module.exists_surjective_quotient_of_finite | null |
Subalgebra.finite_sup {K L : Type*} [CommSemiring K] [CommSemiring L] [Algebra K L]
(E1 E2 : Subalgebra K L) [Module.Finite K E1] [Module.Finite K E2] :
Module.Finite K ↥(E1 ⊔ E2) := by
rw [← E1.range_val, ← E2.range_val, ← Algebra.TensorProduct.productMap_range]
exact Module.Finite.range (Algebra.TensorProduct.productMap E1.val E2.val).toLinearMap
open TensorProduct in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | Subalgebra.finite_sup | null |
RingHom.surjective_of_tmul_eq_tmul_of_finite {R S}
[CommRing R] [Ring S] [Algebra R S] [Module.Finite R S]
(h₁ : ∀ s : S, s ⊗ₜ[R] 1 = 1 ⊗ₜ s) : Function.Surjective (algebraMap R S) := by
let R' := LinearMap.range (Algebra.ofId R S).toLinearMap
rcases subsingleton_or_nontrivial (S ⧸ R') with h | _
· rwa [Submodule.subsingleton_quotient_iff_eq_top, LinearMap.range_eq_top] at h
have : Subsingleton ((S ⧸ R') ⊗[R] (S ⧸ R')) := by
refine subsingleton_of_forall_eq 0 fun y ↦ ?_
induction y with
| zero => rfl
| add a b e₁ e₂ => rwa [e₁, zero_add]
| tmul x y =>
obtain ⟨x, rfl⟩ := R'.mkQ_surjective x
obtain ⟨y, rfl⟩ := R'.mkQ_surjective y
obtain ⟨s, hs⟩ : ∃ s, 1 ⊗ₜ[R] s = x ⊗ₜ[R] y := by
use x * y
trans x ⊗ₜ 1 * 1 ⊗ₜ y
· simp [h₁]
· simp
have : R'.mkQ 1 = 0 := (Submodule.Quotient.mk_eq_zero R').mpr ⟨1, map_one (algebraMap R S)⟩
rw [← map_tmul R'.mkQ R'.mkQ, ← hs, map_tmul, this, zero_tmul]
cases false_of_nontrivial_of_subsingleton ((S ⧸ R') ⊗[R] (S ⧸ R')) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear",
"Mathlib.RingTheory.Ideal.Quotient.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/TensorProduct/Finite.lean | RingHom.surjective_of_tmul_eq_tmul_of_finite | null |
noncomputable basisAux : A ⊗[R] M ≃ₗ[R] ι →₀ A :=
_root_.TensorProduct.congr (Finsupp.LinearEquiv.finsuppUnique R A PUnit.{uι+1}).symm b.repr ≪≫ₗ
(finsuppTensorFinsupp R R A R PUnit ι).trans
(Finsupp.lcongr (Equiv.uniqueProd ι PUnit) (_root_.TensorProduct.rid R A)) | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.Finsupp.Pi",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/RingTheory/TensorProduct/Free.lean | basisAux | 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). |
basisAux_tmul (a : A) (m : M) :
basisAux A b (a ⊗ₜ m) = a • Finsupp.mapRange (algebraMap R A) (map_zero _) (b.repr m) := by
ext
simp [basisAux, ← Algebra.commutes, Algebra.smul_def] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.Finsupp.Pi",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/RingTheory/TensorProduct/Free.lean | basisAux_tmul | null |
basisAux_map_smul (a : A) (x : A ⊗[R] M) : basisAux A b (a • x) = a • basisAux A b x :=
TensorProduct.induction_on x (by simp)
(fun x y => by simp only [TensorProduct.smul_tmul', basisAux_tmul, smul_assoc])
fun x y hx hy => by simp [hx, hy]
variable (A) in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.Finsupp.Pi",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/RingTheory/TensorProduct/Free.lean | basisAux_map_smul | null |
noncomputable basis : Basis ι A (A ⊗[R] M) where
repr := { basisAux A b with map_smul' := basisAux_map_smul b }
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.LinearAlgebra.Finsupp.Pi",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/RingTheory/TensorProduct/Free.lean | basis | Given a `R`-algebra `A`, this is the `A`-basis of `A ⊗[R] M` induced by a `R`-basis of `M`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.