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 _ (MulSemi... | 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 Fintyp... | 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... | 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 _ ... | 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 ... | 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,... | 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.IsAl... | 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) ... | 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 [p... | 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... |
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)
exa... | 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... | 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 ... |
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_app... | 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 elemen... |
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... | 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_... | 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,
... | 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... | 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.... | 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)
the... |
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,... |
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.isIntegr... | 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 h... | 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.