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 ⌀ |
|---|---|---|---|---|---|---|
free_cotangent : Module.Free S P.toExtension.Cotangent :=
Module.Free.of_basis P.basisCotangent | instance | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | free_cotangent | null |
noncomputable sectionCotangent : P.toExtension.CotangentSpace →ₗ[S] P.toExtension.Cotangent :=
(cotangentEquiv P).symm ∘ₗ (Finsupp.linearEquivFunOnFinite S S σ).toLinearMap ∘ₗ
Finsupp.lcomapDomain _ P.map_inj ∘ₗ P.cotangentSpaceBasis.repr.toLinearMap | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | sectionCotangent | If `P` is a submersive presentation, this is the section of the map
`I ⧸ I ^ 2 → ⊕ S dxᵢ` given by projecting to the summands indexed by `σ` and composing with the
inverse of `P.cotangentEquiv`.
By `SubmersivePresentation.sectionCotangent_comp` this is indeed a section. |
sectionCotangent_eq_iff [Finite σ]
(x : P.toExtension.CotangentSpace) (y : P.toExtension.Cotangent) :
sectionCotangent P x = y ↔
∀ i : σ, P.cotangentSpaceBasis.repr x (P.map i) = (P.cotangentComplexAux y) i := by
simp only [sectionCotangent, LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply]
rw [← (cotangentEquiv P).injective.eq_iff, funext_iff, LinearEquiv.apply_symm_apply]
simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | sectionCotangent_eq_iff | null |
sectionCotangent_comp :
sectionCotangent P ∘ₗ P.toExtension.cotangentComplex = LinearMap.id := by
ext : 1
simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.id_coe, id_eq]
rw [sectionCotangent_eq_iff]
intro i
rfl | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | sectionCotangent_comp | null |
sectionCotangent_zero_of_notMem_range (i : ι) (hi : i ∉ Set.range P.map) :
(sectionCotangent P) (P.cotangentSpaceBasis i) = 0 := by
classical
contrapose hi
rw [sectionCotangent_eq_iff] at hi
simp only [Basis.repr_self, map_zero, Pi.zero_apply, Finsupp.single_apply] at hi
grind
@[deprecated (since := "2025-05-23")]
alias sectionCotangent_zero_of_not_mem_range := sectionCotangent_zero_of_notMem_range | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | sectionCotangent_zero_of_notMem_range | null |
noncomputable basisKaehlerOfIsCompl {κ : Type*} {f : κ → ι}
(hf : Function.Injective f) (hcompl : IsCompl (Set.range f) (Set.range P.map)) :
Basis κ S Ω[S⁄R] := by
apply P.cotangentSpaceBasis.ofSplitExact (sectionCotangent_comp P)
Extension.exact_cotangentComplex_toKaehler Extension.toKaehler_surjective hf (b := P.map)
· intro i
apply sectionCotangent_zero_of_notMem_range _ _
simp [← hcompl.compl_eq]
· simp only [sectionCotangent, LinearMap.coe_comp, Function.comp_assoc, LinearEquiv.coe_coe]
apply LinearIndependent.map' _ _ P.cotangentEquiv.symm.ker
convert (Pi.basisFun S σ).linearIndependent
classical
ext i j
simp only [Function.comp_apply, Basis.repr_self, Finsupp.linearEquivFunOnFinite_apply,
Pi.basisFun_apply]
simp [Finsupp.single_eq_pi_single]
· exact hcompl.2 | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | basisKaehlerOfIsCompl | Given a submersive presentation of `S` as `R`-algebra, any indexing type `κ` complementary to
the `σ` in `ι` indexes a basis of `Ω[S⁄R]`.
See `SubmersivePresentation.basisKaehler` for the special case `κ = (Set.range P.map)ᶜ`. |
@[stacks 00T7 "(2)"]
noncomputable basisKaehler :
Basis ((Set.range P.map)ᶜ : Set _) S Ω[S⁄R] :=
P.basisKaehlerOfIsCompl Subtype.val_injective <| by
rw [Subtype.range_coe_subtype]
exact IsCompl.symm isCompl_compl | def | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | basisKaehler | Given a submersive presentation of `S` as `R`-algebra, the images of `dxᵢ`
for `i` in the complement of `σ` in `ι` form a basis of `Ω[S⁄R]`. |
@[stacks 00T7 "(2)"]
free_kaehlerDifferential (P : SubmersivePresentation R S ι σ) :
Module.Free S Ω[S⁄R] :=
Module.Free.of_basis P.basisKaehler
attribute [local instance] Fintype.ofFinite in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | free_kaehlerDifferential | If `P` is a submersive presentation of `S` as an `R`-algebra, `Ω[S⁄R]` is free. |
rank_kaehlerDifferential [Nontrivial S] [Finite ι]
(P : SubmersivePresentation R S ι σ) : Module.rank S Ω[S⁄R] = P.dimension := by
simp only [rank_eq_card_basis P.basisKaehler, Fintype.card_compl_set,
Presentation.dimension, Nat.card_eq_fintype_card, Set.card_range_of_injective P.map_inj] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | rank_kaehlerDifferential | If `P` is a submersive presentation of `S` as an `R`-algebra and `S` is nontrivial,
`Ω[S⁄R]` is free of rank the dimension of `P`, i.e. the number of generators minus the number
of relations. |
IsStandardSmooth.free_kaehlerDifferential [IsStandardSmooth R S] :
Module.Free S Ω[S⁄R] := by
obtain ⟨_, _, _, _, ⟨P⟩⟩ := ‹IsStandardSmooth R S›
exact P.free_kaehlerDifferential | instance | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | IsStandardSmooth.free_kaehlerDifferential | If `S` is `R`-standard smooth, `Ω[S⁄R]` is a free `S`-module. |
IsStandardSmooth.subsingleton_h1Cotangent [IsStandardSmooth R S] :
Subsingleton (H1Cotangent R S) := by
obtain ⟨_, _, _, _, ⟨P⟩⟩ := ‹IsStandardSmooth R S›
exact P.equivH1Cotangent.symm.toEquiv.subsingleton | instance | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | IsStandardSmooth.subsingleton_h1Cotangent | null |
IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential [Nontrivial S] (n : ℕ)
[IsStandardSmoothOfRelativeDimension n R S] :
Module.rank S Ω[S⁄R] = n := by
obtain ⟨_, _, _, _, ⟨P, hP⟩⟩ := ‹IsStandardSmoothOfRelativeDimension n R S›
rw [P.rank_kaehlerDifferential, hP] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential | If `S` is non-trivial and `R`-standard smooth of relative dimension, `Ω[S⁄R]` is a free
`S`-module of rank `n`. |
IsStandardSmoothOfRelationDimension.subsingleton_kaehlerDifferential
[IsStandardSmoothOfRelativeDimension 0 R S] : Subsingleton Ω[S⁄R] := by
cases subsingleton_or_nontrivial S
· exact Module.subsingleton S _
haveI : IsStandardSmooth R S := IsStandardSmoothOfRelativeDimension.isStandardSmooth 0
exact Module.subsingleton_of_rank_zero
(IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential 0) | instance | RingTheory | [
"Mathlib.LinearAlgebra.Basis.Exact",
"Mathlib.RingTheory.Extension.Cotangent.Basic",
"Mathlib.RingTheory.Smooth.StandardSmooth",
"Mathlib.RingTheory.Smooth.Kaehler",
"Mathlib.RingTheory.Etale.Basic"
] | Mathlib/RingTheory/Smooth/StandardSmoothCotangent.lean | IsStandardSmoothOfRelationDimension.subsingleton_kaehlerDifferential | null |
liftBaseChangeEquiv : (M →ₗ[R] N) ≃ₗ[A] (A ⊗[R] M →ₗ[A] N) :=
(LinearMap.ringLmapEquivSelf _ _ _).symm.trans (AlgebraTensorModule.lift.equiv _ _ _ _ _ _) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | liftBaseChangeEquiv | 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`. |
liftBaseChange (l : M →ₗ[R] N) : A ⊗[R] M →ₗ[A] N :=
LinearMap.liftBaseChangeEquiv A l
@[simp] | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | liftBaseChange | If `N` is an `A` module, we may lift a linear map `M →ₗ[R] N` to `A ⊗[R] M →ₗ[A] N` |
liftBaseChange_tmul (l : M →ₗ[R] N) (x y) : l.liftBaseChange A (x ⊗ₜ y) = x • l y := 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 | liftBaseChange_tmul | null |
liftBaseChange_one_tmul (l : M →ₗ[R] N) (y) : l.liftBaseChange A (1 ⊗ₜ y) = l y := by simp
@[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 | liftBaseChange_one_tmul | null |
liftBaseChangeEquiv_symm_apply (l : A ⊗[R] M →ₗ[A] N) (x) :
(liftBaseChangeEquiv A).symm l x = l (1 ⊗ₜ x) := 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 | liftBaseChangeEquiv_symm_apply | null |
liftBaseChange_comp {P} [AddCommMonoid P] [Module A P] [Module R P] [IsScalarTower R A P]
(l : M →ₗ[R] N) (l' : N →ₗ[A] P) :
l' ∘ₗ l.liftBaseChange A = (l'.restrictScalars R ∘ₗ l).liftBaseChange A := by
ext
simp
@[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 | liftBaseChange_comp | null |
range_liftBaseChange (l : M →ₗ[R] N) :
LinearMap.range (l.liftBaseChange A) = Submodule.span A (LinearMap.range l) := by
apply le_antisymm
· rintro _ ⟨x, rfl⟩
induction x using TensorProduct.induction_on
· simp
· rw [LinearMap.liftBaseChange_tmul]
exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨_, rfl⟩)
· rw [map_add]
exact add_mem ‹_› ‹_›
· rw [Submodule.span_le]
rintro _ ⟨x, rfl⟩
exact ⟨1 ⊗ₜ x, 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 | range_liftBaseChange | null |
@[simps!]
lTensorAlgHom : Module.End R M →ₐ[R] Module.End R (N ⊗[R] M) :=
.ofLinearMap (lTensorHom (M := N)) (lTensor_id N M) (lTensor_mul N) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lTensorAlgHom | The map `LinearMap.lTensorHom` which sends `f ↦ 1 ⊗ f` as a morphism of algebras. |
@[simps!]
rTensorAlgHom : Module.End R M →ₐ[R] Module.End R (M ⊗[R] N) :=
.ofLinearMap (rTensorHom (M := N)) (rTensor_id N M) (rTensor_mul N) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | rTensorAlgHom | The map `LinearMap.rTensorHom` which sends `f ↦ f ⊗ 1` as a morphism of algebras. |
one_def : (1 : A ⊗[R] B) = (1 : A) ⊗ₜ (1 : 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 | one_def | null |
instAddCommMonoidWithOne : AddCommMonoidWithOne (A ⊗[R] B) where
natCast n := n ⊗ₜ 1
natCast_zero := by simp
natCast_succ n := by simp [add_tmul, one_def]
add_comm := add_comm | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instAddCommMonoidWithOne | null |
natCast_def (n : ℕ) : (n : A ⊗[R] B) = (n : A) ⊗ₜ (1 : 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 | natCast_def | null |
natCast_def' (n : ℕ) : (n : A ⊗[R] B) = (1 : A) ⊗ₜ (n : B) := by
rw [natCast_def, ← nsmul_one, smul_tmul, nsmul_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | natCast_def' | null |
@[irreducible]
mul : A ⊗[R] B →ₗ[R] A ⊗[R] B →ₗ[R] A ⊗[R] B :=
TensorProduct.map₂ (LinearMap.mul R A) (LinearMap.mul R B)
unseal mul in
@[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 | mul | (Implementation detail)
The multiplication map on `A ⊗[R] B`,
as an `R`-bilinear map. |
mul_apply (a₁ a₂ : A) (b₁ b₂ : B) :
mul (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) = (a₁ * a₂) ⊗ₜ[R] (b₁ * 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 | mul_apply | null |
instMul : Mul (A ⊗[R] B) where
mul a b := mul a b
unseal mul in
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instMul | null |
tmul_mul_tmul (a₁ a₂ : A) (b₁ b₂ : B) :
a₁ ⊗ₜ[R] b₁ * a₂ ⊗ₜ[R] b₂ = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂) :=
rfl
unseal mul 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 | tmul_mul_tmul | null |
_root_.SemiconjBy.tmul {a₁ a₂ a₃ : A} {b₁ b₂ b₃ : B}
(ha : SemiconjBy a₁ a₂ a₃) (hb : SemiconjBy b₁ b₂ b₃) :
SemiconjBy (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) (a₃ ⊗ₜ[R] b₃) :=
congr_arg₂ (· ⊗ₜ[R] ·) ha.eq hb.eq
nonrec theorem _root_.Commute.tmul {a₁ a₂ : A} {b₁ b₂ : B}
(ha : Commute a₁ a₂) (hb : Commute b₁ b₂) :
Commute (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) :=
ha.tmul hb | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | _root_.SemiconjBy.tmul | null |
instNonUnitalNonAssocSemiring : NonUnitalNonAssocSemiring (A ⊗[R] B) where
left_distrib a b c := by simp [HMul.hMul, Mul.mul]
right_distrib a b c := by simp [HMul.hMul, Mul.mul]
zero_mul a := by simp [HMul.hMul, Mul.mul]
mul_zero a := by simp [HMul.hMul, Mul.mul] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonUnitalNonAssocSemiring | null |
protected one_mul (x : A ⊗[R] B) : mul (1 ⊗ₜ 1) x = x := by
refine TensorProduct.induction_on x ?_ ?_ ?_ <;> simp +contextual | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | one_mul | null |
protected mul_one (x : A ⊗[R] B) : mul x (1 ⊗ₜ 1) = x := by
refine TensorProduct.induction_on x ?_ ?_ ?_ <;> simp +contextual | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | mul_one | null |
instNonAssocSemiring : NonAssocSemiring (A ⊗[R] B) where
one_mul := Algebra.TensorProduct.one_mul
mul_one := Algebra.TensorProduct.mul_one
toNonUnitalNonAssocSemiring := instNonUnitalNonAssocSemiring
__ := instAddCommMonoidWithOne | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonAssocSemiring | null |
protected mul_assoc (x y z : A ⊗[R] B) : mul (mul x y) z = mul x (mul y z) := by
suffices LinearMap.llcomp R _ _ _ mul ∘ₗ mul =
(LinearMap.llcomp R _ _ _ LinearMap.lflip.toLinearMap <|
LinearMap.llcomp R _ _ _ mul.flip ∘ₗ mul).flip by
exact DFunLike.congr_fun (DFunLike.congr_fun (DFunLike.congr_fun this x) y) z
ext xa xb ya yb za zb
exact congr_arg₂ (· ⊗ₜ ·) (mul_assoc xa ya za) (mul_assoc xb yb zb) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | mul_assoc | null |
instNonUnitalSemiring : NonUnitalSemiring (A ⊗[R] B) where
mul_assoc := Algebra.TensorProduct.mul_assoc | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonUnitalSemiring | null |
instSemiring : Semiring (A ⊗[R] B) where
left_distrib a b c := by simp [HMul.hMul, Mul.mul]
right_distrib a b c := by simp [HMul.hMul, Mul.mul]
zero_mul a := by simp [HMul.hMul, Mul.mul]
mul_zero a := by simp [HMul.hMul, Mul.mul]
mul_assoc := Algebra.TensorProduct.mul_assoc
one_mul := Algebra.TensorProduct.one_mul
mul_one := Algebra.TensorProduct.mul_one
natCast_zero := AddMonoidWithOne.natCast_zero
natCast_succ := AddMonoidWithOne.natCast_succ
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instSemiring | null |
tmul_pow (a : A) (b : B) (k : ℕ) : a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k) := by
induction k with
| zero => simp [one_def]
| succ k ih => simp [pow_succ, ih] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | tmul_pow | null |
@[simps]
includeLeftRingHom : A →+* A ⊗[R] B where
toFun a := a ⊗ₜ 1
map_zero' := by simp
map_add' := by simp [add_tmul]
map_one' := rfl
map_mul' := by simp
variable [CommSemiring S] [Algebra S A] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | includeLeftRingHom | The ring morphism `A →+* A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. |
leftAlgebra [SMulCommClass R S A] : Algebra S (A ⊗[R] B) :=
{ commutes' := fun r x => by
dsimp only [RingHom.toFun_eq_coe, RingHom.comp_apply, includeLeftRingHom_apply]
rw [algebraMap_eq_smul_one, ← smul_tmul', ← one_def, mul_smul_comm, smul_mul_assoc, mul_one,
one_mul]
smul_def' := fun r x => by
dsimp only [RingHom.toFun_eq_coe, RingHom.comp_apply, includeLeftRingHom_apply]
rw [algebraMap_eq_smul_one, ← smul_tmul', smul_mul_assoc, ← one_def, one_mul]
algebraMap := TensorProduct.includeLeftRingHom.comp (algebraMap S A) } | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | leftAlgebra | null |
instAlgebra : Algebra R (A ⊗[R] B) :=
inferInstance
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instAlgebra | The tensor product of two `R`-algebras is an `R`-algebra. |
algebraMap_apply [SMulCommClass R S A] (r : S) :
algebraMap S (A ⊗[R] B) r = (algebraMap S A) r ⊗ₜ 1 :=
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 | algebraMap_apply | null |
algebraMap_apply' (r : R) :
algebraMap R (A ⊗[R] B) r = 1 ⊗ₜ algebraMap R B r := by
rw [algebraMap_apply, Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one, smul_tmul] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | algebraMap_apply' | null |
includeLeft [SMulCommClass R S A] : A →ₐ[S] A ⊗[R] B :=
{ includeLeftRingHom with commutes' := by 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 | includeLeft | The `R`-algebra morphism `A →ₐ[R] A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. |
includeLeft_apply [SMulCommClass R S A] (a : A) :
(includeLeft : A →ₐ[S] A ⊗[R] B) a = a ⊗ₜ 1 :=
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 | includeLeft_apply | null |
includeRight : B →ₐ[R] A ⊗[R] B where
toFun b := 1 ⊗ₜ b
map_zero' := by simp
map_add' := by simp [tmul_add]
map_one' := rfl
map_mul' := by simp
commutes' r := by simp only [algebraMap_apply']
@[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 | includeRight | The algebra morphism `B →ₐ[R] A ⊗[R] B` sending `b` to `1 ⊗ₜ b`. |
includeRight_apply (b : B) : (includeRight : B →ₐ[R] A ⊗[R] B) b = 1 ⊗ₜ 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 | includeRight_apply | null |
includeLeftRingHom_comp_algebraMap :
(includeLeftRingHom.comp (algebraMap R A) : R →+* A ⊗[R] B) =
includeRight.toRingHom.comp (algebraMap 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 | includeLeftRingHom_comp_algebraMap | null |
@[ext high]
ext ⦃f g : (A ⊗[R] B) →ₐ[S] C⦄
(ha : f.comp includeLeft = g.comp includeLeft)
(hb : (f.restrictScalars R).comp includeRight = (g.restrictScalars R).comp includeRight) :
f = g := by
apply AlgHom.toLinearMap_injective
ext a b
have := congr_arg₂ HMul.hMul (AlgHom.congr_fun ha a) (AlgHom.congr_fun hb b)
dsimp at *
rwa [← map_mul, ← map_mul, tmul_mul_tmul, one_mul, mul_one] at this | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | ext | 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]. |
ext' {g h : A ⊗[R] B →ₐ[S] C} (H : ∀ a b, g (a ⊗ₜ b) = h (a ⊗ₜ b)) : g = h :=
ext (AlgHom.ext fun _ => H _ _) (AlgHom.ext fun _ => H _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | ext' | null |
instAddCommGroupWithOne : AddCommGroupWithOne (A ⊗[R] B) where
toAddCommGroup := TensorProduct.addCommGroup
__ := instAddCommMonoidWithOne
intCast z := z ⊗ₜ (1 : B)
intCast_ofNat n := by simp [natCast_def]
intCast_negSucc n := by simp [natCast_def, add_tmul, neg_tmul, one_def] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instAddCommGroupWithOne | null |
intCast_def (z : ℤ) : (z : A ⊗[R] B) = (z : A) ⊗ₜ (1 : 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 | intCast_def | null |
instNonUnitalNonAssocRing : NonUnitalNonAssocRing (A ⊗[R] B) where
toAddCommGroup := TensorProduct.addCommGroup
__ := instNonUnitalNonAssocSemiring | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonUnitalNonAssocRing | null |
instNonAssocRing : NonAssocRing (A ⊗[R] B) where
toAddCommGroup := TensorProduct.addCommGroup
__ := instNonAssocSemiring
__ := instAddCommGroupWithOne | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonAssocRing | null |
instNonUnitalRing : NonUnitalRing (A ⊗[R] B) where
toAddCommGroup := TensorProduct.addCommGroup
__ := instNonUnitalSemiring | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instNonUnitalRing | null |
instCommSemiring : CommSemiring (A ⊗[R] B) where
toSemiring := inferInstance
mul_comm x y := by
refine TensorProduct.induction_on x ?_ ?_ ?_
· simp
· intro a₁ b₁
refine TensorProduct.induction_on y ?_ ?_ ?_
· simp
· intro a₂ b₂
simp [mul_comm]
· intro a₂ b₂ ha hb
simp [mul_add, add_mul, ha, hb]
· intro x₁ x₂ h₁ h₂
simp [mul_add, add_mul, h₁, h₂] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instCommSemiring | null |
instRing : Ring (A ⊗[R] B) where
toSemiring := instSemiring
__ := TensorProduct.addCommGroup
__ := instNonAssocRing | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instRing | null |
intCast_def' {B} [Ring B] [Algebra R B] (z : ℤ) : (z : A ⊗[R] B) = (1 : A) ⊗ₜ (z : B) := by
rw [intCast_def, ← zsmul_one, smul_tmul, zsmul_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | intCast_def' | null |
instCommRing : CommRing (A ⊗[R] B) :=
{ toRing := inferInstance
mul_comm := mul_comm } | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | instCommRing | null |
rightAlgebra : Algebra B (A ⊗[R] B) :=
includeRight.toRingHom.toAlgebra' fun b x => by
suffices LinearMap.mulLeft R (includeRight b) = LinearMap.mulRight R (includeRight b) from
congr($this x)
ext xa xb
simp [mul_comm]
attribute [local instance] TensorProduct.rightAlgebra | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | rightAlgebra | `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. |
right_isScalarTower : IsScalarTower R B (A ⊗[R] B) :=
IsScalarTower.of_algebraMap_eq fun r => (Algebra.TensorProduct.includeRight.commutes r).symm | instance | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | right_isScalarTower | null |
right_algebraMap_apply (b : B) : algebraMap B (A ⊗[R] B) b = 1 ⊗ₜ b := 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 | right_algebraMap_apply | null |
_root_.LinearMap.map_mul_of_map_mul_tmul {f : A ⊗[R] B →ₗ[S] C}
(hf : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ (b₁ * b₂)) = f (a₁ ⊗ₜ b₁) * f (a₂ ⊗ₜ b₂))
(x y : A ⊗[R] B) : f (x * y) = f x * f y :=
f.map_mul_iff.2 (by
letI : Algebra R C := RestrictScalars.algebra R S C
letI : IsScalarTower R S C := RestrictScalars.isScalarTower R S C
ext
dsimp
exact hf _ _ _ _) x y | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | _root_.LinearMap.map_mul_of_map_mul_tmul | Verify that typeclass search finds the ring structure on `A ⊗[ℤ] B`
when `A` and `B` are merely rings, by treating both as `ℤ`-algebras.
-/
example [Ring A] [Ring B] : Ring (A ⊗[ℤ] B) := by infer_instance
/-- Verify that typeclass search finds the CommRing structure on `A ⊗[ℤ] B`
when `A` and `B` are merely `CommRing`s, by treating both as `ℤ`-algebras.
-/
example [CommRing A] [CommRing B] : CommRing (A ⊗[ℤ] B) := by infer_instance
/-!
We now build the structure maps for the symmetric monoidal category of `R`-algebras.
-/
section Monoidal
section
variable [CommSemiring R] [CommSemiring S] [Algebra R S]
variable [Semiring A] [Algebra R A] [Algebra S A] [IsScalarTower R S A]
variable [Semiring B] [Algebra R B]
variable [Semiring C] [Algebra S C]
variable [Semiring D] [Algebra R D]
/-- To check a linear map preserves multiplication, it suffices to check it on pure tensors. See
`algHomOfLinearMapTensorProduct` for a bundled version. |
algHomOfLinearMapTensorProduct (f : A ⊗[R] B →ₗ[S] C)
(h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ (b₁ * b₂)) = f (a₁ ⊗ₜ b₁) * f (a₂ ⊗ₜ b₂))
(h_one : f (1 ⊗ₜ[R] 1) = 1) : A ⊗[R] B →ₐ[S] C :=
AlgHom.ofLinearMap f h_one (f.map_mul_of_map_mul_tmul h_mul)
@[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 | algHomOfLinearMapTensorProduct | 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`). |
algHomOfLinearMapTensorProduct_apply (f h_mul h_one x) :
(algHomOfLinearMapTensorProduct f h_mul h_one : A ⊗[R] B →ₐ[S] C) x = f x :=
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 | algHomOfLinearMapTensorProduct_apply | null |
algEquivOfLinearEquivTensorProduct (f : A ⊗[R] B ≃ₗ[S] C)
(h_mul : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ (b₁ * b₂)) = f (a₁ ⊗ₜ b₁) * f (a₂ ⊗ₜ b₂))
(h_one : f (1 ⊗ₜ[R] 1) = 1) : A ⊗[R] B ≃ₐ[S] C :=
{ algHomOfLinearMapTensorProduct (f : A ⊗[R] B →ₗ[S] C) h_mul h_one, f with }
@[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 | algEquivOfLinearEquivTensorProduct | 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`). |
algEquivOfLinearEquivTensorProduct_apply (f h_mul h_one x) :
(algEquivOfLinearEquivTensorProduct f h_mul h_one : A ⊗[R] B ≃ₐ[S] C) x = f x :=
rfl
variable [Algebra R C] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | algEquivOfLinearEquivTensorProduct_apply | null |
algEquivOfLinearEquivTripleTensorProduct (f : A ⊗[R] B ⊗[R] C ≃ₗ[R] D)
(h_mul :
∀ (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C),
f ((a₁ * a₂) ⊗ₜ (b₁ * b₂) ⊗ₜ (c₁ * c₂)) = f (a₁ ⊗ₜ b₁ ⊗ₜ c₁) * f (a₂ ⊗ₜ b₂ ⊗ₜ c₂))
(h_one : f (((1 : A) ⊗ₜ[R] (1 : B)) ⊗ₜ[R] (1 : C)) = 1) :
A ⊗[R] B ⊗[R] C ≃ₐ[R] D :=
AlgEquiv.ofLinearEquiv f h_one <| f.map_mul_iff.2 <| by
ext
dsimp
exact h_mul _ _ _ _ _ _
@[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 | algEquivOfLinearEquivTripleTensorProduct | Build an algebra equivalence from a linear equivalence out of a triple tensor product,
and evidence of multiplicativity on pure tensors. |
algEquivOfLinearEquivTripleTensorProduct_apply (f h_mul h_one x) :
(algEquivOfLinearEquivTripleTensorProduct f h_mul h_one : A ⊗[R] B ⊗[R] C ≃ₐ[R] D) x = f x :=
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 | algEquivOfLinearEquivTripleTensorProduct_apply | null |
lift (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ x y, Commute (f x) (g y)) : (A ⊗[R] B) →ₐ[S] C :=
algHomOfLinearMapTensorProduct
(AlgebraTensorModule.lift <|
letI restr : (C →ₗ[S] C) →ₗ[S] _ :=
{ toFun := (·.restrictScalars R)
map_add' := fun _ _ => LinearMap.ext fun _ => rfl
map_smul' := fun _ _ => LinearMap.ext fun _ => rfl }
LinearMap.flip <| (restr ∘ₗ LinearMap.mul S C ∘ₗ f.toLinearMap).flip ∘ₗ g)
(fun a₁ a₂ b₁ b₂ => show f (a₁ * a₂) * g (b₁ * b₂) = f a₁ * g b₁ * (f a₂ * g b₂) by
rw [map_mul, map_mul, (hfg a₂ b₁).mul_mul_mul_comm])
(show f 1 * g 1 = 1 by rw [map_one, map_one, one_mul])
@[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 | lift | 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. |
lift_tmul (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ x y, Commute (f x) (g y))
(a : A) (b : B) :
lift f g hfg (a ⊗ₜ b) = f a * g 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 | lift_tmul | null |
lift_includeLeft_includeRight :
lift includeLeft includeRight (fun _ _ => (Commute.one_right _).tmul (Commute.one_left _)) =
.id S (A ⊗[R] B) := by
ext <;> 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 | lift_includeLeft_includeRight | null |
lift_comp_includeLeft (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ x y, Commute (f x) (g y)) :
(lift f g hfg).comp includeLeft = 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 | lift_comp_includeLeft | null |
lift_comp_includeRight (f : A →ₐ[S] C) (g : B →ₐ[R] C) (hfg : ∀ x y, Commute (f x) (g y)) :
((lift f g hfg).restrictScalars R).comp includeRight = g :=
AlgHom.ext <| by 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 | lift_comp_includeRight | null |
@[simps]
liftEquiv : {fg : (A →ₐ[S] C) × (B →ₐ[R] C) // ∀ x y, Commute (fg.1 x) (fg.2 y)}
≃ ((A ⊗[R] B) →ₐ[S] C) where
toFun fg := lift fg.val.1 fg.val.2 fg.prop
invFun f' := ⟨(f'.comp includeLeft, (f'.restrictScalars R).comp includeRight), fun _ _ =>
((Commute.one_right _).tmul (Commute.one_left _)).map f'⟩
left_inv fg := by ext <;> simp
right_inv f' := by ext <;> 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 | liftEquiv | 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.
See also `GradedTensorProduct.liftEquiv` for an alternative commutativity requirement for graded
algebra. |
mapOfCompatibleSMul : A ⊗[S] B →ₐ[S] A ⊗[R] B :=
.ofLinearMap (_root_.TensorProduct.mapOfCompatibleSMul R S A B) rfl fun x ↦
x.induction_on (by simp) (fun _ _ y ↦ y.induction_on (by simp) (by simp)
fun _ _ h h' ↦ by simp only [mul_add, map_add, h, h'])
fun _ _ h h' _ ↦ by simp only [add_mul, map_add, h, h']
@[simp] theorem mapOfCompatibleSMul_tmul (m n) : mapOfCompatibleSMul R S A B (m ⊗ₜ n) = 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 | mapOfCompatibleSMul | The base ring is a left identity for the tensor product of algebra, up to algebra isomorphism.
-/
protected nonrec def lid : R ⊗[R] A ≃ₐ[R] A :=
algEquivOfLinearEquivTensorProduct (TensorProduct.lid R A) (by
simp only [mul_smul, lid_tmul, Algebra.smul_mul_assoc, Algebra.mul_smul_comm]
simp_rw [← mul_smul, mul_comm]
simp)
(by simp [Algebra.smul_def])
@[simp] theorem lid_toLinearEquiv :
(TensorProduct.lid R A).toLinearEquiv = _root_.TensorProduct.lid R A := rfl
variable {R} {A} in
@[simp]
theorem lid_tmul (r : R) (a : A) : TensorProduct.lid R A (r ⊗ₜ a) = r • a := rfl
variable {A} in
@[simp]
theorem lid_symm_apply (a : A) : (TensorProduct.lid R A).symm a = 1 ⊗ₜ a := rfl
variable (S)
/-- 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`.
-/
protected nonrec def rid : A ⊗[R] R ≃ₐ[S] A :=
algEquivOfLinearEquivTensorProduct (AlgebraTensorModule.rid R S A)
(fun a₁ a₂ r₁ r₂ => smul_mul_smul_comm r₁ a₁ r₂ a₂ |>.symm)
(one_smul R _)
@[simp] theorem rid_toLinearEquiv :
(TensorProduct.rid R S A).toLinearEquiv = AlgebraTensorModule.rid R S A := rfl
variable {R A} in
@[simp]
theorem rid_tmul (r : R) (a : A) : TensorProduct.rid R S A (a ⊗ₜ r) = r • a := rfl
variable {A} in
@[simp]
theorem rid_symm_apply (a : A) : (TensorProduct.rid R S A).symm a = a ⊗ₜ 1 := rfl
section CompatibleSMul
variable (R S A B : Type*) [CommSemiring R] [CommSemiring S] [Semiring A] [Semiring B]
variable [Algebra R A] [Algebra R B] [Algebra S A] [Algebra S B]
variable [SMulCommClass R S A] [CompatibleSMul R S A B]
/-- If A and B are both R- and S-algebras and their actions on them commute,
and if the S-action on `A ⊗[R] B` can switch between the two factors, then there is a
canonical S-algebra homomorphism from `A ⊗[S] B` to `A ⊗[R] B`. |
mapOfCompatibleSMul_surjective : Function.Surjective (mapOfCompatibleSMul R S A B) :=
_root_.TensorProduct.mapOfCompatibleSMul_surjective R S A B
attribute [local instance] SMulCommClass.symm | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | mapOfCompatibleSMul_surjective | null |
mapOfCompatibleSMul' : A ⊗[S] B →ₐ[R] A ⊗[R] B :=
.ofLinearMap (_root_.TensorProduct.mapOfCompatibleSMul' R S A B) rfl
(map_mul <| mapOfCompatibleSMul R S A B) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | mapOfCompatibleSMul' | `mapOfCompatibleSMul R S A B` is also A-linear. |
equivOfCompatibleSMul [CompatibleSMul S R A B] : A ⊗[S] B ≃ₐ[S] A ⊗[R] B where
__ := mapOfCompatibleSMul R S A B
invFun := mapOfCompatibleSMul S R A B
__ := _root_.TensorProduct.equivOfCompatibleSMul R S A B
variable [Algebra R S] [CompatibleSMul R S S A] [CompatibleSMul S R S A]
omit [SMulCommClass R S A] | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | equivOfCompatibleSMul | If the R- and S-actions on A and B satisfy `CompatibleSMul` both ways,
then `A ⊗[S] B` is canonically isomorphic to `A ⊗[R] B`. |
lidOfCompatibleSMul : S ⊗[R] A ≃ₐ[S] A :=
(equivOfCompatibleSMul R S S A).symm.trans (TensorProduct.lid _ _) | def | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | lidOfCompatibleSMul | If the R- and S- action on S and A satisfy `CompatibleSMul` both ways,
then `S ⊗[R] A` is canonically isomorphic to `A`. |
lidOfCompatibleSMul_tmul (s a) : lidOfCompatibleSMul R S A (s ⊗ₜ[R] a) = s • a := 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 | lidOfCompatibleSMul_tmul | null |
protected comm : A ⊗[R] B ≃ₐ[R] B ⊗[R] A :=
algEquivOfLinearEquivTensorProduct (_root_.TensorProduct.comm R A B) (fun _ _ _ _ => rfl) rfl
@[simp] theorem comm_toLinearEquiv :
(Algebra.TensorProduct.comm R A B).toLinearEquiv = _root_.TensorProduct.comm R A B := rfl
variable {A B} in
@[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 | comm | The tensor product of R-algebras is commutative, up to algebra isomorphism. |
comm_tmul (a : A) (b : B) :
TensorProduct.comm R A B (a ⊗ₜ b) = b ⊗ₜ a :=
rfl
variable {A B} in
@[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 | comm_tmul | null |
comm_symm_tmul (a : A) (b : B) :
(TensorProduct.comm R A B).symm (b ⊗ₜ a) = a ⊗ₜ 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 | comm_symm_tmul | null |
comm_symm :
(TensorProduct.comm R A B).symm = TensorProduct.comm R B A := 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 | comm_symm | null |
comm_comp_includeLeft :
(TensorProduct.comm R A B : A ⊗[R] B →ₐ[R] B ⊗[R] A).comp includeLeft = includeRight := 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 | comm_comp_includeLeft | null |
comm_comp_includeRight :
(TensorProduct.comm R A B : A ⊗[R] B →ₐ[R] B ⊗[R] A).comp includeRight = includeLeft := 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_includeRight | null |
adjoin_tmul_eq_top : adjoin R { t : A ⊗[R] B | ∃ a b, a ⊗ₜ[R] b = t } = ⊤ :=
top_le_iff.mp <| (top_le_iff.mpr <| span_tmul_eq_top R A B).trans (span_le_adjoin R _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | adjoin_tmul_eq_top | null |
assoc_aux_1 (a₁ a₂ : A) (b₁ b₂ : B) (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₂) :=
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 | assoc_aux_1 | null |
assoc_aux_2 : (TensorProduct.assoc R A B C) (1 ⊗ₜ[R] 1 ⊗ₜ[R] 1) = 1 :=
rfl
variable (R A C D) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | assoc_aux_2 | null |
protected assoc : A ⊗[S] C ⊗[R] D ≃ₐ[S] A ⊗[S] (C ⊗[R] D) :=
AlgEquiv.ofLinearEquiv
(AlgebraTensorModule.assoc R S S A C D)
(by simp [Algebra.TensorProduct.one_def])
((LinearMap.map_mul_iff _).mpr <| by ext; simp)
@[simp] theorem assoc_toLinearEquiv :
(TensorProduct.assoc R S A C D).toLinearEquiv = AlgebraTensorModule.assoc R S S A C D := rfl
variable {A C D}
@[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 | assoc | The associator for tensor product of R-algebras, as an algebra isomorphism. |
assoc_tmul (a : A) (b : C) (c : D) :
TensorProduct.assoc R S A C D ((a ⊗ₜ b) ⊗ₜ c) = a ⊗ₜ (b ⊗ₜ c) := 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 | assoc_tmul | null |
assoc_symm_tmul (a : A) (b : C) (c : D) :
(TensorProduct.assoc R S A C D).symm (a ⊗ₜ (b ⊗ₜ c)) = (a ⊗ₜ b) ⊗ₜ c := 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 | assoc_symm_tmul | null |
cancelBaseChange : A ⊗[S] (S ⊗[R] B) ≃ₐ[T] A ⊗[R] B :=
AlgEquiv.symm <| AlgEquiv.ofLinearEquiv
(TensorProduct.AlgebraTensorModule.cancelBaseChange R S T A B).symm
(by simp [Algebra.TensorProduct.one_def]) <|
LinearMap.map_mul_of_map_mul_tmul (fun _ _ _ _ ↦ by 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 | cancelBaseChange | The natural isomorphism `A ⊗[S] (S ⊗[R] B) ≃ₐ[T] A ⊗[R] B`. |
cancelBaseChange_tmul (a : A) (s : S) (b : B) :
Algebra.TensorProduct.cancelBaseChange R S T A B (a ⊗ₜ (s ⊗ₜ b)) = (s • a) ⊗ₜ b :=
TensorProduct.AlgebraTensorModule.cancelBaseChange_tmul R S T a b s
@[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 | cancelBaseChange_tmul | null |
cancelBaseChange_symm_tmul (a : A) (b : B) :
(Algebra.TensorProduct.cancelBaseChange R S T A B).symm (a ⊗ₜ b) = a ⊗ₜ (1 ⊗ₜ b) :=
TensorProduct.AlgebraTensorModule.cancelBaseChange_symm_tmul R S T a b | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.RestrictScalars",
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.Module.Rat",
"Mathlib.LinearAlgebra.TensorProduct.Tower"
] | Mathlib/RingTheory/TensorProduct/Basic.lean | cancelBaseChange_symm_tmul | null |
map (f : A →ₐ[S] C) (g : B →ₐ[R] D) : A ⊗[R] B →ₐ[S] C ⊗[R] D :=
algHomOfLinearMapTensorProduct (AlgebraTensorModule.map f.toLinearMap g.toLinearMap) (by simp)
(by simp [one_def])
@[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 | map | The tensor product of a pair of algebra morphisms. |
map_tmul (f : A →ₐ[S] C) (g : B →ₐ[R] D) (a : A) (b : B) : map f g (a ⊗ₜ b) = f a ⊗ₜ g 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 | map_tmul | null |
map_id : map (.id S A) (.id R B) = .id S _ :=
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_id | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.