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 ⌀ |
|---|---|---|---|---|---|---|
card_rootSet_eq_natDegree [Algebra F K] {p : F[X]} (hsep : p.Separable)
(hsplit : Splits (algebraMap F K) p) : Fintype.card (p.rootSet K) = p.natDegree := by
classical
simp_rw [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe]
rw [Multiset.toFinset_card_of_nodup (nodup_roots hsep.map), ← natDegree_eq_card_roots hsplit] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | card_rootSet_eq_natDegree | null |
nodup_roots_iff_of_splits {f : F[X]} (hf : f ≠ 0) (h : f.Splits (RingHom.id F)) :
f.roots.Nodup ↔ f.Separable := by
classical
refine ⟨(fun hnsep ↦ ?_).mtr, nodup_roots⟩
rw [Separable, ← gcd_isUnit_iff, isUnit_iff_degree_eq_zero] at hnsep
obtain ⟨x, hx⟩ := exists_root_of_splits _
(splits_of_splits_of_dvd _ hf h (gcd_dvd_left f _)) hnsep
simp_rw [Multiset.nodup_iff_count_le_one, not_forall, not_le]
exact ⟨x, ((one_lt_rootMultiplicity_iff_isRoot_gcd hf).2 hx).trans_eq f.count_roots.symm⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | nodup_roots_iff_of_splits | If a non-zero polynomial splits, then it has no repeated roots on that field
if and only if it is separable. |
@[stacks 09H3 "Here we only require `f` splits instead of `K` is algebraically closed."]
nodup_aroots_iff_of_splits [Algebra F K] {f : F[X]} (hf : f ≠ 0)
(h : f.Splits (algebraMap F K)) : (f.aroots K).Nodup ↔ f.Separable := by
rw [← (algebraMap F K).id_comp, ← splits_map_iff] at h
rw [nodup_roots_iff_of_splits (map_ne_zero hf) h, separable_map] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | nodup_aroots_iff_of_splits | If a non-zero polynomial over `F` splits in `K`, then it has no repeated roots on `K`
if and only if it is separable. |
card_rootSet_eq_natDegree_iff_of_splits [Algebra F K] {f : F[X]} (hf : f ≠ 0)
(h : f.Splits (algebraMap F K)) : Fintype.card (f.rootSet K) = f.natDegree ↔ f.Separable := by
classical
simp_rw [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe, natDegree_eq_card_roots h,
Multiset.toFinset_card_eq_card_iff_nodup, nodup_aroots_iff_of_splits hf h]
variable {i : F →+* K} | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | card_rootSet_eq_natDegree_iff_of_splits | null |
eq_X_sub_C_of_separable_of_root_eq {x : F} {h : F[X]} (h_sep : h.Separable)
(h_root : h.eval x = 0) (h_splits : Splits i h) (h_roots : ∀ y ∈ (h.map i).roots, y = i x) :
h = C (leadingCoeff h) * (X - C x) := by
have h_ne_zero : h ≠ 0 := by
rintro rfl
exact not_separable_zero h_sep
apply Polynomial.eq_X_sub_C_of_splits_of_single_root i h_splits
apply Finset.mk.inj
· change _ = {i x}
rw [Finset.eq_singleton_iff_unique_mem]
constructor
· apply Finset.mem_mk.mpr
· rw [mem_roots (show h.map i ≠ 0 from map_ne_zero h_ne_zero)]
rw [IsRoot.def, ← eval₂_eq_eval_map, eval₂_hom, h_root]
exact RingHom.map_zero i
· exact nodup_roots (Separable.map h_sep)
· exact h_roots | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | eq_X_sub_C_of_separable_of_root_eq | null |
exists_finset_of_splits (i : F →+* K) {f : F[X]} (sep : Separable f) (sp : Splits i f) :
∃ s : Finset K, f.map i = C (i f.leadingCoeff) * s.prod fun a : K => X - C a := by
classical
obtain ⟨s, h⟩ := (splits_iff_exists_multiset _).1 sp
use s.toFinset
rw [h, Finset.prod_eq_multiset_prod, ← Multiset.toFinset_eq]
apply nodup_of_separable_prod
apply Separable.of_mul_right
rw [← h]
exact sep.map | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | exists_finset_of_splits | null |
_root_.Irreducible.separable [CharZero F] {f : F[X]} (hf : Irreducible f) :
f.Separable := by
rw [separable_iff_derivative_ne_zero hf, Ne, ← degree_eq_bot, degree_derivative_eq]
· rintro ⟨⟩
exact Irreducible.natDegree_pos hf | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | _root_.Irreducible.separable | null |
@[stacks 09H1 "second part"]
IsSeparable (x : K) : Prop := Polynomial.Separable (minpoly F x) | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable | An element `x` of an algebra `K` over a commutative ring `F` is said to be *separable*, if its
minimal polynomial over `K` is separable. Note that the minimal polynomial of any element not
integral over `F` is defined to be `0`, which is not a separable polynomial. |
@[mk_iff isSeparable_def, stacks 09H1 "third part"]
protected Algebra.IsSeparable : Prop where
isSeparable' : ∀ x : K, IsSeparable F x
variable {K} | class | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable | Typeclass for separable field extension: `K` is a separable field extension of `F` iff
the minimal polynomial of every `x : K` is separable. This implies that `K/F` is an algebraic
extension, because the minimal polynomial of a non-integral element is `0`, which is not
separable.
We define this for general (commutative) rings and only assume `F` and `K` are fields if this
is needed for a proof. |
Algebra.IsSeparable.isSeparable [Algebra.IsSeparable F K] : ∀ x : K, IsSeparable F x :=
Algebra.IsSeparable.isSeparable'
variable {F} in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable.isSeparable | null |
IsSeparable.isIntegral {x : K} (h : IsSeparable F x) : IsIntegral F x := by
cases subsingleton_or_nontrivial F
· haveI := Module.subsingleton F K
exact ⟨1, monic_one, Subsingleton.elim _ _⟩
· exact of_not_not (h.ne_zero <| minpoly.eq_zero ·) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.isIntegral | If the minimal polynomial of `x : K` over `F` is separable, then `x` is integral over `F`,
because the minimal polynomial of a non-integral element is `0`, which is not separable. |
Algebra.IsSeparable.isIntegral [Algebra.IsSeparable F K] : ∀ x : K, IsIntegral F x :=
fun x ↦ _root_.IsSeparable.isIntegral (Algebra.IsSeparable.isSeparable F x)
variable (K) in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable.isIntegral | null |
Algebra.IsSeparable.isAlgebraic [Nontrivial F] [Algebra.IsSeparable F K] :
Algebra.IsAlgebraic F K :=
⟨fun x ↦ (Algebra.IsSeparable.isIntegral F x).isAlgebraic⟩
variable {F} | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable.isAlgebraic | null |
Algebra.isSeparable_iff :
Algebra.IsSeparable F K ↔ ∀ x : K, IsIntegral F x ∧ IsSeparable F x :=
⟨fun _ x => ⟨Algebra.IsSeparable.isIntegral F x, Algebra.IsSeparable.isSeparable F x⟩,
fun h => ⟨fun x => (h x).2⟩⟩
variable {L} in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.isSeparable_iff | null |
IsSeparable.map [Ring L] [Algebra F L] {x : K} (f : K →ₐ[F] L) (hf : Function.Injective f)
(H : IsSeparable F x) : IsSeparable F (f x) := by
rwa [IsSeparable, minpoly.algHom_eq _ hf]
variable {E : Type*} | lemma | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.map | null |
AlgEquiv.isSeparable_iff {x : K} : IsSeparable F (e x) ↔ IsSeparable F x := by
simp only [IsSeparable, minpoly.algEquiv_eq e x] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | AlgEquiv.isSeparable_iff | Transfer `IsSeparable` across an `AlgEquiv`. |
AlgEquiv.Algebra.isSeparable [Algebra.IsSeparable F K] : Algebra.IsSeparable F E :=
⟨fun _ ↦ e.symm.isSeparable_iff.mp (Algebra.IsSeparable.isSeparable _ _)⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | AlgEquiv.Algebra.isSeparable | Transfer `Algebra.IsSeparable` across an `AlgEquiv`. |
AlgEquiv.Algebra.isSeparable_iff : Algebra.IsSeparable F K ↔ Algebra.IsSeparable F E :=
⟨fun _ ↦ AlgEquiv.Algebra.isSeparable e, fun _ ↦ AlgEquiv.Algebra.isSeparable e.symm⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | AlgEquiv.Algebra.isSeparable_iff | null |
@[stacks 09H2 "first part"]
IsSeparable.tower_top
{x : E} (h : IsSeparable F x) : IsSeparable L x :=
.of_dvd (.map h) (minpoly.dvd_map_of_isScalarTower ..)
variable (F E) in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.tower_top | If `E / L / F` is a scalar tower and `x : E` is separable over `F`, then it's also separable
over `L`. |
@[stacks 09H2 "second part"]
Algebra.isSeparable_tower_top_of_isSeparable [Algebra.IsSeparable F E] :
Algebra.IsSeparable L E :=
⟨fun x ↦ IsSeparable.tower_top _ (Algebra.IsSeparable.isSeparable F x)⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.isSeparable_tower_top_of_isSeparable | If `E / K / F` is an extension tower, `E` is separable over `F`, then it's also separable
over `K`. |
isSeparable_algebraMap (x : F) : IsSeparable F (algebraMap F K x) :=
Polynomial.Separable.of_dvd (Polynomial.separable_X_sub_C (x := x))
(minpoly.dvd F (algebraMap F K x) (by simp only [map_sub, aeval_X, aeval_C, sub_self])) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | isSeparable_algebraMap | null |
Algebra.isSeparable_self : Algebra.IsSeparable F F :=
⟨isSeparable_algebraMap⟩
variable [IsDomain K] [Algebra.IsIntegral F K] [CharZero F] | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.isSeparable_self | null |
IsSeparable.of_integral (x : K) : IsSeparable F x :=
(minpoly.irreducible <| Algebra.IsIntegral.isIntegral x).separable
variable (K) in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.of_integral | null |
IsSeparable.tower_bot {x : K} (h : IsSeparable F (algebraMap K E x)) : IsSeparable F x :=
have ⟨_q, hq⟩ :=
minpoly.dvd F x
((aeval_algebraMap_eq_zero_iff _ _ _).mp (minpoly.aeval F ((algebraMap K E) x)))
(Eq.mp (congrArg Separable hq) h).of_mul_left
variable (K E) in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.tower_bot | A integral field extension in characteristic 0 is separable. -/
protected instance (priority := 100) Algebra.IsSeparable.of_integral : Algebra.IsSeparable F K :=
⟨_root_.IsSeparable.of_integral _⟩
end IsIntegral
section IsScalarTower
variable [Field K] [Ring E] [Algebra F K] [Algebra F E] [Algebra K E]
[Nontrivial E] [IsScalarTower F K E]
variable {F} in
/-- If `E / K / F` is a scalar tower and `algebraMap K E x` is separable over `F`, then `x` is
also separable over `F`. |
Algebra.isSeparable_tower_bot_of_isSeparable [h : Algebra.IsSeparable F E] :
Algebra.IsSeparable F K :=
⟨fun _ ↦ IsSeparable.tower_bot (h.isSeparable _ _)⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.isSeparable_tower_bot_of_isSeparable | null |
IsSeparable.of_algHom {x : E} (h : IsSeparable F (f x)) : IsSeparable F x := by
let _ : Algebra E E' := RingHom.toAlgebra f.toRingHom
haveI : IsScalarTower F E E' := IsScalarTower.of_algebraMap_eq fun x => (f.commutes x).symm
exact h.tower_bot
variable (E') in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.of_algHom | null |
Algebra.IsSeparable.of_algHom [Algebra.IsSeparable F E'] : Algebra.IsSeparable F E :=
⟨fun x => (Algebra.IsSeparable.isSeparable F (f x)).of_algHom⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable.of_algHom | null |
isSeparable_tower_bot [Algebra.IsSeparable F K] : Algebra.IsSeparable F M :=
Algebra.isSeparable_tower_bot_of_isSeparable F M K | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | isSeparable_tower_bot | null |
isSeparable_tower_top [Algebra.IsSeparable F K] : Algebra.IsSeparable M K :=
Algebra.isSeparable_tower_top_of_isSeparable F M K | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | isSeparable_tower_top | null |
IsSeparable.of_equiv_equiv {x : B₁} (h : IsSeparable A₁ x) : IsSeparable A₂ (e₂ x) :=
letI := e₁.toRingHom.toAlgebra
letI : Algebra A₂ B₁ :=
{ (algebraMap A₁ B₁).comp e₁.symm.toRingHom with
algebraMap := (algebraMap A₁ B₁).comp e₁.symm.toRingHom
smul := fun a b ↦ ((algebraMap A₁ B₁).comp e₁.symm.toRingHom a) * b
commutes' := fun r x ↦ (Algebra.commutes) (e₁.symm.toRingHom r) x
smul_def' := fun _ _ ↦ rfl }
haveI : IsScalarTower A₁ A₂ B₁ := IsScalarTower.of_algebraMap_eq <| fun x ↦
(algebraMap A₁ B₁).congr_arg <| id ((e₁.symm_apply_apply x).symm)
let e : B₁ ≃ₐ[A₂] B₂ :=
{ e₂ with
commutes' := fun x ↦ by
simpa [RingHom.algebraMap_toAlgebra] using DFunLike.congr_fun he.symm (e₁.symm x) }
(AlgEquiv.isSeparable_iff e).mpr <| IsSeparable.tower_top A₂ h | lemma | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | IsSeparable.of_equiv_equiv | null |
Algebra.IsSeparable.of_equiv_equiv [Algebra.IsSeparable A₁ B₁] : Algebra.IsSeparable A₂ B₂ :=
⟨fun x ↦ (e₂.apply_symm_apply x) ▸ _root_.IsSeparable.of_equiv_equiv e₁ e₂ he
(Algebra.IsSeparable.isSeparable _ _)⟩ | lemma | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Algebra.IsSeparable.of_equiv_equiv | null |
AlgHom.natCard_of_powerBasis (pb : PowerBasis K S) (h_sep : IsSeparable K pb.gen)
(h_splits : (minpoly K pb.gen).Splits (algebraMap K L)) :
Nat.card (S →ₐ[K] L) = pb.dim := by
classical
rw [Nat.card_congr pb.liftEquiv', Nat.subtype_card _ (fun x => Multiset.mem_toFinset),
← pb.natDegree_minpoly, natDegree_eq_card_roots h_splits, Multiset.toFinset_card_of_nodup]
exact nodup_roots ((separable_map (algebraMap K L)).mpr h_sep) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | AlgHom.natCard_of_powerBasis | null |
AlgHom.card_of_powerBasis (pb : PowerBasis K S) (h_sep : IsSeparable K pb.gen)
(h_splits : (minpoly K pb.gen).Splits (algebraMap K L)) :
@Fintype.card (S →ₐ[K] L) (PowerBasis.AlgHom.fintype pb) = pb.dim := by
classical
rw [Fintype.card_eq_nat_card, AlgHom.natCard_of_powerBasis pb h_sep h_splits] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | AlgHom.card_of_powerBasis | null |
@[stacks 09HC]
separableClosure : IntermediateField F E where
carrier := {x | IsSeparable F x}
mul_mem' := isSeparable_mul
add_mem' := isSeparable_add
algebraMap_mem' := isSeparable_algebraMap E
inv_mem' _ := isSeparable_inv
variable {F E K} | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure | The (relative) separable closure of `F` in `E`, or called maximal separable subextension
of `E / F`, is defined to be the intermediate field of `E / F` consisting of all separable
elements. The previous results prove that these elements are closed under field operations. |
mem_separableClosure_iff {x : E} :
x ∈ separableClosure F E ↔ IsSeparable F x := Iff.rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | mem_separableClosure_iff | An element is contained in the separable closure of `F` in `E` if and only if
it is a separable element. |
map_mem_separableClosure_iff (i : E →ₐ[F] K) {x : E} :
i x ∈ separableClosure F K ↔ x ∈ separableClosure F E := by
simp_rw [mem_separableClosure_iff, IsSeparable, minpoly.algHom_eq i i.injective] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | map_mem_separableClosure_iff | If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`separableClosure F K` if and only if `x` is contained in `separableClosure F E`. |
separableClosure.comap_eq_of_algHom (i : E →ₐ[F] K) :
(separableClosure F K).comap i = separableClosure F E := by
ext x
exact map_mem_separableClosure_iff i | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.comap_eq_of_algHom | If `i` is an `F`-algebra homomorphism from `E` to `K`, then the preimage of
`separableClosure F K` under the map `i` is equal to `separableClosure F E`. |
separableClosure.map_le_of_algHom (i : E →ₐ[F] K) :
(separableClosure F E).map i ≤ separableClosure F K :=
map_le_iff_le_comap.2 (comap_eq_of_algHom i).ge
variable (F) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.map_le_of_algHom | If `i` is an `F`-algebra homomorphism from `E` to `K`, then the image of `separableClosure F E`
under the map `i` is contained in `separableClosure F K`. |
separableClosure.map_eq_of_separableClosure_eq_bot [Algebra E K] [IsScalarTower F E K]
(h : separableClosure E K = ⊥) :
(separableClosure F E).map (IsScalarTower.toAlgHom F E K) = separableClosure F K := by
refine le_antisymm (map_le_of_algHom _) (fun x hx ↦ ?_)
obtain ⟨y, rfl⟩ := mem_bot.1 <| h ▸ mem_separableClosure_iff.2
(IsSeparable.tower_top E <| mem_separableClosure_iff.1 hx)
exact ⟨y, (map_mem_separableClosure_iff <| IsScalarTower.toAlgHom F E K).mp hx, rfl⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.map_eq_of_separableClosure_eq_bot | If `K / E / F` is a field extension tower, such that `K / E` has no non-trivial separable
subextensions (when `K / E` is algebraic, this means that it is purely inseparable),
then the image of `separableClosure F E` in `K` is equal to `separableClosure F K`. |
separableClosure.map_eq_of_algEquiv (i : E ≃ₐ[F] K) :
(separableClosure F E).map i = separableClosure F K :=
(map_le_of_algHom i.toAlgHom).antisymm
(fun x h ↦ ⟨_, (map_mem_separableClosure_iff i.symm).2 h, by simp⟩) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.map_eq_of_algEquiv | If `i` is an `F`-algebra isomorphism of `E` and `K`, then the image of `separableClosure F E`
under the map `i` is equal to `separableClosure F K`. |
separableClosure.algEquivOfAlgEquiv (i : E ≃ₐ[F] K) :
separableClosure F E ≃ₐ[F] separableClosure F K :=
(intermediateFieldMap i _).trans (equivOfEq (map_eq_of_algEquiv i))
alias AlgEquiv.separableClosure := separableClosure.algEquivOfAlgEquiv
variable (F E K) | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.algEquivOfAlgEquiv | If `E` and `K` are isomorphic as `F`-algebras, then `separableClosure F E` and
`separableClosure F K` are also isomorphic as `F`-algebras. |
separableClosure.isAlgebraic : Algebra.IsAlgebraic F (separableClosure F E) :=
⟨fun x ↦ isAlgebraic_iff.2 (IsSeparable.isIntegral x.2).isAlgebraic⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.isAlgebraic | The separable closure of `F` in `E` is algebraic over `F`. |
@[stacks 030K "$E_{sep}/F$ is separable"]
separableClosure.isSeparable : Algebra.IsSeparable F (separableClosure F E) :=
⟨fun x ↦ by simpa only [IsSeparable, minpoly_eq] using x.2⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.isSeparable | The separable closure of `F` in `E` is separable over `F`. |
le_separableClosure' {L : IntermediateField F E} (hs : ∀ x : L, IsSeparable F x) :
L ≤ separableClosure F E := fun x h ↦ by simpa only [IsSeparable, minpoly_eq] using hs ⟨x, h⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | le_separableClosure' | An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if all of its elements are separable over `F`. |
le_separableClosure (L : IntermediateField F E) [Algebra.IsSeparable F L] :
L ≤ separableClosure F E := le_separableClosure' F E (Algebra.IsSeparable.isSeparable F) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | le_separableClosure | An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if it is separable over `F`. |
le_separableClosure_iff (L : IntermediateField F E) :
L ≤ separableClosure F E ↔ Algebra.IsSeparable F L :=
⟨fun h ↦ ⟨fun x ↦ by simpa only [IsSeparable, minpoly_eq] using h x.2⟩,
fun _ ↦ le_separableClosure _ _ _⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | le_separableClosure_iff | An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if and only if it is separable over `F`. |
separableClosure.separableClosure_eq_bot :
separableClosure (separableClosure F E) E = ⊥ :=
bot_unique fun x hx ↦ mem_bot.2
⟨⟨x, IsSeparable.of_algebra_isSeparable_of_isSeparable F (mem_separableClosure_iff.1 hx)⟩, rfl⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.separableClosure_eq_bot | The separable closure in `E` of the separable closure of `F` in `E` is equal to itself. |
separableClosure.normalClosure_eq_self :
normalClosure F (separableClosure F E) E = separableClosure F E :=
le_antisymm (normalClosure_le_iff.2 fun i ↦
have : Algebra.IsSeparable F i.fieldRange :=
(AlgEquiv.Algebra.isSeparable (AlgEquiv.ofInjectiveField i))
le_separableClosure F E _) (le_normalClosure _) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.normalClosure_eq_self | The normal closure in `E/F` of the separable closure of `F` in `E` is equal to itself. |
@[stacks 0EXK]
separableClosure.isGalois [Normal F E] : IsGalois F (separableClosure F E) where
to_isSeparable := separableClosure.isSeparable F E
to_normal := by
rw [← separableClosure.normalClosure_eq_self]
exact normalClosure.normal F _ E | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.isGalois | If `E` is normal over `F`, then the separable closure of `F` in `E` is Galois (i.e.
normal and separable) over `F`. |
IsSepClosed.separableClosure_eq_bot_iff [IsSepClosed E] :
separableClosure F E = ⊥ ↔ IsSepClosed F := by
refine ⟨fun h ↦ IsSepClosed.of_exists_root _ fun p _ hirr hsep ↦ ?_,
fun _ ↦ IntermediateField.eq_bot_of_isSepClosed_of_isSeparable _⟩
obtain ⟨x, hx⟩ := IsSepClosed.exists_aeval_eq_zero E p (degree_pos_of_irreducible hirr).ne' hsep
obtain ⟨x, rfl⟩ := h ▸ mem_separableClosure_iff.2 (hsep.of_dvd <| minpoly.dvd _ x hx)
exact ⟨x, by simpa [Algebra.ofId_apply] using hx⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | IsSepClosed.separableClosure_eq_bot_iff | If `E / F` is a field extension and `E` is separably closed, then the separable closure
of `F` in `E` is equal to `F` if and only if `F` is separably closed. |
separableClosure.isSepClosure [IsSepClosed E] : IsSepClosure F (separableClosure F E) :=
⟨(IsSepClosed.separableClosure_eq_bot_iff _ E).mp (separableClosure.separableClosure_eq_bot F E),
isSeparable F E⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.isSepClosure | If `E` is separably closed, then the separable closure of `F` in `E` is an absolute
separable closure of `F`. |
SeparableClosure : Type _ := separableClosure F (AlgebraicClosure F) | abbrev | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | SeparableClosure | The absolute separable closure is defined to be the relative separable closure inside the
algebraic closure. It is indeed a separable closure (`IsSepClosure`) by
`separableClosure.isSepClosure`, and it is Galois (`IsGalois`) by `separableClosure.isGalois`
or `IsSepClosure.isGalois`, and every separable extension embeds into it (`IsSepClosed.lift`). |
SeparableClosure.isSepClosed : IsSepClosed (SeparableClosure F) :=
(inferInstanceAs (IsSepClosure F (SeparableClosure F))).sep_closed | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | SeparableClosure.isSepClosed | null |
IntermediateField.isSeparable_adjoin_iff_isSeparable {S : Set E} :
Algebra.IsSeparable F (adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x :=
(le_separableClosure_iff F E _).symm.trans adjoin_le_iff | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | IntermediateField.isSeparable_adjoin_iff_isSeparable | `F(S) / F` is a separable extension if and only if all elements of `S` are
separable elements. |
separableClosure.eq_top_iff : separableClosure F E = ⊤ ↔ Algebra.IsSeparable F E :=
⟨fun h ↦ ⟨fun _ ↦ mem_separableClosure_iff.1 (h ▸ mem_top)⟩,
fun _ ↦ top_unique fun x _ ↦ mem_separableClosure_iff.2 (Algebra.IsSeparable.isSeparable _ x)⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.eq_top_iff | The separable closure of `F` in `E` is equal to `E` if and only if `E / F` is
separable. |
separableClosure.le_restrictScalars [Algebra E K] [IsScalarTower F E K] :
separableClosure F K ≤ (separableClosure E K).restrictScalars F :=
fun _ ↦ IsSeparable.tower_top E | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.le_restrictScalars | If `K / E / F` is a field extension tower, then `separableClosure F K` is contained in
`separableClosure E K`. |
separableClosure.eq_restrictScalars_of_isSeparable [Algebra E K] [IsScalarTower F E K]
[Algebra.IsSeparable F E] : separableClosure F K = (separableClosure E K).restrictScalars F :=
(separableClosure.le_restrictScalars F E K).antisymm fun _ h ↦
IsSeparable.of_algebra_isSeparable_of_isSeparable F h | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.eq_restrictScalars_of_isSeparable | If `K / E / F` is a field extension tower, such that `E / F` is separable, then
`separableClosure F K` is equal to `separableClosure E K`. |
separableClosure.adjoin_le [Algebra E K] [IsScalarTower F E K] :
adjoin E (separableClosure F K) ≤ separableClosure E K :=
adjoin_le_iff.2 <| le_restrictScalars F E K | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | separableClosure.adjoin_le | If `K / E / F` is a field extension tower, then `E` adjoin `separableClosure F K` is contained
in `separableClosure E K`. |
IntermediateField.isSeparable_sup (L1 L2 : IntermediateField F E)
[h1 : Algebra.IsSeparable F L1] [h2 : Algebra.IsSeparable F L2] :
Algebra.IsSeparable F (L1 ⊔ L2 : IntermediateField F E) := by
rw [← le_separableClosure_iff] at h1 h2 ⊢
exact sup_le h1 h2 | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | IntermediateField.isSeparable_sup | A compositum of two separable extensions is separable. |
IntermediateField.isSeparable_iSup {ι : Type*} {t : ι → IntermediateField F E}
[h : ∀ i, Algebra.IsSeparable F (t i)] :
Algebra.IsSeparable F (⨆ i, t i : IntermediateField F E) := by
simp_rw [← le_separableClosure_iff] at h ⊢
exact iSup_le h | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | IntermediateField.isSeparable_iSup | A compositum of separable extensions is separable. |
@[stacks 030L "Part 1"]
sepDegree := Module.rank F (separableClosure F E) | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree | The (infinite) separable degree for a general field extension `E / F` is defined
to be the degree of `separableClosure F E / F`. |
@[stacks 030L "Part 2"]
insepDegree := Module.rank (separableClosure F E) E | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree | The (infinite) inseparable degree for a general field extension `E / F` is defined
to be the degree of `E / separableClosure F E`. |
finInsepDegree : ℕ := finrank (separableClosure F E) E | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree | The finite inseparable degree for a general field extension `E / F` is defined
to be the degree of `E / separableClosure F E` as a natural number. It is defined to be zero
if such field extension is infinite. |
finInsepDegree_def' : finInsepDegree F E = Cardinal.toNat (insepDegree F E) := rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_def' | null |
instNeZeroSepDegree : NeZero (sepDegree F E) := ⟨rank_pos.ne'⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | instNeZeroSepDegree | null |
instNeZeroInsepDegree : NeZero (insepDegree F E) := ⟨rank_pos.ne'⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | instNeZeroInsepDegree | null |
instNeZeroFinInsepDegree [FiniteDimensional F E] :
NeZero (finInsepDegree F E) := ⟨finrank_pos.ne'⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | instNeZeroFinInsepDegree | null |
lift_sepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
Cardinal.lift.{w} (sepDegree F E) = Cardinal.lift.{v} (sepDegree F K) :=
i.separableClosure.toLinearEquiv.lift_rank_eq | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | lift_sepDegree_eq_of_equiv | If `E` and `K` are isomorphic as `F`-algebras, then they have the same
separable degree over `F`. |
sepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
sepDegree F E = sepDegree F K :=
i.separableClosure.toLinearEquiv.rank_eq | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_eq_of_equiv | The same-universe version of `Field.lift_sepDegree_eq_of_equiv`. |
sepDegree_mul_insepDegree : sepDegree F E * insepDegree F E = Module.rank F E :=
rank_mul_rank F (separableClosure F E) E | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_mul_insepDegree | The separable degree multiplied by the inseparable degree is equal
to the (infinite) field extension degree. |
sepDegree_le_rank : sepDegree F E ≤ Module.rank F E :=
Module.rank_bot_le_rank_of_isScalarTower _ _ _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_le_rank | null |
insepDegree_le_rank : insepDegree F E ≤ Module.rank F E :=
Module.rank_top_le_rank_of_isScalarTower _ _ _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_le_rank | null |
lift_insepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
Cardinal.lift.{w} (insepDegree F E) = Cardinal.lift.{v} (insepDegree F K) :=
Algebra.lift_rank_eq_of_equiv_equiv i.separableClosure i rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | lift_insepDegree_eq_of_equiv | If `E` and `K` are isomorphic as `F`-algebras, then they have the same
inseparable degree over `F`. |
insepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
insepDegree F E = insepDegree F K :=
Algebra.rank_eq_of_equiv_equiv i.separableClosure i rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_eq_of_equiv | The same-universe version of `Field.lift_insepDegree_eq_of_equiv`. |
finInsepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
finInsepDegree F E = finInsepDegree F K := by
simpa only [Cardinal.toNat_lift] using congr_arg Cardinal.toNat
(lift_insepDegree_eq_of_equiv F E K i)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_eq_of_equiv | If `E` and `K` are isomorphic as `F`-algebras, then they have the same finite
inseparable degree over `F`. |
sepDegree_self : sepDegree F F = 1 := by
rw [sepDegree, Subsingleton.elim (separableClosure F F) ⊥, IntermediateField.rank_bot]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_self | null |
insepDegree_self : insepDegree F F = 1 := by
rw [insepDegree, Subsingleton.elim (separableClosure F F) ⊤, IntermediateField.rank_top]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_self | null |
finInsepDegree_self : finInsepDegree F F = 1 := by
rw [finInsepDegree_def', insepDegree_self, Cardinal.one_toNat] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_self | null |
@[simp]
sepDegree_bot : sepDegree F (⊥ : IntermediateField F E) = 1 := by
have := lift_sepDegree_eq_of_equiv _ _ _ (botEquiv F E)
rwa [sepDegree_self, Cardinal.lift_one, ← Cardinal.lift_one.{v, u}, Cardinal.lift_inj] at this
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_bot | null |
insepDegree_bot : insepDegree F (⊥ : IntermediateField F E) = 1 := by
have := lift_insepDegree_eq_of_equiv _ _ _ (botEquiv F E)
rwa [insepDegree_self, Cardinal.lift_one, ← Cardinal.lift_one.{v, u}, Cardinal.lift_inj] at this
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_bot | null |
finInsepDegree_bot : finInsepDegree F (⊥ : IntermediateField F E) = 1 := by
rw [finInsepDegree_eq_of_equiv _ _ _ (botEquiv F E), finInsepDegree_self] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_bot | null |
lift_sepDegree_bot' : Cardinal.lift.{v} (sepDegree F (⊥ : IntermediateField E K)) =
Cardinal.lift.{w} (sepDegree F E) :=
lift_sepDegree_eq_of_equiv _ _ _ ((botEquiv E K).restrictScalars F) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | lift_sepDegree_bot' | null |
lift_insepDegree_bot' : Cardinal.lift.{v} (insepDegree F (⊥ : IntermediateField E K)) =
Cardinal.lift.{w} (insepDegree F E) :=
lift_insepDegree_eq_of_equiv _ _ _ ((botEquiv E K).restrictScalars F)
variable {F}
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | lift_insepDegree_bot' | null |
finInsepDegree_bot' :
finInsepDegree F (⊥ : IntermediateField E K) = finInsepDegree F E := by
simpa only [Cardinal.toNat_lift] using congr_arg Cardinal.toNat (lift_insepDegree_bot' F E K)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_bot' | null |
sepDegree_top : sepDegree F (⊤ : IntermediateField E K) = sepDegree F K :=
sepDegree_eq_of_equiv _ _ _ ((topEquiv (F := E) (E := K)).restrictScalars F)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_top | null |
insepDegree_top : insepDegree F (⊤ : IntermediateField E K) = insepDegree F K :=
insepDegree_eq_of_equiv _ _ _ ((topEquiv (F := E) (E := K)).restrictScalars F)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_top | null |
finInsepDegree_top : finInsepDegree F (⊤ : IntermediateField E K) = finInsepDegree F K := by
rw [finInsepDegree_def', insepDegree_top, ← finInsepDegree_def']
variable (K : Type v) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_top | null |
sepDegree_bot' : sepDegree F (⊥ : IntermediateField E K) = sepDegree F E :=
sepDegree_eq_of_equiv _ _ _ ((botEquiv E K).restrictScalars F)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | sepDegree_bot' | null |
insepDegree_bot' : insepDegree F (⊥ : IntermediateField E K) = insepDegree F E :=
insepDegree_eq_of_equiv _ _ _ ((botEquiv E K).restrictScalars F)
variable (F) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | insepDegree_bot' | null |
_root_.Field.insepDegree_top_le_insepDegree_of_isScalarTower :
insepDegree E K ≤ insepDegree F K := by
letI := (IntermediateField.inclusion (separableClosure.le_restrictScalars F E K)).toAlgebra
have : IsScalarTower (separableClosure F K) ((separableClosure E K).restrictScalars F) K :=
.of_algebraMap_eq' rfl
exact Module.rank_top_le_rank_of_isScalarTower
(separableClosure F K) ((separableClosure E K).restrictScalars F) K
variable {K} in | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | _root_.Field.insepDegree_top_le_insepDegree_of_isScalarTower | null |
_root_.Field.insepDegree_le_of_left_le {E₁ E₂ : IntermediateField F K} (H : E₁ ≤ E₂) :
insepDegree E₂ K ≤ insepDegree E₁ K := by
letI := (IntermediateField.inclusion H).toAlgebra
have : IsScalarTower E₁ E₂ K := .of_algebraMap_eq' rfl
exact insepDegree_top_le_insepDegree_of_isScalarTower _ _ _
variable (F) in | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | _root_.Field.insepDegree_le_of_left_le | null |
_root_.Field.finInsepDegree_top_le_finInsepDegree_of_isScalarTower [Module.Finite F K] :
finInsepDegree E K ≤ finInsepDegree F K := by
letI := (IntermediateField.inclusion (separableClosure.le_restrictScalars F E K)).toAlgebra
have : IsScalarTower (separableClosure F K) ((separableClosure E K).restrictScalars F) K :=
.of_algebraMap_eq' rfl
exact Module.finrank_top_le_finrank_of_isScalarTower
(separableClosure F K) ((separableClosure E K).restrictScalars F) K
variable {K} in | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | _root_.Field.finInsepDegree_top_le_finInsepDegree_of_isScalarTower | null |
finInsepDegree_le_of_left_le {E₁ E₂ : IntermediateField F K} (H : E₁ ≤ E₂)
[Module.Finite E₁ K] : finInsepDegree E₂ K ≤ finInsepDegree E₁ K := by
letI := (IntermediateField.inclusion H).toAlgebra
have : IsScalarTower E₁ E₂ K := .of_algebraMap_eq' rfl
exact finInsepDegree_top_le_finInsepDegree_of_isScalarTower _ _ _ | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | finInsepDegree_le_of_left_le | null |
Algebra.IsSeparable.sepDegree_eq [Algebra.IsSeparable F E] :
sepDegree F E = Module.rank F E := by
rw [sepDegree, (separableClosure.eq_top_iff F E).2 ‹_›, IntermediateField.rank_top'] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | Algebra.IsSeparable.sepDegree_eq | A separable extension has separable degree equal to degree. |
Algebra.IsSeparable.insepDegree_eq [Algebra.IsSeparable F E] : insepDegree F E = 1 := by
rw [insepDegree, (separableClosure.eq_top_iff F E).2 ‹_›, IntermediateField.rank_top] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | Algebra.IsSeparable.insepDegree_eq | A separable extension has inseparable degree one. |
Algebra.IsSeparable.finInsepDegree_eq [Algebra.IsSeparable F E] : finInsepDegree F E = 1 :=
Cardinal.one_toNat ▸ congr(Cardinal.toNat $(insepDegree_eq F E)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableDegree",
"Mathlib.FieldTheory.IsSepClosed"
] | Mathlib/FieldTheory/SeparableClosure.lean | Algebra.IsSeparable.finInsepDegree_eq | A separable extension has finite inseparable degree one. |
Emb := E →ₐ[F] AlgebraicClosure E | abbrev | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | Emb | `Field.Emb F E` is the type of `F`-algebra homomorphisms from `E` to the algebraic closure
of `E`. |
finSepDegree : ℕ := Nat.card (Emb F E) | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree | If `E / F` is an algebraic extension, then the (finite) separable degree of `E / F`
is the number of `F`-algebra homomorphisms from `E` to the algebraic closure of `E`,
as a natural number. It is defined to be zero if there are infinitely many of them.
Note that if `E / F` is not algebraic, then this definition makes no mathematical sense. |
instInhabitedEmb : Inhabited (Emb F E) := ⟨IsScalarTower.toAlgHom F E _⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | instInhabitedEmb | null |
instNeZeroFinSepDegree [FiniteDimensional F E] : NeZero (finSepDegree F E) :=
⟨Nat.card_ne_zero.2 ⟨inferInstance, Fintype.finite <| minpoly.AlgHom.fintype _ _ _⟩⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | instNeZeroFinSepDegree | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.