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 ⌀ |
|---|---|---|---|---|---|---|
IsAlgebraic.extendScalars (hinj : Function.Injective (algebraMap R S)) {x : A}
(A_alg : IsAlgebraic R x) : IsAlgebraic S x :=
let ⟨p, hp₁, hp₂⟩ := A_alg
⟨p.map (algebraMap _ _), by
rwa [Ne, ← degree_eq_bot, degree_map_eq_of_injective hinj, degree_eq_bot], by simpa⟩ | 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.extendScalars | If `x` is algebraic over `R`, then `x` is algebraic over `S` when `S` is an extension of `R`,
and the map from `R` to `S` is injective. |
IsAlgebraic.tower_top_of_subalgebra_le
{A B : Subalgebra R S} (hle : A ≤ B) {x : S}
(h : IsAlgebraic A x) : IsAlgebraic B x := by
letI : Algebra A B := (Subalgebra.inclusion hle).toAlgebra
haveI : IsScalarTower A B S := .of_algebraMap_eq fun _ ↦ rfl
exact h.extendScalars (Subalgebra.inclusion_injective hle) | 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.tower_top_of_subalgebra_le | A special case of `IsAlgebraic.extendScalars`. This is extracted as a theorem
because in some cases `IsAlgebraic.extendScalars` will just runs out of memory. |
Transcendental.restrictScalars (hinj : Function.Injective (algebraMap R S)) {x : A}
(h : Transcendental S x) : Transcendental R x := fun H ↦ h (H.extendScalars hinj) | 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.restrictScalars | If `x` is transcendental over `S`, then `x` is transcendental over `R` when `S` is an extension
of `R`, and the map from `R` to `S` is injective. |
Transcendental.of_tower_top_of_subalgebra_le
{A B : Subalgebra R S} (hle : A ≤ B) {x : S}
(h : Transcendental B x) : Transcendental A x :=
fun H ↦ h (H.tower_top_of_subalgebra_le hle) | 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_tower_top_of_subalgebra_le | A special case of `Transcendental.restrictScalars`. This is extracted as a theorem
because in some cases `Transcendental.restrictScalars` will just runs out of memory. |
Algebra.IsAlgebraic.extendScalars (hinj : Function.Injective (algebraMap R S))
[Algebra.IsAlgebraic R A] : Algebra.IsAlgebraic S A :=
⟨fun _ ↦ (Algebra.IsAlgebraic.isAlgebraic _).extendScalars hinj⟩ | 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.extendScalars | If A is an algebraic algebra over R, then A is algebraic over S when S is an extension of R,
and the map from `R` to `S` is injective. |
Algebra.IsAlgebraic.tower_bot_of_injective [Algebra.IsAlgebraic R A]
(hinj : Function.Injective (algebraMap S A)) :
Algebra.IsAlgebraic R S where
isAlgebraic x := by
simpa [isAlgebraic_algebraMap_iff hinj] using isAlgebraic (R := R) (A := A) (algebraMap _ _ x) | 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.tower_bot_of_injective | null |
@[stacks 09GF "part one"]
IsAlgebraic.tower_top {x : A} (A_alg : IsAlgebraic K x) :
IsAlgebraic L x :=
A_alg.extendScalars (algebraMap K L).injective
variable {L} (K) 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.tower_top | If `x` is algebraic over `K`, then `x` is algebraic over `L` when `L` is an extension of `K` |
Transcendental.of_tower_top {x : A} (h : Transcendental L x) :
Transcendental K x := fun H ↦ h (H.tower_top L) | 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_tower_top | If `x` is transcendental over `L`, then `x` is transcendental over `K` when
`L` is an extension of `K` |
@[stacks 09GF "part two"]
Algebra.IsAlgebraic.tower_top [Algebra.IsAlgebraic K A] : Algebra.IsAlgebraic L A :=
Algebra.IsAlgebraic.extendScalars (algebraMap K L).injective
variable (K) (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 | Algebra.IsAlgebraic.tower_top | If A is an algebraic algebra over K, then A is algebraic over L when L is an extension of K |
Algebra.IsAlgebraic.tower_bot (K L A : Type*) [CommRing K] [Field L] [Ring A]
[Algebra K L] [Algebra L A] [Algebra K A] [IsScalarTower K L A]
[Nontrivial A] [Algebra.IsAlgebraic K A] :
Algebra.IsAlgebraic K L :=
tower_bot_of_injective (algebraMap L A).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 | Algebra.IsAlgebraic.tower_bot | null |
algHom_bijective [NoZeroSMulDivisors K L] [Algebra.IsAlgebraic K L] (f : L →ₐ[K] L) :
Function.Bijective f := by
refine ⟨f.injective, fun b ↦ ?_⟩
obtain ⟨p, hp, he⟩ := Algebra.IsAlgebraic.isAlgebraic (R := K) b
let f' : p.rootSet L → p.rootSet L := (rootSet_maps_to' (fun x ↦ x) f).restrict f _ _
have : f'.Surjective := Finite.injective_iff_surjective.1
fun _ _ h ↦ Subtype.eq <| f.injective <| Subtype.ext_iff.1 h
obtain ⟨a, ha⟩ := this ⟨b, mem_rootSet.2 ⟨hp, he⟩⟩
exact ⟨a, Subtype.ext_iff.1 ha⟩ | 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 | algHom_bijective | null |
algHom_bijective₂ [NoZeroSMulDivisors K L] [DivisionRing R] [Algebra K R]
[Algebra.IsAlgebraic K L] (f : L →ₐ[K] R) (g : R →ₐ[K] L) :
Function.Bijective f ∧ Function.Bijective g :=
(g.injective.bijective₂_of_surjective f.injective (algHom_bijective <| g.comp f).2).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 | algHom_bijective₂ | null |
bijective_of_isScalarTower [NoZeroSMulDivisors K L] [Algebra.IsAlgebraic K L]
[DivisionRing R] [Algebra K R] [Algebra L R] [IsScalarTower K L R] (f : R →ₐ[K] L) :
Function.Bijective f :=
(algHom_bijective₂ (IsScalarTower.toAlgHom K L R) f).2 | 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 | bijective_of_isScalarTower | null |
bijective_of_isScalarTower' [Field R] [Algebra K R]
[NoZeroSMulDivisors K R]
[Algebra.IsAlgebraic K R] [Algebra L R] [IsScalarTower K L R] (f : R →ₐ[K] L) :
Function.Bijective f :=
(algHom_bijective₂ f (IsScalarTower.toAlgHom K L R)).1
variable (K L) | 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 | bijective_of_isScalarTower' | null |
@[simps]
noncomputable algEquivEquivAlgHom [NoZeroSMulDivisors K L] [Algebra.IsAlgebraic K L] :
(L ≃ₐ[K] L) ≃* (L →ₐ[K] L) where
toFun ϕ := ϕ.toAlgHom
invFun ϕ := AlgEquiv.ofBijective ϕ (algHom_bijective ϕ)
map_mul' _ _ := rfl | def | 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 | algEquivEquivAlgHom | Bijection between algebra equivalences and algebra homomorphisms |
IsAlgebraic.exists_nonzero_coeff_and_aeval_eq_zero
{s : S} (hRs : IsAlgebraic R s) (hs : s ∈ S⁰) :
∃ q : R[X], q.coeff 0 ≠ 0 ∧ aeval s q = 0 := by
obtain ⟨p, hp0, hp⟩ := hRs
obtain ⟨q, hpq, hq⟩ := exists_eq_pow_rootMultiplicity_mul_and_not_dvd p hp0 0
simp only [C_0, sub_zero, X_pow_mul, X_dvd_iff] at hpq hq
rw [hpq, map_mul, aeval_X_pow] at hp
exact ⟨q, hq, (S⁰.pow_mem hs (rootMultiplicity 0 p)).2 (aeval s q) 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 | IsAlgebraic.exists_nonzero_coeff_and_aeval_eq_zero | null |
IsAlgebraic.exists_nonzero_eq_adjoin_mul {s : S} (hRs : IsAlgebraic R s) (hs : s ∈ S⁰) :
∃ᵉ (t ∈ Algebra.adjoin R {s}) (r ≠ (0 : R)), s * t = algebraMap R S r := by
have ⟨q, hq0, hq⟩ := hRs.exists_nonzero_coeff_and_aeval_eq_zero hs
have ⟨p, hp⟩ := X_dvd_sub_C (p := q)
refine ⟨aeval s p, aeval_mem_adjoin_singleton _ _, _, neg_ne_zero.mpr hq0, ?_⟩
apply_fun aeval s at hp
rwa [map_sub, hq, zero_sub, map_mul, aeval_X, aeval_C, ← map_neg, eq_comm] 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 | IsAlgebraic.exists_nonzero_eq_adjoin_mul | null |
IsAlgebraic.exists_nonzero_dvd {s : S} (hRs : IsAlgebraic R s) (hs : s ∈ S⁰) :
∃ r : R, r ≠ 0 ∧ s ∣ algebraMap R S r := by
obtain ⟨q, hq0, hq⟩ := hRs.exists_nonzero_coeff_and_aeval_eq_zero hs
have key := map_dvd (aeval s) (X_dvd_sub_C (p := q))
rw [map_sub, hq, zero_sub, dvd_neg, aeval_X, aeval_C] at key
exact ⟨q.coeff 0, hq0, key⟩ | 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.exists_nonzero_dvd | null |
IsAlgebraic.exists_smul_eq_mul
(a : S) {b : S} (hRb : IsAlgebraic R b) (hb : b ∈ S⁰) :
∃ᵉ (c : S) (d ≠ (0 : R)), d • a = b * c :=
have ⟨r, hr, s, h⟩ := hRb.exists_nonzero_dvd hb
⟨s * a, r, hr, by rw [Algebra.smul_def, h, mul_assoc]⟩
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 | IsAlgebraic.exists_smul_eq_mul | A fraction `(a : S) / (b : S)` can be reduced to `(c : S) / (d : R)`,
if `b` is algebraic over `R`. |
Algebra.IsAlgebraic.exists_smul_eq_mul [NoZeroDivisors S] [Algebra.IsAlgebraic R S]
(a : S) {b : S} (hb : b ≠ 0) :
∃ᵉ (c : S) (d ≠ (0 : R)), d • a = b * c :=
(isAlgebraic b).exists_smul_eq_mul a (mem_nonZeroDivisors_of_ne_zero hb) | 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.exists_smul_eq_mul | A fraction `(a : S) / (b : S)` can be reduced to `(c : S) / (d : R)`,
if `b` is algebraic over `R`. |
injective_tower_top (inj : Injective (algebraMap R A)) : Injective (algebraMap S A) := by
refine (injective_iff_map_eq_zero _).mpr fun s eq ↦ of_not_not fun ne ↦ ?_
have ⟨r, ne, dvd⟩ := (alg.1 s).exists_nonzero_dvd (mem_nonZeroDivisors_of_ne_zero ne)
refine ne (inj <| map_zero (algebraMap R A) ▸ zero_dvd_iff.mp ?_)
simp_rw [← eq, IsScalarTower.algebraMap_apply R S A, map_dvd (algebraMap S A) dvd]
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 | injective_tower_top | null |
faithfulSMul_tower_top [FaithfulSMul R A] : FaithfulSMul S A := by
rw [faithfulSMul_iff_algebraMap_injective] at *
exact injective_tower_top S ‹_› | 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 | faithfulSMul_tower_top | null |
inv_eq_of_aeval_divX_ne_zero {x : L} {p : K[X]} (aeval_ne : aeval x (divX p) ≠ 0) :
x⁻¹ = aeval x (divX p) / (aeval x p - algebraMap _ _ (p.coeff 0)) := by
rw [inv_eq_iff_eq_inv, inv_div, eq_comm, div_eq_iff, sub_eq_iff_eq_add, mul_comm]
conv_lhs => rw [← divX_mul_X_add p]
· rw [map_add, map_mul, aeval_X, aeval_C]
· exact aeval_ne | 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 | inv_eq_of_aeval_divX_ne_zero | null |
inv_eq_of_root_of_coeff_zero_ne_zero {x : L} {p : K[X]} (aeval_eq : aeval x p = 0)
(coeff_zero_ne : p.coeff 0 ≠ 0) : x⁻¹ = -(aeval x (divX p) / algebraMap _ _ (p.coeff 0)) := by
convert inv_eq_of_aeval_divX_ne_zero (p := p) (L := L)
(mt (fun h => (algebraMap K L).injective ?_) coeff_zero_ne) using 1
· rw [aeval_eq, zero_sub, div_neg]
rw [RingHom.map_zero]
convert aeval_eq
conv_rhs => rw [← divX_mul_X_add p]
rw [map_add, map_mul, h, zero_mul, zero_add, aeval_C] | 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 | inv_eq_of_root_of_coeff_zero_ne_zero | null |
Subalgebra.inv_mem_of_root_of_coeff_zero_ne_zero {x : A} {p : K[X]}
(aeval_eq : aeval x p = 0) (coeff_zero_ne : p.coeff 0 ≠ 0) : (x⁻¹ : L) ∈ A := by
suffices (x⁻¹ : L) = (-p.coeff 0)⁻¹ • aeval x (divX p) by
rw [this]
exact A.smul_mem (aeval x _).2 _
have : aeval (x : L) p = 0 := by rw [Subalgebra.aeval_coe, aeval_eq, Subalgebra.coe_zero]
rw [inv_eq_of_root_of_coeff_zero_ne_zero this coeff_zero_ne, div_eq_inv_mul, Algebra.smul_def,
aeval_coe, map_inv₀, map_neg, inv_neg, neg_mul] | 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 | Subalgebra.inv_mem_of_root_of_coeff_zero_ne_zero | null |
Subalgebra.inv_mem_of_algebraic {x : A} (hx : IsAlgebraic K (x : L)) :
(x⁻¹ : L) ∈ A := by
obtain ⟨p, ne_zero, aeval_eq⟩ := hx
rw [Subalgebra.aeval_coe, Subalgebra.coe_eq_zero] at aeval_eq
revert ne_zero aeval_eq
refine p.recOnHorner ?_ ?_ ?_
· intro h
contradiction
· intro p a hp ha _ih _ne_zero aeval_eq
refine A.inv_mem_of_root_of_coeff_zero_ne_zero aeval_eq ?_
rwa [coeff_add, hp, zero_add, coeff_C, if_pos rfl]
· intro p hp ih _ne_zero aeval_eq
rw [map_mul, aeval_X, mul_eq_zero] at aeval_eq
rcases aeval_eq with aeval_eq | x_eq
· exact ih hp aeval_eq
· rw [x_eq, Subalgebra.coe_zero, inv_zero]
exact A.zero_mem | 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 | Subalgebra.inv_mem_of_algebraic | null |
@[stacks 0BID]
Subalgebra.isField_of_algebraic [Algebra.IsAlgebraic K L] : IsField A :=
{ show Nontrivial A by infer_instance, Subalgebra.toCommRing A with
mul_inv_cancel := fun {a} ha =>
⟨⟨a⁻¹, A.inv_mem_of_algebraic (Algebra.IsAlgebraic.isAlgebraic (a : L))⟩,
Subtype.ext (mul_inv_cancel₀ (mt (Subalgebra.coe_eq_zero _).mp ha))⟩ } | 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 | Subalgebra.isField_of_algebraic | In an algebraic extension L/K, an intermediate subalgebra is a field. |
Transcendental.infinite {x : A} (hx : Transcendental R x) : Infinite A :=
.of_injective _ (transcendental_iff_injective.mp hx)
variable (R A) 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 | Transcendental.infinite | null |
Algebra.Transcendental.infinite [Algebra.Transcendental R A] : Infinite A :=
have ⟨x, hx⟩ := ‹Algebra.Transcendental R A›
hx.infinite | 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.infinite | null |
lift_cardinalMk_le_sigma_polynomial :
lift.{u} #L ≤ #(Σ p : R[X], { x : L // x ∈ p.aroots L }) := by
have := @lift_mk_le_lift_mk_of_injective L (Σ p : R[X], {x : L | x ∈ p.aroots L})
(fun x : L =>
let p := Classical.indefiniteDescription _ (Algebra.IsAlgebraic.isAlgebraic x)
⟨p.1, x, by
dsimp
have := (Polynomial.map_ne_zero_iff (FaithfulSMul.algebraMap_injective R L)).2 p.2.1
rw [Polynomial.mem_roots this, Polynomial.IsRoot, Polynomial.eval_map,
← Polynomial.aeval_def, p.2.2]⟩)
fun x y => by
intro h
simp only [Set.coe_setOf, ne_eq, Set.mem_setOf_eq, Sigma.mk.inj_iff] at h
refine (Subtype.heq_iff_coe_eq ?_).1 h.2
simp only [h.1, forall_true_iff]
rwa [lift_umax, lift_id'.{v}] at this | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Cardinal",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Algebraic.Defs"
] | Mathlib/RingTheory/Algebraic/Cardinality.lean | lift_cardinalMk_le_sigma_polynomial | null |
lift_cardinalMk_le_max : lift.{u} #L ≤ lift.{v} #R ⊔ ℵ₀ :=
calc
lift.{u} #L ≤ #(Σ p : R[X], { x : L // x ∈ p.aroots L }) :=
lift_cardinalMk_le_sigma_polynomial R L
_ = Cardinal.sum fun p : R[X] => #{x : L | x ∈ p.aroots L} := by
rw [← mk_sigma]; rfl
_ ≤ Cardinal.sum.{u, v} fun _ : R[X] => ℵ₀ :=
(sum_le_sum _ _ fun _ => (Multiset.finite_toSet _).lt_aleph0.le)
_ = lift.{v} #(R[X]) * ℵ₀ := by rw [sum_const, lift_aleph0]
_ ≤ lift.{v} (#R ⊔ ℵ₀) ⊔ ℵ₀ ⊔ ℵ₀ := (mul_le_max _ _).trans <| by
gcongr; simp only [lift_le, Polynomial.cardinalMk_le_max]
_ = _ := by simp
variable (L : Type u) [CommRing L] [IsDomain L] [Algebra R L]
variable [NoZeroSMulDivisors R L] [Algebra.IsAlgebraic R L] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Cardinal",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Algebraic.Defs"
] | Mathlib/RingTheory/Algebraic/Cardinality.lean | lift_cardinalMk_le_max | null |
cardinalMk_le_sigma_polynomial :
#L ≤ #(Σ p : R[X], { x : L // x ∈ p.aroots L }) := by
simpa only [lift_id] using lift_cardinalMk_le_sigma_polynomial R L | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Cardinal",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Algebraic.Defs"
] | Mathlib/RingTheory/Algebraic/Cardinality.lean | cardinalMk_le_sigma_polynomial | null |
@[stacks 09GK]
cardinalMk_le_max : #L ≤ max #R ℵ₀ := by
simpa only [lift_id] using lift_cardinalMk_le_max R L | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Cardinal",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.Algebraic.Defs"
] | Mathlib/RingTheory/Algebraic/Cardinality.lean | cardinalMk_le_max | The cardinality of an algebraic extension is at most the maximum of the cardinality
of the base ring or `ℵ₀`. |
@[stacks 09GC "Algebraic elements"]
IsAlgebraic (x : A) : Prop :=
∃ p : R[X], p ≠ 0 ∧ aeval x p = 0 | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | IsAlgebraic | An element of an R-algebra is algebraic over R if it is a root of a nonzero polynomial
with coefficients in R. |
Transcendental (x : A) : Prop :=
¬IsAlgebraic R x
variable {R} | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Transcendental | An element of an R-algebra is transcendental over R if it is not algebraic over R. |
transcendental_iff {x : A} :
Transcendental R x ↔ ∀ p : R[X], aeval x p = 0 → p = 0 := by
rw [Transcendental, IsAlgebraic, not_exists]
congr! 1; tauto | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | transcendental_iff | An element `x` is transcendental over `R` if and only if for any polynomial `p`,
`Polynomial.aeval x p = 0` implies `p = 0`. This is similar to `algebraicIndependent_iff`. |
protected Subalgebra.IsAlgebraic (S : Subalgebra R A) : Prop :=
∀ x ∈ S, IsAlgebraic R x
variable (R A) | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Subalgebra.IsAlgebraic | A subalgebra is algebraic if all its elements are algebraic. |
@[stacks 09GC "Algebraic extensions"]
protected Algebra.IsAlgebraic : Prop where
isAlgebraic : ∀ x : A, IsAlgebraic R x | class | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.IsAlgebraic | An algebra is algebraic if all its elements are algebraic. |
protected Algebra.Transcendental : Prop where
transcendental : ∃ x : A, Transcendental R x
variable {R A} | class | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.Transcendental | An algebra is transcendental if some element is transcendental. |
Algebra.isAlgebraic_def : Algebra.IsAlgebraic R A ↔ ∀ x : A, IsAlgebraic R x :=
⟨fun ⟨h⟩ ↦ h, fun h ↦ ⟨h⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.isAlgebraic_def | null |
Algebra.transcendental_def : Algebra.Transcendental R A ↔ ∃ x : A, Transcendental R x :=
⟨fun ⟨h⟩ ↦ h, fun h ↦ ⟨h⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.transcendental_def | null |
Algebra.transcendental_iff_not_isAlgebraic :
Algebra.Transcendental R A ↔ ¬ Algebra.IsAlgebraic R A := by
simp [isAlgebraic_def, transcendental_def, Transcendental] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.transcendental_iff_not_isAlgebraic | null |
Subalgebra.isAlgebraic_iff (S : Subalgebra R A) :
S.IsAlgebraic ↔ Algebra.IsAlgebraic R S := by
delta Subalgebra.IsAlgebraic
rw [Subtype.forall', Algebra.isAlgebraic_def]
refine forall_congr' fun x => exists_congr fun p => and_congr Iff.rfl ?_
have h : Function.Injective S.val := Subtype.val_injective
conv_rhs => rw [← h.eq_iff, map_zero]
rw [← aeval_algHom_apply, S.val_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Subalgebra.isAlgebraic_iff | A subalgebra is algebraic if and only if it is algebraic as an algebra. |
Algebra.isAlgebraic_iff : Algebra.IsAlgebraic R A ↔ (⊤ : Subalgebra R A).IsAlgebraic := by
delta Subalgebra.IsAlgebraic
simp only [Algebra.isAlgebraic_def, Algebra.mem_top, forall_prop_of_true] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Defs.lean | Algebra.isAlgebraic_iff | An algebra is algebraic if and only if it is algebraic as a subalgebra. |
IsIntegral.isAlgebraic [Nontrivial R] {x : A} : IsIntegral R x → IsAlgebraic R x :=
fun ⟨p, hp, hpx⟩ => ⟨p, hp.ne_zero, hpx⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsIntegral.isAlgebraic | An integral element of an algebra is algebraic. |
Algebra.IsIntegral.isAlgebraic [Nontrivial R] [Algebra.IsIntegral R A] :
Algebra.IsAlgebraic R A := ⟨fun a ↦ (Algebra.IsIntegral.isIntegral a).isAlgebraic⟩ | instance | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.IsIntegral.isAlgebraic | null |
isAlgebraic_iff_isIntegral {x : A} : IsAlgebraic K x ↔ IsIntegral K x := by
refine ⟨?_, IsIntegral.isAlgebraic⟩
rintro ⟨p, hp, hpx⟩
refine ⟨_, monic_mul_leadingCoeff_inv hp, ?_⟩
rw [← aeval_def, map_mul, hpx, zero_mul] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | isAlgebraic_iff_isIntegral | An element of an algebra over a field is algebraic if and only if it is integral. |
protected Algebra.isAlgebraic_iff_isIntegral :
Algebra.IsAlgebraic K A ↔ Algebra.IsIntegral K A := by
rw [Algebra.isAlgebraic_def, Algebra.isIntegral_def,
forall_congr' fun _ ↦ isAlgebraic_iff_isIntegral]
alias ⟨IsAlgebraic.isIntegral, _⟩ := isAlgebraic_iff_isIntegral | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.isAlgebraic_iff_isIntegral | null |
protected Algebra.IsAlgebraic.isIntegral [Algebra.IsAlgebraic K A] :
Algebra.IsIntegral K A := Algebra.isAlgebraic_iff_isIntegral.mp ‹_› | instance | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.IsAlgebraic.isIntegral | This used to be an `alias` of `Algebra.isAlgebraic_iff_isIntegral` but that would make
`Algebra.IsAlgebraic K A` an explicit parameter instead of instance implicit. |
Algebra.IsAlgebraic.of_isIntegralClosure (R B C : Type*) [CommRing R] [Nontrivial R]
[CommRing B] [CommRing C] [Algebra R B] [Algebra R C] [Algebra B C]
[IsScalarTower R B C] [IsIntegralClosure B R C] : Algebra.IsAlgebraic R B :=
have := IsIntegralClosure.isIntegral_algebra R (A := B) C
inferInstance | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.IsAlgebraic.of_isIntegralClosure | null |
IsAlgebraic.of_finite (e : A) [Module.Finite R A] : IsAlgebraic R e :=
(IsIntegral.of_finite R e).isAlgebraic
variable (A) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.of_finite | null |
@[stacks 09GG "first part"]
Algebra.IsAlgebraic.of_finite [Module.Finite R A] : Algebra.IsAlgebraic R A :=
(IsIntegral.of_finite R A).isAlgebraic | instance | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.IsAlgebraic.of_finite | A field extension is algebraic if it is finite. |
@[simp]
transcendental_aeval_iff {r : A} {f : K[X]} :
Transcendental K (Polynomial.aeval r f) ↔ Transcendental K r ∧ Transcendental K f := by
refine ⟨fun h ↦ ⟨?_, h.of_aeval⟩, fun ⟨h1, h2⟩ ↦ h1.aeval_of_transcendental h2⟩
rw [Transcendental] at h ⊢
contrapose! h
rw [isAlgebraic_iff_isIntegral] at h ⊢
exact .of_mem_of_fg _ h.fg_adjoin_singleton _ (aeval_mem_adjoin_singleton _ _)
variable [Field L] [Algebra K L] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | transcendental_aeval_iff | If `K` is a field, `r : A` and `f : K[X]`, then `Polynomial.aeval r f` is
transcendental over `K` if and only if `r` and `f` are both transcendental over `K`.
See also `Transcendental.aeval_of_transcendental` and `Transcendental.of_aeval`. |
AlgHom.bijective [FiniteDimensional K L] (ϕ : L →ₐ[K] L) : Function.Bijective ϕ :=
(Algebra.IsAlgebraic.of_finite K L).algHom_bijective ϕ
variable (K L) in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | AlgHom.bijective | null |
noncomputable algEquivEquivAlgHom [FiniteDimensional K L] :
(L ≃ₐ[K] L) ≃* (L →ₐ[K] L) :=
Algebra.IsAlgebraic.algEquivEquivAlgHom K L | abbrev | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | algEquivEquivAlgHom | Bijection between algebra equivalences and algebra homomorphisms |
exists_integral_multiple (hz : IsAlgebraic R z) : ∃ y ≠ (0 : R), IsIntegral R (y • z) := by
by_cases inj : Function.Injective (algebraMap R A); swap
· rw [injective_iff_map_eq_zero] at inj; push_neg at inj
have ⟨r, eq, ne⟩ := inj
exact ⟨r, ne, by simpa [← algebraMap_smul A, eq, zero_smul] using isIntegral_zero⟩
have ⟨p, p_ne_zero, px⟩ := hz
set a := p.leadingCoeff
have a_ne_zero : a ≠ 0 := mt Polynomial.leadingCoeff_eq_zero.mp p_ne_zero
have x_integral : IsIntegral R (algebraMap R A a * z) :=
⟨p.integralNormalization, monic_integralNormalization p_ne_zero,
integralNormalization_aeval_eq_zero px fun _ ↦ (map_eq_zero_iff _ inj).mp⟩
exact ⟨_, a_ne_zero, Algebra.smul_def a z ▸ x_integral⟩
variable (R) in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | exists_integral_multiple | null |
_root_.Algebra.IsAlgebraic.exists_integral_multiples [NoZeroDivisors R]
[alg : Algebra.IsAlgebraic R A] (s : Finset A) :
∃ y ≠ (0 : R), ∀ z ∈ s, IsIntegral R (y • z) := by
have := Algebra.IsAlgebraic.nontrivial R A
choose r hr int using fun x ↦ (alg.1 x).exists_integral_multiple
refine ⟨∏ x ∈ s, r x, Finset.prod_ne_zero_iff.mpr fun _ _ ↦ hr _, fun _ h ↦ ?_⟩
classical rw [← Finset.prod_erase_mul _ _ h, mul_smul]
exact (int _).smul _ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | _root_.Algebra.IsAlgebraic.exists_integral_multiples | null |
of_smul_isIntegral {y : R} (hy : ¬ IsNilpotent y)
(h : IsIntegral R (y • z)) : IsAlgebraic R z := by
have ⟨p, monic, eval0⟩ := h
refine ⟨p.comp (C y * X), fun h ↦ ?_, by simpa [aeval_comp, Algebra.smul_def] using eval0⟩
apply_fun (coeff · p.natDegree) at h
have hy0 : y ≠ 0 := by rintro rfl; exact hy .zero
rw [coeff_zero, ← mul_one p.natDegree, ← natDegree_C_mul_X y hy0,
coeff_comp_degree_mul_degree, monic, one_mul, leadingCoeff_C_mul_X] at h
· exact hy ⟨_, h⟩
· rw [natDegree_C_mul_X _ hy0]; rintro ⟨⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | of_smul_isIntegral | null |
of_smul {y : R} (hy : y ∈ nonZeroDivisors R)
(h : IsAlgebraic R (y • z)) : IsAlgebraic R z :=
have ⟨p, hp, eval0⟩ := h
⟨_, mt (comp_C_mul_X_eq_zero_iff hy).mp hp, by simpa [aeval_comp, Algebra.smul_def] using eval0⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | of_smul | null |
iff_exists_smul_integral [IsReduced R] :
IsAlgebraic R z ↔ ∃ y ≠ (0 : R), IsIntegral R (y • z) :=
⟨(exists_integral_multiple ·), fun ⟨_, hy, int⟩ ↦
of_smul_isIntegral (by rwa [isNilpotent_iff_eq_zero]) int⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | iff_exists_smul_integral | null |
restrictScalars_of_isIntegral [int : Algebra.IsIntegral R S]
{a : A} (h : IsAlgebraic S a) : IsAlgebraic R a := by
by_cases hRS : Function.Injective (algebraMap R S)
on_goal 2 => exact (Algebra.isAlgebraic_of_not_injective
fun h ↦ hRS <| .of_comp (IsScalarTower.algebraMap_eq R S A ▸ h)).1 _
have := hRS.noZeroDivisors _ (map_zero _) (map_mul _)
have ⟨s, hs, int_s⟩ := h.exists_integral_multiple
cases subsingleton_or_nontrivial R
· have := Module.subsingleton R S
exact (is_transcendental_of_subsingleton _ _ h).elim
have ⟨r, hr, _, e⟩ := (int.1 s).isAlgebraic.exists_nonzero_dvd (mem_nonZeroDivisors_of_ne_zero hs)
refine .of_smul_isIntegral (y := r) (by rwa [isNilpotent_iff_eq_zero]) ?_
rw [Algebra.smul_def, IsScalarTower.algebraMap_apply R S,
e, ← Algebra.smul_def, mul_comm, mul_smul]
exact isIntegral_trans _ (int_s.smul _) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | restrictScalars_of_isIntegral | null |
restrictScalars [Algebra.IsAlgebraic R S]
{a : A} (h : IsAlgebraic S a) : IsAlgebraic R a := by
have ⟨p, hp, eval0⟩ := h
by_cases hRS : Function.Injective (algebraMap R S)
on_goal 2 => exact (Algebra.isAlgebraic_of_not_injective
fun h ↦ hRS <| .of_comp (IsScalarTower.algebraMap_eq R S A ▸ h)).1 _
have := hRS.noZeroDivisors _ (map_zero _) (map_mul _)
classical
have ⟨r, hr, int⟩ := Algebra.IsAlgebraic.exists_integral_multiples R (p.support.image (coeff p))
let p := (r • p).toSubring (integralClosure R S).toSubring fun s hs ↦ by
obtain ⟨n, hn, rfl⟩ := mem_coeffs_iff.mp hs
exact int _ (Finset.mem_image_of_mem _ <| support_smul _ _ hn)
have : IsAlgebraic (integralClosure R S) a := by
refine ⟨p, ?_, ?_⟩
· have : FaithfulSMul R S := (faithfulSMul_iff_algebraMap_injective R S).mpr hRS
simpa only [← Polynomial.map_ne_zero_iff (f := Subring.subtype _) Subtype.val_injective,
p, map_toSubring, smul_ne_zero_iff] using And.intro hr hp
rw [← eval_map_algebraMap, Subalgebra.algebraMap_eq, ← map_map, ← Subalgebra.toSubring_subtype,
map_toSubring, eval_map_algebraMap, ← AlgHom.restrictScalars_apply R,
map_smul, AlgHom.restrictScalars_apply, eval0, smul_zero]
exact restrictScalars_of_isIntegral _ this | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | restrictScalars | null |
_root_.IsIntegral.trans_isAlgebraic [alg : Algebra.IsAlgebraic R S]
{a : A} (h : IsIntegral S a) : IsAlgebraic R a := by
cases subsingleton_or_nontrivial A
· have := Algebra.IsAlgebraic.nontrivial R S
exact Subsingleton.elim a 0 ▸ isAlgebraic_zero
· have := Module.nontrivial S A
exact h.isAlgebraic.restrictScalars _ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | _root_.IsIntegral.trans_isAlgebraic | null |
protected neg : IsAlgebraic R (-a) :=
have ⟨p, h, eval0⟩ := ha
⟨algEquivAevalNegX p, EmbeddingLike.map_ne_zero_iff.mpr h, by simpa [← comp_eq_aeval, aeval_comp]⟩ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | neg | null |
protected smul (r : R) : IsAlgebraic R (r • a) :=
have ⟨_, hp, eval0⟩ := ha
⟨_, scaleRoots_ne_zero hp r, Algebra.smul_def r a ▸ scaleRoots_aeval_eq_zero eval0⟩ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | smul | null |
protected nsmul (n : ℕ) : IsAlgebraic R (n • a) :=
Nat.cast_smul_eq_nsmul R n a ▸ ha.smul _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | nsmul | null |
protected zsmul (n : ℤ) : IsAlgebraic R (n • a) :=
Int.cast_smul_eq_zsmul R n a ▸ ha.smul _
omit [Algebra S A] [IsScalarTower R S A] in | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | zsmul | null |
tmul [FaithfulSMul R S] : IsAlgebraic S (s ⊗ₜ[R] a) := by
rw [← mul_one s, ← smul_eq_mul, ← TensorProduct.smul_tmul']
have ⟨p, h, eval0⟩ := ha
refine .smul ⟨p.map (algebraMap R S),
(Polynomial.map_ne_zero_iff <| FaithfulSMul.algebraMap_injective ..).mpr h, ?_⟩ _
rw [← Algebra.TensorProduct.includeRight_apply, ← AlgHom.coe_toRingHom (A := A),
← map_aeval_eq_aeval_map (by ext; simp), eval0, map_zero] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | tmul | null |
protected mul : IsAlgebraic R (a * b) := by
have ⟨ra, a0, int_a⟩ := ha.exists_integral_multiple
have ⟨rb, b0, int_b⟩ := hb.exists_integral_multiple
refine IsAlgebraic.iff_exists_smul_integral.mpr ⟨_, mul_ne_zero a0 b0, ?_⟩
simp_rw [Algebra.smul_def, map_mul, mul_mul_mul_comm, ← Algebra.smul_def]
exact int_a.mul int_b | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | mul | null |
protected add : IsAlgebraic R (a + b) := by
have ⟨ra, a0, int_a⟩ := ha.exists_integral_multiple
have ⟨rb, b0, int_b⟩ := hb.exists_integral_multiple
refine IsAlgebraic.iff_exists_smul_integral.mpr ⟨_, mul_ne_zero b0 a0, ?_⟩
rw [smul_add, mul_smul, mul_comm, mul_smul]
exact (int_a.smul _).add (int_b.smul _) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | add | null |
protected sub : IsAlgebraic R (a - b) :=
sub_eq_add_neg a b ▸ ha.add hb.neg
omit hb | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | sub | null |
protected pow (n : ℕ) : IsAlgebraic R (a ^ n) :=
have := ha.nontrivial
n.rec (pow_zero a ▸ isAlgebraic_one) fun _ h ↦ pow_succ a _ ▸ h.mul ha | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | pow | null |
@[stacks 09GJ] IsAlgebraic.trans [Algebra.IsAlgebraic R S] [alg : Algebra.IsAlgebraic S A] :
Algebra.IsAlgebraic R A :=
⟨fun _ ↦ (alg.1 _).restrictScalars _⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.trans | Transitivity of algebraicity for algebras over domains. |
IsIntegral.trans_isAlgebraic [Algebra.IsIntegral R S] [alg : Algebra.IsAlgebraic S A] :
Algebra.IsAlgebraic R A :=
⟨fun _ ↦ (alg.1 _).restrictScalars_of_isIntegral _⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsIntegral.trans_isAlgebraic | null |
IsAlgebraic.trans_isIntegral [Algebra.IsAlgebraic R S] [int : Algebra.IsIntegral S A] :
Algebra.IsAlgebraic R A :=
⟨fun _ ↦ (int.1 _).trans_isAlgebraic _⟩
variable {A} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.trans_isIntegral | null |
protected IsIntegral.isAlgebraic_iff [Algebra.IsIntegral R S] [FaithfulSMul R S]
{a : A} : IsAlgebraic R a ↔ IsAlgebraic S a :=
⟨.extendScalars (FaithfulSMul.algebraMap_injective ..), .restrictScalars_of_isIntegral _⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsIntegral.isAlgebraic_iff | null |
IsIntegral.isAlgebraic_iff_top [Algebra.IsIntegral R S]
[FaithfulSMul R S] : Algebra.IsAlgebraic R A ↔ Algebra.IsAlgebraic S A := by
simp_rw [Algebra.isAlgebraic_def, Algebra.IsIntegral.isAlgebraic_iff R S] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsIntegral.isAlgebraic_iff_top | null |
protected IsAlgebraic.isAlgebraic_iff [Algebra.IsAlgebraic R S] [FaithfulSMul R S]
{a : A} : IsAlgebraic R a ↔ IsAlgebraic S a :=
⟨.extendScalars (FaithfulSMul.algebraMap_injective ..), .restrictScalars _⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.isAlgebraic_iff | null |
IsAlgebraic.isAlgebraic_iff_top [Algebra.IsAlgebraic R S]
[FaithfulSMul R S] : Algebra.IsAlgebraic R A ↔ Algebra.IsAlgebraic S A := by
simp_rw [Algebra.isAlgebraic_def, Algebra.IsAlgebraic.isAlgebraic_iff R S] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.isAlgebraic_iff_top | null |
IsAlgebraic.isAlgebraic_iff_bot [Algebra.IsAlgebraic S A] [FaithfulSMul S A] :
Algebra.IsAlgebraic R A ↔ Algebra.IsAlgebraic R S :=
⟨fun _ ↦ .tower_bot_of_injective (FaithfulSMul.algebraMap_injective S A), fun _ ↦ .trans R S A⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.isAlgebraic_iff_bot | null |
Subalgebra.algebraicClosure [IsDomain R] : Subalgebra R S where
carrier := {s | IsAlgebraic R s}
mul_mem' ha hb := ha.mul hb
add_mem' ha hb := ha.add hb
algebraMap_mem' := isAlgebraic_algebraMap | def | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Subalgebra.algebraicClosure | If `R` is a domain and `S` is an arbitrary `R`-algebra, then the elements of `S`
that are algebraic over `R` form a subalgebra. |
Subalgebra.mem_algebraicClosure [IsDomain R] {x : S} :
x ∈ algebraicClosure R S ↔ IsAlgebraic R x := Iff.rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Subalgebra.mem_algebraicClosure | null |
integralClosure_le_algebraicClosure [IsDomain R] :
integralClosure R S ≤ Subalgebra.algebraicClosure R S :=
fun _ ↦ IsIntegral.isAlgebraic | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | integralClosure_le_algebraicClosure | null |
Subalgebra.algebraicClosure_eq_integralClosure {K} [Field K] [Algebra K S] :
algebraicClosure K S = integralClosure K S :=
SetLike.ext fun _ ↦ isAlgebraic_iff_isIntegral | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Subalgebra.algebraicClosure_eq_integralClosure | null |
Algebra.isAlgebraic_adjoin_iff [IsDomain R] {s : Set S} :
(adjoin R s).IsAlgebraic ↔ ∀ x ∈ s, IsAlgebraic R x :=
Algebra.adjoin_le_iff (S := Subalgebra.algebraicClosure R S) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.isAlgebraic_adjoin_iff | null |
Algebra.isAlgebraic_adjoin_of_nonempty [NoZeroDivisors R] {s : Set S} (hs : s.Nonempty) :
(adjoin R s).IsAlgebraic ↔ ∀ x ∈ s, IsAlgebraic R x :=
⟨fun h x hx ↦ h _ (subset_adjoin hx), fun h ↦
have ⟨x, hx⟩ := hs
have := (isDomain_iff_noZeroDivisors_and_nontrivial _).mpr ⟨‹_›, (h x hx).nontrivial⟩
isAlgebraic_adjoin_iff.mpr h⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.isAlgebraic_adjoin_of_nonempty | null |
Algebra.isAlgebraic_adjoin_singleton_iff [NoZeroDivisors R] {s : S} :
(adjoin R {s}).IsAlgebraic ↔ IsAlgebraic R s :=
(isAlgebraic_adjoin_of_nonempty <| Set.singleton_nonempty s).trans forall_eq | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Algebra.isAlgebraic_adjoin_singleton_iff | In an algebra generated by a single algebraic element over a domain `R`, every element is
algebraic. This may fail when `R` is not a domain: see https://mathoverflow.net/a/132192/ for
an example. |
IsAlgebraic.of_mul [NoZeroDivisors R] {y z : S} (hy : y ∈ nonZeroDivisors S)
(alg_y : IsAlgebraic R y) (alg_yz : IsAlgebraic R (y * z)) : IsAlgebraic R z := by
have ⟨t, ht, r, hr, eq⟩ := alg_y.exists_nonzero_eq_adjoin_mul hy
have := alg_yz.mul (Algebra.isAlgebraic_adjoin_singleton_iff.mpr alg_y _ ht)
rw [mul_right_comm, eq, ← Algebra.smul_def] at this
exact this.of_smul (mem_nonZeroDivisors_of_ne_zero hr)
open Algebra in
omit [Algebra R A] [IsScalarTower R S A] in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.of_mul | null |
IsAlgebraic.adjoin_of_forall_isAlgebraic [NoZeroDivisors S] {s t : Set S}
(alg : ∀ x ∈ s \ t, IsAlgebraic (adjoin R t) x) {a : A}
(ha : IsAlgebraic (adjoin R s) a) : IsAlgebraic (adjoin R t) a := by
set Rs := adjoin R s
set Rt := adjoin R t
let Rts := adjoin Rt s
let _ : Algebra Rs Rts := (Subalgebra.inclusion
(T := Rts.restrictScalars R) <| adjoin_le <| by apply subset_adjoin).toAlgebra
have : IsScalarTower Rs Rts A := .of_algebraMap_eq fun ⟨a, _⟩ ↦ rfl
have : Algebra.IsAlgebraic Rt Rts := by
have := ha.nontrivial
have := Subtype.val_injective (p := (· ∈ Rs)).nontrivial
have := (isDomain_iff_noZeroDivisors_and_nontrivial Rt).mpr ⟨inferInstance, inferInstance⟩
rw [← Subalgebra.isAlgebraic_iff, isAlgebraic_adjoin_iff]
intro x hs
by_cases ht : x ∈ t
· exact isAlgebraic_algebraMap (⟨x, subset_adjoin ht⟩ : Rt)
exact alg _ ⟨hs, ht⟩
have : IsAlgebraic Rts a := ha.extendScalars (by apply Subalgebra.inclusion_injective)
exact this.restrictScalars Rt | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.adjoin_of_forall_isAlgebraic | null |
extendScalars_of_isIntegral [Algebra.IsIntegral R S] :
Transcendental S a := by
contrapose ha
rw [Transcendental, not_not] at ha ⊢
exact ha.restrictScalars_of_isIntegral _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | extendScalars_of_isIntegral | null |
extendScalars [Algebra.IsAlgebraic R S] : Transcendental S a := by
contrapose ha
rw [Transcendental, not_not] at ha ⊢
exact ha.restrictScalars _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | extendScalars | null |
protected integralClosure : Transcendental (integralClosure R S) a :=
ha.extendScalars_of_isIntegral _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | integralClosure | null |
subalgebraAlgebraicClosure [IsDomain R] :
Transcendental (Subalgebra.algebraicClosure R S) a := ha.extendScalars _ | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | subalgebraAlgebraicClosure | null |
protected IsIntegral.transcendental_iff [Algebra.IsIntegral R S] :
Transcendental R a ↔ Transcendental S a :=
⟨(·.extendScalars_of_isIntegral _), (·.restrictScalars (FaithfulSMul.algebraMap_injective R S))⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsIntegral.transcendental_iff | null |
protected IsAlgebraic.transcendental_iff [Algebra.IsAlgebraic R S] :
Transcendental R a ↔ Transcendental S a :=
⟨(·.extendScalars _), (·.restrictScalars (FaithfulSMul.algebraMap_injective R S))⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | IsAlgebraic.transcendental_iff | null |
isBaseChange_of_isFractionRing [Module R' S'] [IsScalarTower R R' S'] :
IsBaseChange R' (IsScalarTower.toAlgHom R S S').toLinearMap :=
(isLocalizedModule_iff_isBaseChange R⁰ ..).mp inferInstance
variable [Algebra R' S'] [IsScalarTower R R' S'] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | isBaseChange_of_isFractionRing | null |
lift_rank_of_isFractionRing :
Cardinal.lift.{u} (Module.rank R' S') = Cardinal.lift.{v} (Module.rank R S) := by
rw [IsLocalization.rank_eq R' R⁰ le_rfl,
IsLocalizedModule.lift_rank_eq R⁰ (IsScalarTower.toAlgHom R S S').toLinearMap le_rfl] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | lift_rank_of_isFractionRing | null |
finrank_of_isFractionRing : Module.finrank R' S' = Module.finrank R S := by
simpa using congr_arg Cardinal.toNat (lift_rank_of_isFractionRing ..) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | finrank_of_isFractionRing | null |
rank_of_isFractionRing (S' : Type u) [CommRing S'] [Algebra R S'] [Algebra S S']
[Module R' S'] [IsScalarTower R R' S'] [IsScalarTower R S S'] [IsFractionRing S S'] :
Module.rank R' S' = Module.rank R S := by
simpa using lift_rank_of_isFractionRing R R' S S' | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | rank_of_isFractionRing | null |
rank_fractionRing [IsDomain S] :
Module.rank (FractionRing R) (FractionRing S) = Module.rank R S :=
rank_of_isFractionRing .. | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | rank_fractionRing | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.