Module docstring
{"# Adjoining elements to form subalgebras
This file contains basic results on Algebra.adjoin.
Tags
adjoin, algebra
"}
{"# Adjoining elements to form subalgebras
This file contains basic results on Algebra.adjoin.
adjoin, algebra
"}
Algebra.adjoin_prod_le
theorem
(s : Set A) (t : Set B) : adjoin R (s ×ˢ t) ≤ (adjoin R s).prod (adjoin R t)
theorem adjoin_prod_le (s : Set A) (t : Set B) :
adjoin R (s ×ˢ t) ≤ (adjoin R s).prod (adjoin R t) :=
adjoin_le <| Set.prod_mono subset_adjoin subset_adjoin
Algebra.adjoin_inl_union_inr_eq_prod
theorem
(s) (t) :
adjoin R (LinearMap.inl R A B '' (s ∪ { 1 }) ∪ LinearMap.inr R A B '' (t ∪ { 1 })) = (adjoin R s).prod (adjoin R t)
theorem adjoin_inl_union_inr_eq_prod (s) (t) :
adjoin R (LinearMap.inlLinearMap.inl R A B '' (s ∪ {1})LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1})) =
(adjoin R s).prod (adjoin R t) := by
apply le_antisymm
· simp only [adjoin_le_iff, Set.insert_subset_iff, Subalgebra.zero_mem, Subalgebra.one_mem,
subset_adjoin,-- the rest comes from `squeeze_simp`
Set.union_subset_iff,
LinearMap.coe_inl, Set.mk_preimage_prod_right, Set.image_subset_iff, SetLike.mem_coe,
Set.mk_preimage_prod_left, LinearMap.coe_inr, and_self_iff, Set.union_singleton,
Subalgebra.coe_prod]
· rintro ⟨a, b⟩ ⟨ha, hb⟩
let P := adjoin R (LinearMap.inlLinearMap.inl R A B '' (s ∪ {1})LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1}))
have Ha : (a, (0 : B))(a, (0 : B)) ∈ adjoin R (LinearMap.inl R A B '' (s ∪ {1})) :=
mem_adjoin_of_map_mul R LinearMap.inl_map_mul ha
have Hb : ((0 : A), b)((0 : A), b) ∈ adjoin R (LinearMap.inr R A B '' (t ∪ {1})) :=
mem_adjoin_of_map_mul R LinearMap.inr_map_mul hb
replace Ha : (a, (0 : B))(a, (0 : B)) ∈ P := adjoin_mono Set.subset_union_left Ha
replace Hb : ((0 : A), b)((0 : A), b) ∈ P := adjoin_mono Set.subset_union_right Hb
simpa [P] using Subalgebra.add_mem _ Ha Hb
Algebra.adjoin_algebraMap
theorem
(s : Set S) : adjoin R (algebraMap S A '' s) = (adjoin R s).map (IsScalarTower.toAlgHom R S A)
theorem adjoin_algebraMap (s : Set S) :
adjoin R (algebraMapalgebraMap S A '' s) = (adjoin R s).map (IsScalarTower.toAlgHom R S A) :=
adjoin_image R (IsScalarTower.toAlgHom R S A) s
Algebra.adjoin_algebraMap_image_union_eq_adjoin_adjoin
theorem
(s : Set S) (t : Set A) : adjoin R (algebraMap S A '' s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R
theorem adjoin_algebraMap_image_union_eq_adjoin_adjoin (s : Set S) (t : Set A) :
adjoin R (algebraMapalgebraMap S A '' salgebraMap S A '' s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R :=
le_antisymm
(closure_mono <|
Set.union_subset (Set.range_subset_iff.2 fun r => Or.inl ⟨algebraMap R (adjoin R s) r,
(IsScalarTower.algebraMap_apply _ _ _ _).symm⟩)
(Set.union_subset_union_left _ fun _ ⟨_x, hx, hxs⟩ => hxs ▸ ⟨⟨_, subset_adjoin hx⟩, rfl⟩))
(closure_le.2 <|
Set.union_subset (Set.range_subset_iff.2 fun x => adjoin_mono Set.subset_union_left <|
Algebra.adjoin_algebraMap R A s ▸ ⟨x, x.prop, rfl⟩)
(Set.Subset.trans Set.subset_union_right subset_adjoin))
Algebra.adjoin_adjoin_of_tower
theorem
(s : Set A) : adjoin S (adjoin R s : Set A) = adjoin S s
theorem adjoin_adjoin_of_tower (s : Set A) : adjoin S (adjoin R s : Set A) = adjoin S s := by
apply le_antisymm (adjoin_le _)
· exact adjoin_mono subset_adjoin
· change adjoin R s ≤ (adjoin S s).restrictScalars R
refine adjoin_le ?_
-- Porting note: unclear why this was broken
have : (Subalgebra.restrictScalars R (adjoin S s) : Set A) = adjoin S s := rfl
rw [this]
exact subset_adjoin
Algebra.Subalgebra.restrictScalars_adjoin
theorem
{s : Set A} : (adjoin S s).restrictScalars R = (IsScalarTower.toAlgHom R S A).range ⊔ adjoin R s
theorem Subalgebra.restrictScalars_adjoin {s : Set A} :
(adjoin S s).restrictScalars R = (IsScalarTower.toAlgHom R S A).range ⊔ adjoin R s := by
refine le_antisymm (fun _ hx ↦ adjoin_induction
(fun x hx ↦ le_sup_right (α := Subalgebra R A) (subset_adjoin hx))
(fun x ↦ le_sup_left (α := Subalgebra R A) ⟨x, rfl⟩)
(fun _ _ _ _ ↦ add_mem) (fun _ _ _ _ ↦ mul_mem) <|
(Subalgebra.mem_restrictScalars _).mp hx) (sup_le ?_ <| adjoin_le subset_adjoin)
rintro _ ⟨x, rfl⟩; exact algebraMap_mem (adjoin S s) x
Algebra.adjoin_top
theorem
{A} [Semiring A] [Algebra S A] (t : Set A) :
adjoin (⊤ : Subalgebra R S) t = (adjoin S t).restrictScalars (⊤ : Subalgebra R S)
@[simp]
theorem adjoin_top {A} [Semiring A] [Algebra S A] (t : Set A) :
adjoin (⊤ : Subalgebra R S) t = (adjoin S t).restrictScalars (⊤ : Subalgebra R S) :=
let equivTop : SubalgebraSubalgebra (⊤ : Subalgebra R S) A ≃o Subalgebra S A :=
{ toFun := fun s => { s with algebraMap_mem' := fun r => s.algebraMap_mem ⟨r, trivial⟩ }
invFun := fun s => s.restrictScalars _
left_inv := fun _ => SetLike.coe_injective rfl
right_inv := fun _ => SetLike.coe_injective rfl
map_rel_iff' := @fun _ _ => Iff.rfl }
le_antisymm
(adjoin_le <| show t ⊆ adjoin S t from subset_adjoin)
(equivTop.symm_apply_le.mpr <|
adjoin_le <| show t ⊆ adjoin (⊤ : Subalgebra R S) t from subset_adjoin)
Algebra.adjoin_union_eq_adjoin_adjoin
theorem
: adjoin R (s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R
theorem adjoin_union_eq_adjoin_adjoin :
adjoin R (s ∪ t) = (adjoin (adjoin R s) t).restrictScalars R := by
simpa using adjoin_algebraMap_image_union_eq_adjoin_adjoin R s t
Algebra.pow_smul_mem_of_smul_subset_of_mem_adjoin
theorem
[CommSemiring B] [Algebra R B] [Algebra A B] [IsScalarTower R A B] (r : A) (s : Set B) (B' : Subalgebra R B)
(hs : r • s ⊆ B') {x : B} (hx : x ∈ adjoin R s) (hr : algebraMap A B r ∈ B') : ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ B'
theorem pow_smul_mem_of_smul_subset_of_mem_adjoin [CommSemiring B] [Algebra R B] [Algebra A B]
[IsScalarTower R A B] (r : A) (s : Set B) (B' : Subalgebra R B) (hs : r • s ⊆ B') {x : B}
(hx : x ∈ adjoin R s) (hr : algebraMapalgebraMap A B r ∈ B') : ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ B' := by
change x ∈ Subalgebra.toSubmodule (adjoin R s) at hx
rw [adjoin_eq_span, Finsupp.mem_span_iff_linearCombination] at hx
rcases hx with ⟨l, rfl : (l.sum fun (i : Submonoid.closure s) (c : R) => c • (i : B)) = x⟩
choose n₁ n₂ using fun x : Submonoid.closure s => Submonoid.pow_smul_mem_closure_smul r s x.prop
use l.support.sup n₁
intro n hn
rw [Finsupp.smul_sum]
refine B'.toSubmodule.sum_mem ?_
intro a ha
have : n ≥ n₁ a := le_trans (Finset.le_sup ha) hn
dsimp only
rw [← tsub_add_cancel_of_le this, pow_add, ← smul_smul, ←
IsScalarTower.algebraMap_smul A (l a) (a : B), smul_smul (r ^ n₁ a), mul_comm, ← smul_smul,
smul_def, map_pow, IsScalarTower.algebraMap_smul]
apply Subalgebra.mul_mem _ (Subalgebra.pow_mem _ hr _) _
refine Subalgebra.smul_mem _ ?_ _
change _ ∈ B'.toSubmonoid
rw [← Submonoid.closure_eq B'.toSubmonoid]
apply Submonoid.closure_mono hs (n₂ a)
Algebra.pow_smul_mem_adjoin_smul
theorem
(r : R) (s : Set A) {x : A} (hx : x ∈ adjoin R s) : ∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ adjoin R (r • s)
theorem pow_smul_mem_adjoin_smul (r : R) (s : Set A) {x : A} (hx : x ∈ adjoin R s) :
∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ adjoin R (r • s) :=
pow_smul_mem_of_smul_subset_of_mem_adjoin r s _ subset_adjoin hx (Subalgebra.algebraMap_mem _ _)
Algebra.adjoin_nonUnitalSubalgebra_eq_span
theorem
(s : NonUnitalSubalgebra R A) : Subalgebra.toSubmodule (adjoin R (s : Set A)) = span R { 1 } ⊔ s.toSubmodule
lemma adjoin_nonUnitalSubalgebra_eq_span (s : NonUnitalSubalgebra R A) :
Subalgebra.toSubmodule (adjoin R (s : Set A)) = spanspan R {1} ⊔ s.toSubmodule := by
rw [adjoin_eq_span, Submonoid.closure_eq_one_union, span_union, ← NonUnitalAlgebra.adjoin_eq_span,
NonUnitalAlgebra.adjoin_eq]
Subalgebra.adjoin_eq_span_basis
theorem
{ι : Type*} (bL : Basis ι F L) : toSubmodule (adjoin E (L : Set K)) = span E (Set.range fun i : ι ↦ (bL i).1)
/-- If `K / E / F` is a ring extension tower, `L` is a subalgebra of `K / F`,
then `E[L]` is generated by any basis of `L / F` as an `E`-module. -/
theorem Subalgebra.adjoin_eq_span_basis {ι : Type*} (bL : Basis ι F L) :
toSubmodule (adjoin E (L : Set K)) = span E (Set.range fun i : ι ↦ (bL i).1) :=
L.adjoin_eq_span_of_eq_span E <| by
simpa only [← L.range_val, Submodule.map_span, Submodule.map_top, ← Set.range_comp]
using congr_arg (Submodule.map L.val) bL.span_eq.symm
Algebra.restrictScalars_adjoin
theorem
(F : Type*) [CommSemiring F] {E : Type*} [CommSemiring E] [Algebra F E] (K : Subalgebra F E) (S : Set E) :
(Algebra.adjoin K S).restrictScalars F = Algebra.adjoin F (K ∪ S)
theorem Algebra.restrictScalars_adjoin (F : Type*) [CommSemiring F] {E : Type*} [CommSemiring E]
[Algebra F E] (K : Subalgebra F E) (S : Set E) :
(Algebra.adjoin K S).restrictScalars F = Algebra.adjoin F (K ∪ S) := by
conv_lhs => rw [← Algebra.adjoin_eq K, ← Algebra.adjoin_union_eq_adjoin_adjoin]
Algebra.restrictScalars_adjoin_of_algEquiv
theorem
{F E L L' : Type*} [CommSemiring F] [CommSemiring L] [CommSemiring L'] [Semiring E] [Algebra F L] [Algebra L E]
[Algebra F L'] [Algebra L' E] [Algebra F E] [IsScalarTower F L E] [IsScalarTower F L' E] (i : L ≃ₐ[F] L')
(hi : algebraMap L E = (algebraMap L' E) ∘ i) (S : Set E) :
(Algebra.adjoin L S).restrictScalars F = (Algebra.adjoin L' S).restrictScalars F
/-- If `E / L / F` and `E / L' / F` are two ring extension towers, `L ≃ₐ[F] L'` is an isomorphism
compatible with `E / L` and `E / L'`, then for any subset `S` of `E`, `L[S]` and `L'[S]` are
equal as subalgebras of `E / F`. -/
theorem Algebra.restrictScalars_adjoin_of_algEquiv
{F E L L' : Type*} [CommSemiring F] [CommSemiring L] [CommSemiring L'] [Semiring E]
[Algebra F L] [Algebra L E] [Algebra F L'] [Algebra L' E] [Algebra F E]
[IsScalarTower F L E] [IsScalarTower F L' E] (i : L ≃ₐ[F] L')
(hi : algebraMap L E = (algebraMap L' E) ∘ i) (S : Set E) :
(Algebra.adjoin L S).restrictScalars F = (Algebra.adjoin L' S).restrictScalars F := by
apply_fun Subalgebra.toSubsemiring using fun K K' h ↦ by rwa [SetLike.ext'_iff] at h ⊢
change Subsemiring.closure _ = Subsemiring.closure _
rw [hi, Set.range_comp, EquivLike.range_eq_univ, Set.image_univ]