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 ⌀ |
|---|---|---|---|---|---|---|
finrank_algHom (K : Type u) (V : Type v) [Field K] [Field V] [Algebra K V]
[FiniteDimensional K V] : Fintype.card (V →ₐ[K] V) ≤ finrank V (V →ₗ[K] V) :=
(linearIndependent_toLinearMap K V V).fintype_card_le_finrank | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | finrank_algHom | null |
AlgHom.card_le {F K : Type*} [Field F] [Field K] [Algebra F K] [FiniteDimensional F K] :
Fintype.card (K →ₐ[F] K) ≤ Module.finrank F K :=
Module.finrank_linearMap_self F K K ▸ finrank_algHom F K | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | AlgHom.card_le | null |
AlgEquiv.card_le {F K : Type*} [Field F] [Field K] [Algebra F K] [FiniteDimensional F K] :
Fintype.card (K ≃ₐ[F] K) ≤ Module.finrank F K :=
Fintype.ofEquiv_card (algEquivEquivAlgHom F K).toEquiv.symm ▸ AlgHom.card_le | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | AlgEquiv.card_le | null |
@[stacks 09I3 "second part"]
finrank_eq_card [Fintype G] [FaithfulSMul G F] :
finrank (FixedPoints.subfield G F) F = Fintype.card G :=
le_antisymm (FixedPoints.finrank_le_card G F) <|
calc
Fintype.card G ≤ Fintype.card (F →ₐ[FixedPoints.subfield G F] F) :=
Fintype.card_le_of_injective _ (MulSemiringAction.toAlgHom_injective _ F)
_ ≤ finrank F (F →ₗ[FixedPoints.subfield G F] F) := finrank_algHom (subfield G F) F
_ = finrank (FixedPoints.subfield G F) F := finrank_linearMap_self _ _ _ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | finrank_eq_card | Let $F$ be a field. Let $G$ be a finite group acting faithfully on $F$.
Then $[F : F^G] = |G|$. |
toAlgHom_bijective [Finite G] [FaithfulSMul G F] :
Function.Bijective (MulSemiringAction.toAlgHom _ _ : G → F →ₐ[subfield G F] F) := by
cases nonempty_fintype G
rw [Fintype.bijective_iff_injective_and_card]
constructor
· exact MulSemiringAction.toAlgHom_injective _ F
· apply le_antisymm
· exact Fintype.card_le_of_injective _ (MulSemiringAction.toAlgHom_injective _ F)
· rw [← finrank_eq_card G F]
exact LE.le.trans_eq (finrank_algHom _ F) (finrank_linearMap_self _ _ _) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | toAlgHom_bijective | `MulSemiringAction.toAlgHom` is bijective. |
toAlgHomEquiv [Finite G] [FaithfulSMul G F] : G ≃ (F →ₐ[FixedPoints.subfield G F] F) :=
Equiv.ofBijective _ (toAlgHom_bijective G F) | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | toAlgHomEquiv | Bijection between `G` and algebra endomorphisms of `F` that fix the fixed points. |
toAlgAut_bijective [Finite G] [FaithfulSMul G F] :
Function.Bijective (MulSemiringAction.toAlgAut G (FixedPoints.subfield G F) F) := by
refine ⟨fun _ _ h ↦ (FixedPoints.toAlgHom_bijective G F).injective ?_,
fun f ↦ ((FixedPoints.toAlgHom_bijective G F).surjective f).imp (fun _ h ↦ ?_)⟩ <;>
rwa [DFunLike.ext_iff] at h ⊢ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | toAlgAut_bijective | `MulSemiringAction.toAlgAut` is bijective. |
toAlgAutMulEquiv [Finite G] [FaithfulSMul G F] : G ≃* (F ≃ₐ[FixedPoints.subfield G F] F) :=
MulEquiv.ofBijective _ (toAlgAut_bijective G F) | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | toAlgAutMulEquiv | Bijection between `G` and algebra automorphisms of `F` that fix the fixed points. |
toAlgAut_surjective [Finite G] :
Function.Surjective (MulSemiringAction.toAlgAut G (FixedPoints.subfield G F) F) := by
let f : G →* F ≃ₐ[FixedPoints.subfield G F] F :=
MulSemiringAction.toAlgAut G (FixedPoints.subfield G F) F
let Q := G ⧸ f.ker
let _ : MulSemiringAction Q F := MulSemiringAction.compHom _ (QuotientGroup.kerLift f)
have : FaithfulSMul Q F := ⟨by
intro q₁ q₂
refine Quotient.inductionOn₂' q₁ q₂ (fun g₁ g₂ h ↦ QuotientGroup.eq.mpr ?_)
rwa [MonoidHom.mem_ker, map_mul, map_inv, inv_mul_eq_one, AlgEquiv.ext_iff]⟩
intro f
obtain ⟨q, hq⟩ := (toAlgAut_bijective Q F).surjective
(AlgEquiv.ofRingEquiv (f := f) (fun ⟨x, hx⟩ ↦ f.commutes' ⟨x, fun g ↦ hx g⟩))
revert hq
refine QuotientGroup.induction_on q (fun g hg ↦ ⟨g, ?_⟩)
rwa [AlgEquiv.ext_iff] at hg ⊢ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | toAlgAut_surjective | `MulSemiringAction.toAlgAut` is surjective. |
nonempty_algHom_of_exist_roots (h : ∀ x : E, ∃ y : K, aeval y (minpoly F x) = 0) :
Nonempty (E →ₐ[F] K) := by
refine Lifts.nonempty_algHom_of_exist_lifts_finset fun S ↦ ⟨⟨adjoin F S, ?_⟩, subset_adjoin _ _⟩
let p := (S.prod <| minpoly F).map (algebraMap F K)
let K' := SplittingField p
have splits s (hs : s ∈ S) : (minpoly F s).Splits (algebraMap F K') := by
apply splits_of_splits_of_dvd _
(Finset.prod_ne_zero_iff.mpr fun _ _ ↦ minpoly.ne_zero <| (alg.isIntegral).1 _)
((splits_map_iff _ _).mp <| SplittingField.splits p) (Finset.dvd_prod_of_mem _ hs)
let K₀ := (⊥ : IntermediateField K K').restrictScalars F
let FS := adjoin F (S : Set E)
let Ω := FS →ₐ[F] K'
have := finiteDimensional_adjoin (S := (S : Set E)) fun _ _ ↦ (alg.isIntegral).1 _
let M (ω : Ω) := Subalgebra.toSubmodule (K₀.comap ω).toSubalgebra
have : ⋃ ω : Ω, (M ω : Set FS) = Set.univ :=
Set.eq_univ_of_forall fun ⟨α, hα⟩ ↦ Set.mem_iUnion.mpr <| by
have ⟨β, hβ⟩ := h α
let ϕ : F⟮α⟯ →ₐ[F] K' := (IsScalarTower.toAlgHom _ _ _).comp ((AdjoinRoot.liftHom _ _ hβ).comp
(adjoinRootEquivAdjoin F <| (alg.isIntegral).1 _).symm.toAlgHom)
have ⟨ω, hω⟩ := exists_algHom_adjoin_of_splits
(fun s hs ↦ ⟨(alg.isIntegral).1 _, splits s hs⟩) ϕ (adjoin_simple_le_iff.mpr hα)
refine ⟨ω, β, ((DFunLike.congr_fun hω <| AdjoinSimple.gen F α).trans ?_).symm⟩
rw [AlgHom.comp_apply, AlgHom.comp_apply, AlgEquiv.coe_algHom,
adjoinRootEquivAdjoin_symm_apply_gen, AdjoinRoot.liftHom_root]
rfl
have ω : ∃ ω : Ω, ⊤ ≤ M ω := by
cases finite_or_infinite F
· have ⟨α, hα⟩ := exists_primitive_element_of_finite_bot F FS
have ⟨ω, hω⟩ := Set.mem_iUnion.mp (this ▸ Set.mem_univ α)
exact ⟨ω, show ⊤ ≤ K₀.comap ω by rwa [← hα, adjoin_simple_le_iff]⟩
· simp_rw [top_le_iff, Subspace.exists_eq_top_of_iUnion_eq_univ this]
exact ((botEquiv K K').toAlgHom.restrictScalars F).comp
(ω.choose.codRestrict K₀.toSubalgebra fun x ↦ ω.choose_spec trivial) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algHom_of_exist_roots | null |
nonempty_algHom_of_minpoly_eq
(h : ∀ x : E, ∃ y : K, minpoly F x = minpoly F y) :
Nonempty (E →ₐ[F] K) :=
nonempty_algHom_of_exist_roots fun x ↦ have ⟨y, hy⟩ := h x; ⟨y, by rw [hy, minpoly.aeval]⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algHom_of_minpoly_eq | null |
nonempty_algHom_of_range_minpoly_subset
(h : Set.range (@minpoly F E _ _ _) ⊆ Set.range (@minpoly F K _ _ _)) :
Nonempty (E →ₐ[F] K) :=
nonempty_algHom_of_minpoly_eq fun x ↦ have ⟨y, hy⟩ := h ⟨x, rfl⟩; ⟨y, hy.symm⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algHom_of_range_minpoly_subset | null |
nonempty_algEquiv_of_range_minpoly_eq
(h : Set.range (@minpoly F E _ _ _) = Set.range (@minpoly F K _ _ _)) :
Nonempty (E ≃ₐ[F] K) :=
have ⟨σ⟩ := nonempty_algHom_of_range_minpoly_subset h.le
have : Algebra.IsAlgebraic F K := ⟨fun y ↦ IsIntegral.isAlgebraic <| by
by_contra hy
have ⟨x, hx⟩ := h.ge ⟨y, rfl⟩
rw [minpoly.eq_zero hy] at hx
exact minpoly.ne_zero ((alg.isIntegral).1 x) hx⟩
have ⟨τ⟩ := nonempty_algHom_of_range_minpoly_subset h.ge
⟨.ofBijective _ (Algebra.IsAlgebraic.algHom_bijective₂ σ τ).1⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algEquiv_of_range_minpoly_eq | null |
nonempty_algHom_of_aeval_eq_zero_subset
(h : {p : F[X] | ∃ x : E, aeval x p = 0} ⊆ {p | ∃ y : K, aeval y p = 0}) :
Nonempty (E →ₐ[F] K) :=
nonempty_algHom_of_minpoly_eq fun x ↦
have ⟨y, hy⟩ := h ⟨_, minpoly.aeval F x⟩
⟨y, (minpoly.eq_iff_aeval_minpoly_eq_zero <| (alg.isIntegral).1 x).mpr hy⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algHom_of_aeval_eq_zero_subset | null |
nonempty_algEquiv_of_aeval_eq_zero_eq [Algebra.IsAlgebraic F K]
(h : {p : F[X] | ∃ x : E, aeval x p = 0} = {p | ∃ y : K, aeval y p = 0}) :
Nonempty (E ≃ₐ[F] K) :=
have ⟨σ⟩ := nonempty_algHom_of_aeval_eq_zero_subset h.le
have ⟨τ⟩ := nonempty_algHom_of_aeval_eq_zero_subset h.ge
⟨.ofBijective _ (Algebra.IsAlgebraic.algHom_bijective₂ σ τ).1⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | nonempty_algEquiv_of_aeval_eq_zero_eq | null |
_root_.IsAlgClosure.of_exist_roots
(h : ∀ p : F[X], p.Monic → Irreducible p → ∃ x : E, aeval x p = 0) :
IsAlgClosure F E :=
.of_splits fun p _ _ ↦
have ⟨σ⟩ := nonempty_algHom_of_exist_roots fun x : p.SplittingField ↦
have := Algebra.IsAlgebraic.isIntegral (K := F).1 x
h _ (minpoly.monic this) (minpoly.irreducible this)
splits_of_algHom (SplittingField.splits _) σ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Basic",
"Mathlib.FieldTheory.PrimitiveElement",
"Mathlib.GroupTheory.CosetCover"
] | Mathlib/FieldTheory/Isaacs.lean | _root_.IsAlgClosure.of_exist_roots | null |
pNilradical (R : Type*) [CommSemiring R] (p : ℕ) : Ideal R := if 1 < p then nilradical R else ⊥ | def | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical | Given a natural number `p`, the `p`-nilradical of a ring is defined to be the
nilradical if `p > 1` (`pNilradical_eq_nilradical`), and defined to be the zero ideal if `p ≤ 1`
(`pNilradical_eq_bot'`). Equivalently, it is the ideal consisting of elements `x` such that
`x ^ p ^ n = 0` for some `n` (`mem_pNilradical`). |
pNilradical_le_nilradical {R : Type*} [CommSemiring R] {p : ℕ} :
pNilradical R p ≤ nilradical R := by
by_cases hp : 1 < p
· rw [pNilradical, if_pos hp]
simp_rw [pNilradical, if_neg hp, bot_le] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_le_nilradical | null |
pNilradical_eq_nilradical {R : Type*} [CommSemiring R] {p : ℕ} (hp : 1 < p) :
pNilradical R p = nilradical R := by rw [pNilradical, if_pos hp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_eq_nilradical | null |
pNilradical_eq_bot {R : Type*} [CommSemiring R] {p : ℕ} (hp : ¬ 1 < p) :
pNilradical R p = ⊥ := by rw [pNilradical, if_neg hp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_eq_bot | null |
pNilradical_eq_bot' {R : Type*} [CommSemiring R] {p : ℕ} (hp : p ≤ 1) :
pNilradical R p = ⊥ := pNilradical_eq_bot (not_lt.2 hp) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_eq_bot' | null |
pNilradical_prime {R : Type*} [CommSemiring R] {p : ℕ} (hp : p.Prime) :
pNilradical R p = nilradical R := pNilradical_eq_nilradical hp.one_lt | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_prime | null |
pNilradical_one {R : Type*} [CommSemiring R] :
pNilradical R 1 = ⊥ := pNilradical_eq_bot' rfl.le | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_one | null |
mem_pNilradical {R : Type*} [CommSemiring R] {p : ℕ} {x : R} :
x ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = 0 := by
by_cases hp : 1 < p
· rw [pNilradical_eq_nilradical hp]
refine ⟨fun ⟨n, h⟩ ↦ ⟨n, ?_⟩, fun ⟨n, h⟩ ↦ ⟨p ^ n, h⟩⟩
rw [← Nat.sub_add_cancel ((n.lt_pow_self hp).le), pow_add, h, mul_zero]
rw [pNilradical_eq_bot hp, Ideal.mem_bot]
refine ⟨fun h ↦ ⟨0, by rw [pow_zero, pow_one, h]⟩, fun ⟨n, h⟩ ↦ ?_⟩
rcases Nat.le_one_iff_eq_zero_or_eq_one.1 (not_lt.1 hp) with hp | hp
· by_cases hn : n = 0
· rwa [hn, pow_zero, pow_one] at h
rw [hp, zero_pow hn, pow_zero] at h
subsingleton [subsingleton_of_zero_eq_one h.symm]
rwa [hp, one_pow, pow_one] at h | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | mem_pNilradical | null |
sub_mem_pNilradical_iff_pow_expChar_pow_eq {R : Type*} [CommRing R] {p : ℕ} [ExpChar R p]
{x y : R} : x - y ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = y ^ p ^ n := by
simp_rw [mem_pNilradical, sub_pow_expChar_pow, sub_eq_zero] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | sub_mem_pNilradical_iff_pow_expChar_pow_eq | null |
pow_expChar_pow_inj_of_pNilradical_eq_bot (R : Type*) [CommRing R] (p : ℕ) [ExpChar R p]
(h : pNilradical R p = ⊥) (n : ℕ) : Function.Injective fun x : R ↦ x ^ p ^ n := fun _ _ H ↦
sub_eq_zero.1 <| Ideal.mem_bot.1 <| h ▸ sub_mem_pNilradical_iff_pow_expChar_pow_eq.2 ⟨n, H⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pow_expChar_pow_inj_of_pNilradical_eq_bot | null |
pNilradical_eq_bot_of_frobenius_inj (R : Type*) [CommSemiring R] (p : ℕ) [ExpChar R p]
(h : Function.Injective (frobenius R p)) : pNilradical R p = ⊥ := bot_unique fun x ↦ by
rw [mem_pNilradical, Ideal.mem_bot]
exact fun ⟨n, _⟩ ↦ h.iterate n (by rwa [← coe_iterateFrobenius, map_zero]) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | pNilradical_eq_bot_of_frobenius_inj | null |
PerfectRing.pNilradical_eq_bot (R : Type*) [CommSemiring R] (p : ℕ) [ExpChar R p]
[PerfectRing R p] : pNilradical R p = ⊥ :=
pNilradical_eq_bot_of_frobenius_inj R p (injective_frobenius R p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | PerfectRing.pNilradical_eq_bot | null |
@[mk_iff]
IsPRadical : Prop where
pow_mem' : ∀ x : L, ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
ker_le' : RingHom.ker i ≤ pNilradical K p | class | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical | If `i : K →+* L` is a ring homomorphism of characteristic `p` rings, then it is called
`p`-radical if the following conditions are satisfied:
- For any element `x` of `L` there is `n : ℕ` such that `x ^ (p ^ n)` is contained in `K`.
- The kernel of `i` is contained in the `p`-nilradical of `K`.
It is a generalization of purely inseparable extension for fields. |
IsPRadical.pow_mem [IsPRadical i p] (x : L) :
∃ (n : ℕ) (y : K), i y = x ^ p ^ n := pow_mem' x | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.pow_mem | null |
IsPRadical.ker_le [IsPRadical i p] :
RingHom.ker i ≤ pNilradical K p := ker_le' | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.ker_le | null |
IsPRadical.comap_pNilradical [IsPRadical i p] :
(pNilradical L p).comap i = pNilradical K p := by
refine le_antisymm (fun x h ↦ mem_pNilradical.2 ?_) (fun x h ↦ ?_)
· obtain ⟨n, h⟩ := mem_pNilradical.1 <| Ideal.mem_comap.1 h
obtain ⟨m, h⟩ := mem_pNilradical.1 <| ker_le i p ((map_pow i x _).symm ▸ h)
exact ⟨n + m, by rwa [pow_add, pow_mul]⟩
simp only [Ideal.mem_comap, mem_pNilradical] at h ⊢
obtain ⟨n, h⟩ := h
exact ⟨n, by simpa only [map_pow, map_zero] using congr(i $h)⟩
variable (K) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.comap_pNilradical | null |
IsPRadical.of_id : IsPRadical (RingHom.id K) p where
pow_mem' x := ⟨0, x, by simp⟩
ker_le' x h := by convert Ideal.zero_mem _ | instance | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.of_id | null |
IsPRadical.trans [IsPRadical i p] [IsPRadical f p] :
IsPRadical (f.comp i) p where
pow_mem' x := by
obtain ⟨n, y, hy⟩ := pow_mem f p x
obtain ⟨m, z, hz⟩ := pow_mem i p y
exact ⟨n + m, z, by rw [RingHom.comp_apply, hz, map_pow, hy, pow_add, pow_mul]⟩
ker_le' x h := by
rw [RingHom.mem_ker, RingHom.comp_apply, ← RingHom.mem_ker] at h
simpa only [← Ideal.mem_comap, comap_pNilradical] using ker_le f p h | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.trans | Composition of `p`-radical ring homomorphisms is also `p`-radical. |
@[nolint unusedArguments]
IsPerfectClosure [ExpChar L p] [PerfectRing L p] := IsPRadical i p | abbrev | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPerfectClosure | If `i : K →+* L` is a `p`-radical ring homomorphism, then it makes `L` a perfect closure
of `K`, if `L` is perfect.
In this case the kernel of `i` is equal to the `p`-nilradical of `K`
(see `IsPerfectClosure.ker_eq`).
Our definition makes it synonymous to `IsPRadical` if `PerfectRing L p` is present. A caveat is
that you need to write `[PerfectRing L p] [IsPerfectClosure i p]`. This is similar to
`PerfectRing` which has `ExpChar` as a prerequisite. |
RingHom.pNilradical_le_ker_of_perfectRing [ExpChar L p] [PerfectRing L p] :
pNilradical K p ≤ RingHom.ker i := fun x h ↦ by
obtain ⟨n, h⟩ := mem_pNilradical.1 h
replace h := congr((iterateFrobeniusEquiv L p n).symm (i $h))
rwa [map_pow, ← iterateFrobenius_def, ← iterateFrobeniusEquiv_apply, RingEquiv.symm_apply_apply,
map_zero, map_zero] at h
variable [ExpChar L p] in | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | RingHom.pNilradical_le_ker_of_perfectRing | If `i : K →+* L` is a ring homomorphism of exponential characteristic `p` rings, such that `L`
is perfect, then the `p`-nilradical of `K` is contained in the kernel of `i`. |
IsPerfectClosure.ker_eq [PerfectRing L p] [IsPerfectClosure i p] :
RingHom.ker i = pNilradical K p :=
IsPRadical.ker_le'.antisymm (i.pNilradical_le_ker_of_perfectRing p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPerfectClosure.ker_eq | null |
lift_aux (x : L) : ∃ y : ℕ × K, i y.2 = x ^ p ^ y.1 := by
obtain ⟨n, y, h⟩ := IsPRadical.pow_mem i p x
exact ⟨(n, y), h⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_aux | null |
liftAux (x : L) : M := (iterateFrobeniusEquiv M p (Classical.choose (lift_aux i p x)).1).symm
(j (Classical.choose (lift_aux i p x)).2)
@[simp] | def | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux | If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical (in fact only the `IsPRadical.pow_mem` is required) and `M` is a perfect ring,
then one can define a map `L → M` which maps an element `x` of `L` to `y ^ (p ^ -n)` if
`x ^ (p ^ n)` is equal to some element `y` of `K`. |
liftAux_self_apply [ExpChar L p] [PerfectRing L p] (x : L) : liftAux i i p x = x := by
rw [liftAux, Classical.choose_spec (lift_aux i p x), ← iterateFrobenius_def,
← iterateFrobeniusEquiv_apply, RingEquiv.symm_apply_apply]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux_self_apply | null |
liftAux_self [ExpChar L p] [PerfectRing L p] : liftAux i i p = id :=
funext (liftAux_self_apply i p)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux_self | null |
liftAux_id_apply (x : K) : liftAux (RingHom.id K) j p x = j x := by
have := RingHom.id_apply _ ▸ Classical.choose_spec (lift_aux (RingHom.id K) p x)
rw [liftAux, this, map_pow, ← iterateFrobenius_def, ← iterateFrobeniusEquiv_apply,
RingEquiv.symm_apply_apply]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux_id_apply | null |
liftAux_id : liftAux (RingHom.id K) j p = j := funext (liftAux_id_apply j p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux_id | null |
injective_comp_of_pNilradical_eq_bot [IsPRadical i p] (h : pNilradical M p = ⊥) :
Function.Injective fun f : L →+* M ↦ f.comp i := fun f g heq ↦ by
ext x
obtain ⟨n, y, hx⟩ := IsPRadical.pow_mem i p x
apply_fun _ using pow_expChar_pow_inj_of_pNilradical_eq_bot M p h n
simpa only [← map_pow, ← hx] using congr($(heq) y)
variable (M) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | injective_comp_of_pNilradical_eq_bot | If `i : K →+* L` is `p`-radical, then for any ring `M` of exponential charactistic `p` whose
`p`-nilradical is zero, the map `(L →+* M) → (K →+* M)` induced by `i` is injective. |
injective_comp [IsPRadical i p] [IsReduced M] :
Function.Injective fun f : L →+* M ↦ f.comp i :=
injective_comp_of_pNilradical_eq_bot i p <| bot_unique <|
pNilradical_le_nilradical.trans (nilradical_eq_zero M).le | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | injective_comp | If `i : K →+* L` is `p`-radical, then for any reduced ring `M` of exponential charactistic `p`,
the map `(L →+* M) → (K →+* M)` induced by `i` is injective.
A special case of `IsPRadical.injective_comp_of_pNilradical_eq_bot`
and a generalization of `IsPurelyInseparable.injective_comp_algebraMap`. |
injective_comp_of_perfect [IsPRadical i p] [PerfectRing M p] :
Function.Injective fun f : L →+* M ↦ f.comp i :=
injective_comp_of_pNilradical_eq_bot i p (PerfectRing.pNilradical_eq_bot M p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | injective_comp_of_perfect | If `i : K →+* L` is `p`-radical, then for any perfect ring `M` of exponential charactistic `p`,
the map `(L →+* M) → (K →+* M)` induced by `i` is injective.
A special case of `IsPRadical.injective_comp_of_pNilradical_eq_bot`. |
liftAux_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
liftAux i j p x = (iterateFrobeniusEquiv M p n).symm (j y) := by
rw [liftAux]
have h' := Classical.choose_spec (lift_aux i p x)
set n' := (Classical.choose (lift_aux i p x)).1
replace h := congr($(h.symm) ^ p ^ n')
rw [← pow_mul, mul_comm, pow_mul, ← h', ← map_pow, ← map_pow, ← sub_eq_zero, ← map_sub,
← RingHom.mem_ker] at h
obtain ⟨m, h⟩ := mem_pNilradical.1 (IsPRadical.ker_le i p h)
refine (iterateFrobeniusEquiv M p (m + n + n')).injective ?_
conv_lhs => rw [iterateFrobeniusEquiv_add_apply, RingEquiv.apply_symm_apply]
rw [add_assoc, add_comm n n', ← add_assoc,
iterateFrobeniusEquiv_add_apply (m := m + n'), RingEquiv.apply_symm_apply,
iterateFrobeniusEquiv_def, iterateFrobeniusEquiv_def,
← sub_eq_zero, ← map_pow, ← map_pow, ← map_sub,
add_comm m, add_comm m, pow_add, pow_mul, pow_add, pow_mul, ← sub_pow_expChar_pow, h, map_zero]
variable [ExpChar L p] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftAux_apply | If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring, then `PerfectRing.liftAux` is well-defined. |
lift : L →+* M where
toFun := liftAux i j p
map_one' := by simp [liftAux_apply i j p 1 0 1 (by rw [one_pow, map_one])]
map_mul' x1 x2 := by
obtain ⟨n1, y1, h1⟩ := IsPRadical.pow_mem i p x1
obtain ⟨n2, y2, h2⟩ := IsPRadical.pow_mem i p x2
rw [liftAux_apply i j p _ _ _ h1, liftAux_apply i j p _ _ _ h2,
liftAux_apply i j p (x1 * x2) (n1 + n2) (y1 ^ p ^ n2 * y2 ^ p ^ n1) (by rw [map_mul,
map_pow, map_pow, h1, h2, ← pow_mul, ← pow_add, ← pow_mul, ← pow_add,
add_comm n2, mul_pow]),
map_mul, map_pow, map_pow, map_mul, ← iterateFrobeniusEquiv_def]
nth_rw 1 [iterateFrobeniusEquiv_symm_add_apply]
rw [RingEquiv.symm_apply_apply, add_comm n1, iterateFrobeniusEquiv_symm_add_apply,
← iterateFrobeniusEquiv_def, RingEquiv.symm_apply_apply]
map_zero' := by simp [liftAux_apply i j p 0 0 0 (by rw [pow_zero, pow_one, map_zero])]
map_add' x1 x2 := by
obtain ⟨n1, y1, h1⟩ := IsPRadical.pow_mem i p x1
obtain ⟨n2, y2, h2⟩ := IsPRadical.pow_mem i p x2
rw [liftAux_apply i j p _ _ _ h1, liftAux_apply i j p _ _ _ h2,
liftAux_apply i j p (x1 + x2) (n1 + n2) (y1 ^ p ^ n2 + y2 ^ p ^ n1) (by rw [map_add,
map_pow, map_pow, h1, h2, ← pow_mul, ← pow_add, ← pow_mul, ← pow_add,
add_comm n2, add_pow_expChar_pow]),
map_add, map_pow, map_pow, map_add, ← iterateFrobeniusEquiv_def]
nth_rw 1 [iterateFrobeniusEquiv_symm_add_apply]
rw [RingEquiv.symm_apply_apply, add_comm n1, iterateFrobeniusEquiv_symm_add_apply,
← iterateFrobeniusEquiv_def, RingEquiv.symm_apply_apply] | def | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift | If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring, then `PerfectRing.liftAux`
is a ring homomorphism. This is similar to `IsAlgClosed.lift` and `IsSepClosed.lift`. |
lift_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
lift i j p x = (iterateFrobeniusEquiv M p n).symm (j y) :=
liftAux_apply i j p _ _ _ h
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_apply | null |
lift_comp_apply (x : K) : lift i j p (i x) = j x := by
rw [lift_apply i j p _ 0 x (by rw [pow_zero, pow_one]), iterateFrobeniusEquiv_zero]; rfl
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp_apply | null |
lift_comp : (lift i j p).comp i = j := RingHom.ext (lift_comp_apply i j p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp | null |
lift_self_apply [PerfectRing L p] (x : L) : lift i i p x = x := liftAux_self_apply i p x
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_self_apply | null |
lift_self [PerfectRing L p] : lift i i p = RingHom.id L :=
RingHom.ext (liftAux_self_apply i p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_self | null |
lift_id_apply (x : K) : lift (RingHom.id K) j p x = j x := liftAux_id_apply j p x
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_id_apply | null |
lift_id : lift (RingHom.id K) j p = j := RingHom.ext (liftAux_id_apply j p)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_id | null |
comp_lift : lift i (f.comp i) p = f :=
IsPRadical.injective_comp_of_perfect _ i p (lift_comp i _ p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | comp_lift | null |
comp_lift_apply (x : L) : lift i (f.comp i) p x = f x := congr($(comp_lift i f p) x)
variable (M) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | comp_lift_apply | null |
liftEquiv : (K →+* M) ≃ (L →+* M) where
toFun j := lift i j p
invFun f := f.comp i
left_inv f := lift_comp i f p
right_inv f := comp_lift i f p | def | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv | If `i : K →+* L` is a homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring of characteristic `p`,
then `K →+* M` is one-to-one correspondence to
`L →+* M`, given by `PerfectRing.lift`. This is a generalization to `PerfectClosure.lift`. |
liftEquiv_apply : liftEquiv M i p j = lift i j p := rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_apply | null |
liftEquiv_symm_apply : (liftEquiv M i p).symm f = f.comp i := rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_symm_apply | null |
liftEquiv_id_apply : liftEquiv M (RingHom.id K) p j = j :=
lift_id j p
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_id_apply | null |
liftEquiv_id : liftEquiv M (RingHom.id K) p = Equiv.refl _ :=
Equiv.ext (liftEquiv_id_apply · p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_id | null |
@[simp]
lift_comp_lift : (lift j k p).comp (lift i j p) = lift i k p :=
IsPRadical.injective_comp_of_perfect _ i p (by ext; simp)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp_lift | null |
lift_comp_lift_apply (x : L) : lift j k p (lift i j p x) = lift i k p x :=
congr($(lift_comp_lift i j k p) x) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp_lift_apply | null |
lift_comp_lift_apply_eq_self [PerfectRing L p] (x : L) :
lift j i p (lift i j p x) = x := by
rw [lift_comp_lift_apply, lift_self_apply] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp_lift_apply_eq_self | null |
lift_comp_lift_eq_id [PerfectRing L p] :
(lift j i p).comp (lift i j p) = RingHom.id L :=
RingHom.ext (lift_comp_lift_apply_eq_self i j p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_comp_lift_eq_id | null |
@[simp]
lift_lift : lift g (lift i j p) p = lift (g.comp i) j p := by
refine IsPRadical.injective_comp_of_perfect _ (g.comp i) p ?_
simp_rw [← RingHom.comp_assoc _ _ (lift g _ p), lift_comp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_lift | null |
lift_lift_apply (x : N) : lift g (lift i j p) p x = lift (g.comp i) j p x :=
congr($(lift_lift i j g p) x)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | lift_lift_apply | null |
liftEquiv_comp_apply :
liftEquiv M g p (liftEquiv M i p j) = liftEquiv M (g.comp i) p j := lift_lift i j g p
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_comp_apply | null |
liftEquiv_trans :
(liftEquiv M i p).trans (liftEquiv M g p) = liftEquiv M (g.comp i) p :=
Equiv.ext (liftEquiv_comp_apply i · g p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | liftEquiv_trans | null |
equiv : L ≃+* M where
__ := PerfectRing.lift i j p
invFun := PerfectRing.liftAux j i p
left_inv := PerfectRing.lift_comp_lift_apply_eq_self i j p
right_inv := PerfectRing.lift_comp_lift_apply_eq_self j i p | def | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv | If `L` and `M` are both perfect closures of `K`, then there is a ring isomorphism `L ≃+* M`.
This is similar to `IsAlgClosure.equiv` and `IsSepClosure.equiv`. |
equiv_toRingHom : (equiv i j p).toRingHom = PerfectRing.lift i j p := rfl
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_toRingHom | null |
equiv_symm : (equiv i j p).symm = equiv j i p := rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_symm | null |
equiv_symm_toRingHom :
(equiv i j p).symm.toRingHom = PerfectRing.lift j i p := rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_symm_toRingHom | null |
equiv_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
equiv i j p x = (iterateFrobeniusEquiv M p n).symm (j y) :=
PerfectRing.liftAux_apply i j p _ _ _ h | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_apply | null |
equiv_symm_apply (x : M) (n : ℕ) (y : K) (h : j y = x ^ p ^ n) :
(equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y) := by
rw [equiv_symm, equiv_apply j i p _ _ _ h] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_symm_apply | null |
equiv_self_apply (x : L) : equiv i i p x = x :=
PerfectRing.liftAux_self_apply i p x
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_self_apply | null |
equiv_self : equiv i i p = RingEquiv.refl L :=
RingEquiv.ext (equiv_self_apply i p)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_self | null |
equiv_comp_apply (x : K) : equiv i j p (i x) = j x :=
PerfectRing.lift_comp_apply i j p x
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp_apply | null |
equiv_comp : RingHom.comp (equiv i j p) i = j :=
RingHom.ext (equiv_comp_apply i j p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp | null |
@[simp]
equiv_comp_equiv_apply (x : L) :
equiv j k p (equiv i j p x) = equiv i k p x :=
PerfectRing.lift_comp_lift_apply i j k p x
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp_equiv_apply | null |
equiv_comp_equiv : (equiv i j p).trans (equiv j k p) = equiv i k p :=
RingEquiv.ext (equiv_comp_equiv_apply i j k p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp_equiv | null |
equiv_comp_equiv_apply_eq_self (x : L) :
equiv j i p (equiv i j p x) = x := by
rw [equiv_comp_equiv_apply, equiv_self_apply] | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp_equiv_apply_eq_self | null |
equiv_comp_equiv_eq_id :
(equiv i j p).trans (equiv j i p) = RingEquiv.refl L :=
RingEquiv.ext (equiv_comp_equiv_apply_eq_self i j p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | equiv_comp_equiv_eq_id | null |
isPRadical : IsPRadical (PerfectClosure.of K p) p where
pow_mem' x := PerfectClosure.induction_on x fun x ↦ ⟨x.1, x.2, by
rw [← iterate_frobenius, iterate_frobenius_mk K p x.1 x.2]⟩
ker_le' x h := by
rw [RingHom.mem_ker, of_apply, zero_def, mk_eq_iff] at h
obtain ⟨n, h⟩ := h
simp_rw [zero_add, ← coe_iterateFrobenius, map_zero] at h
exact mem_pNilradical.2 ⟨n, h⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | isPRadical | The absolute perfect closure `PerfectClosure` is a `p`-radical extension over the base ring.
In particular, it is a perfect closure of the base ring, that is,
`IsPerfectClosure (PerfectClosure.of K p) p`. |
IsPRadical.isPurelyInseparable [IsPRadical (algebraMap K L) p] :
IsPurelyInseparable K L :=
(isPurelyInseparable_iff_pow_mem K p).2 (IsPRadical.pow_mem (algebraMap K L) p) | theorem | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPRadical.isPurelyInseparable | If `L / K` is a `p`-radical field extension, then it is purely inseparable. |
IsPurelyInseparable.isPRadical [IsPurelyInseparable K L] :
IsPRadical (algebraMap K L) p where
pow_mem' := (isPurelyInseparable_iff_pow_mem K p).1 ‹_›
ker_le' := (RingHom.injective_iff_ker_eq_bot _).1 (algebraMap K L).injective ▸ bot_le | instance | FieldTheory | [
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.FieldTheory.PerfectClosure"
] | Mathlib/FieldTheory/IsPerfectClosure.lean | IsPurelyInseparable.isPRadical | If `L / K` is a purely inseparable field extension, then it is `p`-radical. In particular, if
`L` is perfect, then the (relative) perfect closure `perfectClosure K L` is a perfect closure
of `K`, that is, `IsPerfectClosure (algebraMap K (perfectClosure K L)) p`. |
IsSepClosed : Prop where
splits_of_separable : ∀ p : k[X], p.Separable → (p.Splits <| RingHom.id k) | class | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosed | Typeclass for separably closed fields.
To show `Polynomial.Splits p f` for an arbitrary ring homomorphism `f`,
see `IsSepClosed.splits_codomain` and `IsSepClosed.splits_domain`. |
IsSepClosed.of_isAlgClosed [IsAlgClosed k] : IsSepClosed k :=
⟨fun p _ ↦ IsAlgClosed.splits p⟩
variable {k} {K} | instance | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosed.of_isAlgClosed | An algebraically closed field is also separably closed. |
IsSepClosed.splits_codomain [IsSepClosed K] {f : k →+* K}
(p : k[X]) (h : p.Separable) : p.Splits f := by
convert IsSepClosed.splits_of_separable (p.map f) (Separable.map h); simp [splits_map_iff] | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosed.splits_codomain | Every separable polynomial splits in the field extension `f : k →+* K` if `K` is
separably closed.
See also `IsSepClosed.splits_domain` for the case where `k` is separably closed. |
IsSepClosed.splits_domain [IsSepClosed k] {f : k →+* K}
(p : k[X]) (h : p.Separable) : p.Splits f :=
Polynomial.splits_of_splits_id _ <| IsSepClosed.splits_of_separable _ h | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosed.splits_domain | Every separable polynomial splits in the field extension `f : k →+* K` if `k` is
separably closed.
See also `IsSepClosed.splits_codomain` for the case where `k` is separably closed. |
exists_root [IsSepClosed k] (p : k[X]) (hp : p.degree ≠ 0) (hsep : p.Separable) :
∃ x, IsRoot p x :=
exists_root_of_splits _ (IsSepClosed.splits_of_separable p hsep) hp | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | exists_root | null |
exists_root_C_mul_X_pow_add_C_mul_X_add_C
[IsSepClosed k] {n : ℕ} (a b c : k) (hn : (n : k) = 0) (hn' : 2 ≤ n) (hb : b ≠ 0) :
∃ x, a * x ^ n + b * x + c = 0 := by
let f : k[X] := C a * X ^ n + C b * X + C c
have hdeg : f.degree ≠ 0 := degree_ne_of_natDegree_ne <| by
by_cases ha : a = 0
· suffices f.natDegree = 1 from this ▸ one_ne_zero
simp_rw [f, ha, map_zero, zero_mul, zero_add]
compute_degree!
· suffices f.natDegree = n from this ▸ (lt_of_lt_of_le zero_lt_two hn').ne'
simp_rw [f]
have h0 : n ≠ 0 := by linarith only [hn']
have h1 : n ≠ 1 := by linarith only [hn']
have : 1 ≤ n := le_trans one_le_two hn'
compute_degree!
simp [h0, h1, ha]
have hsep : f.Separable := separable_C_mul_X_pow_add_C_mul_X_add_C a b c hn hb.isUnit
obtain ⟨x, hx⟩ := exists_root f hdeg hsep
exact ⟨x, by simpa [f] using hx⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | exists_root_C_mul_X_pow_add_C_mul_X_add_C | If `n ≥ 2` equals zero in a separably closed field `k`, `b ≠ 0`,
then there exists `x` in `k` such that `a * x ^ n + b * x + c = 0`. |
exists_root_C_mul_X_pow_add_C_mul_X_add_C'
[IsSepClosed k] (p n : ℕ) (a b c : k) [CharP k p] (hn : p ∣ n) (hn' : 2 ≤ n) (hb : b ≠ 0) :
∃ x, a * x ^ n + b * x + c = 0 :=
exists_root_C_mul_X_pow_add_C_mul_X_add_C a b c ((CharP.cast_eq_zero_iff k p n).2 hn) hn' hb
variable (k) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | exists_root_C_mul_X_pow_add_C_mul_X_add_C' | If a separably closed field `k` is of characteristic `p`, `n ≥ 2` is such that `p ∣ n`, `b ≠ 0`,
then there exists `x` in `k` such that `a * x ^ n + b * x + c = 0`. |
IntermediateField.eq_bot_of_isSepClosed_of_isSeparable [IsSepClosed k] [Algebra k K]
(L : IntermediateField k K) [Algebra.IsSeparable k L] : L = ⊥ := bot_unique fun x hx ↦ by
obtain ⟨y, hy⟩ := IsSepClosed.algebraMap_surjective k L ⟨x, hx⟩
exact ⟨y, congr_arg (algebraMap L K) hy⟩
variable (k) (K) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IntermediateField.eq_bot_of_isSepClosed_of_isSeparable | A separably closed perfect field is also algebraically closed. -/
instance (priority := 100) isAlgClosed_of_perfectField [IsSepClosed k] [PerfectField k] :
IsAlgClosed k :=
IsAlgClosed.of_exists_root k fun p _ h ↦ exists_root p ((degree_pos_of_irreducible h).ne')
(PerfectField.separable_of_irreducible h)
theorem exists_pow_nat_eq [IsSepClosed k] (x : k) (n : ℕ) [hn : NeZero (n : k)] :
∃ z, z ^ n = x := by
have hn' : 0 < n := Nat.pos_of_ne_zero fun h => by
rw [h, Nat.cast_zero] at hn
exact hn.out rfl
have : degree (X ^ n - C x) ≠ 0 := by
rw [degree_X_pow_sub_C hn' x]
exact (WithBot.coe_lt_coe.2 hn').ne'
by_cases hx : x = 0
· exact ⟨0, by rw [hx, pow_eq_zero_iff hn'.ne']⟩
· obtain ⟨z, hz⟩ := exists_root _ this <| separable_X_pow_sub_C x hn.out hx
use z
simpa [eval_C, eval_X, eval_pow, eval_sub, IsRoot.def, sub_eq_zero] using hz
theorem exists_eq_mul_self [IsSepClosed k] (x : k) [h2 : NeZero (2 : k)] : ∃ z, x = z * z := by
rcases exists_pow_nat_eq x 2 with ⟨z, rfl⟩
exact ⟨z, sq z⟩
theorem roots_eq_zero_iff [IsSepClosed k] {p : k[X]} (hsep : p.Separable) :
p.roots = 0 ↔ p = Polynomial.C (p.coeff 0) := by
refine ⟨fun h => ?_, fun hp => by rw [hp, roots_C]⟩
rcases le_or_gt (degree p) 0 with hd | hd
· exact eq_C_of_degree_le_zero hd
· obtain ⟨z, hz⟩ := IsSepClosed.exists_root p hd.ne' hsep
rw [← mem_roots (ne_zero_of_degree_gt hd), h] at hz
simp at hz
theorem exists_eval₂_eq_zero [IsSepClosed K] (f : k →+* K)
(p : k[X]) (hp : p.degree ≠ 0) (hsep : p.Separable) :
∃ x, p.eval₂ f x = 0 :=
let ⟨x, hx⟩ := exists_root (p.map f) (by rwa [degree_map_eq_of_injective f.injective])
(Separable.map hsep)
⟨x, by rwa [eval₂_eq_eval_map, ← IsRoot]⟩
variable (K)
theorem exists_aeval_eq_zero [IsSepClosed K] [Algebra k K] (p : k[X])
(hp : p.degree ≠ 0) (hsep : p.Separable) : ∃ x : K, aeval x p = 0 :=
exists_eval₂_eq_zero (algebraMap k K) p hp hsep
variable (k) {K}
theorem of_exists_root (H : ∀ p : k[X], p.Monic → Irreducible p → Separable p → ∃ x, p.eval x = 0) :
IsSepClosed k := by
refine ⟨fun p hsep ↦ Or.inr ?_⟩
intro q hq hdvd
simp only [map_id] at hdvd
have hlc : IsUnit (leadingCoeff q)⁻¹ := IsUnit.inv <| Ne.isUnit <|
leadingCoeff_ne_zero.2 <| Irreducible.ne_zero hq
have hsep' : Separable (q * C (leadingCoeff q)⁻¹) :=
Separable.mul (Separable.of_dvd hsep hdvd) ((separable_C _).2 hlc)
(by simpa only [← isCoprime_mul_unit_right_right (isUnit_C.2 hlc) q 1, one_mul]
using isCoprime_one_right (x := q))
have hirr' := hq
rw [← irreducible_mul_isUnit (isUnit_C.2 hlc)] at hirr'
obtain ⟨x, hx⟩ := H (q * C (leadingCoeff q)⁻¹) (monic_mul_leadingCoeff_inv hq.ne_zero) hirr' hsep'
exact degree_mul_leadingCoeff_inv q hq.ne_zero ▸ degree_eq_one_of_irreducible_of_root hirr' hx
theorem degree_eq_one_of_irreducible [IsSepClosed k] {p : k[X]}
(hp : Irreducible p) (hsep : p.Separable) : p.degree = 1 :=
degree_eq_one_of_irreducible_of_splits hp (IsSepClosed.splits_codomain p hsep)
variable (K)
theorem algebraMap_surjective
[IsSepClosed k] [Algebra k K] [Algebra.IsSeparable k K] :
Function.Surjective (algebraMap k K) := by
refine fun x => ⟨-(minpoly k x).coeff 0, ?_⟩
have hq : (minpoly k x).leadingCoeff = 1 := minpoly.monic (Algebra.IsSeparable.isIntegral k x)
have hsep : IsSeparable k x := Algebra.IsSeparable.isSeparable k x
have h : (minpoly k x).degree = 1 :=
degree_eq_one_of_irreducible k (minpoly.irreducible (Algebra.IsSeparable.isIntegral k x)) hsep
have : aeval x (minpoly k x) = 0 := minpoly.aeval k x
rw [eq_X_add_C_of_degree_eq_one h, hq, C_1, one_mul, aeval_add, aeval_X, aeval_C,
add_eq_zero_iff_eq_neg] at this
exact (RingHom.map_neg (algebraMap k K) ((minpoly k x).coeff 0)).symm ▸ this.symm
end IsSepClosed
/-- If `k` is separably closed, `K / k` is a field extension, `L / k` is an intermediate field
which is separable, then `L` is equal to `k`. A corollary of `IsSepClosed.algebraMap_surjective`. |
IsSepClosure [Algebra k K] : Prop where
sep_closed : IsSepClosed K
separable : Algebra.IsSeparable k K | class | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosure | Typeclass for an extension being a separable closure. |
IsSepClosure.self_of_isSepClosed [IsSepClosed k] : IsSepClosure k k :=
⟨by assumption, Algebra.isSeparable_self k⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | IsSepClosure.self_of_isSepClosed | A separably closed field is its separable closure. |
noncomputable equiv : L ≃ₐ[K] M :=
AlgEquiv.ofBijective _ (Normal.toIsAlgebraic.algHom_bijective₂
(IsSepClosed.lift : L →ₐ[K] M) (IsSepClosed.lift : M →ₐ[K] L)).1 | def | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/IsSepClosed.lean | equiv | If `K` is perfect and is a separable closure of `k`,
then it is also an algebraic closure of `k`. -/
instance (priority := 100) IsSepClosure.isAlgClosure_of_perfectField_top
[Algebra k K] [IsSepClosure k K] [PerfectField K] : IsAlgClosure k K :=
haveI : IsSepClosed K := IsSepClosure.sep_closed k
⟨inferInstance, IsSepClosure.separable.isAlgebraic⟩
/-- If `k` is perfect, `K` is a separable closure of `k`,
then it is also an algebraic closure of `k`. -/
instance (priority := 100) IsSepClosure.isAlgClosure_of_perfectField
[Algebra k K] [IsSepClosure k K] [PerfectField k] : IsAlgClosure k K :=
have halg : Algebra.IsAlgebraic k K := IsSepClosure.separable.isAlgebraic
haveI := halg.perfectField; inferInstance
/-- If `k` is perfect, `K` is an algebraic closure of `k`,
then it is also a separable closure of `k`. -/
instance (priority := 100) IsSepClosure.of_isAlgClosure_of_perfectField
[Algebra k K] [IsAlgClosure k K] [PerfectField k] : IsSepClosure k K :=
⟨haveI := IsAlgClosure.isAlgClosed (R := k) (K := K); inferInstance,
(IsAlgClosure.isAlgebraic (R := k) (K := K)).isSeparable_of_perfectField⟩
variable {k} {K}
theorem isSepClosure_iff [Algebra k K] :
IsSepClosure k K ↔ IsSepClosed K ∧ Algebra.IsSeparable k K :=
⟨fun h ↦ ⟨h.1, h.2⟩, fun h ↦ ⟨h.1, h.2⟩⟩
namespace IsSepClosure
instance isSeparable [Algebra k K] [IsSepClosure k K] : Algebra.IsSeparable k K :=
IsSepClosure.separable
instance (priority := 100) isGalois [Algebra k K] [IsSepClosure k K] : IsGalois k K where
to_isSeparable := IsSepClosure.separable
to_normal.toIsAlgebraic := inferInstance
to_normal.splits' x := (IsSepClosure.sep_closed k).splits_codomain _
(Algebra.IsSeparable.isSeparable k x)
end IsSepClosure
namespace IsSepClosed
variable {K : Type u} (L : Type v) {M : Type w} [Field K] [Field L] [Algebra K L] [Field M]
[Algebra K M] [IsSepClosed M]
theorem surjective_restrictDomain_of_isSeparable {E : Type*}
[Field E] [Algebra K E] [Algebra L E] [IsScalarTower K L E] [Algebra.IsSeparable L E] :
Function.Surjective fun φ : E →ₐ[K] M ↦ φ.restrictDomain L :=
fun f ↦ IntermediateField.exists_algHom_of_splits' (E := E) f
fun s ↦ ⟨Algebra.IsSeparable.isIntegral L s,
IsSepClosed.splits_codomain _ <| Algebra.IsSeparable.isSeparable L s⟩
variable [Algebra.IsSeparable K L] {L}
/-- A (random) homomorphism from a separable extension L of K into a separably
closed extension M of K. -/
noncomputable irreducible_def lift : L →ₐ[K] M :=
Classical.choice <| IntermediateField.nonempty_algHom_of_adjoin_splits
(fun x _ ↦ ⟨Algebra.IsSeparable.isIntegral K x,
splits_codomain _ (Algebra.IsSeparable.isSeparable K x)⟩)
(IntermediateField.adjoin_univ K L)
end IsSepClosed
namespace IsSepClosure
variable (K : Type u) [Field K] (L : Type v) (M : Type w) [Field L] [Field M]
variable [Algebra K M] [IsSepClosure K M]
variable [Algebra K L] [IsSepClosure K L]
attribute [local instance] IsSepClosure.sep_closed in
/-- A (random) isomorphism between two separable closures of `K`. |
exists_pow_mem_center_of_inseparable (p : ℕ) [hchar : ExpChar D p] (a : D)
(hinsep : ∀ x : D, IsSeparable k x → x ∈ k) : ∃ n, a ^ (p ^ n) ∈ k := by
have := (@isPurelyInseparable_iff_pow_mem k D _ _ _ _ p (ExpChar.expChar_center_iff.2 hchar)).1
have pure : IsPurelyInseparable k D := ⟨Algebra.IsAlgebraic.isIntegral, fun x hx ↦ by
rw [RingHom.mem_range, Subtype.exists]
exact ⟨x, ⟨hinsep x hx, rfl⟩⟩⟩
obtain ⟨n, ⟨m, hm⟩⟩ := this pure a
have := Subalgebra.range_subset (R := k) ⟨(k).toSubsemiring, fun r ↦ r.2⟩
exact ⟨n, Set.mem_of_subset_of_mem this <| Set.mem_range.2 ⟨m, hm⟩⟩ | lemma | FieldTheory | [
"Mathlib.Algebra.Central.Defs",
"Mathlib.Algebra.CharP.LinearMaps",
"Mathlib.Algebra.CharP.Subring",
"Mathlib.Algebra.GroupWithZero.Conj",
"Mathlib.Algebra.Lie.OfAssociative",
"Mathlib.FieldTheory.PurelyInseparable.Basic"
] | Mathlib/FieldTheory/JacobsonNoether.lean | exists_pow_mem_center_of_inseparable | If `D` is a purely inseparable extension of `k` with characteristic `p`,
then for every element `a` of `D`, there exists a natural number `n`
such that `a ^ (p ^ n)` is contained in `k`. |
exists_pow_mem_center_of_inseparable' (p : ℕ) [ExpChar D p] {a : D}
(ha : a ∉ k) (hinsep : ∀ x : D, IsSeparable k x → x ∈ k) : ∃ n, 1 ≤ n ∧ a ^ (p ^ n) ∈ k := by
obtain ⟨n, hn⟩ := exists_pow_mem_center_of_inseparable p a hinsep
have nzero : n ≠ 0 := by
rintro rfl
rw [pow_zero, pow_one] at hn
exact ha hn
exact ⟨n, ⟨Nat.one_le_iff_ne_zero.mpr nzero, hn⟩⟩ | lemma | FieldTheory | [
"Mathlib.Algebra.Central.Defs",
"Mathlib.Algebra.CharP.LinearMaps",
"Mathlib.Algebra.CharP.Subring",
"Mathlib.Algebra.GroupWithZero.Conj",
"Mathlib.Algebra.Lie.OfAssociative",
"Mathlib.FieldTheory.PurelyInseparable.Basic"
] | Mathlib/FieldTheory/JacobsonNoether.lean | exists_pow_mem_center_of_inseparable' | If `D` is a purely inseparable extension of `k` with characteristic `p`,
then for every element `a` of `D \ k`, there exists a natural number `n`
**greater than 0** such that `a ^ (p ^ n)` is contained in `k`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.