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 ⌀ |
|---|---|---|---|---|---|---|
FG.prod {S : Subalgebra R A} {T : Subalgebra R B} (hS : S.FG) (hT : T.FG) :
(S.prod T).FG := by
obtain ⟨s, hs⟩ := fg_def.1 hS
obtain ⟨t, ht⟩ := fg_def.1 hT
rw [← hs.2, ← ht.2]
exact fg_def.2 ⟨LinearMap.inl R A B '' (s ∪ {1}) ∪ LinearMap.inr R A B '' (t ∪ {1}),
Set.Finite.union (Set.Finite.image _ (Set.Finite.union hs.1 (Set.finite_singleton _)))
(Set.Finite.image _ (Set.Finite.union ht.1 (Set.finite_singleton _))),
Algebra.adjoin_inl_union_inr_eq_prod R s t⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | FG.prod | null |
FG.map {S : Subalgebra R A} (f : A →ₐ[R] B) (hs : S.FG) : (S.map f).FG := by
let ⟨s, hs⟩ := hs
classical
exact ⟨s.image f, by rw [Finset.coe_image, Algebra.adjoin_image, hs]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | FG.map | null |
fg_of_fg_map (S : Subalgebra R A) (f : A →ₐ[R] B) (hf : Function.Injective f)
(hs : (S.map f).FG) : S.FG :=
let ⟨s, hs⟩ := hs
⟨s.preimage f fun _ _ _ _ h ↦ hf h,
map_injective hf <| by
rw [← Algebra.adjoin_image, Finset.coe_preimage, Set.image_preimage_eq_of_subset, hs]
rw [← AlgHom.coe_range, ← Algebra.adjoin_le_iff, hs, ← Algebra.map_top]
exact map_mono le_top⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_of_fg_map | null |
fg_top (S : Subalgebra R A) : (⊤ : Subalgebra R S).FG ↔ S.FG :=
⟨fun h ↦ by
rw [← S.range_val, ← Algebra.map_top]
exact FG.map _ h, fun h ↦
fg_of_fg_map _ S.val Subtype.val_injective <| by
rw [Algebra.map_top, range_val]
exact h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | fg_top | null |
induction_on_adjoin [IsNoetherian R A] (P : Subalgebra R A → Prop) (base : P ⊥)
(ih : ∀ (S : Subalgebra R A) (x : A), P S → P (Algebra.adjoin R (insert x S)))
(S : Subalgebra R A) : P S := by
classical
obtain ⟨t, rfl⟩ := S.fg_of_noetherian
refine Finset.induction_on t ?_ ?_
· simpa using base
intro x t _ h
rw [Finset.coe_insert]
simpa only [Algebra.adjoin_insert_adjoin] using ih _ x h | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | induction_on_adjoin | null |
FG.sup {S S' : Subalgebra R A} (hS : Subalgebra.FG S) (hS' : Subalgebra.FG S') :
Subalgebra.FG (S ⊔ S') :=
let ⟨s, hs⟩ := Subalgebra.fg_def.1 hS
let ⟨s', hs'⟩ := Subalgebra.fg_def.1 hS'
fg_def.mpr ⟨s ∪ s', Set.Finite.union hs.1 hs'.1,
(by rw [Algebra.adjoin_union, hs.2, hs'.2])⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | FG.sup | null |
AlgHom.isNoetherianRing_range (f : A →ₐ[R] B) [IsNoetherianRing A] :
IsNoetherianRing f.range :=
_root_.isNoetherianRing_range f.toRingHom | instance | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | AlgHom.isNoetherianRing_range | The image of a Noetherian R-algebra under an R-algebra map is a Noetherian ring. |
isNoetherianRing_of_fg {S : Subalgebra R A} (HS : S.FG) [IsNoetherianRing R] :
IsNoetherianRing S :=
let ⟨t, ht⟩ := HS
ht ▸ (Algebra.adjoin_eq_range R (↑t : Set A)).symm ▸ AlgHom.isNoetherianRing_range _ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | isNoetherianRing_of_fg | null |
is_noetherian_subring_closure (s : Set R) (hs : s.Finite) :
IsNoetherianRing (Subring.closure s) :=
show IsNoetherianRing (subalgebraOfSubring (Subring.closure s)) from
Algebra.adjoin_int s ▸ isNoetherianRing_of_fg (Subalgebra.fg_def.2 ⟨s, hs, rfl⟩) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Int",
"Mathlib.Algebra.MvPolynomial.Eval",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/Adjoin/FG.lean | is_noetherian_subring_closure | null |
AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly {R : Type*} [CommRing R] [Algebra F R] (x : R) :
Algebra.adjoin F ({x} : Set R) ≃ₐ[F] AdjoinRoot (minpoly F x) :=
AlgEquiv.symm <| AlgEquiv.ofBijective (Minpoly.toAdjoin F x) <| by
refine ⟨(injective_iff_map_eq_zero _).2 fun P₁ hP₁ ↦ ?_, Minpoly.toAdjoin.surjective F x⟩
obtain ⟨P, rfl⟩ := mk_surjective P₁
refine AdjoinRoot.mk_eq_zero.mpr (minpoly.dvd F x ?_)
simp_all [← Subalgebra.coe_eq_zero]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly | If `p` is the minimal polynomial of `a` over `F` then `F[a] ≃ₐ[F] F[x]/(p)` |
AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly_symm_toAlgHom {R : Type*} [CommRing R]
[Algebra F R] (x : R) :
(adjoinSingletonEquivAdjoinRootMinpoly F x).symm = AdjoinRoot.Minpoly.toAdjoin F x := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly_symm_toAlgHom | null |
AlgEquiv.coe_adjoinSingletonEquivAdjoinRootMinpoly_symm {R : Type*} [CommRing R]
[Algebra F R] (x : R) :
⇑(adjoinSingletonEquivAdjoinRootMinpoly F x).symm = AdjoinRoot.Minpoly.toAdjoin F x := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | AlgEquiv.coe_adjoinSingletonEquivAdjoinRootMinpoly_symm | null |
noncomputable Algebra.adjoin.liftSingleton {S T : Type*}
[CommRing S] [CommRing T] [Algebra F S] [Algebra F T]
(x : S) (y : T) (h : aeval y (minpoly F x) = 0) :
Algebra.adjoin F {x} →ₐ[F] T :=
(AdjoinRoot.liftHom _ y h).comp (AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly F x).toAlgHom
open Finset | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | Algebra.adjoin.liftSingleton | Produce an algebra homomorphism `Adjoin R {x} →ₐ[R] T` sending `x` to
a root of `x`'s minimal polynomial in `T`. |
Polynomial.lift_of_splits {F K L : Type*} [Field F] [Field K] [Field L] [Algebra F K]
[Algebra F L] (s : Finset K) : (∀ x ∈ s, IsIntegral F x ∧
Splits (algebraMap F L) (minpoly F x)) → Nonempty (Algebra.adjoin F (s : Set K) →ₐ[F] L) := by
classical
refine Finset.induction_on s (fun _ ↦ ?_) fun a s _ ih H ↦ ?_
· rw [coe_empty, Algebra.adjoin_empty]
exact ⟨(Algebra.ofId F L).comp (Algebra.botEquiv F K)⟩
rw [forall_mem_insert] at H
rcases H with ⟨⟨H1, H2⟩, H3⟩
obtain ⟨f⟩ := ih H3
choose H3 _ using H3
rw [coe_insert, Set.insert_eq, Set.union_comm, Algebra.adjoin_union_eq_adjoin_adjoin]
set Ks := Algebra.adjoin F (s : Set K)
haveI : FiniteDimensional F Ks := ((Submodule.fg_iff_finiteDimensional _).1
(fg_adjoin_of_finite s.finite_toSet H3)).of_subalgebra_toSubmodule
letI := fieldOfFiniteDimensional F Ks
letI := (f : Ks →+* L).toAlgebra
have H5 : IsIntegral Ks a := H1.tower_top
have H6 : (minpoly Ks a).Splits (algebraMap Ks L) := by
refine splits_of_splits_of_dvd _ ((minpoly.monic H1).map (algebraMap F Ks)).ne_zero
((splits_map_iff _ _).2 ?_) (minpoly.dvd _ _ ?_)
· rw [← IsScalarTower.algebraMap_eq]
exact H2
· rw [Polynomial.aeval_map_algebraMap, minpoly.aeval]
obtain ⟨y, hy⟩ := Polynomial.exists_root_of_splits _ H6 (minpoly.degree_pos H5).ne'
exact ⟨Subalgebra.ofRestrictScalars F _ <| Algebra.adjoin.liftSingleton Ks a y hy⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | Polynomial.lift_of_splits | If `K` and `L` are field extensions of `F` and we have `s : Finset K` such that
the minimal polynomial of each `x ∈ s` splits in `L` then `Algebra.adjoin F s` embeds in `L`. |
IsIntegral.mem_range_algHom_of_minpoly_splits
(int : IsIntegral R x) (h : Splits (algebraMap R K) (minpoly R x)) (f : K →ₐ[R] L) :
x ∈ f.range :=
show x ∈ Set.range f from Set.image_subset_range _ ((minpoly R x).rootSet K) <| by
rw [image_rootSet h f, mem_rootSet']
exact ⟨((minpoly.monic int).map _).ne_zero, minpoly.aeval R x⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | IsIntegral.mem_range_algHom_of_minpoly_splits | null |
IsIntegral.mem_range_algebraMap_of_minpoly_splits [Algebra K L] [IsScalarTower R K L]
(int : IsIntegral R x) (h : Splits (algebraMap R K) (minpoly R x)) :
x ∈ (algebraMap K L).range :=
int.mem_range_algHom_of_minpoly_splits h (IsScalarTower.toAlgHom R K L) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | IsIntegral.mem_range_algebraMap_of_minpoly_splits | null |
minpoly_neg_splits [Algebra K L] {x : L} (g : (minpoly K x).Splits (algebraMap K L)) :
(minpoly K (-x)).Splits (algebraMap K L) := by
rw [minpoly.neg]
apply splits_mul _ _ g.comp_neg_X
simpa only [map_pow, map_neg, map_one] using
splits_C (algebraMap K L) ((-1) ^ (minpoly K x).natDegree) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | minpoly_neg_splits | null |
minpoly_add_algebraMap_splits [Algebra K L] {x : L} (r : K)
(g : (minpoly K x).Splits (algebraMap K L)) :
(minpoly K (x + algebraMap K L r)).Splits (algebraMap K L) := by
simpa [minpoly.add_algebraMap] using g.comp_X_sub_C r | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | minpoly_add_algebraMap_splits | null |
minpoly_sub_algebraMap_splits [Algebra K L] {x : L} (r : K)
(g : (minpoly K x).Splits (algebraMap K L)) :
(minpoly K (x - algebraMap K L r)).Splits (algebraMap K L) := by
simpa only [sub_eq_add_neg, map_neg] using minpoly_add_algebraMap_splits (-r) g | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | minpoly_sub_algebraMap_splits | null |
minpoly_algebraMap_add_splits [Algebra K L] {x : L} (r : K)
(g : (minpoly K x).Splits (algebraMap K L)) :
(minpoly K (algebraMap K L r + x)).Splits (algebraMap K L) := by
simpa only [add_comm] using minpoly_add_algebraMap_splits r g | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | minpoly_algebraMap_add_splits | null |
minpoly_algebraMap_sub_splits [Algebra K L] {x : L} (r : K)
(g : (minpoly K x).Splits (algebraMap K L)) :
(minpoly K (algebraMap K L r - x)).Splits (algebraMap K L) := by
simpa only [neg_sub] using minpoly_neg_splits (minpoly_sub_algebraMap_splits r g) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | minpoly_algebraMap_sub_splits | null |
IsIntegral.minpoly_splits_tower_top' (int : IsIntegral R x) {f : K →+* L}
(h : Splits (f.comp <| algebraMap R K) (minpoly R x)) :
Splits f (minpoly K x) :=
splits_of_splits_of_dvd _ ((minpoly.monic int).map _).ne_zero
((splits_map_iff _ _).mpr h) (minpoly.dvd_map_of_isScalarTower R _ x) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | IsIntegral.minpoly_splits_tower_top' | The `RingHom` version of `IsIntegral.minpoly_splits_tower_top`. |
IsIntegral.minpoly_splits_tower_top [Algebra K L] [Algebra R L] [IsScalarTower R K L]
(int : IsIntegral R x) (h : Splits (algebraMap R L) (minpoly R x)) :
Splits (algebraMap K L) (minpoly K x) := by
rw [IsScalarTower.algebraMap_eq R K L] at h
exact int.minpoly_splits_tower_top' h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | IsIntegral.minpoly_splits_tower_top | null |
Subalgebra.adjoin_rank_le {F : Type*} (E : Type*) {K : Type*}
[CommSemiring F] [StrongRankCondition F] [CommSemiring E] [StrongRankCondition E] [Semiring K]
[SMul F E] [Algebra E K] [Algebra F K] [IsScalarTower F E K]
(L : Subalgebra F K) [Module.Free F L] :
Module.rank E (Algebra.adjoin E (L : Set K)) ≤ Module.rank F L := by
rw [← rank_toSubmodule, Module.Free.rank_eq_card_chooseBasisIndex F L,
L.adjoin_eq_span_basis E (Module.Free.chooseBasis F L)]
exact rank_span_le _ |>.trans Cardinal.mk_range_le | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.AdjoinRoot"
] | Mathlib/RingTheory/Adjoin/Field.lean | Subalgebra.adjoin_rank_le | If `K / E / F` is a ring extension tower, `L` is a subalgebra of `K / F`,
then `[E[L] : E] ≤ [L : F]`. |
@[simp]
adjoin_X : adjoin R ({X} : Set R[X]) = ⊤ := by
refine top_unique fun p _hp => ?_
set S := adjoin R ({X} : Set R[X])
rw [← sum_monomial_eq p]; simp only [← smul_X_eq_monomial]
exact S.sum_mem fun n _hn => S.smul_mem (S.pow_mem (subset_adjoin rfl) _) _
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | adjoin_X | null |
_root_.Algebra.adjoin_singleton_eq_range_aeval (x : A) :
adjoin R {x} = (aeval x).range := by
rw [← Algebra.map_top, ← adjoin_X, AlgHom.map_adjoin, Set.image_singleton, aeval_X]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | _root_.Algebra.adjoin_singleton_eq_range_aeval | null |
aeval_mem_adjoin_singleton : aeval x p ∈ adjoin R {x} := by
simp [adjoin_singleton_eq_range_aeval] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | aeval_mem_adjoin_singleton | null |
_root_.Algebra.adjoin_mem_exists_aeval {a : A} (h : a ∈ Algebra.adjoin R {x}) :
∃ p : R[X], aeval x p = a := by
rw [Algebra.adjoin_singleton_eq_range_aeval] at h
simp_all | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | _root_.Algebra.adjoin_mem_exists_aeval | null |
_root_.Algebra.adjoin_eq_exists_aeval (a : Algebra.adjoin R {x}) :
∃ p : R[X], aeval x p = a := by
have : (a : A) ∈ Algebra.adjoin R {x} := by simp
set y := (a : A) with h
rw [Algebra.adjoin_singleton_eq_range_aeval] at this
simp_all
@[elab_as_elim] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | _root_.Algebra.adjoin_eq_exists_aeval | null |
_root_.Algebra.adjoin_singleton_induction {M : (adjoin R {x}) → Prop}
(a : adjoin R {x}) (f : ∀ (p : Polynomial R),
M (⟨aeval x p, aeval_mem_adjoin_singleton R x⟩ : adjoin R {x})) :
M a := by
obtain ⟨p, hp⟩ := Algebra.adjoin_eq_exists_aeval _ x a
aesop | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | _root_.Algebra.adjoin_singleton_induction | null |
instCommSemiringAdjoinSingleton :
CommSemiring <| adjoin R {x} :=
{ mul_comm := fun ⟨p, hp⟩ ⟨q, hq⟩ ↦ by
obtain ⟨p', rfl⟩ := Algebra.adjoin_singleton_eq_range_aeval R x ▸ hp
obtain ⟨q', rfl⟩ := Algebra.adjoin_singleton_eq_range_aeval R x ▸ hq
simp only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe, MulMemClass.mk_mul_mk, ← map_mul,
mul_comm p' q'] } | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | instCommSemiringAdjoinSingleton | null |
instCommRingAdjoinSingleton {R A : Type*} [CommRing R] [Ring A] [Algebra R A] (x : A) :
CommRing <| Algebra.adjoin R {x} :=
{ mul_comm := mul_comm } | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Adjoin/Polynomial.lean | instCommRingAdjoinSingleton | null |
noncomputable adjoin.powerBasisAux {x : S} (hx : IsIntegral K x) :
Basis (Fin (minpoly K x).natDegree) K (adjoin K ({x} : Set S)) := by
have hST : Function.Injective (algebraMap (adjoin K ({x} : Set S)) S) := Subtype.coe_injective
have hx' :
IsIntegral K (⟨x, subset_adjoin (Set.mem_singleton x)⟩ : adjoin K ({x} : Set S)) := by
apply (isIntegral_algebraMap_iff hST).mp
convert hx
apply Basis.mk (v := fun i : Fin _ ↦ ⟨x, subset_adjoin (Set.mem_singleton x)⟩ ^ (i : ℕ))
· have : LinearIndependent K _ := linearIndependent_pow
(⟨x, self_mem_adjoin_singleton _ _⟩ : adjoin K {x})
rwa [← minpoly.algebraMap_eq hST] at this
· rintro ⟨y, hy⟩ _
have := hx'.mem_span_pow (y := ⟨y, hy⟩)
rw [← minpoly.algebraMap_eq hST] at this
apply this
rw [adjoin_singleton_eq_range_aeval] at hy
obtain ⟨f, rfl⟩ := (aeval x).mem_range.mp hy
use f
ext
exact aeval_algebraMap_apply S (⟨x, _⟩ : adjoin K {x}) _ | def | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | adjoin.powerBasisAux | The elements `1, x, ..., x ^ (d - 1)` for a basis for the `K`-module `K[x]`,
where `d` is the degree of the minimal polynomial of `x`. |
@[simps gen dim]
noncomputable adjoin.powerBasis {x : S} (hx : IsIntegral K x) :
PowerBasis K (adjoin K ({x} : Set S)) where
gen := ⟨x, subset_adjoin (Set.mem_singleton x)⟩
dim := (minpoly K x).natDegree
basis := adjoin.powerBasisAux hx
basis_eq_pow i := by rw [adjoin.powerBasisAux, Basis.mk_apply] | def | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | adjoin.powerBasis | The power basis `1, x, ..., x ^ (d - 1)` for `K[x]`,
where `d` is the degree of the minimal polynomial of `x`. See `Algebra.adjoin.powerBasis'` for
a version over a more general base ring. |
noncomputable _root_.PowerBasis.ofAdjoinEqTop {x : S} (hx : IsIntegral K x)
(hx' : adjoin K {x} = ⊤) : PowerBasis K S :=
(adjoin.powerBasis hx).map ((Subalgebra.equivOfEq _ _ hx').trans Subalgebra.topEquiv)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | _root_.PowerBasis.ofAdjoinEqTop | If `x` generates `S` over `K` and is integral over `K`, then it defines a power basis.
See `PowerBasis.ofAdjoinEqTop'` for a version over a more general base ring. |
_root_.PowerBasis.ofAdjoinEqTop_gen {x : S} (hx : IsIntegral K x)
(hx' : adjoin K {x} = ⊤) : (PowerBasis.ofAdjoinEqTop hx hx').gen = x := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | _root_.PowerBasis.ofAdjoinEqTop_gen | null |
_root_.PowerBasis.ofAdjoinEqTop_dim {x : S} (hx : IsIntegral K x)
(hx' : adjoin K {x} = ⊤) :
(PowerBasis.ofAdjoinEqTop hx hx').dim = (minpoly K x).natDegree := rfl
@[deprecated "Use in combination with `PowerBasis.adjoin_eq_top_of_gen_mem_adjoin` to recover the \
deprecated definition" (since := "2025-09-29")] alias PowerBasis.ofGenMemAdjoin :=
PowerBasis.ofAdjoinEqTop | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | _root_.PowerBasis.ofAdjoinEqTop_dim | null |
repr_gen_pow_isIntegral (hB : IsIntegral R B.gen)
(hmin : minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)) (n : ℕ) :
∀ i, IsIntegral R (B.basis.repr (B.gen ^ n) i) := by
intro i
nontriviality S
let Q := X ^ n %ₘ minpoly R B.gen
have : B.gen ^ n = aeval B.gen Q := by
rw [← @aeval_X_pow R _ _ _ _ B.gen, ← modByMonic_add_div (X ^ n) (minpoly.monic hB)]
simp [Q]
by_cases hQ : Q = 0
· simp [this, hQ, isIntegral_zero]
have hlt : Q.natDegree < B.dim := by
rw [← B.natDegree_minpoly, hmin, (minpoly.monic hB).natDegree_map,
natDegree_lt_natDegree_iff hQ]
letI : Nontrivial R := Nontrivial.of_polynomial_ne hQ
exact degree_modByMonic_lt _ (minpoly.monic hB)
rw [this, aeval_eq_sum_range' hlt]
simp only [map_sum, Finset.sum_apply']
refine IsIntegral.sum _ fun j hj => ?_
replace hj := Finset.mem_range.1 hj
rw [← Fin.val_mk hj, ← B.basis_eq_pow, Algebra.smul_def, IsScalarTower.algebraMap_apply R S A, ←
Algebra.smul_def, LinearEquiv.map_smul]
simp only [algebraMap_smul, Finsupp.coe_smul, Pi.smul_apply, B.basis.repr_self_apply]
by_cases hij : (⟨j, hj⟩ : Fin _) = i
· simp only [hij, if_true]
rw [Algebra.smul_def, mul_one]
exact isIntegral_algebraMap
· simp [hij, isIntegral_zero] | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | repr_gen_pow_isIntegral | If `B : PowerBasis S A` is such that `IsIntegral R B.gen`, then
`IsIntegral R (B.basis.repr (B.gen ^ n) i)` for all `i` if
`minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD domain
and `S` is its fraction ring. |
repr_mul_isIntegral (hB : IsIntegral R B.gen) {x y : A}
(hx : ∀ i, IsIntegral R (B.basis.repr x i)) (hy : ∀ i, IsIntegral R (B.basis.repr y i))
(hmin : minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)) :
∀ i, IsIntegral R (B.basis.repr (x * y) i) := by
intro i
rw [← B.basis.sum_repr x, ← B.basis.sum_repr y, Finset.sum_mul_sum, ← Finset.sum_product',
map_sum, Finset.sum_apply']
refine IsIntegral.sum _ fun I _ => ?_
simp only [Algebra.smul_mul_assoc, Algebra.mul_smul_comm, LinearEquiv.map_smulₛₗ,
RingHom.id_apply, Finsupp.coe_smul, Pi.smul_apply, id.smul_eq_mul]
refine (hy _).mul ((hx _).mul ?_)
simp only [coe_basis, ← pow_add]
exact repr_gen_pow_isIntegral hB hmin _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | repr_mul_isIntegral | Let `B : PowerBasis S A` be such that `IsIntegral R B.gen`, and let `x y : A` be elements with
integral coordinates in the base `B.basis`. Then `IsIntegral R ((B.basis.repr (x * y) i)` for all
`i` if `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD
domain and `S` is its fraction ring. |
repr_pow_isIntegral (hB : IsIntegral R B.gen) {x : A}
(hx : ∀ i, IsIntegral R (B.basis.repr x i))
(hmin : minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)) (n : ℕ) :
∀ i, IsIntegral R (B.basis.repr (x ^ n) i) := by
nontriviality A using Subsingleton.elim (x ^ n) 0, isIntegral_zero
revert hx
refine Nat.case_strong_induction_on
(p := fun n ↦ _ → ∀ (i : Fin B.dim), IsIntegral R (B.basis.repr (x ^ n) i))
n ?_ fun n hn => ?_
· intro _ i
rw [pow_zero, ← pow_zero B.gen, ← Fin.val_mk B.dim_pos, ← B.basis_eq_pow,
B.basis.repr_self_apply]
split_ifs
· exact isIntegral_one
· exact isIntegral_zero
· intro hx
rw [pow_succ]
exact repr_mul_isIntegral hB (fun _ => hn _ le_rfl (fun _ => hx _) _) hx hmin | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | repr_pow_isIntegral | Let `B : PowerBasis S A` be such that `IsIntegral R B.gen`, and let `x : A` be an element
with integral coordinates in the base `B.basis`. Then `IsIntegral R ((B.basis.repr (x ^ n) i)` for
all `i` and all `n` if `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case
if `R` is a GCD domain and `S` is its fraction ring. |
toMatrix_isIntegral {B B' : PowerBasis K S} {P : R[X]} (h : aeval B.gen P = B'.gen)
(hB : IsIntegral R B.gen) (hmin : minpoly K B.gen = (minpoly R B.gen).map (algebraMap R K)) :
∀ i j, IsIntegral R (B.basis.toMatrix B'.basis i j) := by
intro i j
rw [B.basis.toMatrix_apply, B'.coe_basis]
refine repr_pow_isIntegral hB (fun i => ?_) hmin _ _
rw [← h, aeval_eq_sum_range, map_sum, Finset.sum_apply']
refine IsIntegral.sum _ fun n _ => ?_
rw [Algebra.smul_def, IsScalarTower.algebraMap_apply R K S, ← Algebra.smul_def,
LinearEquiv.map_smul, algebraMap_smul]
exact (repr_gen_pow_isIntegral hB hmin _ _).smul _ | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.LinearAlgebra.Matrix.Basis"
] | Mathlib/RingTheory/Adjoin/PowerBasis.lean | toMatrix_isIntegral | Let `B B' : PowerBasis K S` be such that `IsIntegral R B.gen`, and let `P : R[X]` be such that
`aeval B.gen P = B'.gen`. Then `IsIntegral R (B.basis.to_matrix B'.basis i j)` for all `i` and `j`
if `minpoly K B.gen = (minpoly R B.gen).map (algebraMap R L)`. This is the case
if `R` is a GCD domain and `K` is its fraction ring. |
adjoin_restrictScalars (C D E : Type*) [CommSemiring C] [CommSemiring D] [CommSemiring E]
[Algebra C D] [Algebra C E] [Algebra D E] [IsScalarTower C D E] (S : Set E) :
(Algebra.adjoin D S).restrictScalars C =
(Algebra.adjoin ((⊤ : Subalgebra C D).map (IsScalarTower.toAlgHom C D E)) S).restrictScalars
C := by
suffices
Set.range (algebraMap D E) =
Set.range (algebraMap ((⊤ : Subalgebra C D).map (IsScalarTower.toAlgHom C D E)) E) by
ext x
change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
rw [this]
ext x
constructor
· rintro ⟨y, hy⟩
exact ⟨⟨algebraMap D E y, ⟨y, ⟨Algebra.mem_top, rfl⟩⟩⟩, hy⟩
· rintro ⟨⟨y, ⟨z, ⟨h0, h1⟩⟩⟩, h2⟩
exact ⟨z, Eq.trans h1 h2⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/Adjoin/Tower.lean | adjoin_restrictScalars | null |
adjoin_res_eq_adjoin_res (C D E F : Type*) [CommSemiring C] [CommSemiring D]
[CommSemiring E] [CommSemiring F] [Algebra C D] [Algebra C E] [Algebra C F] [Algebra D F]
[Algebra E F] [IsScalarTower C D F] [IsScalarTower C E F] {S : Set D} {T : Set E}
(hS : Algebra.adjoin C S = ⊤) (hT : Algebra.adjoin C T = ⊤) :
(Algebra.adjoin E (algebraMap D F '' S)).restrictScalars C =
(Algebra.adjoin D (algebraMap E F '' T)).restrictScalars C := by
rw [adjoin_restrictScalars C E, adjoin_restrictScalars C D, ← hS, ← hT, ← Algebra.adjoin_image,
← Algebra.adjoin_image, ← AlgHom.coe_toRingHom, ← AlgHom.coe_toRingHom,
IsScalarTower.coe_toAlgHom, IsScalarTower.coe_toAlgHom, ← adjoin_union_eq_adjoin_adjoin, ←
adjoin_union_eq_adjoin_adjoin, Set.union_comm] | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/Adjoin/Tower.lean | adjoin_res_eq_adjoin_res | null |
Algebra.fg_trans' {R S A : Type*} [CommSemiring R] [CommSemiring S] [Semiring A]
[Algebra R S] [Algebra S A] [Algebra R A] [IsScalarTower R S A] (hRS : (⊤ : Subalgebra R S).FG)
(hSA : (⊤ : Subalgebra S A).FG) : (⊤ : Subalgebra R A).FG := by
classical
rcases hRS with ⟨s, hs⟩
rcases hSA with ⟨t, ht⟩
exact ⟨s.image (algebraMap S A) ∪ t, by
rw [Finset.coe_union, Finset.coe_image,
Algebra.adjoin_algebraMap_image_union_eq_adjoin_adjoin,
hs, Algebra.adjoin_top, ht, Subalgebra.restrictScalars_top,
Subalgebra.restrictScalars_top
]
⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/Adjoin/Tower.lean | Algebra.fg_trans' | null |
exists_subalgebra_of_fg (hAC : (⊤ : Subalgebra A C).FG) (hBC : (⊤ : Submodule B C).FG) :
∃ B₀ : Subalgebra A B, B₀.FG ∧ (⊤ : Submodule B₀ C).FG := by
obtain ⟨x, hx⟩ := hAC
obtain ⟨y, hy⟩ := hBC
have := hy
simp_rw [eq_top_iff', mem_span_finset] at this
choose f _ hf using this
classical
let s : Finset B := Finset.image₂ f (x ∪ y * y) y
have hxy :
∀ xi ∈ x, xi ∈ span (Algebra.adjoin A (↑s : Set B)) (↑(insert 1 y : Finset C) : Set C) :=
fun xi hxi =>
hf xi ▸
sum_mem fun yj hyj =>
smul_mem (span (Algebra.adjoin A (↑s : Set B)) (↑(insert 1 y : Finset C) : Set C))
⟨f xi yj, Algebra.subset_adjoin <| mem_image₂_of_mem (mem_union_left _ hxi) hyj⟩
(subset_span <| mem_insert_of_mem hyj)
have hyy :
span (Algebra.adjoin A (↑s : Set B)) (↑(insert 1 y : Finset C) : Set C) *
span (Algebra.adjoin A (↑s : Set B)) (↑(insert 1 y : Finset C) : Set C) ≤
span (Algebra.adjoin A (↑s : Set B)) (↑(insert 1 y : Finset C) : Set C) := by
rw [span_mul_span, span_le, coe_insert]
rintro _ ⟨yi, rfl | hyi, yj, rfl | hyj, rfl⟩ <;> dsimp
· rw [mul_one]
exact subset_span (Set.mem_insert _ _)
· rw [one_mul]
exact subset_span (Set.mem_insert_of_mem _ hyj)
· rw [mul_one]
exact subset_span (Set.mem_insert_of_mem _ hyi)
· rw [← hf (yi * yj)]
exact
SetLike.mem_coe.2
(sum_mem fun yk hyk =>
smul_mem (span (Algebra.adjoin A (↑s : Set B)) (insert 1 ↑y : Set C))
⟨f (yi * yj) yk,
Algebra.subset_adjoin <|
mem_image₂_of_mem (mem_union_right _ <| mul_mem_mul hyi hyj) hyk⟩
(subset_span <| Set.mem_insert_of_mem _ hyk : yk ∈ _))
refine ⟨Algebra.adjoin A (↑s : Set B), Subalgebra.fg_adjoin_finset _, insert 1 y, ?_⟩
convert restrictScalars_injective A (Algebra.adjoin A (s : Set B)) C _
rw [restrictScalars_top, eq_top_iff, ← Algebra.top_toSubmodule, ← hx, Algebra.adjoin_eq_span,
span_le]
refine fun r hr =>
Submonoid.closure_induction (fun c hc => hxy c hc) (subset_span <| mem_insert_self _ _)
(fun p q _ _ hp hq => hyy <| Submodule.mul_mem_mul hp hq) hr | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/Adjoin/Tower.lean | exists_subalgebra_of_fg | null |
@[stacks 00IS]
fg_of_fg_of_fg [IsNoetherianRing A] (hAC : (⊤ : Subalgebra A C).FG)
(hBC : (⊤ : Submodule B C).FG) (hBCi : Function.Injective (algebraMap B C)) :
(⊤ : Subalgebra A B).FG :=
let ⟨B₀, hAB₀, hB₀C⟩ := exists_subalgebra_of_fg A B C hAC hBC
Algebra.fg_trans' (B₀.fg_top.2 hAB₀) <|
Subalgebra.fg_of_submodule_fg <|
have : IsNoetherianRing B₀ := isNoetherianRing_of_fg hAB₀
have : Module.Finite B₀ C := ⟨hB₀C⟩
fg_of_injective (IsScalarTower.toAlgHom B₀ B C).toLinearMap hBCi | theorem | RingTheory | [
"Mathlib.RingTheory.Adjoin.FG"
] | Mathlib/RingTheory/Adjoin/Tower.lean | fg_of_fg_of_fg | **Artin--Tate lemma**: if A ⊆ B ⊆ C is a chain of subrings of commutative rings, and
A is Noetherian, and C is algebra-finite over A, and C is module-finite over B,
then B is algebra-finite over A.
References: Atiyah--Macdonald Proposition 7.8; Altman--Kleiman 16.17. |
@[nontriviality]
is_transcendental_of_subsingleton [Subsingleton R] (x : A) : Transcendental R x :=
fun ⟨p, h, _⟩ => h <| Subsingleton.elim p 0
variable {R} | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | is_transcendental_of_subsingleton | null |
IsAlgebraic.nontrivial {a : A} (h : IsAlgebraic R a) : Nontrivial R := by
contrapose! h
apply is_transcendental_of_subsingleton
variable (R A) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.nontrivial | null |
Algebra.IsAlgebraic.nontrivial [alg : Algebra.IsAlgebraic R A] : Nontrivial R :=
(alg.1 0).nontrivial | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.IsAlgebraic.nontrivial | null |
Polynomial.transcendental_X : Transcendental R (X (R := R)) := by
simp [transcendental_iff]
variable {R A} | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Polynomial.transcendental_X | null |
IsAlgebraic.of_aeval {r : A} (f : R[X]) (hf : f.natDegree ≠ 0)
(hf' : f.leadingCoeff ∈ R⁰) (H : IsAlgebraic R (aeval r f)) :
IsAlgebraic R r := by
obtain ⟨p, h1, h2⟩ := H
have : (p.comp f).coeff (p.natDegree * f.natDegree) ≠ 0 := fun h ↦ h1 <| by
rwa [coeff_comp_degree_mul_degree hf,
mul_right_mem_nonZeroDivisors_eq_zero_iff (pow_mem hf' _),
leadingCoeff_eq_zero] at h
exact ⟨p.comp f, fun h ↦ this (by simp [h]), by rwa [aeval_comp]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.of_aeval | null |
Transcendental.aeval {r : A} (H : Transcendental R r) (f : R[X]) (hf : f.natDegree ≠ 0)
(hf' : f.leadingCoeff ∈ R⁰) :
Transcendental R (aeval r f) := fun h ↦ H (h.of_aeval f hf hf') | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.aeval | null |
Transcendental.aeval_of_transcendental {r : A} (H : Transcendental R r)
{f : R[X]} (hf : Transcendental R f) : Transcendental R (Polynomial.aeval r f) := by
rw [transcendental_iff] at H hf ⊢
intro p hp
exact hf _ (H _ (by rwa [← aeval_comp, comp_eq_aeval] at hp)) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.aeval_of_transcendental | If `r : A` and `f : R[X]` are transcendental over `R`, then `Polynomial.aeval r f` is also
transcendental over `R`. For the converse, see `Transcendental.of_aeval` and
`transcendental_aeval_iff`. |
Transcendental.of_aeval {r : A} {f : R[X]}
(H : Transcendental R (Polynomial.aeval r f)) : Transcendental R f := by
rw [transcendental_iff] at H ⊢
intro p hp
exact H p (by rw [← aeval_comp, comp_eq_aeval, hp, map_zero]) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.of_aeval | If `Polynomial.aeval r f` is transcendental over `R`, then `f : R[X]` is also
transcendental over `R`. In fact, the `r` is also transcendental over `R` provided that `R`
is a field (see `transcendental_aeval_iff`). |
IsAlgebraic.of_aeval_of_transcendental {r : A} {f : R[X]}
(H : IsAlgebraic R (aeval r f)) (hf : Transcendental R f) : IsAlgebraic R r := by
contrapose H
exact Transcendental.aeval_of_transcendental H hf | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.of_aeval_of_transcendental | null |
Polynomial.transcendental (f : R[X]) (hf : f.natDegree ≠ 0)
(hf' : f.leadingCoeff ∈ R⁰) :
Transcendental R f := by
simpa using (transcendental_X R).aeval f hf hf' | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Polynomial.transcendental | null |
isAlgebraic_iff_not_injective {x : A} :
IsAlgebraic R x ↔ ¬Function.Injective (Polynomial.aeval x : R[X] →ₐ[R] A) := by
simp only [IsAlgebraic, injective_iff_map_eq_zero, not_forall, and_comm, exists_prop] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_iff_not_injective | null |
transcendental_iff_injective {x : A} :
Transcendental R x ↔ Function.Injective (Polynomial.aeval x : R[X] →ₐ[R] A) :=
isAlgebraic_iff_not_injective.not_left | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | transcendental_iff_injective | An element `x` is transcendental over `R` if and only if the map `Polynomial.aeval x`
is injective. This is similar to `algebraicIndependent_iff_injective_aeval`. |
transcendental_iff_ker_eq_bot {x : A} :
Transcendental R x ↔ RingHom.ker (aeval (R := R) x) = ⊥ := by
rw [transcendental_iff_injective, RingHom.injective_iff_ker_eq_bot] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | transcendental_iff_ker_eq_bot | An element `x` is transcendental over `R` if and only if the kernel of the ring homomorphism
`Polynomial.aeval x` is the zero ideal. This is similar to `algebraicIndependent_iff_ker_eq_bot`. |
Algebra.isAlgebraic_of_not_injective (h : ¬ Function.Injective (algebraMap R A)) :
Algebra.IsAlgebraic R A where
isAlgebraic a := isAlgebraic_iff_not_injective.mpr
fun inj ↦ h <| by convert inj.comp C_injective; ext; simp | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.isAlgebraic_of_not_injective | null |
Algebra.injective_of_transcendental [h : Algebra.Transcendental R A] :
Function.Injective (algebraMap R A) := by
rw [transcendental_iff_not_isAlgebraic] at h
contrapose! h
exact isAlgebraic_of_not_injective h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.injective_of_transcendental | null |
isAlgebraic_zero [Nontrivial R] : IsAlgebraic R (0 : A) :=
⟨_, X_ne_zero, aeval_X 0⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_zero | null |
isAlgebraic_algebraMap [Nontrivial R] (x : R) : IsAlgebraic R (algebraMap R A x) :=
⟨_, X_sub_C_ne_zero x, by rw [map_sub, aeval_X, aeval_C, sub_self]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_algebraMap | An element of `R` is algebraic, when viewed as an element of the `R`-algebra `A`. |
isAlgebraic_one [Nontrivial R] : IsAlgebraic R (1 : A) := by
rw [← map_one (algebraMap R A)]
exact isAlgebraic_algebraMap 1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_one | null |
isAlgebraic_nat [Nontrivial R] (n : ℕ) : IsAlgebraic R (n : A) := by
rw [← map_natCast (_ : R →+* A) n]
exact isAlgebraic_algebraMap (Nat.cast n) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_nat | null |
isAlgebraic_int [Nontrivial R] (n : ℤ) : IsAlgebraic R (n : A) := by
rw [← map_intCast (algebraMap R A)]
exact isAlgebraic_algebraMap (Int.cast n) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_int | null |
isAlgebraic_rat (R : Type u) {A : Type v} [DivisionRing A] [Field R] [Algebra R A] (n : ℚ) :
IsAlgebraic R (n : A) := by
rw [← map_ratCast (algebraMap R A)]
exact isAlgebraic_algebraMap (Rat.cast n) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_rat | null |
isAlgebraic_of_mem_rootSet {R : Type u} {A : Type v} [CommRing R] [Field A] [Algebra R A]
{p : R[X]} {x : A} (hx : x ∈ p.rootSet A) : IsAlgebraic R x :=
⟨p, ne_zero_of_mem_rootSet hx, aeval_eq_zero_of_mem_rootSet hx⟩
variable (S) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_of_mem_rootSet | null |
IsLocalization.isAlgebraic [Nontrivial R] (M : Submonoid R) [IsLocalization M S] :
Algebra.IsAlgebraic R S where
isAlgebraic x := by
obtain rfl | hx := eq_or_ne x 0
· exact isAlgebraic_zero
have ⟨⟨r, m⟩, h⟩ := surj M x
refine ⟨C m.1 * X - C r, fun eq ↦ hx ?_, by simpa [sub_eq_zero, mul_comm x] using h⟩
rwa [← eq_mk'_iff_mul_eq, show r = 0 by simpa using congr(coeff $eq 0), mk'_zero] at h
open IsScalarTower | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsLocalization.isAlgebraic | null |
protected IsAlgebraic.algebraMap {a : S} :
IsAlgebraic R a → IsAlgebraic R (algebraMap S A a) := fun ⟨f, hf₁, hf₂⟩ =>
⟨f, hf₁, by rw [aeval_algebraMap_apply, hf₂, map_zero]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.algebraMap | null |
protected IsAlgebraic.algHom (f : A →ₐ[R] B) {a : A}
(h : IsAlgebraic R a) : IsAlgebraic R (f a) :=
let ⟨p, hp, ha⟩ := h
⟨p, hp, by rw [aeval_algHom, f.comp_apply, ha, map_zero]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.algHom | This is slightly more general than `IsAlgebraic.algebraMap` in that it
allows noncommutative intermediate rings `A`. |
isAlgebraic_algHom_iff (f : A →ₐ[R] B) (hf : Function.Injective f)
{a : A} : IsAlgebraic R (f a) ↔ IsAlgebraic R a :=
⟨fun ⟨p, hp0, hp⟩ ↦ ⟨p, hp0, hf <| by rwa [map_zero, ← f.comp_apply, ← aeval_algHom]⟩,
IsAlgebraic.algHom f⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_algHom_iff | null |
IsAlgebraic.ringHom_of_comp_eq (halg : IsAlgebraic R a)
(hf : Function.Injective f)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
IsAlgebraic S (g a) := by
obtain ⟨p, h1, h2⟩ := halg
refine ⟨p.map f, (Polynomial.map_ne_zero_iff hf).2 h1, ?_⟩
change aeval ((g : A →+* B) a) _ = 0
rw [← map_aeval_eq_aeval_map h, h2, map_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.ringHom_of_comp_eq | null |
Transcendental.of_ringHom_of_comp_eq (H : Transcendental S (g a))
(hf : Function.Injective f)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Transcendental R a := fun halg ↦ H (halg.ringHom_of_comp_eq f g hf h) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.of_ringHom_of_comp_eq | null |
Algebra.IsAlgebraic.ringHom_of_comp_eq [Algebra.IsAlgebraic R A]
(hf : Function.Injective f) (hg : Function.Surjective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.IsAlgebraic S B := by
refine ⟨fun b ↦ ?_⟩
obtain ⟨a, rfl⟩ := hg b
exact (Algebra.IsAlgebraic.isAlgebraic a).ringHom_of_comp_eq f g hf h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.IsAlgebraic.ringHom_of_comp_eq | null |
Algebra.Transcendental.of_ringHom_of_comp_eq [H : Algebra.Transcendental S B]
(hf : Function.Injective f) (hg : Function.Surjective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.Transcendental R A := by
rw [Algebra.transcendental_iff_not_isAlgebraic] at H ⊢
exact fun halg ↦ H (halg.ringHom_of_comp_eq f g hf hg h) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.Transcendental.of_ringHom_of_comp_eq | null |
IsAlgebraic.of_ringHom_of_comp_eq (halg : IsAlgebraic S (g a))
(hf : Function.Surjective f) (hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
IsAlgebraic R a := by
obtain ⟨p, h1, h2⟩ := halg
obtain ⟨q, rfl⟩ := map_surjective (f : R →+* S) hf p
refine ⟨q, fun h' ↦ by simp [h'] at h1, hg ?_⟩
change aeval ((g : A →+* B) a) _ = 0 at h2
change (g : A →+* B) _ = _
rw [map_zero, map_aeval_eq_aeval_map h, h2] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.of_ringHom_of_comp_eq | null |
Transcendental.ringHom_of_comp_eq (H : Transcendental R a)
(hf : Function.Surjective f) (hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Transcendental S (g a) := fun halg ↦ H (halg.of_ringHom_of_comp_eq f g hf hg h) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.ringHom_of_comp_eq | null |
Algebra.IsAlgebraic.of_ringHom_of_comp_eq [Algebra.IsAlgebraic S B]
(hf : Function.Surjective f) (hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.IsAlgebraic R A :=
⟨fun a ↦ (Algebra.IsAlgebraic.isAlgebraic (g a)).of_ringHom_of_comp_eq f g hf hg h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.IsAlgebraic.of_ringHom_of_comp_eq | null |
Algebra.Transcendental.ringHom_of_comp_eq [H : Algebra.Transcendental R A]
(hf : Function.Surjective f) (hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.Transcendental S B := by
rw [Algebra.transcendental_iff_not_isAlgebraic] at H ⊢
exact fun halg ↦ H (halg.of_ringHom_of_comp_eq f g hf hg h) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.Transcendental.ringHom_of_comp_eq | null |
isAlgebraic_ringHom_iff_of_comp_eq
(hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) {a : A} :
IsAlgebraic S (g a) ↔ IsAlgebraic R a :=
⟨fun H ↦ H.of_ringHom_of_comp_eq f g (EquivLike.surjective f) hg h,
fun H ↦ H.ringHom_of_comp_eq f g (EquivLike.injective f) h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_ringHom_iff_of_comp_eq | null |
transcendental_ringHom_iff_of_comp_eq
(hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) {a : A} :
Transcendental S (g a) ↔ Transcendental R a :=
not_congr (isAlgebraic_ringHom_iff_of_comp_eq f g hg h) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | transcendental_ringHom_iff_of_comp_eq | null |
Algebra.isAlgebraic_ringHom_iff_of_comp_eq
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.IsAlgebraic S B ↔ Algebra.IsAlgebraic R A :=
⟨fun H ↦ H.of_ringHom_of_comp_eq f g (EquivLike.surjective f) (EquivLike.injective g) h,
fun H ↦ H.ringHom_of_comp_eq f g (EquivLike.injective f) (EquivLike.surjective g) h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.isAlgebraic_ringHom_iff_of_comp_eq | null |
Algebra.transcendental_ringHom_iff_of_comp_eq
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
Algebra.Transcendental S B ↔ Algebra.Transcendental R A := by
simp_rw [Algebra.transcendental_iff_not_isAlgebraic,
Algebra.isAlgebraic_ringHom_iff_of_comp_eq f g h] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.transcendental_ringHom_iff_of_comp_eq | null |
Algebra.IsAlgebraic.of_injective (f : A →ₐ[R] B) (hf : Function.Injective f)
[Algebra.IsAlgebraic R B] : Algebra.IsAlgebraic R A :=
⟨fun _ ↦ (isAlgebraic_algHom_iff f hf).mp (Algebra.IsAlgebraic.isAlgebraic _)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Algebra.IsAlgebraic.of_injective | null |
AlgEquiv.isAlgebraic (e : A ≃ₐ[R] B)
[Algebra.IsAlgebraic R A] : Algebra.IsAlgebraic R B :=
Algebra.IsAlgebraic.of_injective e.symm.toAlgHom e.symm.injective | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | AlgEquiv.isAlgebraic | Transfer `Algebra.IsAlgebraic` across an `AlgEquiv`. |
AlgEquiv.isAlgebraic_iff (e : A ≃ₐ[R] B) :
Algebra.IsAlgebraic R A ↔ Algebra.IsAlgebraic R B :=
⟨fun _ ↦ e.isAlgebraic, fun _ ↦ e.symm.isAlgebraic⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | AlgEquiv.isAlgebraic_iff | null |
isAlgebraic_algebraMap_iff {a : S} (h : Function.Injective (algebraMap S A)) :
IsAlgebraic R (algebraMap S A a) ↔ IsAlgebraic R a :=
isAlgebraic_algHom_iff (IsScalarTower.toAlgHom R S A) h | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_algebraMap_iff | null |
transcendental_algebraMap_iff {a : S} (h : Function.Injective (algebraMap S A)) :
Transcendental R (algebraMap S A a) ↔ Transcendental R a := by
simp_rw [Transcendental, isAlgebraic_algebraMap_iff h] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | transcendental_algebraMap_iff | null |
isAlgebraic_iff_isAlgebraic_val {S : Subalgebra R A} {x : S} :
IsAlgebraic R x ↔ IsAlgebraic R x.1 :=
(isAlgebraic_algHom_iff S.val Subtype.val_injective).symm | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_iff_isAlgebraic_val | null |
isAlgebraic_of_isAlgebraic_bot {x : S} (halg : IsAlgebraic (⊥ : Subalgebra R S) x) :
IsAlgebraic R x :=
halg.of_ringHom_of_comp_eq (algebraMap R (⊥ : Subalgebra R S))
(RingHom.id S) (by rintro ⟨_, r, rfl⟩; exact ⟨r, rfl⟩) Function.injective_id rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_of_isAlgebraic_bot | null |
isAlgebraic_bot_iff (h : Function.Injective (algebraMap R S)) {x : S} :
IsAlgebraic (⊥ : Subalgebra R S) x ↔ IsAlgebraic R x :=
isAlgebraic_ringHom_iff_of_comp_eq (Algebra.botEquivOfInjective h).symm (RingHom.id S)
Function.injective_id (by rfl)
variable (R S) in | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | isAlgebraic_bot_iff | null |
algebra_isAlgebraic_of_algebra_isAlgebraic_bot_left
[Algebra.IsAlgebraic (⊥ : Subalgebra R S) S] : Algebra.IsAlgebraic R S :=
Algebra.IsAlgebraic.of_ringHom_of_comp_eq (algebraMap R (⊥ : Subalgebra R S))
(RingHom.id S) (by rintro ⟨_, r, rfl⟩; exact ⟨r, rfl⟩) Function.injective_id (by ext; rfl) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | algebra_isAlgebraic_of_algebra_isAlgebraic_bot_left | null |
algebra_isAlgebraic_bot_left_iff (h : Function.Injective (algebraMap R S)) :
Algebra.IsAlgebraic (⊥ : Subalgebra R S) S ↔ Algebra.IsAlgebraic R S := by
simp_rw [Algebra.isAlgebraic_def, isAlgebraic_bot_iff h] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | algebra_isAlgebraic_bot_left_iff | null |
algebra_isAlgebraic_bot_right [Nontrivial R] :
Algebra.IsAlgebraic R (⊥ : Subalgebra R S) :=
⟨by rintro ⟨_, x, rfl⟩; exact isAlgebraic_algebraMap _⟩ | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | algebra_isAlgebraic_bot_right | null |
IsAlgebraic.of_pow {r : A} {n : ℕ} (hn : 0 < n) (ht : IsAlgebraic R (r ^ n)) :
IsAlgebraic R r :=
have ⟨p, p_nonzero, hp⟩ := ht
⟨_, by rwa [expand_ne_zero hn], by rwa [expand_aeval n p r]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.of_pow | null |
Transcendental.pow {r : A} (ht : Transcendental R r) {n : ℕ} (hn : 0 < n) :
Transcendental R (r ^ n) := fun ht' ↦ ht <| ht'.of_pow hn | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | Transcendental.pow | null |
IsAlgebraic.invOf {x : S} [Invertible x] (h : IsAlgebraic R x) : IsAlgebraic R (⅟x) := by
obtain ⟨p, hp, hp'⟩ := h
refine ⟨p.reverse, by simpa using hp, ?_⟩
rwa [Polynomial.aeval_def, Polynomial.eval₂_reverse_eq_zero_iff, ← Polynomial.aeval_def] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.invOf | null |
IsAlgebraic.invOf_iff {x : S} [Invertible x] :
IsAlgebraic R (⅟x) ↔ IsAlgebraic R x :=
⟨IsAlgebraic.invOf, IsAlgebraic.invOf⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.invOf_iff | null |
IsAlgebraic.inv_iff {K} [Field K] [Algebra R K] {x : K} :
IsAlgebraic R (x⁻¹) ↔ IsAlgebraic R x := by
by_cases hx : x = 0
· simp [hx]
letI := invertibleOfNonzero hx
exact IsAlgebraic.invOf_iff (R := R) (x := x)
alias ⟨_, IsAlgebraic.inv⟩ := IsAlgebraic.inv_iff | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Defs",
"Mathlib.RingTheory.Polynomial.Tower"
] | Mathlib/RingTheory/Algebraic/Basic.lean | IsAlgebraic.inv_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.