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 ?_⟩
exacts [isClosed_closure, fun _ ↦ smul_closure_orbit_subset _ _,
(nonempty_orbit _).closure.ne_empty] | 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.all _ _).isNilpotent_mul_left ?_
simpa using Commute.isNilpotent_add (Commute.all _ _)
(isNilpotent_aeval_sub_of_isNilpotent_sub P ih) h | 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] x)
(-Ring.inverse (aeval (P.newtonMap^[n] x) <| derivative P) * aeval (P.newtonMap^[n] x) P)
rw [eval_map_algebraMap, eval_map_algebraMap] at hd
rw [iterate_succ', comp_apply, newtonMap_apply, sub_eq_add_neg, neg_mul_eq_neg_mul, hd]
refine dvd_add ?_ (dvd_mul_of_dvd_right ?_ _)
· convert dvd_zero _
have : IsUnit (aeval (P.newtonMap^[n] x) <| derivative P) :=
isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub h' <|
isNilpotent_iterate_newtonMap_sub_of_isNilpotent h n
rw [derivative_map, eval_map_algebraMap, ← mul_assoc, mul_neg, Ring.mul_inverse_cancel _ this,
neg_mul, one_mul, add_neg_cancel]
· rw [neg_mul, even_two.neg_pow, mul_pow, pow_succ, pow_mul]
exact dvd_mul_of_dvd_right (pow_dvd_pow_of_dvd ih 2) _ | 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₂'⟩ ↦ ?_
· -- Existence
obtain ⟨n, hn⟩ := id h
refine ⟨P.newtonMap^[n] x, isNilpotent_iterate_newtonMap_sub_of_isNilpotent h n, ?_⟩
rw [← zero_dvd_iff, ← pow_eq_zero_of_le (n.lt_two_pow_self).le hn]
exact aeval_pow_two_pow_dvd_aeval_iterate_newtonMap h h' n
· -- Uniqueness
have ⟨u, hu⟩ := binomExpansion (P.map (algebraMap R S)) r₁ (r₂ - r₁)
suffices IsUnit (aeval r₁ (derivative P) + u * (r₂ - r₁)) by
rwa [derivative_map, eval_map_algebraMap, eval_map_algebraMap, eval_map_algebraMap,
add_sub_cancel, hr₂', hr₁', zero_add, pow_two, ← mul_assoc, ← add_mul, eq_comm,
this.mul_right_eq_zero, sub_eq_zero, eq_comm] at hu
have : IsUnit (aeval r₁ (derivative P)) :=
isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub h' hr₁
rw [← sub_sub_sub_cancel_right r₂ r₁ x]
refine IsNilpotent.isUnit_add_left_of_commute ?_ this (Commute.all _ _)
exact (Commute.all _ _).isNilpotent_mul_left <| (Commute.all _ _).isNilpotent_sub hr₂ hr₁ | 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_preimage]⟩
· intro h _ hu _ hn
rcases h _ hn hu with ⟨_, ht, _, hx, hϕtx⟩
exact ⟨_, hϕtx, _, ht, _, hx, rfl⟩ | 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
-/
open omegaLimit
theorem omegaLimit_def : ω f ϕ s = ⋂ u ∈ f, closure (image2 ϕ u s) := rfl
theorem omegaLimit_subset_of_tendsto {m : τ → τ} {f₁ f₂ : Filter τ} (hf : Tendsto m f₁ f₂) :
ω f₁ (fun t x ↦ ϕ (m t) x) s ⊆ ω f₂ ϕ s := by
refine iInter₂_mono' fun u hu ↦ ⟨m ⁻¹' u, tendsto_def.mp hf _ hu, ?_⟩
rw [← image2_image_left]
exact closure_mono (image2_subset (image_preimage_subset _ _) Subset.rfl)
theorem omegaLimit_mono_left {f₁ f₂ : Filter τ} (hf : f₁ ≤ f₂) : ω f₁ ϕ s ⊆ ω f₂ ϕ s :=
omegaLimit_subset_of_tendsto ϕ s (tendsto_id'.2 hf)
theorem omegaLimit_mono_right {s₁ s₂ : Set α} (hs : s₁ ⊆ s₂) : ω f ϕ s₁ ⊆ ω f ϕ s₂ :=
iInter₂_mono fun _u _hu ↦ closure_mono (image2_subset Subset.rfl hs)
theorem isClosed_omegaLimit : IsClosed (ω f ϕ s) :=
isClosed_iInter fun _u ↦ isClosed_iInter fun _hu ↦ isClosed_closure
theorem mapsTo_omegaLimit' {α' β' : Type*} [TopologicalSpace β'] {f : Filter τ} {ϕ : τ → α → β}
{ϕ' : τ → α' → β'} {ga : α → α'} {s' : Set α'} (hs : MapsTo ga s s') {gb : β → β'}
(hg : ∀ᶠ t in f, EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s) (hgc : Continuous gb) :
MapsTo gb (ω f ϕ s) (ω f ϕ' s') := by
simp only [omegaLimit_def, mem_iInter, MapsTo]
intro y hy u hu
refine map_mem_closure hgc (hy _ (inter_mem hu hg)) (forall_mem_image2.2 fun t ht x hx ↦ ?_)
calc
ϕ' t (ga x) ∈ image2 ϕ' u s' := mem_image2_of_mem ht.1 (hs hx)
_ = gb (ϕ t x) := ht.2 hx |>.symm
theorem mapsTo_omegaLimit {α' β' : Type*} [TopologicalSpace β'] {f : Filter τ} {ϕ : τ → α → β}
{ϕ' : τ → α' → β'} {ga : α → α'} {s' : Set α'} (hs : MapsTo ga s s') {gb : β → β'}
(hg : ∀ t x, gb (ϕ t x) = ϕ' t (ga x)) (hgc : Continuous gb) :
MapsTo gb (ω f ϕ s) (ω f ϕ' s') :=
mapsTo_omegaLimit' _ hs (Eventually.of_forall fun t x _hx ↦ hg t x) hgc
theorem omegaLimit_image_eq {α' : Type*} (ϕ : τ → α' → β) (f : Filter τ) (g : α → α') :
ω f ϕ (g '' s) = ω f (fun t x ↦ ϕ t (g x)) s := by simp only [omegaLimit, image2_image_right]
theorem omegaLimit_preimage_subset {α' : Type*} (ϕ : τ → α' → β) (s : Set α') (f : Filter τ)
(g : α → α') : ω f (fun t x ↦ ϕ t (g x)) (g ⁻¹' s) ⊆ ω f ϕ s :=
mapsTo_omegaLimit _ (mapsTo_preimage _ _) (fun _t _x ↦ rfl) continuous_id
/-!
### Equivalent definitions of the omega limit
The next few lemmas are various versions of the property
characterising ω-limits:
-/
/-- An element `y` is in the ω-limit set of `s` w.r.t. `f` if the
preimages of an arbitrary neighbourhood of `y` frequently (w.r.t. `f`) intersects of `s`. |
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 ⟨⟨n₁, hn₁, h₁⟩, ⟨n₂, hn₂, h₂⟩⟩
refine ⟨n₁ ∩ n₂, inter_mem hn₁ hn₂, h₁.mono fun t ↦ ?_, h₂.mono fun t ↦ ?_⟩
exacts [Subset.trans <| inter_subset_inter_right _ <| preimage_mono inter_subset_left,
Subset.trans <| inter_subset_inter_right _ <| preimage_mono inter_subset_right]
· rintro (hy | hy)
exacts [omegaLimit_mono_right _ _ subset_union_left hy,
omegaLimit_mono_right _ _ subset_union_right hy] | 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 set `v` also in `f`.
-/ | 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 s)
have hk : IsCompact (k \ n) :=
(hc₁.of_isClosed_subset isClosed_closure hv₂).diff hn₁
let j u := (closure (image2 ϕ (u ∩ v) s))ᶜ
have hj₁ : ∀ u ∈ f, IsOpen (j u) := fun _ _ ↦ isOpen_compl_iff.mpr isClosed_closure
have hj₂ : k \ n ⊆ ⋃ u ∈ f, j u := by
have : ⋃ u ∈ f, j u = ⋃ u : (↥f.sets), j u := biUnion_eq_iUnion _ _
rw [this, diff_subset_comm, diff_iUnion]
rw [omegaLimit_eq_iInter_inter _ _ _ hv₁] at hn₂
simp_rw [j, diff_compl]
rw [← inter_iInter]
exact Subset.trans inter_subset_right hn₂
rcases hk.elim_finite_subcover_image hj₁ hj₂ with ⟨g, hg₁ : ∀ u ∈ g, u ∈ f, hg₂, hg₃⟩
let w := (⋂ u ∈ g, u) ∩ v
have hw₂ : w ∈ f := by simpa [w, *]
have hw₃ : k \ n ⊆ (closure (image2 ϕ w s))ᶜ := by
apply Subset.trans hg₃
simp only [j, iUnion_subset_iff, compl_subset_compl]
intro u hu
unfold w
gcongr
refine iInter_subset_of_subset u (iInter_subset_of_subset hu ?_)
all_goals exact Subset.rfl
have hw₄ : kᶜ ⊆ (closure (image2 ϕ w s))ᶜ := by
simp only [compl_subset_compl]
exact closure_mono (image2_subset inter_subset_right Subset.rfl)
have hnc : nᶜ ⊆ k \ n ∪ kᶜ := by rw [union_comm, ← inter_subset, diff_eq, inter_comm]
have hw : closure (image2 ϕ w s) ⊆ n :=
compl_subset_compl.mp (Subset.trans hnc (union_subset hw₃ hw₄))
exact ⟨_, hw₂, hw⟩ | 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_of_omegaLimit_subset' f ϕ _ hc₁
⟨_, hc₂, closure_minimal (image2_subset_iff.2 fun _t ↦ id) hc₁.isClosed⟩ hn₁ hn₂ | 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_omegaLimit_subset f ϕ s hc₁
hc₂ hn₁ hn₂ with
⟨u, hu_mem, hu⟩
refine mem_of_superset hu_mem fun t ht x hx ↦ ?_
exact hu (subset_closure <| mem_image2_of_mem ht hx) | 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 (subset_closure <| mem_image2_of_mem ht hx) | 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_isClosed
· rintro ⟨u₁, hu₁⟩ ⟨u₂, hu₂⟩
use ⟨u₁ ∩ u₂, inter_mem hu₁ hu₂⟩
constructor
all_goals exact closure_mono (image2_subset (inter_subset_inter_left _ (by simp)) Subset.rfl)
· intro u
have hn : (image2 ϕ (u ∩ v) s).Nonempty :=
Nonempty.image2 (Filter.nonempty_of_mem (inter_mem u.prop hv₁)) hs
exact hn.mono subset_closure
· intro
apply hc₁.of_isClosed_subset isClosed_closure
calc
_ ⊆ closure (image2 ϕ v s) := closure_mono (image2_subset inter_subset_right Subset.rfl)
_ ⊆ c := hv₂
· exact fun _ ↦ isClosed_closure | 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₁ : (ω f ϕ s ∩ o).Nonempty :=
ht₂.mono
(inter_subset_inter_left _
((isInvariant_iff_image _ _).mp (isInvariant_omegaLimit _ _ _ hf) _))
have l₂ : (closure (image2 ϕ u s) ∩ o).Nonempty :=
l₁.mono fun b hb ↦ ⟨omegaLimit_subset_closure_fw_image _ _ _ hu hb.1, hb.2⟩
have l₃ : (o ∩ image2 ϕ u s).Nonempty := by
rcases l₂ with ⟨b, hb₁, hb₂⟩
exact mem_closure_iff_nhds.mp hb₁ o (IsOpen.mem_nhds ho₂ hb₂)
rcases l₃ with ⟨ϕra, ho, ⟨_, hr, _, ha, hϕra⟩⟩
exact ⟨_, hr, ϕra, ⟨_, ha, hϕra⟩, ho₁ ho⟩ | 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 ϕ : (L ≃ₐ[K] L) ≃* (q.map (algebraMap F K)).Gal :=
(IsSplittingField.algEquiv L (q.map (algebraMap F K))).autCongr
have ϕ_inj : Function.Injective ϕ.toMonoidHom := ϕ.injective
haveI : IsSolvable (K ≃ₐ[F] K) := hp
haveI : IsSolvable (L ≃ₐ[K] L) := solvable_of_solvable_injective ϕ_inj
exact isSolvable_of_isScalarTower F p.SplittingField q.SplittingField | 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 ha
simp only [mem_rootSet_of_ne hn'', map_sub, aeval_X_pow, aeval_one, sub_eq_zero] at ha
have key : ∀ σ : (X ^ n - 1 : F[X]).Gal, ∃ m : ℕ, σ a = a ^ m := by
intro σ
lift n to ℕ+ using hn'
exact map_rootsOfUnity_eq_pow_self σ.toAlgHom (rootsOfUnity.mkOfPowEq a ha)
obtain ⟨c, hc⟩ := key σ
obtain ⟨d, hd⟩ := key τ
rw [σ.mul_apply, τ.mul_apply, hc, map_pow, hd, map_pow, hc, ← pow_mul, pow_mul'] | 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 _).mp (RingHom.injective _) a) ha
by_cases hn : n = 0
· rw [hn, pow_zero, ← C_1, ← C_sub]
exact gal_C_isSolvable (1 - a)
have hn' : 0 < n := pos_iff_ne_zero.mpr hn
have hn'' : X ^ n - C a ≠ 0 := X_pow_sub_C_ne_zero hn' a
have hn''' : (X ^ n - 1 : F[X]) ≠ 0 := X_pow_sub_C_ne_zero hn' 1
have mem_range : ∀ {c : (X ^ n - C a).SplittingField},
(c ^ n = 1 → (∃ d, algebraMap F (X ^ n - C a).SplittingField d = c)) := fun {c} hc =>
RingHom.mem_range.mp (minpoly.mem_range_of_degree_eq_one F c (h.def.resolve_left hn'''
(minpoly.irreducible ((SplittingField.instNormal (X ^ n - C a)).isIntegral c))
(minpoly.dvd F c (by rwa [map_id, map_sub, sub_eq_zero, aeval_X_pow, aeval_one]))))
apply isSolvable_of_comm
intro σ τ
ext b hb
rw [mem_rootSet_of_ne hn'', map_sub, aeval_X_pow, aeval_C, sub_eq_zero] at hb
have hb' : b ≠ 0 := by
intro hb'
rw [hb', zero_pow hn] at hb
exact ha' hb.symm
have key : ∀ σ : (X ^ n - C a).Gal, ∃ c, σ b = b * algebraMap F _ c := by
intro σ
have key : (σ b / b) ^ n = 1 := by rw [div_pow, ← map_pow, hb, σ.commutes, div_self ha']
obtain ⟨c, hc⟩ := mem_range key
use c
rw [hc, mul_div_cancel₀ (σ b) hb']
obtain ⟨c, hc⟩ := key σ
obtain ⟨d, hd⟩ := key τ
rw [σ.mul_apply, τ.mul_apply, hc, map_mul, τ.commutes, hd, map_mul, σ.commutes, hc,
mul_assoc, mul_assoc, mul_right_inj' hb', mul_comm] | 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, sub_self]
exact splits_zero i
have hn' : 0 < n := pos_iff_ne_zero.mpr hn
have hn'' : (X ^ n - C a).degree ≠ 0 :=
ne_of_eq_of_ne (degree_X_pow_sub_C hn' a) (mt WithBot.coe_eq_coe.mp hn)
obtain ⟨b, hb⟩ := exists_root_of_splits i h hn''
rw [eval₂_sub, eval₂_X_pow, eval₂_C, sub_eq_zero] at hb
have hb' : b ≠ 0 := by
intro hb'
rw [hb', zero_pow hn] at hb
exact ha' hb.symm
let s := ((X ^ n - C a).map i).roots
have hs : _ = _ * (s.map _).prod := eq_prod_roots_of_splits h
rw [leadingCoeff_X_pow_sub_C hn', RingHom.map_one, C_1, one_mul] at hs
have hs' : Multiset.card s = n := (natDegree_eq_card_roots h).symm.trans natDegree_X_pow_sub_C
apply @splits_of_exists_multiset F E _ _ i (X ^ n - 1) (s.map fun c : E => c / b)
rw [leadingCoeff_X_pow_sub_one hn', RingHom.map_one, C_1, one_mul, Multiset.map_map]
have C_mul_C : C (i a⁻¹) * C (i a) = 1 := by
rw [← C_mul, ← i.map_mul, inv_mul_cancel₀ ha, i.map_one, C_1]
have key1 : (X ^ n - 1 : F[X]).map i = C (i a⁻¹) * ((X ^ n - C a).map i).comp (C b * X) := by
rw [Polynomial.map_sub, Polynomial.map_sub, Polynomial.map_pow, map_X, map_C,
Polynomial.map_one, sub_comp, pow_comp, X_comp, C_comp, mul_pow, ← C_pow, hb, mul_sub, ←
mul_assoc, C_mul_C, one_mul]
have key2 : ((fun q : E[X] => q.comp (C b * X)) ∘ fun c : E => X - C c) = fun c : E =>
C b * (X - C (c / b)) := by
ext1 c
dsimp only [Function.comp_apply]
rw [sub_comp, X_comp, C_comp, mul_sub, ← C_mul, mul_div_cancel₀ c hb']
rw [key1, hs, multiset_prod_comp, Multiset.map_map, key2, Multiset.prod_map_mul,
Function.const_def (α := E) (y := C b), Multiset.map_const, Multiset.prod_replicate,
hs', ← C_pow, hb, ← mul_assoc, C_mul_C, one_mul]
rfl | 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_one_isSolvable n
· rw [Polynomial.map_sub, Polynomial.map_pow, map_X, map_C]
apply gal_X_pow_sub_C_isSolvable_aux
have key := SplittingField.splits (X ^ n - 1 : F[X])
rwa [← splits_id_iff_splits, Polynomial.map_sub, Polynomial.map_pow, map_X,
Polynomial.map_one] at key | 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 (α : E) : IsSolvableByRad α → IsSolvableByRad α⁻¹
| rad (α : E) (n : ℕ) (hn : n ≠ 0) : IsSolvableByRad (α ^ n) → IsSolvableByRad α
variable (E) | 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 (E := E) (1 : F); rw [RingHom.map_one]
mul_mem' := by apply IsSolvableByRad.mul
inv_mem' := IsSolvableByRad.inv
algebraMap_mem' := 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 α⁻¹)
(rad : ∀ α : solvableByRad F E, ∀ n : ℕ, n ≠ 0 → P (α ^ n) → P α) (α : solvableByRad F E) :
P α := by
revert α
suffices ∀ α : E, IsSolvableByRad F α → ∃ β : solvableByRad F E, ↑β = α ∧ P β by
intro α
obtain ⟨α₀, hα₀, Pα⟩ := this α (Subtype.mem α)
convert Pα
exact Subtype.ext hα₀.symm
apply IsSolvableByRad.rec
· exact fun α => ⟨algebraMap F (solvableByRad F E) α, rfl, base α⟩
· intro α β _ _ Pα Pβ
obtain ⟨⟨α₀, hα₀, Pα⟩, β₀, hβ₀, Pβ⟩ := Pα, Pβ
exact ⟨α₀ + β₀, by rw [← hα₀, ← hβ₀]; rfl, add α₀ β₀ Pα Pβ⟩
· intro α _ Pα
obtain ⟨α₀, hα₀, Pα⟩ := Pα
exact ⟨-α₀, by rw [← hα₀]; rfl, neg α₀ Pα⟩
· intro α β _ _ Pα Pβ
obtain ⟨⟨α₀, hα₀, Pα⟩, β₀, hβ₀, Pβ⟩ := Pα, Pβ
exact ⟨α₀ * β₀, by rw [← hα₀, ← hβ₀]; rfl, mul α₀ β₀ Pα Pβ⟩
· intro α _ Pα
obtain ⟨α₀, hα₀, Pα⟩ := Pα
exact ⟨α₀⁻¹, by rw [← hα₀]; rfl, inv α₀ Pα⟩
· intro α n hn hα Pα
obtain ⟨α₀, hα₀, Pα⟩ := Pα
refine ⟨⟨α, IsSolvableByRad.rad α n hn hα⟩, rfl, rad _ n hn ?_⟩
convert Pα
exact Subtype.ext (Eq.trans ((solvableByRad F E).coe_pow _ n) hα₀.symm) | 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α
obtain ⟨p, h1, h2⟩ := hα.isAlgebraic
refine IsAlgebraic.isIntegral ⟨p.comp (X ^ n),
⟨fun h => h1 (leadingCoeff_eq_zero.mp ?_), by rw [aeval_comp, aeval_X_pow, h2]⟩⟩
rwa [← leadingCoeff_eq_zero, leadingCoeff_comp, leadingCoeff_X_pow, one_pow, mul_one] at h
rwa [natDegree_X_pow] | 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_X_pow])
apply gal_isSolvable_of_splits
· exact ⟨splits_of_splits_of_dvd _ hp (SplittingField.splits (p.comp (X ^ n)))
(minpoly.dvd F α (by rw [aeval_comp, aeval_X_pow, minpoly.aeval]))⟩
· refine gal_isSolvable_tower p (p.comp (X ^ n)) ?_ hα ?_
· exact Gal.splits_in_splittingField_of_comp _ _ (by rwa [natDegree_X_pow])
· obtain ⟨s, hs⟩ := (splits_iff_exists_multiset _).1 (SplittingField.splits p)
rw [map_comp, Polynomial.map_pow, map_X, hs, mul_comp, C_comp]
apply gal_mul_isSolvable (gal_C_isSolvable _)
rw [multiset_prod_comp]
apply gal_prod_isSolvable
intro q hq
rw [Multiset.mem_map] at hq
obtain ⟨q, hq, rfl⟩ := hq
rw [Multiset.mem_map] at hq
obtain ⟨q, _, rfl⟩ := hq
rw [sub_comp, X_comp, C_comp]
exact gal_X_pow_sub_C_isSolvable n q
open IntermediateField | 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⟮α, β⟯ →ₐ[F] (p * q).SplittingField :=
Classical.choice <| nonempty_algHom_adjoin_of_splits <| by
intro x hx
simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hx
cases hx with rw [hx]
| inl hx => exact ⟨isIntegral α, hpq.1⟩
| inr hx => exact ⟨isIntegral β, hpq.2⟩
have key : minpoly F γ = minpoly F (f ⟨γ, hγ⟩) := by
refine minpoly.eq_of_irreducible_of_monic
(minpoly.irreducible (isIntegral γ)) ?_ (minpoly.monic (isIntegral γ))
rw [aeval_algHom_apply, map_eq_zero]
apply (algebraMap (↥F⟮α, β⟯) (solvableByRad F E)).injective
simp only [map_zero, ← aeval_algebraMap_apply]
exact minpoly.aeval F γ
rw [P, key]
refine gal_isSolvable_of_splits ⟨Normal.splits ?_ (f ⟨γ, hγ⟩)⟩ (gal_mul_isSolvable hα hβ)
apply SplittingField.instNormal | 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 _ (Set.mem_insert_of_mem α (Set.mem_singleton β))))
· exact fun α => induction1 (neg_mem (mem_adjoin_simple_self F α))
· exact fun α β => induction2 (mul_mem (subset_adjoin F _ (Set.mem_insert α _))
(subset_adjoin F _ (Set.mem_insert_of_mem α (Set.mem_singleton β))))
· exact fun α => induction1 (inv_mem (mem_adjoin_simple_self F α))
· exact fun α n => induction3 | 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 α from
(minpoly.algebraMap_eq (RingHom.injective _) _).symm]
exact isSolvable ⟨α, hα⟩
refine solvable_of_surjective (Gal.restrictDvd_surjective ⟨C q.leadingCoeff⁻¹, rfl⟩ ?_)
rw [mul_ne_zero_iff, Ne, Ne, C_eq_zero, inv_eq_zero]
exact ⟨q_irred.ne_zero, leadingCoeff_ne_zero.mpr q_irred.ne_zero⟩ | 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 of all integral/algebraic elements. |
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'.2
(IsIntegral.tower_top <| mem_algebraicClosure_iff'.1 hx)
exact ⟨y, (map_mem_algebraicClosure_iff <| IsScalarTower.toAlgHom F E K).mp hx, rfl⟩ | 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_iff] using h x.2⟩,
fun _ ↦ le_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_irreducible hirr).ne'
obtain ⟨x, rfl⟩ := h ▸ mem_algebraicClosure_iff'.2 (minpoly.ne_zero_iff.1 <|
ne_zero_of_dvd_ne_zero hmon.ne_zero (minpoly.dvd _ x hx))
exact ⟨x, by simpa [Algebra.ofId_apply] using hx⟩ | 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 => eval v (ps i)) S := by
have is_int : ∀ x : R, IsIntegral K x := fun x => isAlgebraic_iff_isIntegral.1
(alg.isAlgebraic x)
classical
intro v hvS
cases nonempty_fintype ι
/- `s` is the set of all coefficients of the polynomial, as well as all of
the coordinates of `v`, the point I am trying to find the preimage of. -/
let s : Finset R :=
(Finset.biUnion (univ : Finset ι) fun i => (ps i).support.image fun x => coeff x (ps i)) ∪
(univ : Finset ι).image v
have hv : ∀ i, v i ∈ Algebra.adjoin K (s : Set R) := fun j =>
Algebra.subset_adjoin (mem_union_right _ (mem_image.2 ⟨j, mem_univ _, rfl⟩))
have hs₁ : ∀ (i : ι) (k : ι →₀ ℕ),
k ∈ (ps i).support → coeff k (ps i) ∈ Algebra.adjoin K (s : Set R) :=
fun i k hk => Algebra.subset_adjoin
(mem_union_left _ (mem_biUnion.2 ⟨i, mem_univ _, mem_image_of_mem _ hk⟩))
have := isNoetherian_adjoin_finset s fun x _ => is_int x
have : Finite (Algebra.adjoin K (s : Set R)) := Module.finite_of_finite K
let S' : Set (ι → Algebra.adjoin K (s : Set R)) :=
(fun v => Subtype.val ∘ v) ⁻¹' S
let res : S' → S' := fun x => ⟨fun i =>
⟨eval (fun j : ι => (x.1 j : R)) (ps i), eval_mem (hs₁ _) fun i => (x.1 i).2⟩,
hm x.2⟩
have hres_surj : Function.Surjective res := by
rw [← Finite.injective_iff_surjective]
intro x y hxy
ext i
simp only [Subtype.ext_iff, funext_iff] at hxy
exact congr_fun (hinj x.2 y.2 (funext hxy)) i
rcases hres_surj ⟨fun i => ⟨v i, hv i⟩, hvS⟩ with ⟨⟨w, hwS'⟩, hw⟩
refine ⟨fun i => w i, hwS', ?_⟩
simpa [Subtype.ext_iff, funext_iff] using hw | 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 (fun i => (0, i)))
=' (termOfFreeCommRing (genericPolyMap mons i)).relabel
(Sum.inl ∘ Sum.map id (fun i => (1, i)))
let f1 : Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
iInf l1
let l2 : ι → Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
fun i => .var (Sum.inl (Sum.inr (0, i))) =' .var (Sum.inl (Sum.inr (1, i)))
let f2 : Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
iInf l2
let injOn : Language.ring.Formula (α ⊕ Σ i : ι, mons i) :=
Formula.iAlls (Fin 2 × ι)
(φ.relabel (Sum.map Sum.inl (fun i => (0, i))) ⟹
φ.relabel (Sum.map Sum.inl (fun i => (1, i))) ⟹
(f1.imp f2).relabel (fun x => (Equiv.sumAssoc _ _ _).symm (Sum.inr x)))
let l3 : ι → Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
fun i => (termOfFreeCommRing (genericPolyMap mons i)).relabel
(Sum.inl ∘ Sum.map id (fun i => (0, i))) ='
.var (Sum.inl (Sum.inr (1, i)))
let f3 : Language.ring.Formula ((Σ i : ι, mons i) ⊕ (Fin 2 × ι)) :=
iInf l3
let surjOn : Language.ring.Formula (α ⊕ Σ i : ι, mons i) :=
Formula.iAlls ι
(Formula.imp (φ.relabel (Sum.map Sum.inl id)) <|
Formula.iExs ι <|
((φ.relabel (Sum.map Sum.inl (fun i => (0, i)))) ⊓
(f3.relabel (fun x => (Equiv.sumAssoc _ _ _).symm (Sum.inr x)))).relabel
(fun (i : (α ⊕ (Σ i : ι, mons i)) ⊕ (Fin 2 × ι)) =>
show ((α ⊕ (Σ i : ι, mons i)) ⊕ ι) ⊕ ι
from Sum.elim (Sum.inl ∘ Sum.inl)
(fun i => if i.1 = 0 then Sum.inr i.2 else (Sum.inl (Sum.inr i.2))) i))
let mapsTo : Language.ring.Formula (α ⊕ Σ i : ι, mons i) :=
Formula.iAlls ι
(Formula.imp (φ.relabel (Sum.map Sum.inl id))
(φ.subst <| Sum.elim
(fun a => .var (Sum.inl (Sum.inl a)))
(fun i => (termOfFreeCommRing (genericPolyMap mons i)).relabel
(fun i => (Equiv.sumAssoc _ _ _).symm (Sum.inr i)))))
Formula.iAlls (α ⊕ Σ i : ι, mons i) ((mapsTo.imp <| injOn.imp <| surjOn).relabel Sum.inr) | 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 S : Set (ι → K) := {x | φ.Realize (Sum.elim v x)}
S.MapsTo f S → S.InjOn f → S.SurjOn f S := by
classical
have injOnAlt : ∀ {S : Set (ι → K)} (f : (ι → K) → (ι → K)),
S.InjOn f ↔ ∀ x y, x ∈ S → y ∈ S → f x = f y → x = y := by
simp [Set.InjOn]; tauto
simp only [Sentence.Realize, Formula.Realize, genericPolyMapSurjOnOfInjOn, Formula.relabel,
Function.comp_def, Sum.map, id_eq, Equiv.sumAssoc, Equiv.coe_fn_symm_mk, Sum.elim_inr,
realize_iAlls, realize_imp, realize_relabel, Fin.natAdd_zero, realize_subst, realize_iInf,
realize_bdEqual, Term.realize_relabel,
Equiv.forall_congr_left (Equiv.curry (Fin 2) ι K), Equiv.curry_symm_apply,
Fin.forall_fin_succ_pi, Fin.forall_fin_zero_pi, realize_iExs, realize_inf, Sum.forall_sum,
Set.MapsTo, Set.mem_setOf_eq, injOnAlt, funext_iff, Set.SurjOn, Set.image,
Set.subset_def, Equiv.forall_congr_left (mvPolynomialSupportLEEquiv mons)]
simp +singlePass only [← Sum.elim_comp_inl_inr]
simp only [Function.comp_def, Sum.elim_inl, Sum.elim_inr, Fin.castAdd_zero, Fin.cast_eq_self,
Nat.add_zero, Term.realize_var, Term.realize_relabel, realize_termOfFreeCommRing,
lift_genericPolyMap, Nat.reduceAdd, Fin.isValue, Function.uncurry_apply_pair, Fin.cons_zero,
Fin.cons_one, ↓reduceIte, one_ne_zero] | 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_isComplete (Or.inl hp)).realize_sentence_iff _
(AlgebraicClosure (ZMod p)), realize_genericPolyMapSurjOnOfInjOn]
rintro v ⟨f, _⟩
exact ax_grothendieck_of_locally_finite (K := ZMod p) (ι := ι) f _ | 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
· rw [ACF_zero_realize_iff_infinite_ACF_prime_realize]
convert Set.infinite_univ (α := Nat.Primes)
rw [Set.eq_univ_iff_forall]
intro ⟨p, hp⟩
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 : ℕ := ringChar K
rw [Set.definable_iff_finitely_definable] at hS
rcases hS with ⟨c, _, hS⟩
rw [Set.definable_iff_exists_formula_sum] at hS
rcases hS with ⟨φ, hφ⟩
rw [hφ]
have := ACF_models_genericPolyMapSurjOnOfInjOn_of_prime_or_zero
(CharP.char_is_prime_or_zero K p) φ (fun i => (ps i).support)
rw [← (ACF_isComplete (CharP.char_is_prime_or_zero K p)).realize_sentence_iff _ K,
realize_genericPolyMapSurjOnOfInjOn] at this
exact this Subtype.val ⟨ps, fun i => Set.Subset.refl _⟩ | 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 := IsNoetherian.noetherian I
exact ax_grothendieck_of_definable S (mvPolynomial_zeroLocus_definable s) 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_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 initial ordinal. |
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)
rw [adjoin_basis_eq_top, ← eq_top_iff] at this
apply_fun Module.rank F at this
refine ne_of_lt ?_ this
let _ : AddCommMonoid (⊤ : IntermediateField F E) := inferInstance
conv_rhs => rw [topEquiv.toLinearEquiv.rank_eq]
have := mk_Iio_ord_toType i
obtain eq | lt := rank_inf.out.eq_or_lt
· replace this := mk_lt_aleph0_iff.mp (this.trans_eq eq.symm)
have : FiniteDimensional F (adjoin F s) :=
finiteDimensional_adjoin fun x _ ↦ (IsAlgebraic.isAlgebraic x).isIntegral
exact (Module.rank_lt_aleph0 _ _).trans_eq eq
· exact (Subalgebra.equivOfEq _ _ <| adjoin_algebraic_toSubalgebra
fun x _ ↦ IsAlgebraic.isAlgebraic x)|>.toLinearEquiv.rank_eq.trans_lt <|
(Algebra.rank_adjoin_le _).trans_lt (max_lt (mk_range_le.trans_lt this) lt)
local notation "φ" => leastExt 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 | 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
exact fun k (hk : k < i) ↦ hk.trans h | 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.