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 ⌀ |
|---|---|---|---|---|---|---|
embEquivOfEquiv (i : E ≃ₐ[F] K) :
Emb F E ≃ Emb F K := AlgEquiv.arrowCongr i <| AlgEquiv.symm <| by
let _ : Algebra E K := i.toAlgHom.toRingHom.toAlgebra
have : Algebra.IsAlgebraic E K := by
constructor
intro x
have h := isAlgebraic_algebraMap (R := E) (A := K) (i.symm.toAlgHom x)
rw [show ∀ y : E, (algebraMap E K) y = i.toAlgHom y from fun y ↦ rfl] at h
simpa only [AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_coe, AlgEquiv.apply_symm_apply] using h
apply AlgEquiv.restrictScalars (R := F) (S := E)
exact IsAlgClosure.equivOfAlgebraic E K (AlgebraicClosure K) (AlgebraicClosure E) | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | embEquivOfEquiv | A random bijection between `Field.Emb F E` and `Field.Emb F K` when `E` and `K` are isomorphic
as `F`-algebras. |
finSepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
finSepDegree F E = finSepDegree F K := Nat.card_congr (embEquivOfEquiv F E K i)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_of_equiv | If `E` and `K` are isomorphic as `F`-algebras, then they have the same `Field.finSepDegree`
over `F`. |
finSepDegree_self : finSepDegree F F = 1 := by
have : Cardinal.mk (Emb F F) = 1 := le_antisymm
(Cardinal.le_one_iff_subsingleton.2 AlgHom.subsingleton)
(Cardinal.one_le_iff_ne_zero.2 <| Cardinal.mk_ne_zero _)
rw [finSepDegree, Nat.card, this, Cardinal.one_toNat] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_self | null |
@[simp]
finSepDegree_bot : finSepDegree F (⊥ : IntermediateField F E) = 1 := by
rw [finSepDegree_eq_of_equiv _ _ _ (botEquiv F E), finSepDegree_self] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_bot | null |
@[simp]
finSepDegree_bot' : finSepDegree F (⊥ : IntermediateField E K) = finSepDegree F E :=
finSepDegree_eq_of_equiv _ _ _ ((botEquiv E K).restrictScalars F)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_bot' | null |
finSepDegree_top : finSepDegree F (⊤ : IntermediateField E K) = finSepDegree F K :=
finSepDegree_eq_of_equiv _ _ _ ((topEquiv (F := E) (E := K)).restrictScalars F) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_top | null |
embEquivOfAdjoinSplits {S : Set E} (hS : adjoin F S = ⊤)
(hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)) :
Emb F E ≃ (E →ₐ[F] K) :=
have : Algebra.IsAlgebraic F (⊤ : IntermediateField F E) :=
(hS ▸ isAlgebraic_adjoin (S := S) fun x hx ↦ (hK x hx).1)
have halg := (topEquiv (F := F) (E := E)).isAlgebraic
Classical.choice <| Function.Embedding.antisymm
(halg.algHomEmbeddingOfSplits (fun _ ↦ splits_of_mem_adjoin F E (S := S) hK (hS ▸ mem_top)) _)
(halg.algHomEmbeddingOfSplits (fun _ ↦ IsAlgClosed.splits_codomain _) _) | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | embEquivOfAdjoinSplits | A random bijection between `Field.Emb F E` and `E →ₐ[F] K` if `E = F(S)` such that every
element `s` of `S` is integral (= algebraic) over `F` and whose minimal polynomial splits in `K`.
Combined with `Field.instInhabitedEmb`, it can be viewed as a stronger version of
`IntermediateField.nonempty_algHom_of_adjoin_splits`. |
finSepDegree_eq_of_adjoin_splits {S : Set E} (hS : adjoin F S = ⊤)
(hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)) :
finSepDegree F E = Nat.card (E →ₐ[F] K) := Nat.card_congr (embEquivOfAdjoinSplits F E K hS hK) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_of_adjoin_splits | The `Field.finSepDegree F E` is equal to the cardinality of `E →ₐ[F] K`
if `E = F(S)` such that every element
`s` of `S` is integral (= algebraic) over `F` and whose minimal polynomial splits in `K`. |
embEquivOfIsAlgClosed [Algebra.IsAlgebraic F E] [IsAlgClosed K] :
Emb F E ≃ (E →ₐ[F] K) :=
embEquivOfAdjoinSplits F E K (adjoin_univ F E) fun s _ ↦
⟨Algebra.IsIntegral.isIntegral s, IsAlgClosed.splits_codomain _⟩ | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | embEquivOfIsAlgClosed | A random bijection between `Field.Emb F E` and `E →ₐ[F] K` when `E / F` is algebraic
and `K / F` is algebraically closed. |
@[stacks 09HJ "We use `finSepDegree` to state a more general result."]
finSepDegree_eq_of_isAlgClosed [Algebra.IsAlgebraic F E] [IsAlgClosed K] :
finSepDegree F E = Nat.card (E →ₐ[F] K) := Nat.card_congr (embEquivOfIsAlgClosed F E K) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_of_isAlgClosed | The `Field.finSepDegree F E` is equal to the cardinality of `E →ₐ[F] K` as a natural number,
when `E / F` is algebraic and `K / F` is algebraically closed. |
embProdEmbOfIsAlgebraic [Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic E K] :
Emb F E × Emb E K ≃ Emb F K :=
let e : ∀ f : E →ₐ[F] AlgebraicClosure K,
@AlgHom E K _ _ _ _ _ f.toRingHom.toAlgebra ≃ Emb E K := fun f ↦
(@embEquivOfIsAlgClosed E K _ _ _ _ _ f.toRingHom.toAlgebra).symm
(algHomEquivSigma (A := F) (B := E) (C := K) (D := AlgebraicClosure K) |>.trans
(Equiv.sigmaEquivProdOfEquiv e) |>.trans <| Equiv.prodCongrLeft <|
fun _ : Emb E K ↦ AlgEquiv.arrowCongr (@AlgEquiv.refl F E _ _ _) <|
(IsAlgClosure.equivOfAlgebraic E K (AlgebraicClosure K)
(AlgebraicClosure E)).restrictScalars F).symm | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | embProdEmbOfIsAlgebraic | If `K / E / F` is a field extension tower, such that `K / E` is algebraic,
then there is a non-canonical bijection
`Field.Emb F E × Field.Emb E K ≃ Field.Emb F K`. A corollary of `algHomEquivSigma`. |
infinite_emb_of_transcendental [H : Algebra.Transcendental F E] : Infinite (Emb F E) := by
obtain ⟨ι, x, hx⟩ := exists_isTranscendenceBasis' F E
have := hx.isAlgebraic_field
rw [← (embProdEmbOfIsAlgebraic F (adjoin F (Set.range x)) E).infinite_iff]
refine @Prod.infinite_of_left _ _ ?_ _
rw [← (embEquivOfEquiv _ _ _ hx.1.aevalEquivField).infinite_iff]
obtain ⟨i⟩ := hx.nonempty_iff_transcendental.2 H
let K := FractionRing (MvPolynomial ι F)
let i1 := IsScalarTower.toAlgHom F (MvPolynomial ι F) (AlgebraicClosure K)
have hi1 : Function.Injective i1 := by
rw [IsScalarTower.coe_toAlgHom', IsScalarTower.algebraMap_eq _ K]
exact (algebraMap K (AlgebraicClosure K)).injective.comp (IsFractionRing.injective _ _)
let f (n : ℕ) : Emb F K := IsFractionRing.liftAlgHom
(g := i1.comp <| MvPolynomial.aeval fun i : ι ↦ MvPolynomial.X i ^ (n + 1)) <| hi1.comp <| by
simpa [algebraicIndependent_iff_injective_aeval] using
MvPolynomial.algebraicIndependent_polynomial_aeval_X _
fun i : ι ↦ (Polynomial.transcendental_X F).pow n.succ_pos
refine Infinite.of_injective f fun m n h ↦ ?_
replace h : (MvPolynomial.X i) ^ (m + 1) = (MvPolynomial.X i) ^ (n + 1) := hi1 <| by
simpa [f, -map_pow] using congr($h (algebraMap _ K (MvPolynomial.X (R := F) i)))
simpa using congr(MvPolynomial.totalDegree $h) | instance | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | infinite_emb_of_transcendental | If the field extension `E / F` is transcendental, then `Field.Emb F E` is infinite. |
finSepDegree_eq_zero_of_transcendental [Algebra.Transcendental F E] :
finSepDegree F E = 0 := Nat.card_eq_zero_of_infinite | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_zero_of_transcendental | If the field extension `E / F` is transcendental, then `Field.finSepDegree F E = 0`, which
actually means that `Field.Emb F E` is infinite (see `Field.infinite_emb_of_transcendental`). |
@[stacks 09HK "Part 1, `finSepDegree` variant"]
finSepDegree_mul_finSepDegree_of_isAlgebraic
[Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic E K] :
finSepDegree F E * finSepDegree E K = finSepDegree F K := by
simpa only [Nat.card_prod] using Nat.card_congr (embProdEmbOfIsAlgebraic F E K) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_mul_finSepDegree_of_isAlgebraic | If `K / E / F` is a field extension tower, such that `K / E` is algebraic, then their
separable degrees satisfy the tower law
$[E:F]_s [K:E]_s = [K:F]_s$. See also `Module.finrank_mul_finrank`. |
natSepDegree : ℕ := (f.aroots f.SplittingField).toFinset.card | def | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree | The separable degree `Polynomial.natSepDegree` of a polynomial is a natural number,
defined to be the number of distinct roots of it over its splitting field.
This is similar to `Polynomial.natDegree` but not to `Polynomial.degree`, namely, the separable
degree of `0` is `0`, not negative infinity. |
natSepDegree_le_natDegree : f.natSepDegree ≤ f.natDegree := by
have := f.map (algebraMap F f.SplittingField) |>.card_roots'
rw [← aroots_def, natDegree_map] at this
classical
exact (f.aroots f.SplittingField).toFinset_card_le.trans this
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_le_natDegree | The separable degree of a polynomial is smaller than its degree. |
natSepDegree_X_sub_C (x : F) : (X - C x).natSepDegree = 1 := by
simp only [natSepDegree, aroots_X_sub_C, Multiset.toFinset_singleton, Finset.card_singleton]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_X_sub_C | null |
natSepDegree_X : (X : F[X]).natSepDegree = 1 := by
simp only [natSepDegree, aroots_X, Multiset.toFinset_singleton, Finset.card_singleton] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_X | null |
natSepDegree_eq_zero (h : f.natDegree = 0) : f.natSepDegree = 0 := by
linarith only [natSepDegree_le_natDegree f, h]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_zero | A constant polynomial has zero separable degree. |
natSepDegree_C (x : F) : (C x).natSepDegree = 0 := natSepDegree_eq_zero _ (natDegree_C _)
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_C | null |
natSepDegree_zero : (0 : F[X]).natSepDegree = 0 := by
rw [← C_0, natSepDegree_C]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_zero | null |
natSepDegree_one : (1 : F[X]).natSepDegree = 0 := by
rw [← C_1, natSepDegree_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_one | null |
natSepDegree_ne_zero (h : f.natDegree ≠ 0) : f.natSepDegree ≠ 0 := by
rw [natSepDegree, ne_eq, Finset.card_eq_zero, ← ne_eq, ← Finset.nonempty_iff_ne_empty]
use rootOfSplits _ (SplittingField.splits f) (ne_of_apply_ne _ h)
classical
rw [Multiset.mem_toFinset, mem_aroots]
exact ⟨ne_of_apply_ne _ h, map_rootOfSplits _ (SplittingField.splits f) (ne_of_apply_ne _ h)⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_ne_zero | A non-constant polynomial has non-zero separable degree. |
natSepDegree_eq_zero_iff : f.natSepDegree = 0 ↔ f.natDegree = 0 :=
⟨(natSepDegree_ne_zero f).mtr, natSepDegree_eq_zero f⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_zero_iff | A polynomial has zero separable degree if and only if it is constant. |
natSepDegree_ne_zero_iff : f.natSepDegree ≠ 0 ↔ f.natDegree ≠ 0 :=
Iff.not <| natSepDegree_eq_zero_iff f | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_ne_zero_iff | A polynomial has non-zero separable degree if and only if it is non-constant. |
natSepDegree_eq_natDegree_iff (hf : f ≠ 0) :
f.natSepDegree = f.natDegree ↔ f.Separable := by
classical
simp_rw [← card_rootSet_eq_natDegree_iff_of_splits hf (SplittingField.splits f),
rootSet_def, Finset.coe_sort_coe, Fintype.card_coe]
rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_natDegree_iff | The separable degree of a non-zero polynomial is equal to its degree if and only if
it is separable. |
natSepDegree_eq_natDegree_of_separable (h : f.Separable) :
f.natSepDegree = f.natDegree := (natSepDegree_eq_natDegree_iff f h.ne_zero).2 h
variable {f} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_natDegree_of_separable | If a polynomial is separable, then its separable degree is equal to its degree. |
Separable.natSepDegree_eq_natDegree (h : f.Separable) :
f.natSepDegree = f.natDegree := natSepDegree_eq_natDegree_of_separable f h | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | Separable.natSepDegree_eq_natDegree | Same as `Polynomial.natSepDegree_eq_natDegree_of_separable`, but enables the use of
dot notation. |
natSepDegree_eq_of_splits [DecidableEq E] (h : f.Splits (algebraMap F E)) :
f.natSepDegree = (f.aroots E).toFinset.card := by
classical
rw [aroots, ← (SplittingField.lift f h).comp_algebraMap, ← map_map,
roots_map _ ((splits_id_iff_splits _).mpr <| SplittingField.splits f),
Multiset.toFinset_map, Finset.card_image_of_injective _ (RingHom.injective _), natSepDegree]
variable (E) in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_of_splits | If a polynomial splits over `E`, then its separable degree is equal to
the number of distinct roots of it over `E`. |
natSepDegree_eq_of_isAlgClosed [DecidableEq E] [IsAlgClosed E] :
f.natSepDegree = (f.aroots E).toFinset.card :=
natSepDegree_eq_of_splits f (IsAlgClosed.splits_codomain f) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_of_isAlgClosed | The separable degree of a polynomial is equal to
the number of distinct roots of it over any algebraically closed field. |
natSepDegree_map (f : E[X]) (i : E →+* K) : (f.map i).natSepDegree = f.natSepDegree := by
classical
let _ := i.toAlgebra
simp_rw [show i = algebraMap E K by rfl, natSepDegree_eq_of_isAlgClosed (AlgebraicClosure K),
aroots_def, map_map, ← IsScalarTower.algebraMap_eq]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_map | null |
natSepDegree_C_mul {x : F} (hx : x ≠ 0) :
(C x * f).natSepDegree = f.natSepDegree := by
classical
simp only [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_C_mul _ hx]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_C_mul | null |
natSepDegree_smul_nonzero {x : F} (hx : x ≠ 0) :
(x • f).natSepDegree = f.natSepDegree := by
classical
simp only [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_smul_nonzero _ hx]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_smul_nonzero | null |
natSepDegree_pow {n : ℕ} : (f ^ n).natSepDegree = if n = 0 then 0 else f.natSepDegree := by
classical
simp only [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_pow]
by_cases h : n = 0
· simp only [h, zero_smul, Multiset.toFinset_zero, Finset.card_empty, ite_true]
simp only [h, Multiset.toFinset_nsmul _ n h, ite_false] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_pow | null |
natSepDegree_pow_of_ne_zero {n : ℕ} (hn : n ≠ 0) :
(f ^ n).natSepDegree = f.natSepDegree := by simp_rw [natSepDegree_pow, hn, ite_false] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_pow_of_ne_zero | null |
natSepDegree_X_pow {n : ℕ} : (X ^ n : F[X]).natSepDegree = if n = 0 then 0 else 1 := by
simp only [natSepDegree_pow, natSepDegree_X] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_X_pow | null |
natSepDegree_X_sub_C_pow {x : F} {n : ℕ} :
((X - C x) ^ n).natSepDegree = if n = 0 then 0 else 1 := by
simp only [natSepDegree_pow, natSepDegree_X_sub_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_X_sub_C_pow | null |
natSepDegree_C_mul_X_sub_C_pow {x y : F} {n : ℕ} (hx : x ≠ 0) :
(C x * (X - C y) ^ n).natSepDegree = if n = 0 then 0 else 1 := by
simp only [natSepDegree_C_mul _ hx, natSepDegree_X_sub_C_pow] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_C_mul_X_sub_C_pow | null |
natSepDegree_mul (g : F[X]) :
(f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree := by
by_cases h : f * g = 0
· simp only [h, natSepDegree_zero, zero_le]
classical
simp_rw [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_mul h, Multiset.toFinset_add]
exact Finset.card_union_le _ _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_mul | null |
natSepDegree_mul_eq_iff (g : F[X]) :
(f * g).natSepDegree = f.natSepDegree + g.natSepDegree ↔ (f = 0 ∧ g = 0) ∨ IsCoprime f g := by
by_cases h : f * g = 0
· rw [mul_eq_zero] at h
wlog hf : f = 0 generalizing f g
· simpa only [mul_comm, add_comm, and_comm,
isCoprime_comm] using this g f h.symm (h.resolve_left hf)
rw [hf, zero_mul, natSepDegree_zero, zero_add, isCoprime_zero_left, isUnit_iff, eq_comm,
natSepDegree_eq_zero_iff, natDegree_eq_zero]
refine ⟨fun ⟨x, h⟩ ↦ ?_, ?_⟩
· by_cases hx : x = 0
· exact .inl ⟨rfl, by rw [← h, hx, map_zero]⟩
exact .inr ⟨x, Ne.isUnit hx, h⟩
rintro (⟨-, h⟩ | ⟨x, -, h⟩)
· exact ⟨0, by rw [h, map_zero]⟩
exact ⟨x, h⟩
classical
simp_rw [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_mul h, Multiset.toFinset_add,
Finset.card_union_eq_card_add_card, Finset.disjoint_iff_ne, Multiset.mem_toFinset, mem_aroots]
rw [mul_eq_zero, not_or] at h
refine ⟨fun H ↦ .inr (isCoprime_of_irreducible_dvd (not_and.2 fun _ ↦ h.2)
fun u hu ⟨v, hf⟩ ⟨w, hg⟩ ↦ ?_), ?_⟩
· obtain ⟨x, hx⟩ := IsAlgClosed.exists_aeval_eq_zero
(AlgebraicClosure F) _ (degree_pos_of_irreducible hu).ne'
exact H x ⟨h.1, by simpa only [map_mul, hx, zero_mul] using congr(aeval x $hf)⟩
x ⟨h.2, by simpa only [map_mul, hx, zero_mul] using congr(aeval x $hg)⟩ rfl
rintro (⟨rfl, rfl⟩ | hc)
· exact (h.1 rfl).elim
rintro x hf _ hg rfl
obtain ⟨u, v, hfg⟩ := hc
simpa only [map_add, map_mul, map_one, hf.2, hg.2, mul_zero, add_zero,
zero_ne_one] using congr(aeval x $hfg) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_mul_eq_iff | null |
natSepDegree_mul_of_isCoprime (g : F[X]) (hc : IsCoprime f g) :
(f * g).natSepDegree = f.natSepDegree + g.natSepDegree :=
(natSepDegree_mul_eq_iff f g).2 (.inr hc) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_mul_of_isCoprime | null |
natSepDegree_le_of_dvd (g : F[X]) (h1 : f ∣ g) (h2 : g ≠ 0) :
f.natSepDegree ≤ g.natSepDegree := by
classical
simp_rw [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F)]
exact Finset.card_le_card <| Multiset.toFinset_subset.mpr <|
Multiset.Le.subset <| roots.le_of_dvd (map_ne_zero h2) <| map_dvd _ h1 | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_le_of_dvd | null |
natSepDegree_expand (q : ℕ) [hF : ExpChar F q] {n : ℕ} :
(expand F (q ^ n) f).natSepDegree = f.natSepDegree := by
obtain - | hprime := hF
· simp only [one_pow, expand_one]
haveI := Fact.mk hprime
classical
simpa only [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_def, map_expand,
Fintype.card_coe] using Fintype.card_eq.2
⟨(f.map (algebraMap F (AlgebraicClosure F))).rootsExpandPowEquivRoots q n⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_expand | If a field `F` is of exponential characteristic `q`, then `Polynomial.expand F (q ^ n) f`
and `f` have the same separable degree. |
natSepDegree_X_pow_char_pow_sub_C (q : ℕ) [ExpChar F q] (n : ℕ) (y : F) :
(X ^ q ^ n - C y).natSepDegree = 1 := by
rw [← expand_X, ← expand_C (q ^ n), ← map_sub, natSepDegree_expand, natSepDegree_X_sub_C]
variable {f} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_X_pow_char_pow_sub_C | null |
IsSeparableContraction.natSepDegree_eq {g : Polynomial F} {q : ℕ} [ExpChar F q]
(h : IsSeparableContraction q f g) : f.natSepDegree = g.natDegree := by
obtain ⟨h1, m, h2⟩ := h
rw [← h2, natSepDegree_expand, h1.natSepDegree_eq_natDegree]
variable {f} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | IsSeparableContraction.natSepDegree_eq | If `g` is a separable contraction of `f`, then the separable degree of `f` is equal to
the degree of `g`. |
HasSeparableContraction.natSepDegree_eq
{q : ℕ} [ExpChar F q] (hf : f.HasSeparableContraction q) :
f.natSepDegree = hf.degree := hf.isSeparableContraction.natSepDegree_eq | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | HasSeparableContraction.natSepDegree_eq | If a polynomial has separable contraction, then its separable degree is equal to the degree of
the given separable contraction. |
natSepDegree_dvd_natDegree (h : Irreducible f) :
f.natSepDegree ∣ f.natDegree := by
obtain ⟨q, _⟩ := ExpChar.exists F
have hf := h.hasSeparableContraction q
rw [hf.natSepDegree_eq]
exact hf.dvd_degree | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_dvd_natDegree | The separable degree of an irreducible polynomial divides its degree. |
natSepDegree_eq_one_iff_of_monic' (q : ℕ) [ExpChar F q] (hm : f.Monic)
(hi : Irreducible f) : f.natSepDegree = 1 ↔
∃ (n : ℕ) (y : F), f = expand F (q ^ n) (X - C y) := by
refine ⟨fun h ↦ ?_, fun ⟨n, y, h⟩ ↦ ?_⟩
· obtain ⟨g, h1, n, rfl⟩ := hi.hasSeparableContraction q
have h2 : g.natDegree = 1 := by
rwa [natSepDegree_expand _ q, h1.natSepDegree_eq_natDegree] at h
rw [((monic_expand_iff <| expChar_pow_pos F q n).mp hm).eq_X_add_C h2]
exact ⟨n, -(g.coeff 0), by rw [map_neg, sub_neg_eq_add]⟩
rw [h, natSepDegree_expand _ q, natSepDegree_X_sub_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_of_monic' | A monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one if and only if it is of the form `Polynomial.expand F (q ^ n) (X - C y)`
for some `n : ℕ` and `y : F`. |
natSepDegree_eq_one_iff_of_monic (q : ℕ) [ExpChar F q] (hm : f.Monic)
(hi : Irreducible f) : f.natSepDegree = 1 ↔ ∃ (n : ℕ) (y : F), f = X ^ q ^ n - C y := by
simp_rw [hi.natSepDegree_eq_one_iff_of_monic' q hm, map_sub, expand_X, expand_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_of_monic | A monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one if and only if it is of the form `X ^ (q ^ n) - C y`
for some `n : ℕ` and `y : F`. |
eq_X_sub_C_pow_of_natSepDegree_eq_one_of_splits (hm : f.Monic)
(hs : f.Splits (RingHom.id F))
(h : f.natSepDegree = 1) : ∃ (m : ℕ) (y : F), m ≠ 0 ∧ f = (X - C y) ^ m := by
classical
have h1 := eq_prod_roots_of_monic_of_splits_id hm hs
have h2 := (natSepDegree_eq_of_splits f hs).symm
rw [h, aroots_def, Algebra.algebraMap_self, map_id, Multiset.toFinset_card_eq_one_iff] at h2
obtain ⟨h2, y, h3⟩ := h2
exact ⟨_, y, h2, by rwa [h3, Multiset.map_nsmul, Multiset.map_singleton, Multiset.prod_nsmul,
Multiset.prod_singleton] at h1⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | eq_X_sub_C_pow_of_natSepDegree_eq_one_of_splits | If a monic polynomial of separable degree one splits, then it is of form `(X - C y) ^ m` for
some non-zero natural number `m` and some element `y` of `F`. |
eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible (q : ℕ) [ExpChar F q]
(hm : f.Monic) (hi : Irreducible f) (h : f.natSepDegree = 1) : ∃ (n : ℕ) (y : F),
(n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = X ^ q ^ n - C y := by
obtain ⟨n, y, hf⟩ := (hm.natSepDegree_eq_one_iff_of_irreducible q hi).1 h
cases id ‹ExpChar F q› with
| zero =>
simp_rw [one_pow, pow_one] at hf ⊢
exact ⟨0, y, .inl rfl, hf⟩
| prime hq =>
refine ⟨n, y, (em _).imp id fun hn ⟨z, hy⟩ ↦ ?_, hf⟩
haveI := expChar_of_injective_ringHom (R := F) C_injective q
rw [hf, ← Nat.succ_pred hn, pow_succ, pow_mul, ← hy, frobenius_def, map_pow,
← sub_pow_expChar] at hi
exact not_irreducible_pow hq.ne_one hi | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible | If a monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one, then it is of the form `X ^ (q ^ n) - C y` for some natural number `n`,
and some element `y` of `F`, such that either `n = 0` or `y` has no `q`-th root in `F`. |
eq_X_pow_char_pow_sub_C_pow_of_natSepDegree_eq_one (q : ℕ) [ExpChar F q] (hm : f.Monic)
(h : f.natSepDegree = 1) : ∃ (m n : ℕ) (y : F),
m ≠ 0 ∧ (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = (X ^ q ^ n - C y) ^ m := by
obtain ⟨p, hM, hI, hf⟩ := exists_monic_irreducible_factor _ <| not_isUnit_of_natDegree_pos _
<| Nat.pos_of_ne_zero <| (natSepDegree_ne_zero_iff _).1 (h.symm ▸ Nat.one_ne_zero)
have hD := (h ▸ natSepDegree_le_of_dvd p f hf hm.ne_zero).antisymm <|
Nat.pos_of_ne_zero <| (natSepDegree_ne_zero_iff _).2 hI.natDegree_pos.ne'
obtain ⟨n, y, H, hp⟩ := hM.eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible q hI hD
have hF := finiteMultiplicity_of_degree_pos_of_monic (degree_pos_of_irreducible hI) hM hm.ne_zero
classical
have hne := (multiplicity_pos_of_dvd hf).ne'
refine ⟨_, n, y, hne, H, ?_⟩
obtain ⟨c, hf, H⟩ := hF.exists_eq_pow_mul_and_not_dvd
rw [hf, natSepDegree_mul_of_isCoprime _ c <| IsCoprime.pow_left <|
(hI.isCoprime_or_dvd c).resolve_right H, natSepDegree_pow_of_ne_zero _ hne, hD,
add_eq_left, natSepDegree_eq_zero_iff] at h
simpa only [eq_one_of_monic_natDegree_zero ((hM.pow _).of_mul_monic_left (hf ▸ hm)) h,
mul_one, ← hp] using hf | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | eq_X_pow_char_pow_sub_C_pow_of_natSepDegree_eq_one | If a monic polynomial over a field `F` of exponential characteristic `q` has separable degree
one, then it is of the form `(X ^ (q ^ n) - C y) ^ m` for some non-zero natural number `m`,
some natural number `n`, and some element `y` of `F`, such that either `n = 0` or `y` has no
`q`-th root in `F`. |
natSepDegree_eq_one_iff (q : ℕ) [ExpChar F q] (hm : f.Monic) :
f.natSepDegree = 1 ↔ ∃ (m n : ℕ) (y : F), m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m := by
refine ⟨fun h ↦ ?_, fun ⟨m, n, y, hm, h⟩ ↦ ?_⟩
· obtain ⟨m, n, y, hm, -, h⟩ := hm.eq_X_pow_char_pow_sub_C_pow_of_natSepDegree_eq_one q h
exact ⟨m, n, y, hm, h⟩
simp_rw [h, natSepDegree_pow, hm, ite_false, natSepDegree_X_pow_char_pow_sub_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff | A monic polynomial over a field `F` of exponential characteristic `q` has separable degree one
if and only if it is of the form `(X ^ (q ^ n) - C y) ^ m` for some non-zero natural number `m`,
some natural number `n`, and some element `y` of `F`. |
natSepDegree_eq_one_iff_eq_expand_X_sub_C : (minpoly F x).natSepDegree = 1 ↔
∃ (n : ℕ) (y : F), minpoly F x = expand F (q ^ n) (X - C y) := by
refine ⟨fun h ↦ ?_, fun ⟨n, y, h⟩ ↦ ?_⟩
· have halg : IsIntegral F x := by_contra fun h' ↦ by
simp only [eq_zero h', natSepDegree_zero, zero_ne_one] at h
exact (minpoly.irreducible halg).natSepDegree_eq_one_iff_of_monic' q
(minpoly.monic halg) |>.1 h
rw [h, natSepDegree_expand _ q, natSepDegree_X_sub_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_eq_expand_X_sub_C | The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`Polynomial.expand F (q ^ n) (X - C y)` for some `n : ℕ` and `y : F`. |
natSepDegree_eq_one_iff_eq_X_pow_sub_C : (minpoly F x).natSepDegree = 1 ↔
∃ (n : ℕ) (y : F), minpoly F x = X ^ q ^ n - C y := by
simp only [minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C q, map_sub, expand_X, expand_C] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_eq_X_pow_sub_C | The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`X ^ (q ^ n) - C y` for some `n : ℕ` and `y : F`. |
natSepDegree_eq_one_iff_pow_mem : (minpoly F x).natSepDegree = 1 ↔
∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range := by
convert_to _ ↔ ∃ (n : ℕ) (y : F), Polynomial.aeval x (X ^ q ^ n - C y) = 0
· simp_rw [RingHom.mem_range, map_sub, map_pow, aeval_C, aeval_X, sub_eq_zero, eq_comm]
refine ⟨fun h ↦ ?_, fun ⟨n, y, h⟩ ↦ ?_⟩
· obtain ⟨n, y, hx⟩ := (minpoly.natSepDegree_eq_one_iff_eq_X_pow_sub_C q).1 h
exact ⟨n, y, hx ▸ aeval F x⟩
have hnezero := X_pow_sub_C_ne_zero (expChar_pow_pos F q n) y
refine ((natSepDegree_le_of_dvd _ _ (minpoly.dvd F x h) hnezero).trans_eq <|
natSepDegree_X_pow_char_pow_sub_C q n y).antisymm ?_
rw [Nat.one_le_iff_ne_zero, natSepDegree_ne_zero_iff, ← Nat.one_le_iff_ne_zero]
exact minpoly.natDegree_pos <| IsAlgebraic.isIntegral ⟨_, hnezero, h⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_pow_mem | The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if `x ^ (q ^ n) ∈ F` for some `n : ℕ`. |
natSepDegree_eq_one_iff_eq_X_sub_C_pow : (minpoly F x).natSepDegree = 1 ↔
∃ n : ℕ, (minpoly F x).map (algebraMap F E) = (X - C x) ^ q ^ n := by
haveI := expChar_of_injective_algebraMap (algebraMap F E).injective q
haveI := expChar_of_injective_ringHom (C_injective (R := E)) q
refine ⟨fun h ↦ ?_, fun ⟨n, h⟩ ↦ (natSepDegree_eq_one_iff_pow_mem q).2 ?_⟩
· obtain ⟨n, y, h⟩ := (natSepDegree_eq_one_iff_eq_X_pow_sub_C q).1 h
have hx := congr_arg (Polynomial.aeval x) h.symm
rw [minpoly.aeval, map_sub, map_pow, aeval_X, aeval_C, sub_eq_zero, eq_comm] at hx
use n
rw [h, Polynomial.map_sub, Polynomial.map_pow, map_X, map_C, hx, map_pow,
← sub_pow_expChar_pow_of_commute _ _ (commute_X _)]
apply_fun constantCoeff at h
simp_rw [map_pow, map_sub, constantCoeff_apply, coeff_map, coeff_X_zero, coeff_C_zero] at h
rw [zero_sub, neg_pow, neg_one_pow_expChar_pow] at h
exact ⟨n, -(minpoly F x).coeff 0, by rw [map_neg, h, neg_mul, one_mul, neg_neg]⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | natSepDegree_eq_one_iff_eq_X_sub_C_pow | The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`(X - x) ^ (q ^ n)` for some `n : ℕ`. |
finSepDegree_adjoin_simple_eq_natSepDegree {α : E} (halg : IsAlgebraic F α) :
finSepDegree F F⟮α⟯ = (minpoly F α).natSepDegree := by
have : finSepDegree F F⟮α⟯ = _ := Nat.card_congr
(algHomAdjoinIntegralEquiv F (K := AlgebraicClosure F⟮α⟯) halg.isIntegral)
classical
rw [this, Nat.card_eq_fintype_card, natSepDegree_eq_of_isAlgClosed (E := AlgebraicClosure F⟮α⟯),
← Fintype.card_coe]
simp_rw [Multiset.mem_toFinset] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_adjoin_simple_eq_natSepDegree | The separable degree of `F⟮α⟯ / F` is equal to the separable degree of the
minimal polynomial of `α` over `F`. |
private finSepDegree_adjoin_simple_dvd_finrank (α : E) :
finSepDegree F F⟮α⟯ ∣ finrank F F⟮α⟯ := by
by_cases halg : IsAlgebraic F α
· rw [finSepDegree_adjoin_simple_eq_natSepDegree F E halg, adjoin.finrank halg.isIntegral]
exact (minpoly.irreducible halg.isIntegral).natSepDegree_dvd_natDegree
have : finrank F F⟮α⟯ = 0 := finrank_of_infinite_dimensional fun _ ↦
halg ((AdjoinSimple.isIntegral_gen F α).1 (IsIntegral.of_finite F _)).isAlgebraic
rw [this]
exact dvd_zero _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_adjoin_simple_dvd_finrank | null |
finSepDegree_adjoin_simple_le_finrank (α : E) (halg : IsAlgebraic F α) :
finSepDegree F F⟮α⟯ ≤ finrank F F⟮α⟯ := by
haveI := adjoin.finiteDimensional halg.isIntegral
exact Nat.le_of_dvd finrank_pos <| finSepDegree_adjoin_simple_dvd_finrank F E α | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_adjoin_simple_le_finrank | The separable degree of `F⟮α⟯ / F` is smaller than the degree of `F⟮α⟯ / F` if `α` is
algebraic over `F`. |
finSepDegree_adjoin_simple_eq_finrank_iff (α : E) (halg : IsAlgebraic F α) :
finSepDegree F F⟮α⟯ = finrank F F⟮α⟯ ↔ IsSeparable F α := by
rw [finSepDegree_adjoin_simple_eq_natSepDegree F E halg, adjoin.finrank halg.isIntegral,
natSepDegree_eq_natDegree_iff _ (minpoly.ne_zero halg.isIntegral), IsSeparable] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_adjoin_simple_eq_finrank_iff | If `α` is algebraic over `F`, then the separable degree of `F⟮α⟯ / F` is equal to the degree
of `F⟮α⟯ / F` if and only if `α` is a separable element. |
finSepDegree_dvd_finrank : finSepDegree F E ∣ finrank F E := by
by_cases hfd : FiniteDimensional F E
· rw [← finSepDegree_top F, ← finrank_top F E]
refine induction_on_adjoin (fun K : IntermediateField F E ↦ finSepDegree F K ∣ finrank F K)
(by simp_rw [finSepDegree_bot, IntermediateField.finrank_bot, one_dvd]) (fun L x h ↦ ?_) ⊤
simp only at h ⊢
have hdvd := mul_dvd_mul h <| finSepDegree_adjoin_simple_dvd_finrank L E x
set M := L⟮x⟯
rwa [finSepDegree_mul_finSepDegree_of_isAlgebraic F L M,
Module.finrank_mul_finrank F L M] at hdvd
rw [finrank_of_infinite_dimensional hfd]
exact dvd_zero _ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_dvd_finrank | The separable degree of any field extension `E / F` divides the degree of `E / F`. |
@[stacks 09HA "The inequality"]
finSepDegree_le_finrank [FiniteDimensional F E] :
finSepDegree F E ≤ finrank F E := Nat.le_of_dvd finrank_pos <| finSepDegree_dvd_finrank F E | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_le_finrank | The separable degree of a finite extension `E / F` is smaller than the degree of `E / F`. |
finSepDegree_eq_finrank_of_isSeparable [Algebra.IsSeparable F E] :
finSepDegree F E = finrank F E := by
wlog hfd : FiniteDimensional F E generalizing E with H
· rw [finrank_of_infinite_dimensional hfd]
obtain ⟨L, h, h'⟩ := exists_lt_finrank_of_infinite_dimensional hfd (finSepDegree F E)
have hd := finSepDegree_mul_finSepDegree_of_isAlgebraic F L E
rw [H L h] at hd
by_cases hd' : finSepDegree L E = 0
· rw [← hd, hd', mul_zero]
linarith only [h', hd, Nat.le_mul_of_pos_right (finrank F L) (Nat.pos_of_ne_zero hd')]
rw [← finSepDegree_top F, ← finrank_top F E]
refine induction_on_adjoin (fun K : IntermediateField F E ↦ finSepDegree F K = finrank F K)
(by simp_rw [finSepDegree_bot, IntermediateField.finrank_bot]) (fun L x h ↦ ?_) ⊤
simp only at h ⊢
have heq : _ * _ = _ * _ := congr_arg₂ (· * ·) h <|
(finSepDegree_adjoin_simple_eq_finrank_iff L E x (IsAlgebraic.of_finite L x)).2 <|
IsSeparable.tower_top L (Algebra.IsSeparable.isSeparable F x)
set M := L⟮x⟯
rwa [finSepDegree_mul_finSepDegree_of_isAlgebraic F L M,
Module.finrank_mul_finrank F L M] at heq
alias Algebra.IsSeparable.finSepDegree_eq := finSepDegree_eq_finrank_of_isSeparable | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_finrank_of_isSeparable | If `E / F` is a separable extension, then its separable degree is equal to its degree.
When `E / F` is infinite, it means that `Field.Emb F E` has infinitely many elements.
(But the cardinality of `Field.Emb F E` is not equal to `Module.rank F E` in general!) |
@[stacks 09HA "The equality condition"]
finSepDegree_eq_finrank_iff [FiniteDimensional F E] :
finSepDegree F E = finrank F E ↔ Algebra.IsSeparable F E :=
⟨fun heq ↦ ⟨fun x ↦ by
have halg := IsAlgebraic.of_finite F x
refine (finSepDegree_adjoin_simple_eq_finrank_iff F E x halg).1 <| le_antisymm
(finSepDegree_adjoin_simple_le_finrank F E x halg) <| le_of_not_gt fun h ↦ ?_
have := Nat.mul_lt_mul_of_lt_of_le' h (finSepDegree_le_finrank F⟮x⟯ E) Fin.pos'
rw [finSepDegree_mul_finSepDegree_of_isAlgebraic F F⟮x⟯ E,
Module.finrank_mul_finrank F F⟮x⟯ E] at this
linarith only [heq, this]⟩, fun _ ↦ finSepDegree_eq_finrank_of_isSeparable F E⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | finSepDegree_eq_finrank_iff | If `E / F` is a finite extension, then its separable degree is equal to its degree if and
only if it is a separable extension. |
IntermediateField.isSeparable_of_mem_isSeparable {L : IntermediateField F E}
[Algebra.IsSeparable F L] {x : E} (h : x ∈ L) : IsSeparable F x := by
simpa only [IsSeparable, minpoly_eq] using Algebra.IsSeparable.isSeparable F (K := L) ⟨x, h⟩ | lemma | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | IntermediateField.isSeparable_of_mem_isSeparable | null |
IntermediateField.isSeparable_adjoin_simple_iff_isSeparable {x : E} :
Algebra.IsSeparable F F⟮x⟯ ↔ IsSeparable F x := by
refine ⟨fun _ ↦ ?_, fun hsep ↦ ?_⟩
· exact isSeparable_of_mem_isSeparable F E <| mem_adjoin_simple_self F x
· have h := IsSeparable.isIntegral hsep
haveI := adjoin.finiteDimensional h
rwa [← finSepDegree_eq_finrank_iff,
finSepDegree_adjoin_simple_eq_finrank_iff F E x h.isAlgebraic]
variable {E K} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | IntermediateField.isSeparable_adjoin_simple_iff_isSeparable | `F⟮x⟯ / F` is a separable extension if and only if `x` is a separable element.
As a consequence, any rational function of `x` is also a separable element. |
IsSeparable.of_algebra_isSeparable_of_isSeparable [Algebra E K] [IsScalarTower F E K]
[Algebra.IsSeparable F E] {x : K} (hsep : IsSeparable E x) : IsSeparable F x := by
set f := minpoly E x with hf
let E' : IntermediateField F E := adjoin F f.coeffs
haveI : FiniteDimensional F E' :=
finiteDimensional_adjoin fun x _ ↦ Algebra.IsSeparable.isIntegral F x
let g : E'[X] := f.toSubring E'.toSubring (subset_adjoin F _)
have h : g.map (algebraMap E' E) = f := f.map_toSubring E'.toSubring (subset_adjoin F _)
clear_value g
have hx : x ∈ restrictScalars F E'⟮x⟯ := mem_adjoin_simple_self _ x
have hzero : aeval x g = 0 := by
simpa only [← hf, ← h, aeval_map_algebraMap] using minpoly.aeval E x
have halg : IsIntegral E' x :=
isIntegral_trans (R := F) (A := E) _ (IsSeparable.isIntegral hsep) |>.tower_top
simp only [IsSeparable, ← hf, ← h, separable_map] at hsep
replace hsep := hsep.of_dvd <| minpoly.dvd E' x hzero
haveI : Algebra.IsSeparable F E' := Algebra.isSeparable_tower_bot_of_isSeparable F E' E
haveI := (isSeparable_adjoin_simple_iff_isSeparable _ _).2 hsep
haveI := adjoin.finiteDimensional halg
haveI : FiniteDimensional F E'⟮x⟯ := FiniteDimensional.trans F E' E'⟮x⟯
have := finSepDegree_mul_finSepDegree_of_isAlgebraic F E' E'⟮x⟯
rw [finSepDegree_eq_finrank_of_isSeparable F E',
finSepDegree_eq_finrank_of_isSeparable E' E'⟮x⟯,
Module.finrank_mul_finrank F E' E'⟮x⟯,
eq_comm, finSepDegree_eq_finrank_iff F E'⟮x⟯] at this
change Algebra.IsSeparable F (restrictScalars F E'⟮x⟯) at this
exact isSeparable_of_mem_isSeparable F K hx | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | IsSeparable.of_algebra_isSeparable_of_isSeparable | If `K / E / F` is an extension tower such that `E / F` is separable,
`x : K` is separable over `E`, then it's also separable over `F`. |
@[stacks 09HB]
Algebra.IsSeparable.trans [Algebra E K] [IsScalarTower F E K]
[Algebra.IsSeparable F E] [Algebra.IsSeparable E K] : Algebra.IsSeparable F K :=
⟨fun x ↦ IsSeparable.of_algebra_isSeparable_of_isSeparable F
(Algebra.IsSeparable.isSeparable E x)⟩ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | Algebra.IsSeparable.trans | If `E / F` and `K / E` are both separable extensions, then `K / F` is also separable. |
IntermediateField.isSeparable_adjoin_pair_of_isSeparable {x y : E}
(hx : IsSeparable F x) (hy : IsSeparable F y) :
Algebra.IsSeparable F F⟮x, y⟯ := by
rw [← adjoin_simple_adjoin_simple]
replace hy := IsSeparable.tower_top F⟮x⟯ hy
rw [← isSeparable_adjoin_simple_iff_isSeparable] at hx hy
exact Algebra.IsSeparable.trans F F⟮x⟯ F⟮x⟯⟮y⟯ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | IntermediateField.isSeparable_adjoin_pair_of_isSeparable | If `x` and `y` are both separable elements, then `F⟮x, y⟯ / F` is a separable extension.
As a consequence, any rational function of `x` and `y` is also a separable element. |
isSeparable_algebraMap (x : F) : IsSeparable F ((algebraMap F E) x) := by
rw [IsSeparable, minpoly.algebraMap_eq (algebraMap F E).injective]
exact Algebra.IsSeparable.isSeparable F x
variable {E} | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_algebraMap | Any element `x` of `F` is a separable element of `E / F` when embedded into `E`. |
isSeparable_mul {x y : E} (hx : IsSeparable F x) (hy : IsSeparable F y) :
IsSeparable F (x * y) :=
haveI := isSeparable_adjoin_pair_of_isSeparable F E hx hy
isSeparable_of_mem_isSeparable F E <| F⟮x, y⟯.mul_mem (subset_adjoin F _ (.inl rfl))
(subset_adjoin F _ (.inr rfl)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_mul | If `x` and `y` are both separable elements, then `x * y` is also a separable element. |
isSeparable_add {x y : E} (hx : IsSeparable F x) (hy : IsSeparable F y) :
IsSeparable F (x + y) :=
haveI := isSeparable_adjoin_pair_of_isSeparable F E hx hy
isSeparable_of_mem_isSeparable F E <| F⟮x, y⟯.add_mem (subset_adjoin F _ (.inl rfl))
(subset_adjoin F _ (.inr rfl)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_add | If `x` and `y` are both separable elements, then `x + y` is also a separable element. |
isSeparable_neg {x : E} (hx : IsSeparable F x) :
IsSeparable F (-x) :=
haveI := (isSeparable_adjoin_simple_iff_isSeparable F E).2 hx
isSeparable_of_mem_isSeparable F E <| F⟮x⟯.neg_mem <| mem_adjoin_simple_self F x | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_neg | If `x` is a separable elements, then `-x` is also a separable element. |
isSeparable_sub {x y : E} (hx : IsSeparable F x) (hy : IsSeparable F y) :
IsSeparable F (x - y) :=
haveI := isSeparable_adjoin_pair_of_isSeparable F E hx hy
isSeparable_of_mem_isSeparable F E <| F⟮x, y⟯.sub_mem (subset_adjoin F _ (.inl rfl))
(subset_adjoin F _ (.inr rfl)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_sub | If `x` and `y` are both separable elements, then `x - y` is also a separable element. |
isSeparable_inv {x : E} (hx : IsSeparable F x) : IsSeparable F x⁻¹ :=
haveI := (isSeparable_adjoin_simple_iff_isSeparable F E).2 hx
isSeparable_of_mem_isSeparable F E <| F⟮x⟯.inv_mem <| mem_adjoin_simple_self F x | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | isSeparable_inv | If `x` is a separable element, then `x⁻¹` is also a separable element. |
perfectField_iff_splits_of_natSepDegree_eq_one (F : Type*) [Field F] :
PerfectField F ↔ ∀ f : F[X], f.natSepDegree = 1 → f.Splits (RingHom.id F) := by
refine ⟨fun ⟨h⟩ f hf ↦ or_iff_not_imp_left.2 fun hn g hg hd ↦ ?_, fun h ↦ ?_⟩
· rw [Polynomial.map_id] at hn hd
have := natSepDegree_le_of_dvd g f hd hn
rw [hf, (h hg).natSepDegree_eq_natDegree] at this
exact (degree_eq_iff_natDegree_eq_of_pos one_pos).2 <| this.antisymm <|
natDegree_pos_iff_degree_pos.2 (degree_pos_of_irreducible hg)
obtain ⟨p, _⟩ := ExpChar.exists F
haveI := PerfectRing.ofSurjective F p fun x ↦ by
obtain ⟨y, hy⟩ := exists_root_of_splits _
(h _ (pow_one p ▸ natSepDegree_X_pow_char_pow_sub_C p 1 x))
((degree_X_pow_sub_C (expChar_pos F p) x).symm ▸ Nat.cast_pos.2 (expChar_pos F p)).ne'
exact ⟨y, by rwa [← eval, eval_sub, eval_pow, eval_X, eval_C, sub_eq_zero] at hy⟩
exact PerfectRing.toPerfectField F p
variable {E K} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | perfectField_iff_splits_of_natSepDegree_eq_one | A field is a perfect field (which means that any irreducible polynomial is separable)
if and only if every separable degree one polynomial splits. |
PerfectField.splits_of_natSepDegree_eq_one [PerfectField K] {f : E[X]}
(i : E →+* K) (hf : f.natSepDegree = 1) : f.Splits i :=
(splits_id_iff_splits _).mp <| (perfectField_iff_splits_of_natSepDegree_eq_one K).mp ‹_› _
(natSepDegree_map K f i ▸ hf) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure",
"Mathlib.FieldTheory.Separable",
"Mathlib.FieldTheory.Normal.Closure",
"Mathlib.RingTheory.AlgebraicIndependent.Adjoin",
"Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis",
"Mathlib.RingTheor... | Mathlib/FieldTheory/SeparableDegree.lean | PerfectField.splits_of_natSepDegree_eq_one | null |
left [Nontrivial A] : Module.Finite F K :=
let ⟨x, hx⟩ := exists_ne (0 : A)
Module.Finite.of_injective
(LinearMap.ringLmapEquivSelf K ℕ A |>.symm x |>.restrictScalars F) (smul_left_injective K hx)
variable [Semiring F] [Semiring K] [Module F K]
[AddCommMonoid A] [Module K A] [Module F A] [IsScalarTower F K A] in
@[stacks 09G5] | theorem | FieldTheory | [
"Mathlib.RingTheory.Noetherian.Basic"
] | Mathlib/FieldTheory/Tower.lean | left | In a tower of field extensions `A / K / F`, if `A / F` is finite, so is `K / F`.
(In fact, it suffices that `A` is a nontrivial ring.)
Note this cannot be an instance as Lean cannot infer `A`. |
right [hf : Module.Finite F A] : Module.Finite K A :=
let ⟨⟨b, hb⟩⟩ := hf
⟨⟨b, Submodule.restrictScalars_injective F _ _ <| by
rw [Submodule.restrictScalars_top, eq_top_iff, ← hb, Submodule.span_le]
exact Submodule.subset_span⟩⟩ | theorem | FieldTheory | [
"Mathlib.RingTheory.Noetherian.Basic"
] | Mathlib/FieldTheory/Tower.lean | right | null |
@[to_additive AddSubgroup.cyclic_of_min /-- Given a subgroup `H` of a decidable linearly ordered
archimedean abelian group `G`, if there exists a minimal element `a` of `H ∩ G_{>0}` then `H` is
generated by `a`. -/]
Subgroup.cyclic_of_min {H : Subgroup G} {a : G}
(ha : IsLeast { g : G | g ∈ H ∧ 1 < g } a) : H = closure {a} := by
obtain ⟨⟨a_in, a_pos⟩, a_min⟩ := ha
refine le_antisymm ?_ (H.closure_le.mpr <| by simp [a_in])
intro g g_in
obtain ⟨k, ⟨nonneg, lt⟩, _⟩ := existsUnique_zpow_near_of_one_lt a_pos g
have h_zero : g / (a ^ k) = 1 := by
by_contra h
have h : a ≤ g / (a ^ k) := by
refine a_min ⟨?_, ?_⟩
· exact Subgroup.div_mem H g_in (Subgroup.zpow_mem H a_in k)
· exact lt_of_le_of_ne (by simpa using nonneg) (Ne.symm h)
have h' : ¬a ≤ g / (a ^ k) := not_le.mpr (by simpa [zpow_add_one, div_lt_iff_lt_mul'] using lt)
contradiction
simp [div_eq_one.mp h_zero, mem_closure_singleton] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Order",
"Mathlib.Algebra.Order.Archimedean.Basic"
] | Mathlib/GroupTheory/Archimedean.lean | Subgroup.cyclic_of_min | Given a subgroup `H` of a decidable linearly ordered mul-archimedean abelian group `G`, if there
exists a minimal element `a` of `H ∩ G_{>1}` then `H` is generated by `a`. |
@[to_additive /-- If a nontrivial additive subgroup of a linear ordered additive commutative group
is disjoint with the interval `Set.Ioo 0 a` for some positive `a`, then the set of positive
elements of this group admits the least element. -/]
Subgroup.exists_isLeast_one_lt {H : Subgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 1 < a)
(hd : Disjoint (H : Set G) (Ioo 1 a)) : ∃ b, IsLeast { g : G | g ∈ H ∧ 1 < g } b := by
have hex : ∀ g > 1, ∃ n : ℕ, g ∈ Ioc (a ^ n) (a ^ (n + 1)) := fun g hg => by
rcases existsUnique_mul_zpow_mem_Ico h₀ 1 (g / a) with ⟨m, ⟨hm, hm'⟩, -⟩
simp only [one_mul, div_le_iff_le_mul, div_mul_cancel, ← zpow_add_one] at hm hm'
lift m to ℕ
· rw [← Int.lt_add_one_iff, ← zpow_lt_zpow_iff_right h₀, zpow_zero]
exact hg.trans_le hm
· simp only [← Nat.cast_succ, zpow_natCast] at hm hm'
exact ⟨m, hm', hm⟩
have : ∃ n : ℕ, Set.Nonempty (H ∩ Ioc (a ^ n) (a ^ (n + 1))) := by
rcases (bot_or_exists_ne_one H).resolve_left hbot with ⟨g, hgH, hg₀⟩
rcases hex |g|ₘ (one_lt_mabs.2 hg₀) with ⟨n, hn⟩
exact ⟨n, _, (@mabs_mem_iff (Subgroup G) G _ _).2 hgH, hn⟩
classical rcases Nat.findX this with ⟨n, ⟨x, hxH, hnx, hxn⟩, hmin⟩
by_contra hxmin
simp only [IsLeast, not_and, mem_setOf_eq, mem_lowerBounds, not_exists, not_forall,
not_le] at hxmin
rcases hxmin x ⟨hxH, (one_le_pow_of_one_le' h₀.le _).trans_lt hnx⟩ with ⟨y, ⟨hyH, hy₀⟩, hxy⟩
rcases hex y hy₀ with ⟨m, hm⟩
rcases lt_or_ge m n with hmn | hnm
· exact hmin m hmn ⟨y, hyH, hm⟩
· refine disjoint_left.1 hd (div_mem hxH hyH) ⟨one_lt_div'.2 hxy, div_lt_iff_lt_mul'.2 ?_⟩
calc x ≤ a^ (n + 1) := hxn
_ ≤ a ^ (m + 1) := pow_le_pow_right' h₀.le (add_le_add_right hnm _)
_ = a ^ m * a := pow_succ _ _
_ < y * a := mul_lt_mul_right' hm.1 _ | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Order",
"Mathlib.Algebra.Order.Archimedean.Basic"
] | Mathlib/GroupTheory/Archimedean.lean | Subgroup.exists_isLeast_one_lt | If a nontrivial subgroup of a linear ordered commutative group is disjoint
with the interval `Set.Ioo 1 a` for some `1 < a`, then the set of elements greater than 1 of this
group admits the least element. |
@[to_additive AddSubgroup.cyclic_of_isolated_zero /-- If an additive subgroup of a linear ordered
additive commutative group is disjoint with the interval `Set.Ioo 0 a` for some positive `a`, then
this is a cyclic subgroup. -/]
Subgroup.cyclic_of_isolated_one {H : Subgroup G} {a : G} (h₀ : 1 < a)
(hd : Disjoint (H : Set G) (Ioo 1 a)) : ∃ b, H = closure {b} := by
rcases eq_or_ne H ⊥ with rfl | hbot
· exact ⟨1, closure_singleton_one.symm⟩
· exact (exists_isLeast_one_lt hbot h₀ hd).imp fun _ => cyclic_of_min | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Order",
"Mathlib.Algebra.Order.Archimedean.Basic"
] | Mathlib/GroupTheory/Archimedean.lean | Subgroup.cyclic_of_isolated_one | If a subgroup of a linear ordered commutative group is disjoint with the
interval `Set.Ioo 1 a` for some `1 < a`, then this is a cyclic subgroup. |
Int.subgroup_cyclic (H : AddSubgroup ℤ) : ∃ a, H = AddSubgroup.closure {a} :=
have : Ioo (0 : ℤ) 1 = ∅ := eq_empty_of_forall_notMem fun _ hm =>
hm.1.not_ge (lt_add_one_iff.1 hm.2)
AddSubgroup.cyclic_of_isolated_zero one_pos <| by simp [this] | theorem | GroupTheory | [
"Mathlib.Algebra.Group.Subgroup.Order",
"Mathlib.Algebra.Order.Archimedean.Basic"
] | Mathlib/GroupTheory/Archimedean.lean | Int.subgroup_cyclic | Every subgroup of `ℤ` is cyclic. |
exists_pow_lt₀ {G : Type*} [LinearOrderedCommGroupWithZero G] [MulArchimedean G]
{a : G} (ha : a < 1) (b : Gˣ) : ∃ n : ℕ, a ^ n < b := by
rcases eq_or_ne a 0 with rfl | ha'
· use 1
simp
· lift a to Gˣ using IsUnit.mk0 _ ha'
simpa using exists_pow_lt ha b | theorem | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | exists_pow_lt₀ | null |
@[to_additive /-- The additive subgroup generated by an element of an additive group equals the set
of integer multiples of the element, such that each multiple is a unique element.
This is the stronger version of `AddSubgroup.mem_closure_singleton`. -/]
Subgroup.mem_closure_singleton_iff_existsUnique_zpow {G : Type*}
[CommGroup G] [LinearOrder G] [IsOrderedMonoid G] {a b : G} (ha : a ≠ 1) :
b ∈ closure {a} ↔ ∃! k : ℤ, a ^ k = b := by
rw [mem_closure_singleton]
constructor
· suffices Function.Injective (a ^ · : ℤ → G) by
rintro ⟨m, rfl⟩
exact ⟨m, rfl, fun k hk ↦ this hk⟩
rcases ha.lt_or_gt with ha | ha
· exact (zpow_right_strictAnti ha).injective
· exact (zpow_right_strictMono ha).injective
· exact fun h ↦ h.exists | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Subgroup.mem_closure_singleton_iff_existsUnique_zpow | The subgroup generated by an element of a group equals the set of
integer powers of the element, such that each power is a unique element.
This is the stronger version of `Subgroup.mem_closure_singleton`. |
Int.addEquiv_eq_refl_or_neg (e : ℤ ≃+ ℤ) : e = .refl _ ∨ e = .neg _ := by
suffices e 1 = 1 ∨ - e 1 = 1 by simpa [AddEquiv.ext_int_iff, neg_eq_iff_eq_neg]
have he : ¬IsOfFinAddOrder (e 1) :=
not_isOfFinAddOrder_of_isAddTorsionFree ((AddEquiv.map_ne_zero_iff e).mpr Int.one_ne_zero)
rw [← AddSubgroup.zmultiples_eq_zmultiples_iff he]
simpa [e.surjective, eq_comm] using (e : ℤ →+ ℤ).map_zmultiples 1 | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Int.addEquiv_eq_refl_or_neg | null |
@[simp]
Int.univ_addEquiv :
(Finset.univ : Finset (ℤ ≃+ ℤ)) = .cons (.neg ℤ) {.refl ℤ} (by simp [AddEquiv.ext_int_iff]) :=
rfl
@[simp] lemma Int.card_fintype_addEquiv : Fintype.card (ℤ ≃+ ℤ) = 2 := rfl | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Int.univ_addEquiv | null |
@[to_additive /-- In two linearly ordered additive groups, the closure of an element of one group
is isomorphic (and order-isomorphic) to the closure of an element in the other group. -/]
noncomputable LinearOrderedCommGroup.closure_equiv_closure {G G' : Type*}
[CommGroup G] [LinearOrder G] [IsOrderedMonoid G]
[CommGroup G'] [LinearOrder G'] [IsOrderedMonoid G'] (x : G) (y : G') (hxy : x = 1 ↔ y = 1) :
closure ({x} : Set G) ≃*o closure ({y} : Set G') :=
if hx : x = 1 then by
refine ⟨⟨⟨fun _ ↦ ⟨1, by simp [hxy.mp hx]⟩, fun _ ↦ ⟨1, by simp [hx]⟩, ?_, ?_⟩, ?_⟩, ?_⟩
· intro ⟨a, ha⟩
simpa [hx, closure_singleton_one, eq_comm] using ha
· intro ⟨a, ha⟩
simpa [hxy.mp hx, closure_singleton_one, eq_comm] using ha
· intros
simp
· intro ⟨a, ha⟩ ⟨b, hb⟩
simp only [hx, closure_singleton_one, mem_bot] at ha hb
simp [ha, hb]
else by
set x' := max x x⁻¹ with hx'
have xpos : 1 < x' := by
simp [hx', eq_comm, hx]
set y' := max y y⁻¹ with hy'
have ypos : 1 < y' := by
simp [hy', eq_comm, ← hxy, hx]
have hxc : closure {x} = closure {x'} := by
rcases max_cases x x⁻¹ with H|H <;>
simp [hx', H.left]
have hyc : closure {y} = closure {y'} := by
rcases max_cases y y⁻¹ with H|H <;>
simp [hy', H.left]
refine ⟨⟨⟨
fun a ↦ ⟨y' ^ ((mem_closure_singleton).mp
(by simpa [hxc] using a.prop)).choose, ?_⟩,
fun a ↦ ⟨x' ^ ((mem_closure_singleton).mp
(by simpa [hyc] using a.prop)).choose, ?_⟩,
?_, ?_⟩, ?_⟩, ?_⟩
· rw [hyc, mem_closure_singleton]
exact ⟨_, rfl⟩
· rw [hxc, mem_closure_singleton]
exact ⟨_, rfl⟩
· intro a
generalize_proofs A B C D
rw [Subtype.ext_iff, ← (C a).choose_spec, zpow_right_inj xpos,
← zpow_right_inj ypos, (A ⟨_, D a⟩).choose_spec]
· intro a
generalize_proofs A B C D
rw [Subtype.ext_iff, ← (C a).choose_spec, zpow_right_inj ypos,
← zpow_right_inj xpos, (A ⟨_, D a⟩).choose_spec]
· intro a b
generalize_proofs A B C D E F
simp only [coe_mul, MulMemClass.mk_mul_mk, Subtype.ext_iff]
... | def | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.closure_equiv_closure | In two linearly ordered groups, the closure of an element of one group
is isomorphic (and order-isomorphic) to the closure of an element in the other group. |
Subgroup.isLeast_of_closure_iff_eq_mabs {a b : G} :
IsLeast {y : G | y ∈ closure ({a} : Set G) ∧ 1 < y} b ↔ b = |a|ₘ ∧ 1 < b := by
constructor <;> intro h
· have := Subgroup.cyclic_of_min h
have ha : a ∈ closure ({b} : Set G) := by
simp [← this]
rw [mem_closure_singleton] at ha
obtain ⟨n, rfl⟩ := ha
have := h.left
simp only [mem_closure_singleton, mem_setOf_eq] at this
obtain ⟨m, hm⟩ := this.left
have key : m * n = 1 := by
rw [← zpow_right_inj this.right, zpow_mul', hm, zpow_one]
rw [Int.mul_eq_one_iff_eq_one_or_neg_one] at key
rw [eq_comm]
rcases key with ⟨rfl, rfl⟩|⟨rfl, rfl⟩ <;>
simp [this.right.le, this.right, mabs]
· wlog ha : 1 ≤ a generalizing a
· convert @this (a⁻¹) ?_ (by simpa using le_of_not_ge ha) using 4
· simp
· rwa [mabs_inv]
rw [mabs, sup_eq_left.mpr ((inv_le_one'.mpr ha).trans ha)] at h
rcases h with ⟨rfl, h⟩
refine ⟨?_, ?_⟩
· simp [h]
· intro x
simp only [mem_closure_singleton, mem_setOf_eq, and_imp, forall_exists_index]
rintro k rfl hk
rw [← zpow_one b, ← zpow_mul, one_mul, zpow_le_zpow_iff_right h, ← zero_add 1,
← Int.lt_iff_add_one_le]
contrapose! hk
rw [← Left.one_le_inv_iff, ← zpow_neg]
exact one_le_zpow ha (by simp [hk]) | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Subgroup.isLeast_of_closure_iff_eq_mabs | null |
noncomputable LinearOrderedAddCommGroup.int_orderAddMonoidIso_of_isLeast_pos {G : Type*}
[AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G] {x : G}
(h : IsLeast {y : G | 0 < y} x) : G ≃+o ℤ := by
have : IsLeast {y : G | y ∈ (⊤ : AddSubgroup G) ∧ 0 < y} x := by simpa using h
replace this := AddSubgroup.cyclic_of_min this
let e : G ≃+o (⊤ : AddSubgroup G) := ⟨AddSubsemigroup.topEquiv.symm,
(AddEquiv.strictMono_symm AddSubsemigroup.strictMono_topEquiv).le_iff_le⟩
let e' : (⊤ : AddSubgroup G) ≃+o AddSubgroup.closure {x} :=
⟨AddEquiv.subsemigroupCongr (by simp [this]),
(AddEquiv.strictMono_subsemigroupCongr _).le_iff_le⟩
let g : (⊤ : AddSubgroup ℤ) ≃+o ℤ := ⟨AddSubsemigroup.topEquiv,
(AddSubsemigroup.strictMono_topEquiv).le_iff_le⟩
let g' : AddSubgroup.closure ({1} : Set ℤ) ≃+o (⊤ : AddSubgroup ℤ) :=
⟨(.subsemigroupCongr (by simp)),
(AddEquiv.strictMono_subsemigroupCongr _).le_iff_le⟩
let f := closure_equiv_closure x (1 : ℤ) (by simp [h.left.ne'])
exact ((((e.trans e').trans f).trans g').trans g : G ≃+o ℤ) | def | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedAddCommGroup.int_orderAddMonoidIso_of_isLeast_pos | If an element of a linearly ordered archimedean additive group is the least positive element,
then the whole group is isomorphic (and order-isomorphic) to the integers. |
noncomputable LinearOrderedCommGroup.multiplicative_int_orderMonoidIso_of_isLeast_one_lt
{x : G} (h : IsLeast {y : G | 1 < y} x) : G ≃*o Multiplicative ℤ := by
have : IsLeast {y : Additive G | 0 < y} (.ofMul x) := h
let f' := LinearOrderedAddCommGroup.int_orderAddMonoidIso_of_isLeast_pos (G := Additive G) this
exact ⟨AddEquiv.toMultiplicative' f', by simp⟩ | def | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.multiplicative_int_orderMonoidIso_of_isLeast_one_lt | If an element of a linearly ordered mul-archimedean group is the least element greater than 1,
then the whole group is isomorphic (and order-isomorphic) to the multiplicative integers. |
Archimedean.of_locallyFiniteOrder {G : Type*} [AddCommGroup G] [LinearOrder G]
[IsOrderedAddMonoid G] [LocallyFiniteOrder G] :
Archimedean G :=
.comap (LocallyFiniteOrder.addMonoidHom G) LocallyFiniteOrder.orderAddMonoidHom_strictMono | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | Archimedean.of_locallyFiniteOrder | Any locally finite linear additive group is archimedean. |
@[to_additive existing]
MulArchimedean.of_locallyFiniteOrder {G : Type*} [CommGroup G] [LinearOrder G]
[IsOrderedMonoid G] [LocallyFiniteOrder G] :
MulArchimedean G :=
.comap (LocallyFiniteOrder.orderMonoidHom G).toMonoidHom
LocallyFiniteOrder.orderMonoidHom_strictMono | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | MulArchimedean.of_locallyFiniteOrder | Any locally finite linear group is mul-archimedean. |
LinearOrderedAddCommGroup.discrete_or_denselyOrdered (G : Type*)
[AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G] :
Nonempty (G ≃+o ℤ) ∨ DenselyOrdered G := by
by_cases H : ∃ x, IsLeast {y : G | 0 < y} x
· obtain ⟨x, hx⟩ := H
exact Or.inl ⟨(int_orderAddMonoidIso_of_isLeast_pos hx)⟩
· push_neg at H
refine Or.inr ⟨?_⟩
intro x y hxy
specialize H (y - x)
obtain ⟨z, hz⟩ : ∃ z : G, 0 < z ∧ z < y - x := by
contrapose! H
refine ⟨by simp [hxy], fun _ ↦ H _⟩
refine ⟨x + z, ?_, ?_⟩
· simp [hz.left]
· simpa [lt_sub_iff_add_lt'] using hz.right | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedAddCommGroup.discrete_or_denselyOrdered | Any linearly ordered archimedean additive group is either isomorphic (and order-isomorphic)
to the integers, or is densely ordered. |
LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered (G : Type*)
[AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] [Archimedean G] :
Nonempty (G ≃+o ℤ) ↔ ¬ DenselyOrdered G := by
suffices ∀ (_ : G ≃+o ℤ), ¬ DenselyOrdered G by
rcases LinearOrderedAddCommGroup.discrete_or_denselyOrdered G with ⟨⟨h⟩⟩|h
· simpa [this h] using ⟨h⟩
· simp only [h, not_true_eq_false, iff_false, not_nonempty_iff]
exact ⟨fun H ↦ (this H) h⟩
intro e H
rw [denselyOrdered_iff_of_orderIsoClass e] at H
obtain ⟨_, _⟩ := exists_between (one_pos (α := ℤ))
cutsat
variable (G) in | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered | Any linearly ordered archimedean additive group is either isomorphic (and order-isomorphic)
to the integers, or is densely ordered, exclusively. |
LinearOrderedCommGroup.discrete_or_denselyOrdered :
Nonempty (G ≃*o Multiplicative ℤ) ∨ DenselyOrdered G := by
refine (LinearOrderedAddCommGroup.discrete_or_denselyOrdered (Additive G)).imp ?_ id
rintro ⟨f, hf⟩
exact ⟨AddEquiv.toMultiplicative' f, hf⟩
variable (G) in | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.discrete_or_denselyOrdered | Any linearly ordered mul-archimedean group is either isomorphic (and order-isomorphic)
to the multiplicative integers, or is densely ordered. |
LinearOrderedCommGroup.discrete_iff_not_denselyOrdered :
Nonempty (G ≃*o Multiplicative ℤ) ↔ ¬ DenselyOrdered G := by
let e : G ≃o Additive G := OrderIso.refl G
rw [denselyOrdered_iff_of_orderIsoClass e,
← LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered (Additive G)]
refine Nonempty.congr ?_ ?_ <;> intro f
· exact ⟨MulEquiv.toAdditive' f, by simp⟩
· exact ⟨MulEquiv.toAdditive'.symm f, by simp⟩ | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroup.discrete_iff_not_denselyOrdered | Any linearly ordered mul-archimedean group is either isomorphic (and order-isomorphic)
to the multiplicative integers, or is densely ordered, exclusively. |
LinearOrderedCommGroupWithZero.discrete_or_denselyOrdered (G : Type*)
[LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G] :
Nonempty (G ≃*o ℤᵐ⁰) ∨ DenselyOrdered G := by
classical
rw [← denselyOrdered_units_iff]
refine (LinearOrderedCommGroup.discrete_or_denselyOrdered Gˣ).imp_left ?_
intro ⟨f⟩
exact ⟨OrderMonoidIso.withZeroUnits.symm.trans f.withZero⟩
open WithZero in | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroupWithZero.discrete_or_denselyOrdered | Any nontrivial (has other than 0 and 1) linearly ordered mul-archimedean group with zero is
either isomorphic (and order-isomorphic) to `ℤᵐ⁰`, or is densely ordered. |
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered (G : Type*)
[LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G] :
Nonempty (G ≃*o ℤᵐ⁰) ↔ ¬ DenselyOrdered G := by
rw [← denselyOrdered_units_iff,
← LinearOrderedCommGroup.discrete_iff_not_denselyOrdered]
refine Nonempty.congr ?_ ?_ <;> intro f
· refine ⟨MulEquiv.withZero.symm (withZeroUnitsEquiv.trans f), ?_⟩
intros
simp only [MulEquiv.withZero, withZeroUnitsEquiv, MulEquiv.trans_apply,
MulEquiv.coe_mk, Equiv.coe_fn_mk, recZeroCoe_coe, OrderMonoidIso.coe_mulEquiv,
MulEquiv.symm_trans_apply, MulEquiv.symm_mk, Equiv.coe_fn_symm_mk, map_eq_zero, coe_ne_zero,
↓reduceDIte, unzero_coe, MulEquiv.toEquiv_eq_coe, Equiv.toFun_as_coe, EquivLike.coe_coe]
rw [← Units.val_le_val, ← map_le_map_iff f, ← coe_le_coe, coe_unzero, coe_unzero]
· refine ⟨withZeroUnitsEquiv.symm.trans (MulEquiv.withZero f), ?_⟩
intros
simp only [withZeroUnitsEquiv, MulEquiv.symm_mk, MulEquiv.withZero,
MulEquiv.toEquiv_eq_coe, Equiv.toFun_as_coe, EquivLike.coe_coe,
MulEquiv.trans_apply, MulEquiv.coe_mk, Equiv.coe_fn_symm_mk, Equiv.coe_fn_mk]
split_ifs <;>
simp_all [← Units.val_le_val] | lemma | GroupTheory | [
"Mathlib.Algebra.Order.Group.Units",
"Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder",
"Mathlib.Data.Int.Interval",
"Mathlib.GroupTheory.Archimedean",
"Mathlib.GroupTheory.OrderOfElement",
"Mathlib.Order.Interval.Finset.DenselyOrdered"
] | Mathlib/GroupTheory/ArchimedeanDensely.lean | LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered | Any nontrivial (has other than 0 and 1) linearly ordered mul-archimedean group with zero is
either isomorphic (and order-isomorphic) to `ℤᵐ⁰`, or is densely ordered, exclusively |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.