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 ⌀ |
|---|---|---|---|---|---|---|
isMinimal_iff_isClosed_smul_invariant [ContinuousConstSMul M α] :
IsMinimal M α ↔ ∀ s : Set α, IsClosed s → (∀ c : M, c • s ⊆ s) → s = ∅ ∨ s = univ := by
constructor
· intro _ _
exact eq_empty_or_univ_of_smul_invariant_closed M
refine fun H ↦ ⟨fun _ ↦ dense_iff_closure_eq.2 <| (H _ ?_ ?_).resolve_left ?_⟩... | theorem | Dynamics | [
"Mathlib.Topology.Algebra.ConstMulAction"
] | Mathlib/Dynamics/Minimal.lean | isMinimal_iff_isClosed_smul_invariant | null |
newtonMap (x : S) : S :=
x - (Ring.inverse <| aeval x (derivative P)) * aeval x P | def | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | newtonMap | Given a single-variable polynomial `P` with derivative `P'`, this is the map:
`x ↦ x - P(x) / P'(x)`. When `P'(x)` is not a unit we use a junk-value pattern and send `x ↦ x`. |
newtonMap_apply :
P.newtonMap x = x - (Ring.inverse <| aeval x (derivative P)) * (aeval x P) :=
rfl
variable {P} | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | newtonMap_apply | null |
newtonMap_apply_of_isUnit (h : IsUnit <| aeval x (derivative P)) :
P.newtonMap x = x - h.unit⁻¹ * aeval x P := by
simp [newtonMap_apply, Ring.inverse, h] | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | newtonMap_apply_of_isUnit | null |
newtonMap_apply_of_not_isUnit (h : ¬ (IsUnit <| aeval x (derivative P))) :
P.newtonMap x = x := by
simp [newtonMap_apply, Ring.inverse, h] | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | newtonMap_apply_of_not_isUnit | null |
isNilpotent_iterate_newtonMap_sub_of_isNilpotent (h : IsNilpotent <| aeval x P) (n : ℕ) :
IsNilpotent <| P.newtonMap^[n] x - x := by
induction n with
| zero => simp
| succ n ih =>
rw [iterate_succ', comp_apply, newtonMap_apply, sub_right_comm]
refine (Commute.all _ _).isNilpotent_sub ih <| (Commute.al... | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | isNilpotent_iterate_newtonMap_sub_of_isNilpotent | null |
isFixedPt_newtonMap_of_aeval_eq_zero (h : aeval x P = 0) :
IsFixedPt P.newtonMap x := by
rw [IsFixedPt, newtonMap_apply, h, mul_zero, sub_zero] | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | isFixedPt_newtonMap_of_aeval_eq_zero | null |
isFixedPt_newtonMap_of_isUnit_iff (h : IsUnit <| aeval x (derivative P)) :
IsFixedPt P.newtonMap x ↔ aeval x P = 0 := by
rw [IsFixedPt, newtonMap_apply, sub_eq_self, Ring.inverse_mul_eq_iff_eq_mul _ _ _ h, mul_zero] | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | isFixedPt_newtonMap_of_isUnit_iff | null |
aeval_pow_two_pow_dvd_aeval_iterate_newtonMap
(h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) (n : ℕ) :
(aeval x P) ^ (2 ^ n) ∣ aeval (P.newtonMap^[n] x) P := by
induction n with
| zero => simp
| succ n ih =>
have ⟨d, hd⟩ := binomExpansion (P.map (algebraMap R S)) (P.newtonMap^[n... | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | aeval_pow_two_pow_dvd_aeval_iterate_newtonMap | This is really an auxiliary result, en route to
`Polynomial.existsUnique_nilpotent_sub_and_aeval_eq_zero`. |
existsUnique_nilpotent_sub_and_aeval_eq_zero
(h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) :
∃! r, IsNilpotent (x - r) ∧ aeval r P = 0 := by
simp_rw [(neg_sub _ x).symm, isNilpotent_neg_iff]
refine existsUnique_of_exists_of_unique ?_ fun r₁ r₂ ⟨hr₁, hr₁'⟩ ⟨hr₂, hr₂'⟩ ↦ ?_
· -- Exis... | theorem | Dynamics | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Nilpotent.Lemmas",
"Mathlib.RingTheory.Polynomial.Nilpotent"
] | Mathlib/Dynamics/Newton.lean | existsUnique_nilpotent_sub_and_aeval_eq_zero | If `x` is almost a root of `P` in the sense that `P(x)` is nilpotent (and `P'(x)` is a
unit) then we may write `x` as a sum `x = n + r` where `n` is nilpotent and `r` is a root of `P`.
Moreover, `n` and `r` are unique.
This can be used to prove the Jordan-Chevalley decomposition of linear endomorphims. |
omegaLimit [TopologicalSpace β] (f : Filter τ) (ϕ : τ → α → β) (s : Set α) : Set β :=
⋂ u ∈ f, closure (image2 ϕ u s)
@[inherit_doc]
scoped[omegaLimit] notation "ω" => omegaLimit | def | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit | The ω-limit of a set `s` under `ϕ` with respect to a filter `f` is `⋂ u ∈ f, cl (ϕ u s)`. |
mem_omegaLimit_iff_frequently (y : β) :
y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ t in f, (s ∩ ϕ t ⁻¹' n).Nonempty := by
simp_rw [frequently_iff, omegaLimit_def, mem_iInter, mem_closure_iff_nhds]
constructor
· intro h _ hn _ hu
rcases h _ hu _ hn with ⟨_, _, _, ht, _, hx, rfl⟩
exact ⟨_, ht, _, hx, by rwa [mem_prei... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | mem_omegaLimit_iff_frequently | The ω-limit w.r.t. `Filter.atTop`. -/
scoped[omegaLimit] notation "ω⁺" => omegaLimit Filter.atTop
/-- The ω-limit w.r.t. `Filter.atBot`. -/
scoped[omegaLimit] notation "ω⁻" => omegaLimit Filter.atBot
variable [TopologicalSpace β]
variable (f : Filter τ) (ϕ : τ → α → β) (s s₁ s₂ : Set α)
/-!
### Elementary properties... |
mem_omegaLimit_iff_frequently₂ (y : β) :
y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ t in f, (ϕ t '' s ∩ n).Nonempty := by
simp_rw [mem_omegaLimit_iff_frequently, image_inter_nonempty_iff] | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | mem_omegaLimit_iff_frequently₂ | An element `y` is in the ω-limit set of `s` w.r.t. `f` if the forward images of `s`
frequently (w.r.t. `f`) intersect arbitrary neighbourhoods of `y`. |
mem_omegaLimit_singleton_iff_map_cluster_point (x : α) (y : β) :
y ∈ ω f ϕ {x} ↔ MapClusterPt y f fun t ↦ ϕ t x := by
simp_rw [mem_omegaLimit_iff_frequently, mapClusterPt_iff_frequently, singleton_inter_nonempty,
mem_preimage]
/-! | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | mem_omegaLimit_singleton_iff_map_cluster_point | An element `y` is in the ω-limit of `x` w.r.t. `f` if the forward
images of `x` frequently (w.r.t. `f`) falls within an arbitrary neighbourhood of `y`. |
omegaLimit_inter : ω f ϕ (s₁ ∩ s₂) ⊆ ω f ϕ s₁ ∩ ω f ϕ s₂ :=
subset_inter (omegaLimit_mono_right _ _ inter_subset_left)
(omegaLimit_mono_right _ _ inter_subset_right) | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_inter | null |
omegaLimit_iInter (p : ι → Set α) : ω f ϕ (⋂ i, p i) ⊆ ⋂ i, ω f ϕ (p i) :=
subset_iInter fun _i ↦ omegaLimit_mono_right _ _ (iInter_subset _ _) | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_iInter | null |
omegaLimit_union : ω f ϕ (s₁ ∪ s₂) = ω f ϕ s₁ ∪ ω f ϕ s₂ := by
ext y; constructor
· simp only [mem_union, mem_omegaLimit_iff_frequently, union_inter_distrib_right, union_nonempty,
frequently_or_distrib]
contrapose!
simp only [not_frequently, not_nonempty_iff_eq_empty, ← subset_empty_iff]
rintro ⟨⟨... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_union | null |
omegaLimit_iUnion (p : ι → Set α) : ⋃ i, ω f ϕ (p i) ⊆ ω f ϕ (⋃ i, p i) := by
rw [iUnion_subset_iff]
exact fun i ↦ omegaLimit_mono_right _ _ (subset_iUnion _ _)
/-!
Different expressions for omega limits, useful for rewrites. In
particular, one may restrict the intersection to sets in `f` which are
subsets of some ... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_iUnion | null |
omegaLimit_eq_iInter : ω f ϕ s = ⋂ u : ↥f.sets, closure (image2 ϕ u s) :=
biInter_eq_iInter _ _ | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_eq_iInter | null |
omegaLimit_eq_biInter_inter {v : Set τ} (hv : v ∈ f) :
ω f ϕ s = ⋂ u ∈ f, closure (image2 ϕ (u ∩ v) s) :=
Subset.antisymm (iInter₂_mono' fun u hu ↦ ⟨u ∩ v, inter_mem hu hv, Subset.rfl⟩)
(iInter₂_mono fun _u _hu ↦ closure_mono <| image2_subset inter_subset_left Subset.rfl) | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_eq_biInter_inter | null |
omegaLimit_eq_iInter_inter {v : Set τ} (hv : v ∈ f) :
ω f ϕ s = ⋂ u : ↥f.sets, closure (image2 ϕ (u ∩ v) s) := by
rw [omegaLimit_eq_biInter_inter _ _ _ hv]
apply biInter_eq_iInter | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_eq_iInter_inter | null |
omegaLimit_subset_closure_fw_image {u : Set τ} (hu : u ∈ f) :
ω f ϕ s ⊆ closure (image2 ϕ u s) := by
rw [omegaLimit_eq_iInter]
intro _ hx
rw [mem_iInter] at hx
exact hx ⟨u, hu⟩ | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_subset_closure_fw_image | null |
eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset' {c : Set β}
(hc₁ : IsCompact c) (hc₂ : ∃ v ∈ f, closure (image2 ϕ v s) ⊆ c) {n : Set β} (hn₁ : IsOpen n)
(hn₂ : ω f ϕ s ⊆ n) : ∃ u ∈ f, closure (image2 ϕ u s) ⊆ n := by
rcases hc₂ with ⟨v, hv₁, hv₂⟩
let k := closure (image2 ϕ v... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset' | A set is eventually carried into any open neighbourhood of its ω-limit:
if `c` is a compact set such that `closure {ϕ t x | t ∈ v, x ∈ s} ⊆ c` for some `v ∈ f`
and `n` is an open neighbourhood of `ω f ϕ s`, then for some `u ∈ f` we have
`closure {ϕ t x | t ∈ u, x ∈ s} ⊆ n`. |
eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset [T2Space β]
{c : Set β} (hc₁ : IsCompact c) (hc₂ : ∀ᶠ t in f, MapsTo (ϕ t) s c) {n : Set β} (hn₁ : IsOpen n)
(hn₂ : ω f ϕ s ⊆ n) : ∃ u ∈ f, closure (image2 ϕ u s) ⊆ n :=
eventually_closure_subset_of_isCompact_absorbing_of_isOpen_o... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset | A set is eventually carried into any open neighbourhood of its ω-limit:
if `c` is a compact set such that `closure {ϕ t x | t ∈ v, x ∈ s} ⊆ c` for some `v ∈ f`
and `n` is an open neighbourhood of `ω f ϕ s`, then for some `u ∈ f` we have
`closure {ϕ t x | t ∈ u, x ∈ s} ⊆ n`. |
eventually_mapsTo_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset [T2Space β]
{c : Set β} (hc₁ : IsCompact c) (hc₂ : ∀ᶠ t in f, MapsTo (ϕ t) s c) {n : Set β} (hn₁ : IsOpen n)
(hn₂ : ω f ϕ s ⊆ n) : ∀ᶠ t in f, MapsTo (ϕ t) s n := by
rcases eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omeg... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | eventually_mapsTo_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset | null |
eventually_closure_subset_of_isOpen_of_omegaLimit_subset [CompactSpace β] {v : Set β}
(hv₁ : IsOpen v) (hv₂ : ω f ϕ s ⊆ v) : ∃ u ∈ f, closure (image2 ϕ u s) ⊆ v :=
eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset' _ _ _
isCompact_univ ⟨univ, univ_mem, subset_univ _⟩ hv₁ hv₂ | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | eventually_closure_subset_of_isOpen_of_omegaLimit_subset | null |
eventually_mapsTo_of_isOpen_of_omegaLimit_subset [CompactSpace β] {v : Set β}
(hv₁ : IsOpen v) (hv₂ : ω f ϕ s ⊆ v) : ∀ᶠ t in f, MapsTo (ϕ t) s v := by
rcases eventually_closure_subset_of_isOpen_of_omegaLimit_subset f ϕ s hv₁ hv₂ with ⟨u, hu_mem, hu⟩
refine mem_of_superset hu_mem fun t ht x hx ↦ ?_
exact hu (s... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | eventually_mapsTo_of_isOpen_of_omegaLimit_subset | null |
nonempty_omegaLimit_of_isCompact_absorbing [NeBot f] {c : Set β} (hc₁ : IsCompact c)
(hc₂ : ∃ v ∈ f, closure (image2 ϕ v s) ⊆ c) (hs : s.Nonempty) : (ω f ϕ s).Nonempty := by
rcases hc₂ with ⟨v, hv₁, hv₂⟩
rw [omegaLimit_eq_iInter_inter _ _ _ hv₁]
apply IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_i... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | nonempty_omegaLimit_of_isCompact_absorbing | The ω-limit of a nonempty set w.r.t. a nontrivial filter is nonempty. |
nonempty_omegaLimit [CompactSpace β] [NeBot f] (hs : s.Nonempty) : (ω f ϕ s).Nonempty :=
nonempty_omegaLimit_of_isCompact_absorbing _ _ _ isCompact_univ ⟨univ, univ_mem, subset_univ _⟩ hs | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | nonempty_omegaLimit | null |
isInvariant_omegaLimit (hf : ∀ t, Tendsto (t + ·) f f) : IsInvariant ϕ (ω f ϕ s) := by
refine fun t ↦ MapsTo.mono_right ?_ (omegaLimit_subset_of_tendsto ϕ s (hf t))
exact
mapsTo_omegaLimit _ (mapsTo_id _) (fun t' x ↦ (ϕ.map_add _ _ _).symm)
(continuous_const.flow ϕ continuous_id) | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | isInvariant_omegaLimit | null |
omegaLimit_image_subset (t : τ) (ht : Tendsto (· + t) f f) :
ω f ϕ (ϕ t '' s) ⊆ ω f ϕ s := by
simp only [omegaLimit_image_eq, ← map_add]
exact omegaLimit_subset_of_tendsto ϕ s ht | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_image_subset | null |
@[simp]
omegaLimit_image_eq (hf : ∀ t, Tendsto (· + t) f f) (t : τ) : ω f ϕ (ϕ t '' s) = ω f ϕ s :=
Subset.antisymm (omegaLimit_image_subset _ _ _ _ (hf t)) <|
calc
ω f ϕ s = ω f ϕ (ϕ (-t) '' (ϕ t '' s)) := by simp [image_image, ← map_add]
_ ⊆ ω f ϕ (ϕ t '' s) := omegaLimit_image_subset _ _ _ _ (hf _) | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_image_eq | the ω-limit of a forward image of `s` is the same as the ω-limit of `s`. |
omegaLimit_omegaLimit (hf : ∀ t, Tendsto (t + ·) f f) : ω f ϕ (ω f ϕ s) ⊆ ω f ϕ s := by
simp only [subset_def, mem_omegaLimit_iff_frequently₂, frequently_iff]
intro _ h
rintro n hn u hu
rcases mem_nhds_iff.mp hn with ⟨o, ho₁, ho₂, ho₃⟩
rcases h o (IsOpen.mem_nhds ho₂ ho₃) hu with ⟨t, _ht₁, ht₂⟩
have l₁ : (ω... | theorem | Dynamics | [
"Mathlib.Dynamics.Flow",
"Mathlib.Tactic.Monotonicity"
] | Mathlib/Dynamics/OmegaLimit.lean | omegaLimit_omegaLimit | null |
gal_zero_isSolvable : IsSolvable (0 : F[X]).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_zero_isSolvable | null |
gal_one_isSolvable : IsSolvable (1 : F[X]).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_one_isSolvable | null |
gal_C_isSolvable (x : F) : IsSolvable (C x).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_C_isSolvable | null |
gal_X_isSolvable : IsSolvable (X : F[X]).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_isSolvable | null |
gal_X_sub_C_isSolvable (x : F) : IsSolvable (X - C x).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_sub_C_isSolvable | null |
gal_X_pow_isSolvable (n : ℕ) : IsSolvable (X ^ n : F[X]).Gal := by infer_instance | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_pow_isSolvable | null |
gal_mul_isSolvable {p q : F[X]} (_ : IsSolvable p.Gal) (_ : IsSolvable q.Gal) :
IsSolvable (p * q).Gal :=
solvable_of_solvable_injective (Gal.restrictProd_injective p q) | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_mul_isSolvable | null |
gal_prod_isSolvable {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable (Gal p)) :
IsSolvable s.prod.Gal := by
apply Multiset.induction_on' s
· exact gal_one_isSolvable
· intro p t hps _ ht
rw [Multiset.insert_eq_cons, Multiset.prod_cons]
exact gal_mul_isSolvable (hs p hps) ht | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_prod_isSolvable | null |
gal_isSolvable_of_splits {p q : F[X]}
(_ : Fact (p.Splits (algebraMap F q.SplittingField))) (hq : IsSolvable q.Gal) :
IsSolvable p.Gal :=
haveI : IsSolvable (q.SplittingField ≃ₐ[F] q.SplittingField) := hq
solvable_of_surjective (AlgEquiv.restrictNormalHom_surjective q.SplittingField) | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_isSolvable_of_splits | null |
gal_isSolvable_tower (p q : F[X]) (hpq : p.Splits (algebraMap F q.SplittingField))
(hp : IsSolvable p.Gal) (hq : IsSolvable (q.map (algebraMap F p.SplittingField)).Gal) :
IsSolvable q.Gal := by
let K := p.SplittingField
let L := q.SplittingField
haveI : Fact (p.Splits (algebraMap F L)) := ⟨hpq⟩
let ϕ : ... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_isSolvable_tower | null |
gal_X_pow_sub_one_isSolvable (n : ℕ) : IsSolvable (X ^ n - 1 : F[X]).Gal := by
by_cases hn : n = 0
· rw [hn, pow_zero, sub_self]
exact gal_zero_isSolvable
have hn' : 0 < n := pos_iff_ne_zero.mpr hn
have hn'' : (X ^ n - 1 : F[X]) ≠ 0 := X_pow_sub_C_ne_zero hn' 1
apply isSolvable_of_comm
intro σ τ
ext a... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_pow_sub_one_isSolvable | null |
gal_X_pow_sub_C_isSolvable_aux (n : ℕ) (a : F)
(h : (X ^ n - 1 : F[X]).Splits (RingHom.id F)) : IsSolvable (X ^ n - C a).Gal := by
by_cases ha : a = 0
· rw [ha, C_0, sub_zero]
exact gal_X_pow_isSolvable n
have ha' : algebraMap F (X ^ n - C a).SplittingField a ≠ 0 :=
mt ((injective_iff_map_eq_zero _).m... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_pow_sub_C_isSolvable_aux | null |
splits_X_pow_sub_one_of_X_pow_sub_C {F : Type*} [Field F] {E : Type*} [Field E]
(i : F →+* E) (n : ℕ) {a : F} (ha : a ≠ 0) (h : (X ^ n - C a).Splits i) :
(X ^ n - 1 : F[X]).Splits i := by
have ha' : i a ≠ 0 := mt ((injective_iff_map_eq_zero i).mp i.injective a) ha
by_cases hn : n = 0
· rw [hn, pow_zero, s... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | splits_X_pow_sub_one_of_X_pow_sub_C | null |
gal_X_pow_sub_C_isSolvable (n : ℕ) (x : F) : IsSolvable (X ^ n - C x).Gal := by
by_cases hx : x = 0
· rw [hx, C_0, sub_zero]
exact gal_X_pow_isSolvable n
apply gal_isSolvable_tower (X ^ n - 1) (X ^ n - C x)
· exact splits_X_pow_sub_one_of_X_pow_sub_C _ n hx (SplittingField.splits _)
· exact gal_X_pow_sub_... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | gal_X_pow_sub_C_isSolvable | null |
IsSolvableByRad : E → Prop
| base (α : F) : IsSolvableByRad (algebraMap F E α)
| add (α β : E) : IsSolvableByRad α → IsSolvableByRad β → IsSolvableByRad (α + β)
| neg (α : E) : IsSolvableByRad α → IsSolvableByRad (-α)
| mul (α β : E) : IsSolvableByRad α → IsSolvableByRad β → IsSolvableByRad (α * β)
| inv (α :... | inductive | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | IsSolvableByRad | Inductive definition of solvable by radicals |
solvableByRad : IntermediateField F E where
carrier := IsSolvableByRad F
zero_mem' := by
change IsSolvableByRad F 0
convert IsSolvableByRad.base (E := E) (0 : F); rw [RingHom.map_zero]
add_mem' := by apply IsSolvableByRad.add
one_mem' := by
change IsSolvableByRad F 1
convert IsSolvableByRad.base... | def | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | solvableByRad | The intermediate field of solvable-by-radicals elements |
induction (P : solvableByRad F E → Prop)
(base : ∀ α : F, P (algebraMap F (solvableByRad F E) α))
(add : ∀ α β : solvableByRad F E, P α → P β → P (α + β))
(neg : ∀ α : solvableByRad F E, P α → P (-α))
(mul : ∀ α β : solvableByRad F E, P α → P β → P (α * β))
(inv : ∀ α : solvableByRad F E, P α → P α⁻... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | induction | null |
isIntegral (α : solvableByRad F E) : IsIntegral F α := by
revert α
apply solvableByRad.induction
· exact fun _ => isIntegral_algebraMap
· exact fun _ _ => IsIntegral.add
· exact fun _ => IsIntegral.neg
· exact fun _ _ => IsIntegral.mul
· intro α hα
exact IsIntegral.inv hα
· intro α n hn hα
obtai... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | isIntegral | null |
P (α : solvableByRad F E) : Prop :=
IsSolvable (minpoly F α).Gal | def | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | P | The statement to be proved inductively |
induction3 {α : solvableByRad F E} {n : ℕ} (hn : n ≠ 0) (hα : P (α ^ n)) : P α := by
let p := minpoly F (α ^ n)
have hp : p.comp (X ^ n) ≠ 0 := by
intro h
rcases comp_eq_zero_iff.mp h with h' | h'
· exact minpoly.ne_zero (isIntegral (α ^ n)) h'
· exact hn (by rw [← @natDegree_C F, ← h'.2, natDegree_... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | induction3 | An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. |
induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ := by
let p := minpoly F α
let q := minpoly F β
have hpq := Polynomial.splits_of_splits_mul _
(mul_ne_zero (minpoly.ne_zero (isIntegral α)) (minpoly.ne_zero (isIntegral β)))
(SplittingField.splits (p * q))
let f : ↥F⟮α... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | induction2 | An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. |
induction1 {α β : solvableByRad F E} (hβ : β ∈ F⟮α⟯) (hα : P α) : P β :=
induction2 (adjoin.mono F _ _ (ge_of_eq (Set.pair_eq_singleton α)) hβ) hα hα | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | induction1 | An auxiliary induction lemma, which is generalized by `solvableByRad.isSolvable`. |
isSolvable (α : solvableByRad F E) : IsSolvable (minpoly F α).Gal := by
revert α
apply solvableByRad.induction
· exact fun α => by rw [minpoly.eq_X_sub_C (solvableByRad F E)]; exact gal_X_sub_C_isSolvable α
· exact fun α β => induction2 (add_mem (subset_adjoin F _ (Set.mem_insert α _))
(subset_adjoin F _ ... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | isSolvable | null |
isSolvable' {α : E} {q : F[X]} (q_irred : Irreducible q) (q_aeval : aeval α q = 0)
(hα : IsSolvableByRad F α) : IsSolvable q.Gal := by
have : _root_.IsSolvable (q * C q.leadingCoeff⁻¹).Gal := by
rw [minpoly.eq_of_irreducible q_irred q_aeval, ←
show minpoly F (⟨α, hα⟩ : solvableByRad F E) = minpoly F α f... | theorem | FieldTheory | [
"Mathlib.GroupTheory.Solvable",
"Mathlib.FieldTheory.PolynomialGaloisGroup",
"Mathlib.RingTheory.RootsOfUnity.Basic"
] | Mathlib/FieldTheory/AbelRuffini.lean | isSolvable' | **Abel-Ruffini Theorem** (one direction): An irreducible polynomial with an
`IsSolvableByRad` root has solvable Galois group |
absoluteGaloisGroup := AlgebraicClosure K ≃ₐ[K] AlgebraicClosure K
local notation "G_K" => absoluteGaloisGroup | def | FieldTheory | [
"Mathlib.FieldTheory.KrullTopology",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.Topology.Algebra.Group.TopologicalAbelianization"
] | Mathlib/FieldTheory/AbsoluteGaloisGroup.lean | absoluteGaloisGroup | The absolute Galois group of `K`, defined as the Galois group of the field extension `K^al/K`,
where `K^al` is an algebraic closure of `K`. |
absoluteGaloisGroup.commutator_closure_isNormal :
(commutator (G_K K)).topologicalClosure.Normal :=
Subgroup.is_normal_topologicalClosure (commutator (G_K K)) | instance | FieldTheory | [
"Mathlib.FieldTheory.KrullTopology",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.Topology.Algebra.Group.TopologicalAbelianization"
] | Mathlib/FieldTheory/AbsoluteGaloisGroup.lean | absoluteGaloisGroup.commutator_closure_isNormal | `absoluteGaloisGroup` is a topological space with the Krull topology. -/
noncomputable instance : TopologicalSpace (G_K K) := krullTopology K (AlgebraicClosure K)
/-! ### The topological abelianization of the absolute Galois group |
absoluteGaloisGroupAbelianization := TopologicalAbelianization (G_K K)
local notation "G_K_ab" => absoluteGaloisGroupAbelianization | abbrev | FieldTheory | [
"Mathlib.FieldTheory.KrullTopology",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.Topology.Algebra.Group.TopologicalAbelianization"
] | Mathlib/FieldTheory/AbsoluteGaloisGroup.lean | absoluteGaloisGroupAbelianization | The topological abelianization of `absoluteGaloisGroup`, that is, the quotient of
`absoluteGaloisGroup` by the topological closure of its commutator subgroup. |
@[stacks 09GI]
algebraicClosure : IntermediateField F E :=
Algebra.IsAlgebraic.toIntermediateField (integralClosure F E)
variable {F E} | def | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | algebraicClosure | The *relative algebraic closure* of a field `F` in a field extension `E`,
also called the *maximal algebraic subextension* of `E / F`,
is defined to be the subalgebra `integralClosure F E`
upgraded to an intermediate field (since `F` and `E` are both fields).
This is exactly the intermediate field of `E / F` consisting... |
algebraicClosure_toSubalgebra : (algebraicClosure F E).toSubalgebra = integralClosure F E :=
rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | algebraicClosure_toSubalgebra | null |
mem_algebraicClosure_iff' {x : E} :
x ∈ algebraicClosure F E ↔ IsIntegral F x := Iff.rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | mem_algebraicClosure_iff' | An element is contained in the algebraic closure of `F` in `E` if and only if
it is an integral element. |
mem_algebraicClosure_iff {x : E} :
x ∈ algebraicClosure F E ↔ IsAlgebraic F x := isAlgebraic_iff_isIntegral.symm | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | mem_algebraicClosure_iff | An element is contained in the algebraic closure of `F` in `E` if and only if
it is an algebraic element. |
map_mem_algebraicClosure_iff (i : E →ₐ[F] K) {x : E} :
i x ∈ algebraicClosure F K ↔ x ∈ algebraicClosure F E := by
simp_rw [mem_algebraicClosure_iff', ← minpoly.ne_zero_iff, minpoly.algHom_eq i i.injective] | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | map_mem_algebraicClosure_iff | If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`algebraicClosure F K` if and only if `x` is contained in `algebraicClosure F E`. |
comap_eq_of_algHom (i : E →ₐ[F] K) :
(algebraicClosure F K).comap i = algebraicClosure F E := by
ext x
exact map_mem_algebraicClosure_iff i | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | comap_eq_of_algHom | If `i` is an `F`-algebra homomorphism from `E` to `K`, then the preimage of
`algebraicClosure F K` under the map `i` is equal to `algebraicClosure F E`. |
map_le_of_algHom (i : E →ₐ[F] K) :
(algebraicClosure F E).map i ≤ algebraicClosure F K :=
map_le_iff_le_comap.2 (comap_eq_of_algHom i).ge
variable (F) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | map_le_of_algHom | If `i` is an `F`-algebra homomorphism from `E` to `K`, then the image of `algebraicClosure F E`
under the map `i` is contained in `algebraicClosure F K`. |
map_eq_of_algebraicClosure_eq_bot [Algebra E K] [IsScalarTower F E K]
(h : algebraicClosure E K = ⊥) :
(algebraicClosure F E).map (IsScalarTower.toAlgHom F E K) = algebraicClosure F K := by
refine le_antisymm (map_le_of_algHom _) (fun x hx ↦ ?_)
obtain ⟨y, rfl⟩ := mem_bot.1 <| h ▸ mem_algebraicClosure_iff'.... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | map_eq_of_algebraicClosure_eq_bot | If `K / E / F` is a field extension tower, such that `K / E` has no non-trivial algebraic
subextensions (this means that it is purely transcendental),
then the image of `algebraicClosure F E` in `K` is equal to `algebraicClosure F K`. |
map_eq_of_algEquiv (i : E ≃ₐ[F] K) :
(algebraicClosure F E).map i = algebraicClosure F K :=
(map_le_of_algHom i.toAlgHom).antisymm
(fun x h ↦ ⟨_, (map_mem_algebraicClosure_iff i.symm).2 h, by simp⟩) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | map_eq_of_algEquiv | If `i` is an `F`-algebra isomorphism of `E` and `K`, then the image of `algebraicClosure F E`
under the map `i` is equal to `algebraicClosure F K`. |
algEquivOfAlgEquiv (i : E ≃ₐ[F] K) :
algebraicClosure F E ≃ₐ[F] algebraicClosure F K :=
(intermediateFieldMap i _).trans (equivOfEq (map_eq_of_algEquiv i))
alias _root_.AlgEquiv.algebraicClosure := algEquivOfAlgEquiv
variable (F E K) | def | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | algEquivOfAlgEquiv | If `E` and `K` are isomorphic as `F`-algebras, then `algebraicClosure F E` and
`algebraicClosure F K` are also isomorphic as `F`-algebras. |
isAlgebraic : Algebra.IsAlgebraic F (algebraicClosure F E) :=
⟨fun x ↦ isAlgebraic_iff.mpr x.2.isAlgebraic⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | isAlgebraic | The algebraic closure of `F` in `E` is algebraic over `F`. |
isIntegralClosure : IsIntegralClosure (algebraicClosure F E) F E :=
inferInstanceAs (IsIntegralClosure (integralClosure F E) F E) | instance | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | isIntegralClosure | The algebraic closure of `F` in `E` is the integral closure of `F` in `E`. |
protected Transcendental.algebraicClosure {a : E} (ha : Transcendental F a) :
Transcendental (algebraicClosure F E) a :=
ha.extendScalars _
variable (F E K) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | Transcendental.algebraicClosure | null |
le_algebraicClosure' {L : IntermediateField F E} (hs : ∀ x : L, IsAlgebraic F x) :
L ≤ algebraicClosure F E := fun x h ↦ by
simpa only [mem_algebraicClosure_iff, IsAlgebraic, ne_eq, ← aeval_algebraMap_eq_zero_iff E,
Algebra.algebraMap_self, RingHom.id_apply, IntermediateField.algebraMap_apply] using hs ⟨x, h⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | le_algebraicClosure' | An intermediate field of `E / F` is contained in the algebraic closure of `F` in `E`
if all of its elements are algebraic over `F`. |
le_algebraicClosure (L : IntermediateField F E) [Algebra.IsAlgebraic F L] :
L ≤ algebraicClosure F E := le_algebraicClosure' F E (Algebra.IsAlgebraic.isAlgebraic) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | le_algebraicClosure | An intermediate field of `E / F` is contained in the algebraic closure of `F` in `E`
if it is algebraic over `F`. |
le_algebraicClosure_iff (L : IntermediateField F E) :
L ≤ algebraicClosure F E ↔ Algebra.IsAlgebraic F L :=
⟨fun h ↦ ⟨fun x ↦ by simpa only [IsAlgebraic, ne_eq, ← aeval_algebraMap_eq_zero_iff E,
IntermediateField.algebraMap_apply,
Algebra.algebraMap_self, RingHomCompTriple.comp_apply, mem_algebraicClosure... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | le_algebraicClosure_iff | An intermediate field of `E / F` is contained in the algebraic closure of `F` in `E`
if and only if it is algebraic over `F`. |
algebraicClosure_eq_bot :
algebraicClosure (algebraicClosure F E) E = ⊥ :=
bot_unique fun x hx ↦ mem_bot.2
⟨⟨x, isIntegral_trans x (mem_algebraicClosure_iff'.1 hx)⟩, rfl⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | algebraicClosure_eq_bot | The algebraic closure in `E` of the algebraic closure of `F` in `E` is equal to itself. |
normalClosure_eq_self :
normalClosure F (algebraicClosure F E) E = algebraicClosure F E :=
le_antisymm (normalClosure_le_iff.2 fun i ↦
haveI : Algebra.IsAlgebraic F i.fieldRange := (AlgEquiv.ofInjectiveField i).isAlgebraic
le_algebraicClosure F E _) (le_normalClosure _) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | normalClosure_eq_self | The normal closure in `E/F` of the algebraic closure of `F` in `E` is equal to itself. |
IsAlgClosed.algebraicClosure_eq_bot_iff [IsAlgClosed E] :
algebraicClosure F E = ⊥ ↔ IsAlgClosed F := by
refine ⟨fun h ↦ IsAlgClosed.of_exists_root _ fun p hmon hirr ↦ ?_,
fun _ ↦ IntermediateField.eq_bot_of_isAlgClosed_of_isAlgebraic _⟩
obtain ⟨x, hx⟩ := IsAlgClosed.exists_aeval_eq_zero E p (degree_pos_of_... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | IsAlgClosed.algebraicClosure_eq_bot_iff | If `E / F` is a field extension and `E` is algebraically closed, then the algebraic closure
of `F` in `E` is equal to `F` if and only if `F` is algebraically closed. |
IntermediateField.isAlgebraic_adjoin_iff_isAlgebraic {S : Set E} :
Algebra.IsAlgebraic F (adjoin F S) ↔ ∀ x ∈ S, IsAlgebraic F x :=
((le_algebraicClosure_iff F E _).symm.trans (adjoin_le_iff.trans <| forall_congr' <|
fun _ => Iff.imp Iff.rfl mem_algebraicClosure_iff)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | IntermediateField.isAlgebraic_adjoin_iff_isAlgebraic | `F(S) / F` is a algebraic extension if and only if all elements of `S` are
algebraic elements. |
isAlgClosure [IsAlgClosed E] : IsAlgClosure F (algebraicClosure F E) :=
⟨(IsAlgClosed.algebraicClosure_eq_bot_iff _ E).mp (algebraicClosure_eq_bot F E),
isAlgebraic F E⟩ | instance | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | isAlgClosure | If `E` is algebraically closed, then the algebraic closure of `F` in `E` is an absolute
algebraic closure of `F`. |
eq_top_iff : algebraicClosure F E = ⊤ ↔ Algebra.IsAlgebraic F E :=
⟨fun h ↦ ⟨fun _ ↦ mem_algebraicClosure_iff.1 (h ▸ mem_top)⟩,
fun _ ↦ top_unique fun x _ ↦ mem_algebraicClosure_iff.2 (Algebra.IsAlgebraic.isAlgebraic x)⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | eq_top_iff | The algebraic closure of `F` in `E` is equal to `E` if and only if `E / F` is
algebraic. |
le_restrictScalars [Algebra E K] [IsScalarTower F E K] :
algebraicClosure F K ≤ (algebraicClosure E K).restrictScalars F :=
fun _ h ↦ mem_algebraicClosure_iff.2 <| IsAlgebraic.tower_top E (mem_algebraicClosure_iff.1 h) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | le_restrictScalars | If `K / E / F` is a field extension tower, then `algebraicClosure F K` is contained in
`algebraicClosure E K`. |
eq_restrictScalars_of_isAlgebraic [Algebra E K] [IsScalarTower F E K]
[Algebra.IsAlgebraic F E] : algebraicClosure F K = (algebraicClosure E K).restrictScalars F :=
(algebraicClosure.le_restrictScalars F E K).antisymm fun _ h ↦
isIntegral_trans _ h | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | eq_restrictScalars_of_isAlgebraic | If `K / E / F` is a field extension tower, such that `E / F` is algebraic, then
`algebraicClosure F K` is equal to `algebraicClosure E K`. |
adjoin_le [Algebra E K] [IsScalarTower F E K] :
adjoin E (algebraicClosure F K) ≤ algebraicClosure E K :=
adjoin_le_iff.2 <| le_restrictScalars F E K | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | adjoin_le | If `K / E / F` is a field extension tower, then `E` adjoin `algebraicClosure F K` is contained
in `algebraicClosure E K`. |
Splits.algebraicClosure {p : F[X]} (h : p.Splits (algebraMap F E)) :
p.Splits (algebraMap F (algebraicClosure F E)) :=
splits_of_splits h fun _ hx ↦ (isAlgebraic_of_mem_rootSet hx).isIntegral | theorem | FieldTheory | [
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.IntermediateField.Algebraic"
] | Mathlib/FieldTheory/AlgebraicClosure.lean | Splits.algebraicClosure | Let `E / F` be a field extension. If a polynomial `p`
splits in `E`, then it splits in the relative algebraic closure of `F` in `E` already. |
ax_grothendieck_of_locally_finite {ι K R : Type*} [Field K] [Finite K] [CommRing R]
[Finite ι] [Algebra K R] [alg : Algebra.IsAlgebraic K R] (ps : ι → MvPolynomial ι R)
(S : Set (ι → R))
(hm : S.MapsTo (fun v i => eval v (ps i)) S)
(hinj : S.InjOn (fun v i => eval v (ps i))) :
S.SurjOn (fun v i => e... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ax_grothendieck_of_locally_finite | Any injective polynomial map over an algebraic extension of a finite field is surjective. |
noncomputable genericPolyMapSurjOnOfInjOn [Finite ι]
(φ : ring.Formula (α ⊕ ι))
(mons : ι → Finset (ι →₀ ℕ)) : Language.ring.Sentence :=
let l1 : ι → Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
fun i =>
(termOfFreeCommRing (genericPolyMap mons i)).relabel
(Sum.inl ∘ Sum.map id... | def | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | genericPolyMapSurjOnOfInjOn | The collection of first-order formulas corresponding to the Ax-Grothendieck theorem. |
realize_genericPolyMapSurjOnOfInjOn
[Finite ι] (φ : ring.Formula (α ⊕ ι)) (mons : ι → Finset (ι →₀ ℕ)) :
(K ⊨ genericPolyMapSurjOnOfInjOn φ mons) ↔
∀ (v : α → K) (p : { p : ι → MvPolynomial ι K // (∀ i, (p i).support ⊆ mons i) }),
let f : (ι → K) → (ι → K) := fun v i => eval v (p.1 i)
let ... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | realize_genericPolyMapSurjOnOfInjOn | null |
ACF_models_genericPolyMapSurjOnOfInjOn_of_prime [Finite ι]
{p : ℕ} (hp : p.Prime) (φ : ring.Formula (α ⊕ ι)) (mons : ι → Finset (ι →₀ ℕ)) :
Theory.ACF p ⊨ᵇ genericPolyMapSurjOnOfInjOn φ mons := by
classical
have : Fact p.Prime := ⟨hp⟩
letI := compatibleRingOfRing (AlgebraicClosure (ZMod p))
rw [← (ACF_i... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ACF_models_genericPolyMapSurjOnOfInjOn_of_prime | null |
ACF_models_genericPolyMapSurjOnOfInjOn_of_prime_or_zero
[Finite ι] {p : ℕ} (hp : p.Prime ∨ p = 0)
(φ : ring.Formula (α ⊕ ι)) (mons : ι → Finset (ι →₀ ℕ)) :
Theory.ACF p ⊨ᵇ genericPolyMapSurjOnOfInjOn φ mons := by
rcases hp with hp | rfl
· exact ACF_models_genericPolyMapSurjOnOfInjOn_of_prime hp φ mons
... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ACF_models_genericPolyMapSurjOnOfInjOn_of_prime_or_zero | null |
ax_grothendieck_of_definable [CompatibleRing K] {c : Set K}
(S : Set (ι → K)) (hS : c.Definable Language.ring S)
(ps : ι → MvPolynomial ι K) :
S.MapsTo (fun v i => eval v (ps i)) S →
S.InjOn (fun v i => eval v (ps i)) →
S.SurjOn (fun v i => eval v (ps i)) S := by
letI := Fintype.ofFinite ι
let p... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ax_grothendieck_of_definable | A slight generalization of the **Ax-Grothendieck** theorem
If `K` is an algebraically closed field, `ι` is a finite type, and `S` is a definable subset of
`ι → K`, then any injective polynomial map `S → S` is also surjective on `S`. |
ax_grothendieck_zeroLocus
(I : Ideal (MvPolynomial ι K))
(p : ι → MvPolynomial ι K) :
let S := zeroLocus K I
S.MapsTo (fun v i => eval v (p i)) S →
S.InjOn (fun v i => eval v (p i)) →
S.SurjOn (fun v i => eval v (p i)) S := by
letI := compatibleRingOfRing K
intro S
obtain ⟨s, rfl⟩ : I.FG :... | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ax_grothendieck_zeroLocus | The **Ax-Grothendieck** theorem
If `K` is an algebraically closed field, and `S : Set (ι → K)` is the `zeroLocus` of an ideal
of the multivariable polynomial ring, then any injective polynomial map `S → S` is also
surjective on `S`. |
ax_grothendieck_univ (p : ι → MvPolynomial ι K) :
(fun v i => eval v (p i)).Injective →
(fun v i => eval v (p i)).Surjective := by
simpa [Set.injective_iff_injOn_univ, Set.surjective_iff_surjOn_univ] using
ax_grothendieck_zeroLocus 0 p | theorem | FieldTheory | [
"Mathlib.RingTheory.Algebraic.Basic",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.ModelTheory.Algebra.Field.IsAlgClosed",
"Mathlib.ModelTheory.Algebra.Ring.Definability",
"Mathlib.RingTheory.Polynomial.Basic"
] | Mathlib/FieldTheory/AxGrothendieck.lean | ax_grothendieck_univ | A special case of the **Ax-Grothendieck** theorem
Any injective polynomial map `K^n → K^n` is also surjective if `K` is an
algebraically closed field. |
wellOrderedBasis : Basis ι F E :=
(chooseBasis F E).reindex
(Cardinal.eq.mp <| (mk_ord_toType _).trans <| rank_eq_card_chooseBasisIndex F E).some.symm
local notation "b" => wellOrderedBasis F E
local notation "Ē" => AlgebraicClosure E
variable {F E} | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | wellOrderedBasis | Index a basis of E/F using the initial ordinal of the cardinal `Module.rank F E`. -/
local notation "ι" => (Module.rank F E).ord.toType
private local instance : SuccOrder ι := SuccOrder.ofLinearWellFoundedLT ι
local notation i"⁺" => succ i -- Note: conflicts with `PosPart` notation
/-- A basis of E/F indexed by the i... |
adjoin_basis_eq_top : adjoin F (range b) = ⊤ :=
toSubalgebra_injective <| Subalgebra.toSubmodule_injective <| top_unique <|
(Basis.span_eq b).ge.trans <| (Algebra.span_le_adjoin F _).trans <| algebra_adjoin_le_adjoin _ _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | adjoin_basis_eq_top | null |
noMaxOrder_rank_toType : NoMaxOrder ι := Cardinal.noMaxOrder Fact.out
attribute [local instance] noMaxOrder_rank_toType
open _root_.Algebra (IsAlgebraic)
variable [IsAlgebraic F E]
variable (F E) in | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | noMaxOrder_rank_toType | null |
leastExt : ι → ι :=
wellFounded_lt.fix fun i ih ↦
let s := range fun j : Iio i ↦ b (ih j j.2)
wellFounded_lt.min {k | b k ∉ adjoin F s} <| by
rw [← compl_setOf, nonempty_compl]; by_contra!
simp_rw [eq_univ_iff_forall, mem_setOf] at this
have := adjoin_le_iff.mpr (range_subset_iff.mpr this)
... | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | leastExt | `leastExt i` is defined to be the smallest `k : ι` that generates a nontrivial extension over
(i.e. does not lie in) the subalgebra (= intermediate field) generated by all previous
`leastExt j`, `j < i`. For cardinality reasons, such `k` always exist if `ι` is infinite. |
isLeast_leastExt (i : ι) : IsLeast {k | b k ∉ E⟮<i⟯} (φ i) := by
rw [image_eq_range, leastExt, wellFounded_lt.fix_eq]
exact ⟨wellFounded_lt.min_mem _ _, fun _ ↦ (wellFounded_lt.min_le ·)⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | isLeast_leastExt | null |
strictMono_leastExt : StrictMono φ := fun i j h ↦ by
have least := isLeast_leastExt (F := F) (E := E)
by_contra!
obtain eq | lt := this.eq_or_lt
· exact (least j).1 (subset_adjoin _ _ ⟨i, h, congr_arg b eq.symm⟩)
· refine ((least i).2 <| mt (adjoin.mono _ _ _ (image_mono ?_) ·) (least j).1).not_gt lt
exac... | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | strictMono_leastExt | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.