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 ⌀ |
|---|---|---|---|---|---|---|
rank_polynomial_polynomial : Module.rank R[X] S[X] = Module.rank R S :=
((Algebra.isPushout_iff ..).mp inferInstance).rank_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 | rank_polynomial_polynomial | null |
rank_mvPolynomial_mvPolynomial (σ : Type u) :
Module.rank (MvPolynomial σ R) (MvPolynomial σ S) = Cardinal.lift.{u} (Module.rank R S) := by
have := Algebra.isPushout_iff R (MvPolynomial σ R) S (MvPolynomial σ S)
|>.mp inferInstance |>.lift_rank_eq
rwa [Cardinal.lift_id', Cardinal.lift_umax] at 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 | rank_mvPolynomial_mvPolynomial | null |
Algebra.IsAlgebraic.tensorProduct : Algebra.IsAlgebraic R' (R' ⊗[R] S) where
isAlgebraic p :=
have := IsAlgebraic.nontrivial R S
have := (FaithfulSMul.algebraMap_injective R R').nontrivial
p.induction_on isAlgebraic_zero (fun _ s ↦ .tmul _ <| alg.1 s) (fun _ _ ↦ .add)
variable (S' : Type*) [CommRing S'] [Algebra R S'] [Algebra S S'] [Algebra R' S']
[IsScalarTower R R' S'] [IsScalarTower R S S'] | 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.tensorProduct | null |
Algebra.IsPushout.isAlgebraic' [IsPushout R R' S S'] : Algebra.IsAlgebraic R' S' :=
(equiv R R' S S').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 | Algebra.IsPushout.isAlgebraic' | null |
Algebra.IsPushout.isAlgebraic [h : IsPushout R S R' S'] : Algebra.IsAlgebraic R' S' :=
have := h.symm; (equiv R R' S S').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 | Algebra.IsPushout.isAlgebraic | null |
Polynomial.exists_dvd_map_of_isAlgebraic [NoZeroDivisors S] {f : S[X]} (hf : f ≠ 0) :
∃ g : R[X], g ≠ 0 ∧ f ∣ g.map (algebraMap R S) :=
(Algebra.IsAlgebraic.isAlgebraic f).exists_nonzero_dvd (mem_nonZeroDivisors_of_ne_zero hf) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | Polynomial.exists_dvd_map_of_isAlgebraic | null |
MvPolynomial.exists_dvd_map_of_isAlgebraic {σ}
[NoZeroDivisors S] {f : MvPolynomial σ S} (hf : f ≠ 0) :
∃ g : MvPolynomial σ R, g ≠ 0 ∧ f ∣ g.map (algebraMap R S) :=
(Algebra.IsAlgebraic.isAlgebraic f).exists_nonzero_dvd (mem_nonZeroDivisors_of_ne_zero hf)
variable [IsDomain S] [FaithfulSMul R S]
attribute [local instance] FractionRing.liftAlgebra | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.Localization",
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic",
"Mathlib.RingTheory.Localization.BaseChange"
] | Mathlib/RingTheory/Algebraic/Integral.lean | MvPolynomial.exists_dvd_map_of_isAlgebraic | null |
@[stacks 0G1M] rank_fractionRing_polynomial :
Module.rank (FractionRing R[X]) (FractionRing S[X]) = Module.rank R S := by
have := (FaithfulSMul.algebraMap_injective R S).isDomain
rw [rank_fractionRing, rank_polynomial_polynomial]
open Cardinal in
@[stacks 0G1M] theorem rank_fractionRing_mvPolynomial (σ : Type u) :
Module.rank (FractionRing (MvPolynomial σ R)) (FractionRing (MvPolynomial σ S)) =
lift.{u} (Module.rank R S) := by
have := (FaithfulSMul.algebraMap_injective R S).isDomain
rw [rank_fractionRing, rank_mvPolynomial_mvPolynomial] | 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_polynomial | null |
Transcendental.linearIndependent_sub_inv
{F E : Type*} [Field F] [Field E] [Algebra F E] {x : E} (H : Transcendental F x) :
LinearIndependent F fun a ↦ (x - algebraMap F E a)⁻¹ := by
classical
rw [transcendental_iff] at H
refine linearIndependent_iff'.2 fun s m hm i hi ↦ ?_
have hnz (a : F) : x - algebraMap F E a ≠ 0 := fun h ↦
X_sub_C_ne_zero a <| H (.X - .C a) (by simp [h])
let b := s.prod fun j ↦ x - algebraMap F E j
have h1 : ∀ i ∈ s, m i • (b * (x - algebraMap F E i)⁻¹) =
m i • (s.erase i).prod fun j ↦ x - algebraMap F E j := fun i hi ↦ by
simp_rw [b, ← s.prod_erase_mul _ hi, mul_inv_cancel_right₀ (hnz i)]
replace hm := congr(b * $(hm))
simp_rw [mul_zero, Finset.mul_sum, mul_smul_comm, Finset.sum_congr rfl h1] at hm
let p : Polynomial F := s.sum fun i ↦ .C (m i) * (s.erase i).prod fun j ↦ .X - .C j
replace hm := congr(Polynomial.aeval i $(H p (by simp_rw [← hm, p, map_sum, map_mul, map_prod,
map_sub, aeval_X, aeval_C, Algebra.smul_def])))
have h2 : ∀ j ∈ s.erase i, m j * ((s.erase j).prod fun x ↦ i - x) = 0 := fun j hj ↦ by
have := Finset.mem_erase_of_ne_of_mem (Finset.ne_of_mem_erase hj).symm hi
simp_rw [← (s.erase j).prod_erase_mul _ this, sub_self, mul_zero]
simp_rw [map_zero, p, map_sum, map_mul, map_prod, map_sub, aeval_X,
aeval_C, Algebra.algebraMap_self_apply, ← s.sum_erase_add _ hi,
Finset.sum_eq_zero h2, zero_add] at hm
exact eq_zero_of_ne_zero_of_mul_right_eq_zero (Finset.prod_ne_zero_iff.2 fun j hj ↦
sub_ne_zero.2 (Finset.ne_of_mem_erase hj).symm) hm | theorem | RingTheory | [
"Mathlib.LinearAlgebra.LinearIndependent.Defs",
"Mathlib.RingTheory.Algebraic.Defs"
] | Mathlib/RingTheory/Algebraic/LinearIndependent.lean | Transcendental.linearIndependent_sub_inv | If `E / F` is a field extension, `x` is an element of `E` transcendental over `F`,
then `{(x - a)⁻¹ | a : F}` is linearly independent over `F`. |
transcendental_supported_polynomial_aeval_X {i : σ} {s : Set σ} (h : i ∉ s)
{f : R[X]} (hf : Transcendental R f) :
Transcendental (supported R s) (Polynomial.aeval (X i : MvPolynomial σ R) f) := by
classical
rw [transcendental_iff_injective] at hf ⊢
let g := MvPolynomial.mapAlgHom (R := R) (σ := s) (Polynomial.aeval (R := R) f)
replace hf : Function.Injective g := MvPolynomial.map_injective _ hf
let u := (Subalgebra.val _).comp
((optionEquivRight R s).symm |>.trans
(renameEquiv R (Set.subtypeInsertEquivOption h).symm) |>.trans
(supportedEquivMvPolynomial _).symm).toAlgHom |>.comp
g |>.comp
((optionEquivLeft R s).symm.trans (optionEquivRight R s)).toAlgHom
let v := ((Polynomial.aeval (R := supported R s)
(Polynomial.aeval (X i : MvPolynomial σ R) f)).restrictScalars R).comp
(Polynomial.mapAlgEquiv (supportedEquivMvPolynomial s).symm).toAlgHom
replace hf : Function.Injective u := by
simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_comp, Subalgebra.coe_val,
AlgHom.coe_coe, AlgEquiv.coe_trans, Function.comp_assoc, u]
apply Subtype.val_injective.comp
simp only [EquivLike.comp_injective]
apply hf.comp
simp only [EquivLike.comp_injective, EquivLike.injective]
have h1 : Polynomial.aeval (X i : MvPolynomial σ R) = ((Subalgebra.val _).comp
(supportedEquivMvPolynomial _).symm.toAlgHom |>.comp
(Polynomial.aeval (X ⟨i, s.mem_insert i⟩ : MvPolynomial ↑(insert i s) R))) := by
ext1; simp
have h2 : u = v := by
simp only [u, v, g]
ext1
· ext1
simp [Set.subtypeInsertEquivOption, Subalgebra.algebraMap_eq, optionEquivLeft_symm_apply]
· simp [Set.subtypeInsertEquivOption, h1, optionEquivLeft_symm_apply]
simpa only [h2, v, AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_comp, AlgHom.coe_coe,
EquivLike.injective_comp, AlgHom.coe_restrictScalars'] using hf | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_supported_polynomial_aeval_X | null |
transcendental_polynomial_aeval_X (i : σ) {f : R[X]} (hf : Transcendental R f) :
Transcendental R (Polynomial.aeval (X i : MvPolynomial σ R) f) := by
have := transcendental_supported_polynomial_aeval_X R (Set.notMem_empty i) hf
let g := (Algebra.botEquivOfInjective (MvPolynomial.C_injective σ R)).symm.trans
(Subalgebra.equivOfEq _ _ supported_empty).symm
rwa [Transcendental, ← isAlgebraic_ringHom_iff_of_comp_eq g (RingHom.id (MvPolynomial σ R))
Function.injective_id (by ext1; rfl), RingHom.id_apply, ← Transcendental] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_polynomial_aeval_X | null |
transcendental_polynomial_aeval_X_iff (i : σ) {f : R[X]} :
Transcendental R (Polynomial.aeval (X i : MvPolynomial σ R) f) ↔ Transcendental R f := by
refine ⟨?_, transcendental_polynomial_aeval_X R i⟩
simp_rw [Transcendental, not_imp_not]
exact fun h ↦ h.algHom _ | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_polynomial_aeval_X_iff | null |
transcendental_supported_polynomial_aeval_X_iff
[Nontrivial R] {i : σ} {s : Set σ} {f : R[X]} :
Transcendental (supported R s) (Polynomial.aeval (X i : MvPolynomial σ R) f) ↔
i ∉ s ∧ Transcendental R f := by
refine ⟨fun h ↦ ⟨?_, ?_⟩, fun ⟨h, hf⟩ ↦ transcendental_supported_polynomial_aeval_X R h hf⟩
· rw [Transcendental] at h
contrapose! h
refine isAlgebraic_algebraMap (⟨Polynomial.aeval (X i) f, ?_⟩ : supported R s)
exact Algebra.adjoin_mono (Set.singleton_subset_iff.2 (Set.mem_image_of_mem _ h))
(Polynomial.aeval_mem_adjoin_singleton _ _)
· rw [← transcendental_polynomial_aeval_X_iff R i]
refine h.restrictScalars fun _ _ heq ↦ MvPolynomial.C_injective σ R ?_
simp_rw [← MvPolynomial.algebraMap_eq]
exact congr($(heq).1) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_supported_polynomial_aeval_X_iff | null |
transcendental_supported_X {i : σ} {s : Set σ} (h : i ∉ s) :
Transcendental (supported R s) (X i : MvPolynomial σ R) := by
simpa using transcendental_supported_polynomial_aeval_X R h (Polynomial.transcendental_X R) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_supported_X | null |
transcendental_X (i : σ) : Transcendental R (X i : MvPolynomial σ R) := by
simpa using transcendental_polynomial_aeval_X R i (Polynomial.transcendental_X R) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_X | null |
transcendental_supported_X_iff [Nontrivial R] {i : σ} {s : Set σ} :
Transcendental (supported R s) (X i : MvPolynomial σ R) ↔ i ∉ s := by
simpa [Polynomial.transcendental_X] using
transcendental_supported_polynomial_aeval_X_iff R (i := i) (s := s) (f := Polynomial.X) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.Adjoin.Polynomial",
"Mathlib.RingTheory.Algebraic.Basic"
] | Mathlib/RingTheory/Algebraic/MvPolynomial.lean | transcendental_supported_X_iff | null |
Polynomial.hasSMulPi [Semiring R] [SMul R S] : SMul R[X] (R → S) :=
⟨fun p f x => eval x p • f x⟩ | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | Polynomial.hasSMulPi | This is not an instance as it forms a diamond with `Pi.instSMul`.
See the `instance_diamonds` test for details. |
noncomputable Polynomial.hasSMulPi' [CommSemiring R] [Semiring S] [Algebra R S]
[SMul S T] : SMul R[X] (S → T) :=
⟨fun p f x => aeval x p • f x⟩
attribute [local instance] Polynomial.hasSMulPi Polynomial.hasSMulPi'
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | Polynomial.hasSMulPi' | This is not an instance as it forms a diamond with `Pi.instSMul`.
See the `instance_diamonds` test for details. |
polynomial_smul_apply [Semiring R] [SMul R S] (p : R[X]) (f : R → S) (x : R) :
(p • f) x = eval x p • f x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | polynomial_smul_apply | null |
polynomial_smul_apply' [CommSemiring R] [Semiring S] [Algebra R S] [SMul S T]
(p : R[X]) (f : S → T) (x : S) : (p • f) x = aeval x p • f x :=
rfl
variable [CommSemiring R] [CommSemiring S] [CommSemiring T] [Algebra R S] [Algebra S T] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | polynomial_smul_apply' | null |
noncomputable Polynomial.algebraPi : Algebra R[X] (S → T) where
__ := Polynomial.hasSMulPi' R S T
algebraMap :=
{ toFun p z := algebraMap S T (aeval z p)
map_one' := funext fun z => by simp only [Pi.one_apply, map_one]
map_mul' _ _ := funext fun z => by simp only [Pi.mul_apply, map_mul]
map_zero' := funext fun z => by simp only [Pi.zero_apply, map_zero]
map_add' _ _ := funext fun z => by simp only [Pi.add_apply, map_add] }
commutes' _ _ := funext fun z => by exact mul_comm _ _
smul_def' _ _ := funext fun z => by
simp only [polynomial_smul_apply', Algebra.algebraMap_eq_smul_one, RingHom.coe_mk,
MonoidHom.coe_mk, OneHom.coe_mk, Pi.mul_apply, Algebra.smul_mul_assoc, one_mul]
attribute [local instance] Polynomial.algebraPi
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | Polynomial.algebraPi | This is not an instance for the same reasons as `Polynomial.hasSMulPi'`. |
Polynomial.algebraMap_pi_eq_aeval :
(algebraMap R[X] (S → T) : R[X] → S → T) = fun p z => algebraMap _ _ (aeval z p) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | Polynomial.algebraMap_pi_eq_aeval | null |
Polynomial.algebraMap_pi_self_eq_eval :
(algebraMap R[X] (R → R) : R[X] → R → R) = fun p z => eval z p :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap"
] | Mathlib/RingTheory/Algebraic/Pi.lean | Polynomial.algebraMap_pi_self_eq_eval | null |
aevalEquivField :
FractionRing (MvPolynomial ι F) ≃ₐ[F] ↥(IntermediateField.adjoin F (range x)) :=
let i := IsFractionRing.liftAlgHom (K := FractionRing (MvPolynomial ι F))
(algebraicIndependent_iff_injective_aeval.2 hx)
(show _ ≃ₐ[F] i.fieldRange from AlgEquiv.ofInjectiveField i).trans <|
IntermediateField.equivOfEq <|
IsFractionRing.algHom_fieldRange_eq_of_comp_eq_of_range_eq (g := aeval x) (f := i)
(by ext <;> simp [i]) (Algebra.adjoin_range_eq_range_aeval F x).symm
@[simp] | def | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | aevalEquivField | Canonical isomorphism between rational function field and the
intermediate field generated by algebraically independent elements. |
aevalEquivField_apply_coe (a : FractionRing (MvPolynomial ι F)) :
hx.aevalEquivField a =
IsFractionRing.lift (algebraicIndependent_iff_injective_aeval.2 hx) a := rfl | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | aevalEquivField_apply_coe | null |
aevalEquivField_algebraMap_apply_coe (a : MvPolynomial ι F) :
hx.aevalEquivField (algebraMap _ _ a) = aeval x a := by
simp | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | aevalEquivField_algebraMap_apply_coe | null |
reprField : IntermediateField.adjoin F (range x) →ₐ[F] FractionRing (MvPolynomial ι F) :=
hx.aevalEquivField.symm
@[simp] | def | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | reprField | The canonical map from the intermediate field generated by an algebraic independent family
into the rational function field. |
lift_reprField (p) :
IsFractionRing.lift (algebraicIndependent_iff_injective_aeval.2 hx) (hx.reprField p) = p :=
Subtype.ext_iff.1 (AlgEquiv.apply_symm_apply hx.aevalEquivField p) | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | lift_reprField | null |
liftAlgHom_comp_reprField :
(IsFractionRing.liftAlgHom (algebraicIndependent_iff_injective_aeval.2 hx)).comp hx.reprField =
IntermediateField.val _ :=
AlgHom.ext <| hx.lift_reprField | theorem | RingTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra",
"Mathlib.RingTheory.AlgebraicIndependent.Defs"
] | Mathlib/RingTheory/AlgebraicIndependent/Adjoin.lean | liftAlgHom_comp_reprField | null |
extendScalars [alg : Algebra.IsAlgebraic R S] : AlgebraicIndependent S x := by
refine algebraicIndependent_of_finite_type'
(Algebra.IsAlgebraic.injective_tower_top S hx.algebraMap_injective) fun t fin ind i hi ↦ ?_
let Rt := adjoin R (x '' t)
let St := adjoin S (x '' t)
let _ : Algebra Rt St :=
(Rt.inclusion (T := St.restrictScalars R) <| adjoin_le <| by exact subset_adjoin).toAlgebra
have : IsScalarTower Rt St A := .of_algebraMap_eq fun ⟨y, _⟩ ↦ show y = y from rfl
have : NoZeroDivisors St := (Set.image_eq_range _ _ ▸ ind.aevalEquiv)
|>.symm.injective.noZeroDivisors _ (map_zero _) (map_mul _)
have : NoZeroDivisors Rt := (Subalgebra.inclusion_injective _).noZeroDivisors
(algebraMap Rt St) (map_zero _) (map_mul _)
have : Algebra.IsAlgebraic Rt St := ⟨fun ⟨y, hy⟩ ↦ by
rw [← isAlgebraic_algHom_iff (IsScalarTower.toAlgHom Rt St A) Subtype.val_injective]
change IsAlgebraic Rt y
have := Algebra.IsAlgebraic.nontrivial R S
have := hx.algebraMap_injective.nontrivial
exact adjoin_induction (fun _ h ↦ isAlgebraic_algebraMap (⟨_, subset_adjoin h⟩ : Rt))
(fun z ↦ ((alg.1 z).algHom (IsScalarTower.toAlgHom R S A)).extendScalars fun _ _ eq ↦ by
exact hx.algebraMap_injective congr($eq.1)) (fun _ _ _ _ ↦ .add) (fun _ _ _ _ ↦ .mul) hy⟩
change Transcendental St (x i)
exact (hx.transcendental_adjoin hi).extendScalars _ | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | extendScalars | null |
extendScalars_of_isIntegral [Algebra.IsIntegral R S] : AlgebraicIndependent S x := by
nontriviality S
have := Module.nontrivial R S
exact hx.extendScalars S | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | extendScalars_of_isIntegral | null |
subalgebraAlgebraicClosure [IsDomain R] [NoZeroDivisors A] :
AlgebraicIndependent (Subalgebra.algebraicClosure R A) x :=
hx.extendScalars _ | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | subalgebraAlgebraicClosure | null |
protected integralClosure [NoZeroDivisors A] :
AlgebraicIndependent (integralClosure R A) x :=
hx.extendScalars_of_isIntegral _
omit hx in | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | integralClosure | null |
protected algebraicClosure {F E : Type*} [Field F] [Field E] [Algebra F E] {x : ι → E}
(hx : AlgebraicIndependent F x) : AlgebraicIndependent (algebraicClosure F E) x :=
hx.extendScalars _ | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | algebraicClosure | null |
protected IsIntegral.algebraicIndependent_iff [Algebra.IsIntegral R S] :
AlgebraicIndependent R x ↔ AlgebraicIndependent S x :=
⟨(·.extendScalars_of_isIntegral _),
(·.restrictScalars (FaithfulSMul.algebraMap_injective R S))⟩ | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | IsIntegral.algebraicIndependent_iff | null |
protected IsIntegral.isTranscendenceBasis_iff [Algebra.IsIntegral R S] :
IsTranscendenceBasis R x ↔ IsTranscendenceBasis S x := by
simp_rw [IsTranscendenceBasis, IsIntegral.algebraicIndependent_iff R S] | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | IsIntegral.isTranscendenceBasis_iff | null |
protected IsAlgebraic.algebraicIndependent_iff [Algebra.IsAlgebraic R S] :
AlgebraicIndependent R x ↔ AlgebraicIndependent S x :=
⟨(·.extendScalars _), (·.restrictScalars (FaithfulSMul.algebraMap_injective R S))⟩ | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | IsAlgebraic.algebraicIndependent_iff | null |
protected IsAlgebraic.isTranscendenceBasis_iff [Algebra.IsAlgebraic R S] :
IsTranscendenceBasis R x ↔ IsTranscendenceBasis S x := by
simp_rw [IsTranscendenceBasis, IsAlgebraic.algebraicIndependent_iff R S] | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | IsAlgebraic.isTranscendenceBasis_iff | null |
isAlgebraic_adjoin_iff {x : S} :
IsAlgebraic (adjoin F s) x ↔ IsAlgebraic (Algebra.adjoin F s) x :=
(IsAlgebraic.isAlgebraic_iff ..).symm | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | isAlgebraic_adjoin_iff | null |
isAlgebraic_adjoin_iff_top :
Algebra.IsAlgebraic (adjoin F s) S ↔ Algebra.IsAlgebraic (Algebra.adjoin F s) S :=
(IsAlgebraic.isAlgebraic_iff_top ..).symm | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | isAlgebraic_adjoin_iff_top | null |
isAlgebraic_adjoin_iff_bot :
Algebra.IsAlgebraic R (adjoin F s) ↔ Algebra.IsAlgebraic R (Algebra.adjoin F s) :=
IsAlgebraic.isAlgebraic_iff_bot .. | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | isAlgebraic_adjoin_iff_bot | null |
transcendental_adjoin_iff {x : S} :
Transcendental (adjoin F s) x ↔ Transcendental (Algebra.adjoin F s) x :=
(IsAlgebraic.transcendental_iff ..).symm | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | transcendental_adjoin_iff | null |
algebraicIndependent_adjoin_iff {x : ι → S} :
AlgebraicIndependent (adjoin F s) x ↔ AlgebraicIndependent (Algebra.adjoin F s) x :=
(Algebra.IsAlgebraic.algebraicIndependent_iff ..).symm | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | algebraicIndependent_adjoin_iff | null |
isTranscendenceBasis_adjoin_iff {x : ι → S} :
IsTranscendenceBasis (adjoin F s) x ↔ IsTranscendenceBasis (Algebra.adjoin F s) x :=
(Algebra.IsAlgebraic.isTranscendenceBasis_iff ..).symm | theorem | RingTheory | [
"Mathlib.FieldTheory.AlgebraicClosure",
"Mathlib.RingTheory.Algebraic.Integral",
"Mathlib.RingTheory.AlgebraicIndependent.Transcendental"
] | Mathlib/RingTheory/AlgebraicIndependent/AlgebraicClosure.lean | isTranscendenceBasis_adjoin_iff | null |
@[stacks 030G] Algebra.trdeg : Cardinal.{v} :=
⨆ ι : { s : Set A // AlgebraicIndepOn R _root_.id s }, Cardinal.mk ι.1 | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | Algebra.trdeg | The transcendence degree of a commutative algebra `A` over a commutative ring `R` is
defined to be the maximal cardinality of an `R`-algebraically independent set in `A`. |
algebraicIndependent_iff_ker_eq_bot :
AlgebraicIndependent R x ↔
RingHom.ker (MvPolynomial.aeval x : MvPolynomial ι R →ₐ[R] A).toRingHom = ⊥ :=
RingHom.injective_iff_ker_eq_bot _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_iff_ker_eq_bot | null |
algebraicIndependent_empty_type_iff [IsEmpty ι] :
AlgebraicIndependent R x ↔ Injective (algebraMap R A) := by
rw [algebraicIndependent_iff_injective_aeval, MvPolynomial.aeval_injective_iff_of_isEmpty] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_empty_type_iff | null |
algebraMap_injective : Injective (algebraMap R A) := by
simpa [Function.comp_def] using
(Injective.of_comp_iff (algebraicIndependent_iff_injective_aeval.1 hx) MvPolynomial.C).2
(MvPolynomial.C_injective _ _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraMap_injective | null |
linearIndependent : LinearIndependent R x := by
rw [linearIndependent_iff_injective_finsuppLinearCombination]
have : Finsupp.linearCombination R x =
(MvPolynomial.aeval x).toLinearMap.comp (Finsupp.linearCombination R X) := by
ext
simp
rw [this]
refine (algebraicIndependent_iff_injective_aeval.mp hx).comp ?_
rw [← linearIndependent_iff_injective_finsuppLinearCombination]
exact linearIndependent_X _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | linearIndependent | null |
protected injective [Nontrivial R] : Injective x :=
hx.linearIndependent.injective | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | injective | null |
ne_zero [Nontrivial R] (i : ι) : x i ≠ 0 :=
hx.linearIndependent.ne_zero i | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | ne_zero | null |
map {f : A →ₐ[R] A'} (hf_inj : Set.InjOn f (adjoin R (range x))) :
AlgebraicIndependent R (f ∘ x) := by
have : aeval (f ∘ x) = f.comp (aeval x) := by ext; simp
have h : ∀ p : MvPolynomial ι R, aeval x p ∈ (@aeval R _ _ _ _ _ ((↑) : range x → A)).range := by
intro p
rw [AlgHom.mem_range]
refine ⟨MvPolynomial.rename (codRestrict x (range x) mem_range_self) p, ?_⟩
simp [Function.comp_def, aeval_rename]
intro x y hxy
rw [this] at hxy
rw [adjoin_eq_range] at hf_inj
exact hx (hf_inj (h x) (h y) hxy) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | map | null |
map' {f : A →ₐ[R] A'} (hf_inj : Injective f) : AlgebraicIndependent R (f ∘ x) :=
hx.map hf_inj.injOn | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | map' | null |
aeval_of_algebraicIndependent
{f : ι → MvPolynomial ι R} (hf : AlgebraicIndependent R f) :
AlgebraicIndependent R fun i ↦ aeval x (f i) := by
rw [algebraicIndependent_iff] at hx hf ⊢
intro p hp
exact hf _ (hx _ (by rwa [← aeval_comp_bind₁, AlgHom.comp_apply] at hp))
omit hx in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | aeval_of_algebraicIndependent | If `x = {x_i : A | i : ι}` and `f = {f_i : MvPolynomial ι R | i : ι}` are algebraically
independent over `R`, then `{f_i(x) | i : ι}` is also algebraically independent over `R`.
For the partial converse, see `AlgebraicIndependent.of_aeval`. |
of_aeval {f : ι → MvPolynomial ι R}
(H : AlgebraicIndependent R fun i ↦ aeval x (f i)) :
AlgebraicIndependent R f := by
rw [algebraicIndependent_iff] at H ⊢
intro p hp
exact H p (by rw [← aeval_comp_bind₁, AlgHom.comp_apply, bind₁, hp, map_zero]) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | of_aeval | If `{f_i(x) | i : ι}` is algebraically independent over `R`, then
`{f_i : MvPolynomial ι R | i : ι}` is also algebraically independent over `R`.
In fact, the `x = {x_i : A | i : ι}` is also transcendental over `R` provided that `R`
is a field and `ι` is finite; the proof needs transcendence degree. |
isEmpty_algebraicIndependent (h : ¬ Injective (algebraMap R A)) :
IsEmpty { s : Set A // AlgebraicIndepOn R id s } where
false s := h s.2.algebraMap_injective | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | isEmpty_algebraicIndependent | null |
trdeg_eq_zero_of_not_injective (h : ¬ Injective (algebraMap R A)) : trdeg R A = 0 := by
have := isEmpty_algebraicIndependent h
rw [trdeg, ciSup_of_empty, bot_eq_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | trdeg_eq_zero_of_not_injective | null |
MvPolynomial.algebraicIndependent_X (σ R : Type*) [CommRing R] :
AlgebraicIndependent R (X (R := R) (σ := σ)) := by
rw [AlgebraicIndependent, aeval_X_left]
exact injective_id
open AlgebraicIndependent | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | MvPolynomial.algebraicIndependent_X | null |
AlgHom.algebraicIndependent_iff (f : A →ₐ[R] A') (hf : Injective f) :
AlgebraicIndependent R (f ∘ x) ↔ AlgebraicIndependent R x :=
⟨fun h => h.of_comp f, fun h => h.map hf.injOn⟩
@[nontriviality] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgHom.algebraicIndependent_iff | null |
AlgebraicIndependent.of_subsingleton [Subsingleton R] : AlgebraicIndependent R x :=
algebraicIndependent_iff.2 fun _ _ => Subsingleton.elim _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.of_subsingleton | null |
isTranscendenceBasis_iff_of_subsingleton [Subsingleton R] (x : ι → A) :
IsTranscendenceBasis R x ↔ Nonempty ι := by
have := Module.subsingleton R A
refine ⟨fun h ↦ ?_, fun h ↦ ⟨.of_subsingleton, fun s hs hx ↦
hx.antisymm fun a _ ↦ ⟨Classical.arbitrary _, Subsingleton.elim ..⟩⟩⟩
by_contra! hι
have := h.2 {0} .of_subsingleton
simp [range_eq_empty, eq_comm (a := ∅)] at this
@[nontriviality] theorem IsTranscendenceBasis.of_subsingleton [Subsingleton R] [Nonempty ι] :
IsTranscendenceBasis R x :=
(isTranscendenceBasis_iff_of_subsingleton x).mpr ‹_›
@[nontriviality] theorem trdeg_subsingleton [Subsingleton R] : trdeg R A = 1 :=
have := Module.subsingleton R A
(ciSup_le' fun s ↦ by simpa using Set.subsingleton_of_subsingleton).antisymm <| le_ciSup_of_le
(Cardinal.bddAbove_range _) ⟨{0}, .of_subsingleton⟩ (by simp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | isTranscendenceBasis_iff_of_subsingleton | null |
algebraicIndependent_adjoin (hs : AlgebraicIndependent R x) :
@AlgebraicIndependent ι R (adjoin R (range x))
(fun i : ι => ⟨x i, subset_adjoin (mem_range_self i)⟩) _ _ _ :=
AlgebraicIndependent.of_comp (adjoin R (range x)).val hs | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_adjoin | null |
AlgebraicIndependent.restrictScalars {K : Type*} [CommRing K] [Algebra R K] [Algebra K A]
[IsScalarTower R K A] (hinj : Function.Injective (algebraMap R K))
(ai : AlgebraicIndependent K x) : AlgebraicIndependent R x := by
have : (aeval x : MvPolynomial ι K →ₐ[K] A).toRingHom.comp (MvPolynomial.map (algebraMap R K)) =
(aeval x : MvPolynomial ι R →ₐ[R] A).toRingHom := by
ext <;> simp [algebraMap_eq_smul_one]
change Injective (aeval x).toRingHom
rw [← this, RingHom.coe_comp]
exact Injective.comp ai (MvPolynomial.map_injective _ hinj) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.restrictScalars | A set of algebraically independent elements in an algebra `A` over a ring `K` is also
algebraically independent over a subring `R` of `K`. |
AlgebraicIndependent.of_ringHom_of_comp_eq (H : AlgebraicIndependent S (g ∘ x))
(hf : Function.Injective f)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
AlgebraicIndependent R x := by
rw [algebraicIndependent_iff] at H ⊢
intro p hp
have := H (p.map f) <| by
have : (g : A →+* B) _ = _ := congr(g $hp)
rwa [map_zero, map_aeval, ← h, ← eval₂Hom_map_hom, ← aeval_eq_eval₂Hom] at this
exact map_injective (f : R →+* S) hf (by rwa [map_zero]) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.of_ringHom_of_comp_eq | null |
AlgebraicIndependent.ringHom_of_comp_eq (H : AlgebraicIndependent R x)
(hf : Function.Surjective f) (hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
AlgebraicIndependent S (g ∘ x) := by
rw [algebraicIndependent_iff] at H ⊢
intro p hp
obtain ⟨q, rfl⟩ := map_surjective (f : R →+* S) hf p
rw [H q (hg (by rwa [map_zero, ← RingHom.coe_coe g, map_aeval, ← h, ← eval₂Hom_map_hom,
← aeval_eq_eval₂Hom])), map_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.ringHom_of_comp_eq | null |
algebraicIndependent_ringHom_iff_of_comp_eq
(hg : Function.Injective g)
(h : RingHom.comp (algebraMap S B) f = RingHom.comp g (algebraMap R A)) :
AlgebraicIndependent S (g ∘ x) ↔ AlgebraicIndependent R x :=
⟨fun H ↦ H.of_ringHom_of_comp_eq f g (EquivLike.injective f) h,
fun H ↦ H.ringHom_of_comp_eq f g (EquivLike.surjective f) hg h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_ringHom_iff_of_comp_eq | null |
algebraicIndependent_finset_map_embedding_subtype (s : Set A)
(li : AlgebraicIndependent R ((↑) : s → A)) (t : Finset s) :
AlgebraicIndependent R ((↑) : Finset.map (Embedding.subtype s) t → A) := by
let f : t.map (Embedding.subtype s) → s := fun x =>
⟨x.1, by
obtain ⟨x, h⟩ := x
rw [Finset.mem_map] at h
obtain ⟨a, _, rfl⟩ := h
simp only [Subtype.coe_prop, Embedding.coe_subtype]⟩
convert AlgebraicIndependent.comp li f _
rintro ⟨x, hx⟩ ⟨y, hy⟩
rw [Finset.mem_map] at hx hy
obtain ⟨a, _, rfl⟩ := hx
obtain ⟨b, _, rfl⟩ := hy
simp only [f, imp_self, Subtype.mk_eq_mk] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_finset_map_embedding_subtype | Every finite subset of an algebraically independent set is algebraically independent. |
algebraicIndependent_bounded_of_finset_algebraicIndependent_bounded {n : ℕ}
(H : ∀ s : Finset A, (AlgebraicIndependent R fun i : s => (i : A)) → s.card ≤ n) :
∀ s : Set A, AlgebraicIndependent R ((↑) : s → A) → Cardinal.mk s ≤ n := by
intro s li
apply Cardinal.card_le_of
intro t
rw [← Finset.card_map (Embedding.subtype s)]
apply H
apply algebraicIndependent_finset_map_embedding_subtype _ li | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_bounded_of_finset_algebraicIndependent_bounded | If every finite set of algebraically independent element has cardinality at most `n`,
then the same is true for arbitrary sets of algebraically independent elements. |
AlgebraicIndependent.restrict_of_comp_subtype {s : Set ι}
(hs : AlgebraicIndependent R (x ∘ (↑) : s → A)) : AlgebraicIndependent R (s.restrict x) :=
hs
variable (R A) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.restrict_of_comp_subtype | null |
algebraicIndependent_empty_iff :
AlgebraicIndependent R ((↑) : (∅ : Set A) → A) ↔ Injective (algebraMap R A) := by simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_empty_iff | null |
AlgebraicIndependent.to_subtype_range (hx : AlgebraicIndependent R x) :
AlgebraicIndependent R ((↑) : range x → A) := by
nontriviality R
rwa [algebraicIndependent_subtype_range hx.injective] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.to_subtype_range | null |
AlgebraicIndependent.to_subtype_range' (hx : AlgebraicIndependent R x) {t}
(ht : range x = t) : AlgebraicIndependent R ((↑) : t → A) :=
ht ▸ hx.to_subtype_range | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.to_subtype_range' | null |
IsTranscendenceBasis.to_subtype_range (hx : IsTranscendenceBasis R x) :
IsTranscendenceBasis R ((↑) : range x → A) := by
cases subsingleton_or_nontrivial R
· rw [isTranscendenceBasis_iff_of_subsingleton] at hx ⊢; infer_instance
· rwa [isTranscendenceBasis_subtype_range hx.1.injective] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | IsTranscendenceBasis.to_subtype_range | null |
IsTranscendenceBasis.to_subtype_range' (hx : IsTranscendenceBasis R x) {t}
(ht : range x = t) : IsTranscendenceBasis R ((↑) : t → A) :=
ht ▸ hx.to_subtype_range | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | IsTranscendenceBasis.to_subtype_range' | null |
IsTranscendenceBasis.of_comp {x : ι → A} (f : A →ₐ[R] A') (h : Function.Injective f)
(H : IsTranscendenceBasis R (f ∘ x)) :
IsTranscendenceBasis R x := by
refine ⟨(AlgHom.algebraicIndependent_iff f h).mp H.1, ?_⟩
intro s hs hs'
have := H.2 (f '' s)
((algebraicIndependent_image h.injOn).mp ((AlgHom.algebraicIndependent_iff f h).mpr hs))
(by rw [Set.range_comp]; exact Set.image_mono hs')
rwa [Set.range_comp, (Set.image_injective.mpr h).eq_iff] at this | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | IsTranscendenceBasis.of_comp | null |
IsTranscendenceBasis.of_comp_algebraMap [Algebra A A'] [IsScalarTower R A A']
[FaithfulSMul A A'] {x : ι → A} (H : IsTranscendenceBasis R (algebraMap A A' ∘ x)) :
IsTranscendenceBasis R x :=
.of_comp (IsScalarTower.toAlgHom R A A') (FaithfulSMul.algebraMap_injective A A') H | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | IsTranscendenceBasis.of_comp_algebraMap | null |
AlgEquiv.isTranscendenceBasis (e : A ≃ₐ[R] A') (hx : IsTranscendenceBasis R x) :
IsTranscendenceBasis R (e ∘ x) :=
.of_comp e.symm.toAlgHom e.symm.injective (by convert hx; ext; simp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgEquiv.isTranscendenceBasis | Also see `IsTranscendenceBasis.algebraMap_comp`
for the composition with a algebraic extension. |
AlgEquiv.isTranscendenceBasis_iff (e : A ≃ₐ[R] A') :
IsTranscendenceBasis R (e ∘ x) ↔ IsTranscendenceBasis R x :=
⟨fun hx ↦ by convert e.symm.isTranscendenceBasis hx; ext; simp, e.isTranscendenceBasis⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgEquiv.isTranscendenceBasis_iff | null |
AlgebraicIndependent.lift_cardinalMk_le_trdeg [Nontrivial R]
(hx : AlgebraicIndependent R x) : lift.{v} #ι ≤ lift.{u} (trdeg R A) := by
rw [lift_mk_eq'.mpr ⟨.ofInjective _ hx.injective⟩, lift_le]
exact le_ciSup_of_le (bddAbove_range _) ⟨_, hx.to_subtype_range⟩ le_rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.lift_cardinalMk_le_trdeg | null |
AlgebraicIndependent.cardinalMk_le_trdeg [Nontrivial R] {ι : Type v} {x : ι → A}
(hx : AlgebraicIndependent R x) : #ι ≤ trdeg R A := by
rw [← (#ι).lift_id, ← (trdeg R A).lift_id]; exact hx.lift_cardinalMk_le_trdeg | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.cardinalMk_le_trdeg | null |
lift_trdeg_le_of_injective (f : A →ₐ[R] A') (hf : Injective f) :
lift.{v'} (trdeg R A) ≤ lift.{v} (trdeg R A') := by
nontriviality R
rw [trdeg, lift_iSup (bddAbove_range _)]
exact ciSup_le' fun i ↦ (i.2.map' hf).lift_cardinalMk_le_trdeg | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | lift_trdeg_le_of_injective | null |
trdeg_le_of_injective {A' : Type v} [CommRing A'] [Algebra R A'] (f : A →ₐ[R] A')
(hf : Injective f) : trdeg R A ≤ trdeg R A' := by
rw [← (trdeg R A).lift_id, ← (trdeg R A').lift_id]; exact lift_trdeg_le_of_injective f hf | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | trdeg_le_of_injective | null |
lift_trdeg_le_of_surjective (f : A →ₐ[R] A') (hf : Surjective f) :
lift.{v} (trdeg R A') ≤ lift.{v'} (trdeg R A) := by
nontriviality R
rw [trdeg, lift_iSup (bddAbove_range _)]
refine ciSup_le' fun i ↦ (lift_cardinalMk_le_trdeg (x := fun a : i.1 ↦ (⇑f).invFun a) <|
of_comp f ?_)
convert i.2; simp [invFun_eq (hf _)] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | lift_trdeg_le_of_surjective | null |
trdeg_le_of_surjective {A' : Type v} [CommRing A'] [Algebra R A'] (f : A →ₐ[R] A')
(hf : Surjective f) : trdeg R A' ≤ trdeg R A := by
rw [← (trdeg R A).lift_id, ← (trdeg R A').lift_id]; exact lift_trdeg_le_of_surjective f hf | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | trdeg_le_of_surjective | null |
AlgEquiv.lift_trdeg_eq (e : A ≃ₐ[R] A') :
lift.{v'} (trdeg R A) = lift.{v} (trdeg R A') :=
(lift_trdeg_le_of_injective e.toAlgHom e.injective).antisymm
(lift_trdeg_le_of_surjective e.toAlgHom e.surjective) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgEquiv.lift_trdeg_eq | null |
AlgEquiv.trdeg_eq {A' : Type v} [CommRing A'] [Algebra R A'] (e : A ≃ₐ[R] A') :
trdeg R A = trdeg R A' := by
rw [← (trdeg R A).lift_id, e.lift_trdeg_eq, lift_id] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgEquiv.trdeg_eq | null |
algebraicIndependent_comp_subtype {s : Set ι} :
AlgebraicIndependent R (x ∘ (↑) : s → A) ↔
∀ p ∈ MvPolynomial.supported R s, aeval x p = 0 → p = 0 := by
have : (aeval (x ∘ (↑) : s → A) : _ →ₐ[R] _) = (aeval x).comp (rename (↑)) := by ext; simp
have : ∀ p : MvPolynomial s R, rename ((↑) : s → ι) p = 0 ↔ p = 0 :=
(injective_iff_map_eq_zero' (rename ((↑) : s → ι) : MvPolynomial s R →ₐ[R] _).toRingHom).1
(rename_injective _ Subtype.val_injective)
simp [algebraicIndependent_iff, supported_eq_range_rename, *] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_comp_subtype | null |
algebraicIndependent_subtype {s : Set A} :
AlgebraicIndependent R ((↑) : s → A) ↔
∀ p : MvPolynomial A R, p ∈ MvPolynomial.supported R s → aeval id p = 0 → p = 0 := by
apply @algebraicIndependent_comp_subtype _ _ _ id | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_subtype | null |
algebraicIndependent_of_finite (s : Set A)
(H : ∀ t ⊆ s, t.Finite → AlgebraicIndependent R ((↑) : t → A)) :
AlgebraicIndependent R ((↑) : s → A) :=
algebraicIndependent_subtype.2 fun p hp ↦
algebraicIndependent_subtype.1 (H _ (mem_supported.1 hp) (Finset.finite_toSet _)) _ (by simp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_of_finite | null |
algebraicIndependent_of_finite_type
(H : ∀ t : Set ι, t.Finite → AlgebraicIndependent R fun i : t ↦ x i) :
AlgebraicIndependent R x :=
(injective_iff_map_eq_zero _).mpr fun p ↦
algebraicIndependent_comp_subtype.1 (H _ p.vars.finite_toSet) _ p.mem_supported_vars | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_of_finite_type | null |
AlgebraicIndependent.image_of_comp {ι ι'} (s : Set ι) (f : ι → ι') (g : ι' → A)
(hs : AlgebraicIndependent R fun x : s => g (f x)) :
AlgebraicIndependent R fun x : f '' s => g x := by
nontriviality R
have : InjOn f s := injOn_iff_injective.2 hs.injective.of_comp
exact (algebraicIndependent_equiv' (Equiv.Set.imageOfInjOn f s this) rfl).1 hs | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.image_of_comp | null |
AlgebraicIndependent.image {ι} {s : Set ι} {f : ι → A}
(hs : AlgebraicIndependent R fun x : s => f x) :
AlgebraicIndependent R fun x : f '' s => (x : A) := by
convert AlgebraicIndependent.image_of_comp s f id hs | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.image | null |
algebraicIndependent_iUnion_of_directed {η : Type*} [Nonempty η] {s : η → Set A}
(hs : Directed (· ⊆ ·) s) (h : ∀ i, AlgebraicIndependent R ((↑) : s i → A)) :
AlgebraicIndependent R ((↑) : (⋃ i, s i) → A) := by
refine algebraicIndependent_of_finite (⋃ i, s i) fun t ht ft => ?_
rcases finite_subset_iUnion ft ht with ⟨I, fi, hI⟩
rcases hs.finset_le fi.toFinset with ⟨i, hi⟩
exact (h i).mono (Subset.trans hI <| iUnion₂_subset fun j hj => hi j (fi.mem_toFinset.2 hj)) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_iUnion_of_directed | null |
algebraicIndependent_sUnion_of_directed {s : Set (Set A)} (hsn : s.Nonempty)
(hs : DirectedOn (· ⊆ ·) s) (h : ∀ a ∈ s, AlgebraicIndependent R ((↑) : a → A)) :
AlgebraicIndependent R ((↑) : ⋃₀ s → A) := by
letI : Nonempty s := Nonempty.to_subtype hsn
rw [sUnion_eq_iUnion]
exact algebraicIndependent_iUnion_of_directed hs.directed_val (by simpa using h) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | algebraicIndependent_sUnion_of_directed | null |
exists_maximal_algebraicIndependent (s t : Set A) (hst : s ⊆ t)
(hs : AlgebraicIndepOn R id s) : ∃ u, s ⊆ u ∧
Maximal (fun (x : Set A) ↦ AlgebraicIndepOn R id x ∧ x ⊆ t) u := by
refine zorn_subset_nonempty { u : Set A | AlgebraicIndependent R ((↑) : u → A) ∧ u ⊆ t}
(fun c hc chainc hcn ↦ ⟨⋃₀ c, ⟨?_, ?_⟩, fun _ ↦ subset_sUnion_of_mem⟩) s ⟨hs, hst⟩
· exact algebraicIndependent_sUnion_of_directed hcn chainc.directedOn (fun x hxc ↦ (hc hxc).1)
exact fun x ⟨w, hyc, hwy⟩ ↦ (hc hyc).2 hwy | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | exists_maximal_algebraicIndependent | null |
AlgebraicIndependent.repr_ker (hx : AlgebraicIndependent R x) :
RingHom.ker (hx.repr : adjoin R (range x) →+* MvPolynomial ι R) = ⊥ :=
(RingHom.injective_iff_ker_eq_bot _).1 (AlgEquiv.injective _) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.repr_ker | null |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin (hx : AlgebraicIndependent R x) :
MvPolynomial (Option ι) R ≃+* Polynomial (adjoin R (Set.range x)) :=
(MvPolynomial.optionEquivLeft _ _).toRingEquiv.trans
(Polynomial.mapEquiv hx.aevalEquiv.toRingEquiv)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin | The isomorphism between `MvPolynomial (Option ι) R` and the polynomial ring over
the algebra generated by an algebraically independent family. |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_apply
(hx : AlgebraicIndependent R x) (y) :
hx.mvPolynomialOptionEquivPolynomialAdjoin y =
Polynomial.map (hx.aevalEquiv : MvPolynomial ι R →+* adjoin R (range x))
(aeval (fun o : Option ι => o.elim Polynomial.X fun s : ι => Polynomial.C (X s)) y) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_apply | null |
@[simp]
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_C'
(hx : AlgebraicIndependent R x) (r) :
Polynomial.C (hx.aevalEquiv (C r)) = Polynomial.C (algebraMap _ _ r) := by
congr
apply_fun Subtype.val using Subtype.val_injective
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_C' | `simp`-normal form of `mvPolynomialOptionEquivPolynomialAdjoin_C` |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_C
(hx : AlgebraicIndependent R x) (r) :
hx.mvPolynomialOptionEquivPolynomialAdjoin (C r) = Polynomial.C (algebraMap _ _ r) := by
simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.Algebra.MvPolynomial.Supported",
"Mathlib.RingTheory.AlgebraicIndependent.Defs",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.MvPolynomial.Basic"
] | Mathlib/RingTheory/AlgebraicIndependent/Basic.lean | AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_C | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.