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 ⌀ |
|---|---|---|---|---|---|---|
adjoin_image_leastExt (i : ι) : E⟮<i⟯ = adjoin F (b '' Iio (φ i)) := by
refine le_antisymm (adjoin.mono _ _ _ ?_) (adjoin_le_iff.mpr ?_)
· rw [image_comp]; apply image_mono; rintro _ ⟨j, hj, rfl⟩; exact strictMono_leastExt hj
· rintro _ ⟨j, hj, rfl⟩; contrapose! hj; exact ((isLeast_leastExt i).2 hj).not_gt | 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_image_leastExt | null |
iSup_adjoin_eq_top : ⨆ i : ι, E⟮<i⟯ = ⊤ := by
simp_rw [adjoin_image_leastExt, eq_top_iff, ← adjoin_basis_eq_top, adjoin_le_iff]
rintro _ ⟨i, rfl⟩
refine le_iSup (α := IntermediateField F E) _ (i⁺) (subset_adjoin _ _ ⟨i, ?_, rfl⟩)
exact (lt_succ i).trans_le strictMono_leastExt.le_apply | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | iSup_adjoin_eq_top | null |
strictMono_filtration : StrictMono (E⟮<·⟯) :=
fun i _ h ↦ ⟨adjoin.mono _ _ _ (image_mono <| Iio_subset_Iio h.le),
fun incl ↦ (isLeast_leastExt i).1 (incl <| subset_adjoin _ _ ⟨i, h, rfl⟩)⟩ | 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_filtration | null |
filtration_succ (i : ι) : E⟮<i⁺⟯ = E⟮<i⟯⟮b (φ i)⟯.restrictScalars F := by
rw [Iio_succ, ← Iio_insert, image_insert_eq, ← union_singleton, adjoin_adjoin_left]; rfl
local notation "X" i => Field.Emb (E⟮<i⟯) <| E⟮<i⟯⟮b (φ i)⟯ | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | filtration_succ | null |
succEquiv (i : ι) : (E⟮<i⁺⟯ →ₐ[F] Ē) ≃ (E⟮<i⟯ →ₐ[F] Ē) × X i :=
(((show _ ≃ₐ[F] E⟮<i⟯⟮b (φ i)⟯ from equivOfEq (filtration_succ i))).arrowCongr .refl).trans <|
algHomEquivSigma (B := E⟮<i⟯).trans <| .sigmaEquivProdOfEquiv fun _ ↦
(@Field.embEquivOfIsAlgClosed _ _ _ _ _ _ _ (_) <|
(Algebra.IsAlgebraic... | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | succEquiv | Each embedding of `E⟮<i⟯` into `Ē` extend to `#(X i)` embeddings of `E⟮<i⁺⟯`. |
succEquiv_coherence (i : ι) (f) : (succEquiv i f).1 =
f.comp (Subalgebra.inclusion <| strictMono_filtration.monotone <| le_succ i) := by
ext; simp [succEquiv]; rfl -- slow rfl (type checking took 11.9s) | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | succEquiv_coherence | null |
deg_lt_aleph0 (i : ι) : #(X i) < ℵ₀ :=
(toNat_ne_zero.mp (Field.instNeZeroFinSepDegree (E⟮<i⟯) <| E⟮<i⟯⟮b (φ i)⟯).out).2
open WithTop in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | deg_lt_aleph0 | null |
@[simps!] filtration : WithTop ι ↪o IntermediateField F E :=
.ofStrictMono (fun i ↦ i.recTopCoe ⊤ (E⟮<·⟯)) fun i j h ↦ by
cases j
· obtain ⟨i, rfl⟩ := ne_top_iff_exists.mp h.ne
exact ⟨le_top, fun incl ↦ (isLeast_leastExt i).1 (incl trivial)⟩
· obtain ⟨i, rfl⟩ := ne_top_iff_exists.mp (h.trans <| coe_... | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | filtration | Extend the family `E⟮<i⟯, i : ι` by adjoining a top element. |
factor (i : WithTop ι) : Type _ := i.recTopCoe PUnit (X ·)
variable [Algebra.IsSeparable 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 | factor | Extend the family `X i := E⟮<i⟯ →ₐ[F] Ē` from `ι` to `WithTop ι`. |
two_le_deg (i : ι) : 2 ≤ #(X i) := by
rw [← Nat.cast_ofNat, ← toNat_le_iff_le_of_lt_aleph0 (nat_lt_aleph0 _) (deg_lt_aleph0 i),
toNat_natCast, ← Nat.card, ← finSepDegree, finSepDegree_eq_finrank_of_isSeparable, Nat.succ_le]
by_contra!
obtain ⟨x, hx⟩ := finrank_adjoin_simple_eq_one_iff.mp (this.antisymm Module... | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | two_le_deg | null |
embFunctor ⦃i j : WithTop ι⦄ (h : i ≤ j) (f : E⟮<j⟯ →ₐ[F] Ē) : E⟮<i⟯ →ₐ[F] Ē :=
f.comp (Subalgebra.inclusion <| filtration.monotone h) | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | embFunctor | The functor on `WithTop ι` given by embeddings of `E⟮<i⟯` into `Ē` |
equivSucc (i : WithTop ι) : (E⟮<i⁺⟯ →ₐ[F] Ē) ≃ (E⟮<i⟯ →ₐ[F] Ē) × factor i :=
i.recTopCoe (((equivOfEq <| by rw [succ_top]).arrowCongr .refl).trans <| .symm <| .prodPUnit _)
(succEquiv ·) | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | equivSucc | Extend `succEquiv` from `ι` to `WithTop ι`. |
equivSucc_coherence (i f) : (equivSucc i f).1 = embFunctor F E (le_succ i) f := by
cases i; exacts [rfl, succEquiv_coherence _ f] | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | equivSucc_coherence | null |
directed_filtration : Directed (· ≤ ·) fun j : Iio i ↦ filtration j.1 :=
(filtration.monotone.comp <| Subtype.mono_coe _).directed_le
variable (hi : IsSuccPrelimit i)
include hi
open WithTop in | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | directed_filtration | null |
iSup_filtration : ⨆ j : Iio i, filtration j = filtration i := by
cases i
· rw [← range_coe, iSup_range']; exact iSup_adjoin_eq_top
refine (iSup_le fun j ↦ filtration.monotone (mem_Iio.1 j.2).le).antisymm (adjoin_le_iff.2 ?_)
rintro _ ⟨j, hj, rfl⟩
refine le_iSup (α := IntermediateField F E) _ ⟨j⁺, ?_⟩ (subset_... | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | iSup_filtration | null |
eq_bot_of_not_nonempty (hi : ¬ Nonempty (Iio i)) : filtration i = ⊥ := by
cases i
· have := mk_ne_zero_iff.mp (rank_pos.trans_eq (mk_ord_toType <| Module.rank F E).symm).ne'
rw [← range_coe] at hi; exact (hi inferInstance).elim
· exact bot_unique <| adjoin_le_iff.mpr fun _ ⟨j, hj, _⟩ ↦ (hi ⟨j, coe_lt_coe.mpr ... | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | eq_bot_of_not_nonempty | null |
equivLim : (E⟮<i⟯ →ₐ[F] Ē) ≃ limit (embFunctor F E) i where
toFun f := ⟨fun j ↦ embFunctor _ _ (id j.2 : j < i).le f, fun _ _ _ ↦ rfl⟩
invFun f := if h : Nonempty (Iio i) then
Subalgebra.iSupLift _ directed_filtration f.1
(fun _ _ h ↦ (f.2 <| filtration.map_rel_iff.mp h).symm) _ <| by
rw [← iSup_f... | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | equivLim | If `i` is a limit, the type of embeddings of `E⟮<i⟯` into `Ē` is
the limit of the types of embeddings of `E⟮<j⟯` for `j < i`. |
equivLim_coherence (x l) : (equivLim hi x).1 l = embFunctor F E (mem_Iio.mp l.2).le x :=
rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | equivLim_coherence | null |
embEquivPi : Field.Emb F E ≃ ∀ i : ι, factor (F := F) (E := E) i :=
let e := globalEquiv
(fun i _ ↦ ⟨_, equivSucc_coherence i⟩) (fun _ hi ↦ ⟨equivLim hi, fun _ _ ↦ rfl⟩) ⊤
(topEquiv.arrowCongr .refl).symm.trans <| e.trans <| .trans (.piCongrSet WithTop.range_coe.symm)
<| .symm <| .piCongr (.ofInjective _ Wi... | def | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | embEquivPi | A bijection between `E →ₐ[F] Ē` and the product of `E⟮<i⁺⟯ →ₐ[E⟮<i⟯] Ē` over all `i : ι`. |
cardinal_eq_two_pow_rank [Algebra.IsSeparable F E]
(rank_inf : ℵ₀ ≤ Module.rank F E) : #(Field.Emb F E) = 2 ^ Module.rank F E := by
haveI := Fact.mk rank_inf
rw [Emb.Cardinal.embEquivPi.cardinal_eq, mk_pi]
apply le_antisymm
· rw [← power_eq_two_power rank_inf (nat_lt_aleph0 2).le rank_inf]
conv_rhs => r... | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | cardinal_eq_two_pow_rank | null |
cardinal_eq_of_isSeparable [Algebra.IsSeparable F E] :
#(Field.Emb F E) = (fun c ↦ if ℵ₀ ≤ c then 2 ^ c else c) (Module.rank F E) := by
dsimp only; split_ifs with h
· exact cardinal_eq_two_pow_rank h
rw [not_le, ← IsNoetherian.iff_rank_lt_aleph0] at h
rw [← Module.finrank_eq_rank, ← toNat_eq_iff Module.finr... | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | cardinal_eq_of_isSeparable | null |
cardinal_eq_two_pow_sepDegree [Algebra.IsAlgebraic F E]
(rank_inf : ℵ₀ ≤ sepDegree F E) : #(Field.Emb F E) = 2 ^ sepDegree F E := by
rw [← cardinal_separableClosure, cardinal_eq_two_pow_rank rank_inf]
rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | cardinal_eq_two_pow_sepDegree | null |
cardinal_eq [Algebra.IsAlgebraic F E] :
#(Field.Emb F E) = (fun c ↦ if ℵ₀ ≤ c then 2 ^ c else c) (sepDegree F E) := by
rw [← cardinal_separableClosure, cardinal_eq_of_isSeparable]; rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | cardinal_eq | null |
Fintype.isPrimePow_card_of_field {α} [Fintype α] [Field α] : IsPrimePow ‖α‖ :=
FiniteField.isPrimePow_card α | theorem | FieldTheory | [
"Mathlib.Algebra.Field.TransferInstance",
"Mathlib.Algebra.Field.ULift",
"Mathlib.Algebra.MvPolynomial.Cardinal",
"Mathlib.Data.Rat.Encodable",
"Mathlib.FieldTheory.Finite.GaloisField",
"Mathlib.RingTheory.Localization.Cardinality",
"Mathlib.SetTheory.Cardinal.Divisibility"
] | Mathlib/FieldTheory/Cardinality.lean | Fintype.isPrimePow_card_of_field | A finite field has prime power cardinality. |
Fintype.nonempty_field_iff {α} [Fintype α] : Nonempty (Field α) ↔ IsPrimePow ‖α‖ := by
refine ⟨fun ⟨h⟩ => Fintype.isPrimePow_card_of_field, ?_⟩
rintro ⟨p, n, hp, hn, hα⟩
haveI := Fact.mk hp.nat_prime
haveI : Fintype (GaloisField p n) := Fintype.ofFinite (GaloisField p n)
exact ⟨(Fintype.equivOfCardEq
(((F... | theorem | FieldTheory | [
"Mathlib.Algebra.Field.TransferInstance",
"Mathlib.Algebra.Field.ULift",
"Mathlib.Algebra.MvPolynomial.Cardinal",
"Mathlib.Data.Rat.Encodable",
"Mathlib.FieldTheory.Finite.GaloisField",
"Mathlib.RingTheory.Localization.Cardinality",
"Mathlib.SetTheory.Cardinal.Divisibility"
] | Mathlib/FieldTheory/Cardinality.lean | Fintype.nonempty_field_iff | A `Fintype` can be given a field structure iff its cardinality is a prime power. |
Fintype.not_isField_of_card_not_prime_pow {α} [Fintype α] [Ring α] :
¬IsPrimePow ‖α‖ → ¬IsField α :=
mt fun h => Fintype.nonempty_field_iff.mp ⟨h.toField⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Field.TransferInstance",
"Mathlib.Algebra.Field.ULift",
"Mathlib.Algebra.MvPolynomial.Cardinal",
"Mathlib.Data.Rat.Encodable",
"Mathlib.FieldTheory.Finite.GaloisField",
"Mathlib.RingTheory.Localization.Cardinality",
"Mathlib.SetTheory.Cardinal.Divisibility"
] | Mathlib/FieldTheory/Cardinality.lean | Fintype.not_isField_of_card_not_prime_pow | null |
Infinite.nonempty_field {α : Type u} [Infinite α] : Nonempty (Field α) := by
suffices #α = #(FractionRing (MvPolynomial α <| ULift.{u} ℚ)) from
(Cardinal.eq.1 this).map (·.field)
simp | theorem | FieldTheory | [
"Mathlib.Algebra.Field.TransferInstance",
"Mathlib.Algebra.Field.ULift",
"Mathlib.Algebra.MvPolynomial.Cardinal",
"Mathlib.Data.Rat.Encodable",
"Mathlib.FieldTheory.Finite.GaloisField",
"Mathlib.RingTheory.Localization.Cardinality",
"Mathlib.SetTheory.Cardinal.Divisibility"
] | Mathlib/FieldTheory/Cardinality.lean | Infinite.nonempty_field | Any infinite type can be endowed a field structure. |
Field.nonempty_iff {α : Type u} : Nonempty (Field α) ↔ IsPrimePow #α := by
rw [Cardinal.isPrimePow_iff]
obtain h | h := fintypeOrInfinite α
· simpa only [Cardinal.mk_fintype, Nat.cast_inj, exists_eq_left',
(Cardinal.nat_lt_aleph0 _).not_ge, false_or] using Fintype.nonempty_field_iff
· simpa only [← Cardin... | theorem | FieldTheory | [
"Mathlib.Algebra.Field.TransferInstance",
"Mathlib.Algebra.Field.ULift",
"Mathlib.Algebra.MvPolynomial.Cardinal",
"Mathlib.Data.Rat.Encodable",
"Mathlib.FieldTheory.Finite.GaloisField",
"Mathlib.RingTheory.Localization.Cardinality",
"Mathlib.SetTheory.Cardinal.Divisibility"
] | Mathlib/FieldTheory/Cardinality.lean | Field.nonempty_iff | There is a field structure on type if and only if its cardinality is a prime power. |
MvPolynomial.sum_eval_eq_zero (f : MvPolynomial σ K)
(h : f.totalDegree < (q - 1) * Fintype.card σ) : ∑ x, eval x f = 0 := by
haveI : DecidableEq K := Classical.decEq K
calc
∑ x, eval x f = ∑ x : σ → K, ∑ d ∈ f.support, f.coeff d * ∏ i, x i ^ d i := by
simp only [eval_eq']
_ = ∑ d ∈ f.support, ∑ x... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Finite.Basic"
] | Mathlib/FieldTheory/ChevalleyWarning.lean | MvPolynomial.sum_eval_eq_zero | null |
char_dvd_card_solutions_of_sum_lt {s : Finset ι} {f : ι → MvPolynomial σ K}
(h : (∑ i ∈ s, (f i).totalDegree) < Fintype.card σ) :
p ∣ Fintype.card { x : σ → K // ∀ i ∈ s, eval x (f i) = 0 } := by
have hq : 0 < q - 1 := by rw [← Fintype.card_units, Fintype.card_pos_iff]; exact ⟨1⟩
let S : Finset (σ → K) := {... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Finite.Basic"
] | Mathlib/FieldTheory/ChevalleyWarning.lean | char_dvd_card_solutions_of_sum_lt | The **Chevalley–Warning theorem**, finitary version.
Let `(f i)` be a finite family of multivariate polynomials
in finitely many variables (`X s`, `s : σ`) over a finite field of characteristic `p`.
Assume that the sum of the total degrees of the `f i` is less than the cardinality of `σ`.
Then the number of common solu... |
char_dvd_card_solutions_of_fintype_sum_lt [Fintype ι] {f : ι → MvPolynomial σ K}
(h : (∑ i, (f i).totalDegree) < Fintype.card σ) :
p ∣ Fintype.card { x : σ → K // ∀ i, eval x (f i) = 0 } := by
simpa using char_dvd_card_solutions_of_sum_lt p h | theorem | FieldTheory | [
"Mathlib.FieldTheory.Finite.Basic"
] | Mathlib/FieldTheory/ChevalleyWarning.lean | char_dvd_card_solutions_of_fintype_sum_lt | The **Chevalley–Warning theorem**, `Fintype` version.
Let `(f i)` be a finite family of multivariate polynomials
in finitely many variables (`X s`, `s : σ`) over a finite field of characteristic `p`.
Assume that the sum of the total degrees of the `f i` is less than the cardinality of `σ`.
Then the number of common sol... |
char_dvd_card_solutions {f : MvPolynomial σ K} (h : f.totalDegree < Fintype.card σ) :
p ∣ Fintype.card { x : σ → K // eval x f = 0 } := by
let F : Unit → MvPolynomial σ K := fun _ => f
have : (∑ i : Unit, (F i).totalDegree) < Fintype.card σ := h
convert char_dvd_card_solutions_of_sum_lt p this
aesop | theorem | FieldTheory | [
"Mathlib.FieldTheory.Finite.Basic"
] | Mathlib/FieldTheory/ChevalleyWarning.lean | char_dvd_card_solutions | The **Chevalley–Warning theorem**, unary version.
Let `f` be a multivariate polynomial in finitely many variables (`X s`, `s : σ`)
over a finite field of characteristic `p`.
Assume that the total degree of `f` is less than the cardinality of `σ`.
Then the number of solutions of `f` is divisible by `p`.
See `char_dvd_ca... |
char_dvd_card_solutions_of_add_lt {f₁ f₂ : MvPolynomial σ K}
(h : f₁.totalDegree + f₂.totalDegree < Fintype.card σ) :
p ∣ Fintype.card { x : σ → K // eval x f₁ = 0 ∧ eval x f₂ = 0 } := by
let F : Bool → MvPolynomial σ K := fun b => cond b f₂ f₁
have : (∑ b : Bool, (F b).totalDegree) < Fintype.card σ := (add... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Finite.Basic"
] | Mathlib/FieldTheory/ChevalleyWarning.lean | char_dvd_card_solutions_of_add_lt | The **Chevalley–Warning theorem**, binary version.
Let `f₁`, `f₂` be two multivariate polynomials in finitely many variables (`X s`, `s : σ`) over a
finite field of characteristic `p`.
Assume that the sum of the total degrees of `f₁` and `f₂` is less than the cardinality of `σ`.
Then the number of common solutions of t... |
Lifts where
/-- The domain of a lift. -/
carrier : IntermediateField F E
/-- The lifted RingHom, expressed as an AlgHom. -/
emb : carrier →ₐ[F] K
variable {F E K} | structure | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | Lifts | Lifts `L → K` of `F → K` |
le_iff : L₁ ≤ L₂ ↔
∃ h : L₁.carrier ≤ L₂.carrier, L₂.emb.comp (inclusion h) = L₁.emb := by
simp_rw [AlgHom.ext_iff]; rfl | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | le_iff | null |
eq_iff_le_carrier_eq : L₁ = L₂ ↔ L₁ ≤ L₂ ∧ L₁.carrier = L₂.carrier :=
⟨fun eq ↦ ⟨eq.le, congr_arg _ eq⟩, fun ⟨le, eq⟩ ↦ le.antisymm ⟨eq.ge, fun x ↦ (le.2 ⟨x, _⟩).symm⟩⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | eq_iff_le_carrier_eq | null |
eq_iff : L₁ = L₂ ↔
∃ h : L₁.carrier = L₂.carrier, L₂.emb.comp (inclusion h.le) = L₁.emb := by
rw [eq_iff_le_carrier_eq, le_iff]
exact ⟨fun h ↦ ⟨h.2, h.1.2⟩, fun h ↦ ⟨⟨h.1.le, h.2⟩, h.1⟩⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | eq_iff | null |
lt_iff_le_carrier_ne : L₁ < L₂ ↔ L₁ ≤ L₂ ∧ L₁.carrier ≠ L₂.carrier := by
rw [lt_iff_le_and_ne, and_congr_right]; intro h; simp_rw [Ne, eq_iff_le_carrier_eq, h, true_and] | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | lt_iff_le_carrier_ne | null |
lt_iff : L₁ < L₂ ↔
∃ h : L₁.carrier < L₂.carrier, L₂.emb.comp (inclusion h.le) = L₁.emb := by
rw [lt_iff_le_carrier_ne, le_iff]
exact ⟨fun h ↦ ⟨h.1.1.lt_of_ne h.2, h.1.2⟩, fun h ↦ ⟨⟨h.1.le, h.2⟩, h.1.ne⟩⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | lt_iff | null |
le_of_carrier_le_iSup {ι} {ρ : ι → Lifts F E K} {σ τ : Lifts F E K}
(hσ : ∀ i, ρ i ≤ σ) (hτ : ∀ i, ρ i ≤ τ) (carrier_le : σ.carrier ≤ ⨆ i, (ρ i).carrier) :
σ ≤ τ :=
le_iff.mpr ⟨carrier_le.trans (iSup_le fun i ↦ (hτ i).1), algHom_ext_of_eq_adjoin _
(carrier_le.antisymm (iSup_le fun i ↦ (hσ i).1)|>.trans ... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | le_of_carrier_le_iSup | null |
IsExtendible (σ : Lifts F E K) : Prop :=
∀ S : Finset E, ∃ τ ≥ σ, (S : Set E) ⊆ τ.carrier | def | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | IsExtendible | `σ : L →ₐ[F] K` is an extendible lift ("extendible pair" in [Isaacs1980]) if for every
intermediate field `M` that is finite-dimensional over `L`, `σ` extends to some `M →ₐ[F] K`.
In our definition we only require `M` to be finitely generated over `L`, which is equivalent
if the ambient field `E` is algebraic over `F` ... |
noncomputable union : Lifts F E K :=
let t (i : ↑(insert ⊥ c)) := i.val.carrier
have hc := hc.insert fun _ _ _ ↦ .inl bot_le
have dir : Directed (· ≤ ·) t := hc.directedOn.directed_val.mono_comp _ fun _ _ h ↦ h.1
⟨iSup t, (Subalgebra.iSupLift (toSubalgebra <| t ·) dir (·.val.emb) (fun i j h ↦
AlgHom.ext fun... | def | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | union | The union of a chain of lifts. |
le_union ⦃σ : Lifts F E K⦄ (hσ : σ ∈ c) : σ ≤ union c hc :=
have hσ := Set.mem_insert_of_mem ⊥ hσ
let t (i : ↑(insert ⊥ c)) := i.val.carrier
⟨le_iSup t ⟨σ, hσ⟩, fun x ↦ by
dsimp only [union, AlgHom.comp_apply]
exact Subalgebra.iSupLift_inclusion (K := (toSubalgebra <| t ·))
(i := ⟨σ, hσ⟩) x (le_iSup... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | le_union | null |
carrier_union : (union c hc).carrier = ⨆ i : c, i.1.carrier :=
le_antisymm (iSup_le <| by rintro ⟨i, rfl | hi⟩; exacts [bot_le, le_iSup_of_le ⟨i, hi⟩ le_rfl]) <|
iSup_le fun i ↦ le_iSup_of_le ⟨i, .inr i.2⟩ le_rfl | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | carrier_union | null |
exists_upper_bound (c : Set (Lifts F E K)) (hc : IsChain (· ≤ ·) c) :
∃ ub, ∀ a ∈ c, a ≤ ub := ⟨_, le_union c hc⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_upper_bound | A chain of lifts has an upper bound. |
union_isExtendible [alg : Algebra.IsAlgebraic F E]
[Nonempty c] (hext : ∀ σ ∈ c, σ.IsExtendible) :
(union c hc).IsExtendible := fun S ↦ by
let Ω := adjoin F (S : Set E) →ₐ[F] K
have ⟨ω, hω⟩ : ∃ ω : Ω, ∀ π : c, ∃ θ ≥ π.1, ⟨_, ω⟩ ≤ θ ∧ θ.carrier = π.1.1 ⊔ adjoin F S := by
by_contra!; choose π hπ using thi... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | union_isExtendible | null |
nonempty_algHom_of_exist_lifts_finset [alg : Algebra.IsAlgebraic F E]
(h : ∀ S : Finset E, ∃ σ : Lifts F E K, (S : Set E) ⊆ σ.carrier) :
Nonempty (E →ₐ[F] K) := by
have : (⊥ : Lifts F E K).IsExtendible := fun S ↦ have ⟨σ, hσ⟩ := h S; ⟨σ, bot_le, hσ⟩
have ⟨ϕ, hϕ⟩ := zorn_le₀ {ϕ : Lifts F E K | ϕ.IsExtendible... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | nonempty_algHom_of_exist_lifts_finset | null |
exists_lift_of_splits' (x : Lifts F E K) {s : E} (h1 : IsIntegral x.carrier s)
(h2 : (minpoly x.carrier s).Splits x.emb.toRingHom) : ∃ y, x ≤ y ∧ s ∈ y.carrier :=
have I2 := (minpoly.degree_pos h1).ne'
letI : Algebra x.carrier K := x.emb.toRingHom.toAlgebra
let carrier := x.carrier⟮s⟯.restrictScalars F
letI... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_lift_of_splits' | Given a lift `x` and an integral element `s : E` over `x.carrier` whose conjugates over
`x.carrier` are all in `K`, we can extend the lift to a lift whose carrier contains `s`. |
exists_lift_of_splits (x : Lifts F E K) {s : E} (h1 : IsIntegral F s)
(h2 : (minpoly F s).Splits (algebraMap F K)) : ∃ y, x ≤ y ∧ s ∈ y.carrier :=
exists_lift_of_splits' x h1.tower_top <| h1.minpoly_splits_tower_top' <| by
rwa [← x.emb.comp_algebraMap] at h2 | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_lift_of_splits | Given an integral element `s : E` over `F` whose `F`-conjugates are all in `K`,
any lift can be extended to one whose carrier contains `s`. |
private exists_algHom_adjoin_of_splits'' {L : IntermediateField F E}
(f : L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral L s ∧ (minpoly L s).Splits f.toRingHom) :
∃ φ : adjoin L S →ₐ[F] K, φ.restrictDomain L = f := by
obtain ⟨φ, hfφ, hφ⟩ := zorn_le_nonempty_Ici₀ _
(fun c _ hc _ _ ↦ Lifts.exists_upper_bound c hc) ⟨L... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_adjoin_of_splits'' | null |
exists_algHom_adjoin_of_splits' :
∃ φ : adjoin L S →ₐ[F] K, φ.restrictDomain L = f := by
let L' := (IsScalarTower.toAlgHom F L E).fieldRange
let f' : L' →ₐ[F] K := f.comp (AlgEquiv.ofInjectiveField _).symm.toAlgHom
have := exists_algHom_adjoin_of_splits'' f' (S := S) fun s hs ↦ ?_
· obtain ⟨φ, hφ⟩ := this; ... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_adjoin_of_splits' | null |
exists_algHom_of_adjoin_splits' (hS : adjoin L S = ⊤) :
∃ φ : E →ₐ[F] K, φ.restrictDomain L = f :=
have ⟨φ, hφ⟩ := exists_algHom_adjoin_of_splits' f hK
⟨φ.comp (((equivOfEq hS).trans topEquiv).symm.toAlgHom.restrictScalars F), hφ⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_adjoin_splits' | null |
exists_algHom_of_splits' (hK : ∀ s : E, IsIntegral L s ∧ (minpoly L s).Splits f.toRingHom) :
∃ φ : E →ₐ[F] K, φ.restrictDomain L = f :=
exists_algHom_of_adjoin_splits' f (fun x _ ↦ hK x) (adjoin_univ L E) | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_splits' | null |
exists_algHom_adjoin_of_splits : ∃ φ : adjoin F S →ₐ[F] K, φ.comp (inclusion hL) = f := by
obtain ⟨φ, hfφ, hφ⟩ := zorn_le_nonempty_Ici₀ _
(fun c _ hc _ _ ↦ Lifts.exists_upper_bound c hc) ⟨L, f⟩ le_rfl
refine ⟨φ.emb.comp (inclusion <| adjoin_le_iff.mpr fun s hs ↦ ?_), ?_⟩
· rcases φ.exists_lift_of_splits (hK s... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_adjoin_of_splits | null |
nonempty_algHom_adjoin_of_splits : Nonempty (adjoin F S →ₐ[F] K) :=
have ⟨φ, _⟩ := exists_algHom_adjoin_of_splits hK (⊥ : Lifts F E K).emb bot_le; ⟨φ⟩
variable (hS : adjoin F S = ⊤)
include hS in | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | nonempty_algHom_adjoin_of_splits | null |
exists_algHom_of_adjoin_splits : ∃ φ : E →ₐ[F] K, φ.comp L.val = f :=
have ⟨φ, hφ⟩ := exists_algHom_adjoin_of_splits hK f (hS.symm ▸ le_top)
⟨φ.comp ((equivOfEq hS).trans topEquiv).symm.toAlgHom, hφ⟩
include hS in | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_adjoin_splits | null |
nonempty_algHom_of_adjoin_splits : Nonempty (E →ₐ[F] K) :=
have ⟨φ, _⟩ := exists_algHom_of_adjoin_splits hK (⊥ : Lifts F E K).emb hS; ⟨φ⟩
variable (hx : x ∈ adjoin F S) (hy : aeval y (minpoly F x) = 0)
include hy | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | nonempty_algHom_of_adjoin_splits | null |
exists_algHom_adjoin_of_splits_of_aeval : ∃ φ : adjoin F S →ₐ[F] K, φ ⟨x, hx⟩ = y := by
have := isAlgebraic_adjoin (fun s hs ↦ (hK s hs).1)
have ix : IsAlgebraic F _ := Algebra.IsAlgebraic.isAlgebraic (⟨x, hx⟩ : adjoin F S)
rw [isAlgebraic_iff_isIntegral, isIntegral_iff] at ix
obtain ⟨φ, hφ⟩ := exists_algHom_ad... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_adjoin_of_splits_of_aeval | null |
exists_algHom_of_adjoin_splits_of_aeval : ∃ φ : E →ₐ[F] K, φ x = y :=
have ⟨φ, hφ⟩ := exists_algHom_adjoin_of_splits_of_aeval hK (hS ▸ mem_top) hy
⟨φ.comp ((equivOfEq hS).trans topEquiv).symm.toAlgHom, hφ⟩
include hK' | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_adjoin_splits_of_aeval | null |
exists_algHom_of_splits : ∃ φ : E →ₐ[F] K, φ.comp L.val = f :=
exists_algHom_of_adjoin_splits (fun x _ ↦ hK' x) f (adjoin_univ F E) | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_splits | null |
nonempty_algHom_of_splits : Nonempty (E →ₐ[F] K) :=
nonempty_algHom_of_adjoin_splits (fun x _ ↦ hK' x) (adjoin_univ F E) | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | nonempty_algHom_of_splits | null |
exists_algHom_of_splits_of_aeval (hy : aeval y (minpoly F x) = 0) :
∃ φ : E →ₐ[F] K, φ x = y :=
exists_algHom_of_adjoin_splits_of_aeval (fun x _ ↦ hK' x) (adjoin_univ F E) hy | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | exists_algHom_of_splits_of_aeval | null |
Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits {F K : Type*} (L : Type*)
[Field F] [Field K] [Field L] [Algebra F L] [Algebra F K]
(hA : ∀ x : K, (minpoly F x).Splits (algebraMap F L))
[Algebra.IsAlgebraic F K] (x : K) :
(Set.range fun (ψ : K →ₐ[F] L) => ψ x) = (minpoly F x).rootSet L := by... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Extension.lean | Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits | Let `K/F` be an algebraic extension of fields and `L` a field in which all the minimal
polynomial over `F` of elements of `K` splits. Then, for `x ∈ K`, the images of `x` by the
`F`-algebra morphisms from `K` to `L` are exactly the roots in `L` of the minimal polynomial
of `x` over `F`. |
iff_rank_lt_aleph0 : IsNoetherian K V ↔ Module.rank K V < ℵ₀ := by
let b := Basis.ofVectorSpace K V
rw [← b.mk_eq_rank'', lt_aleph0_iff_set_finite]
constructor
· intro
exact (Basis.ofVectorSpaceIndex.linearIndependent K V).set_finite_of_isNoetherian
· intro hbfinite
refine
@isNoetherian_of_linea... | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | iff_rank_lt_aleph0 | A module over a division ring is Noetherian if and only if
its dimension (as a cardinal) is strictly less than the first infinite cardinal `ℵ₀`. |
noncomputable fintypeBasisIndex {ι : Type*} [IsNoetherian K V] (b : Basis ι K V) : Fintype ι :=
b.fintypeIndexOfRankLtAleph0 (rank_lt_aleph0 K V) | def | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | fintypeBasisIndex | In a Noetherian module over a division ring, all bases are indexed by a finite type. |
finite_basis_index {ι : Type*} {s : Set ι} [IsNoetherian K V] (b : Basis s K V) :
s.Finite :=
b.finite_index_of_rank_lt_aleph0 (rank_lt_aleph0 K V)
variable (K V) | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | finite_basis_index | In a Noetherian module over a division ring,
`Basis.ofVectorSpace` is indexed by a finite type. -/
noncomputable instance [IsNoetherian K V] : Fintype (Basis.ofVectorSpaceIndex K V) :=
fintypeBasisIndex (Basis.ofVectorSpace K V)
/-- In a Noetherian module over a division ring,
if a basis is indexed by a set, that se... |
noncomputable finsetBasisIndex [IsNoetherian K V] : Finset V :=
(finite_basis_index (Basis.ofVectorSpace K V)).toFinset
@[simp] | def | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | finsetBasisIndex | In a Noetherian module over a division ring,
there exists a finite basis. This is the indexing `Finset`. |
coe_finsetBasisIndex [IsNoetherian K V] :
(↑(finsetBasisIndex K V) : Set V) = Basis.ofVectorSpaceIndex K V :=
Set.Finite.coe_toFinset _
@[simp] | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | coe_finsetBasisIndex | null |
coeSort_finsetBasisIndex [IsNoetherian K V] :
(finsetBasisIndex K V : Type _) = Basis.ofVectorSpaceIndex K V :=
Set.Finite.coeSort_toFinset _ | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | coeSort_finsetBasisIndex | null |
noncomputable finsetBasis [IsNoetherian K V] : Basis (finsetBasisIndex K V) K V :=
(Basis.ofVectorSpace K V).reindex (by rw [coeSort_finsetBasisIndex])
@[simp] | def | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | finsetBasis | In a Noetherian module over a division ring, there exists a finite basis.
This is indexed by the `Finset` `IsNoetherian.finsetBasisIndex`.
This is in contrast to the result `finite_basis_index (Basis.ofVectorSpace K V)`,
which provides a set and a `Set.Finite`. |
range_finsetBasis [IsNoetherian K V] :
Set.range (finsetBasis K V) = Basis.ofVectorSpaceIndex K V := by
rw [finsetBasis, Basis.range_reindex, Basis.range_ofVectorSpace]
variable {K V} | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | range_finsetBasis | null |
_root_.Module.card_eq_pow_finrank [Fintype K] [Fintype V] :
Fintype.card V = Fintype.card K ^ Module.finrank K V := by
let b := IsNoetherian.finsetBasis K V
rw [Module.card_fintype b, ← Module.finrank_eq_card_basis b]
@[deprecated (since := "2025-03-14")] alias _root_.card_eq_pow_finrank := Module.card_eq_pow_f... | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | _root_.Module.card_eq_pow_finrank | null |
_root_.Module.natCard_eq_pow_finrank [Module.Finite K V] :
Nat.card V = Nat.card K ^ finrank K V := by
let b := IsNoetherian.finsetBasis K V
rw [Nat.card_congr b.equivFun.toEquiv, Nat.card_fun, finrank_eq_nat_card_basis b] | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | _root_.Module.natCard_eq_pow_finrank | null |
iff_fg : IsNoetherian K V ↔ Module.Finite K V := by
constructor
· intro h
exact
⟨⟨finsetBasisIndex K V, by
convert (finsetBasis K V).span_eq
simp⟩⟩
· rintro ⟨s, hs⟩
rw [IsNoetherian.iff_rank_lt_aleph0, ← rank_top, ← hs]
exact lt_of_le_of_lt (rank_span_le _) s.finite_toSet.lt_... | theorem | FieldTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.Dimension.Finite"
] | Mathlib/FieldTheory/Finiteness.lean | iff_fg | A module over a division ring is Noetherian if and only if it is finitely generated. |
FixedBy.subfield : Subfield F where
carrier := fixedBy F m
zero_mem' := smul_zero m
add_mem' hx hy := (smul_add m _ _).trans <| congr_arg₂ _ hx hy
neg_mem' hx := (smul_neg m _).trans <| congr_arg _ hx
one_mem' := smul_one m
mul_mem' hx hy := (smul_mul' m _ _).trans <| congr_arg₂ _ hx hy
inv_mem' x hx := (... | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | FixedBy.subfield | The subfield of F fixed by the field endomorphism `m`. |
IsInvariantSubfield (S : Subfield F) : Prop where
smul_mem : ∀ (m : M) {x : F}, x ∈ S → m • x ∈ S
variable (S : Subfield F) | class | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | IsInvariantSubfield | A typeclass for subrings invariant under a `MulSemiringAction`. |
IsInvariantSubfield.toMulSemiringAction [IsInvariantSubfield M S] :
MulSemiringAction M S where
smul m x := ⟨m • x.1, IsInvariantSubfield.smul_mem m x.2⟩
one_smul s := Subtype.eq <| one_smul M s.1
mul_smul m₁ m₂ s := Subtype.eq <| mul_smul m₁ m₂ s.1
smul_add m s₁ s₂ := Subtype.eq <| smul_add m s₁.1 s₂.1
s... | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | IsInvariantSubfield.toMulSemiringAction | null |
subfield : Subfield F :=
Subfield.copy (⨅ m : M, FixedBy.subfield F m) (fixedPoints M F)
(by ext; simp [FixedBy.subfield]) | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | subfield | The subfield of fixed points by a monoid action. |
smulCommClass' : SMulCommClass (FixedPoints.subfield M F) M F :=
SMulCommClass.symm _ _ _
@[simp] | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | smulCommClass' | null |
smul (m : M) (x : FixedPoints.subfield M F) : m • x = x :=
Subtype.eq <| x.2 m
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | smul | null |
smul_polynomial (m : M) (p : Polynomial (FixedPoints.subfield M F)) : m • p = p :=
Polynomial.induction_on p (fun x => by rw [Polynomial.smul_C, smul])
(fun p q ihp ihq => by rw [smul_add, ihp, ihq]) fun n x _ => by
rw [smul_mul', Polynomial.smul_C, smul, smul_pow', Polynomial.smul_X] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | smul_polynomial | null |
coe_algebraMap :
algebraMap (FixedPoints.subfield M F) F = Subfield.subtype (FixedPoints.subfield M F) :=
rfl | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | coe_algebraMap | null |
linearIndependent_smul_of_linearIndependent {s : Finset F} :
(LinearIndepOn (FixedPoints.subfield G F) id (s : Set F)) →
LinearIndepOn F (MulAction.toFun G F) s := by
classical
have : IsEmpty ((∅ : Finset F) : Set F) := by simp
refine Finset.induction_on s (fun _ => linearIndependent_empty_type) fun a s... | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | linearIndependent_smul_of_linearIndependent | null |
minpoly : Polynomial (FixedPoints.subfield G F) :=
(prodXSubSMul G F x).toSubring (FixedPoints.subfield G F).toSubring fun _ hc g =>
let ⟨n, _, hn⟩ := Polynomial.mem_coeffs_iff.1 hc
hn.symm ▸ prodXSubSMul.coeff G F x g n | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | minpoly | `minpoly G F x` is the minimal polynomial of `(x : F)` over `FixedPoints.subfield G F`. |
monic : (minpoly G F x).Monic := by
simp only [minpoly]
rw [Polynomial.monic_toSubring]
exact prodXSubSMul.monic G F x | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | monic | null |
eval₂ :
Polynomial.eval₂ (Subring.subtype <| (FixedPoints.subfield G F).toSubring) x (minpoly G F x) =
0 := by
rw [← prodXSubSMul.eval G F x, Polynomial.eval₂_eq_eval_map]
simp only [minpoly, Polynomial.map_toSubring] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | eval₂ | null |
eval₂' :
Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x (minpoly G F x) = 0 :=
eval₂ G F x | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | eval₂' | null |
ne_one : minpoly G F x ≠ (1 : Polynomial (FixedPoints.subfield G F)) := fun H =>
have := eval₂ G F x
(one_ne_zero : (1 : F) ≠ 0) <| by rwa [H, Polynomial.eval₂_one] at this | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | ne_one | null |
of_eval₂ (f : Polynomial (FixedPoints.subfield G F))
(hf : Polynomial.eval₂ (Subfield.subtype <| FixedPoints.subfield G F) x f = 0) :
minpoly G F x ∣ f := by
classical
rw [← Polynomial.map_dvd_map' (Subfield.subtype <| FixedPoints.subfield G F), minpoly,
← Subfield.toSubring_subtype_eq_subtype, Polynomi... | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | of_eval₂ | null |
irreducible_aux (f g : Polynomial (FixedPoints.subfield G F)) (hf : f.Monic) (hg : g.Monic)
(hfg : f * g = minpoly G F x) : f = 1 ∨ g = 1 := by
have hf2 : f ∣ minpoly G F x := by rw [← hfg]; exact dvd_mul_right _ _
have hg2 : g ∣ minpoly G F x := by rw [← hfg]; exact dvd_mul_left _ _
have := eval₂ G F x
rw ... | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | irreducible_aux | null |
irreducible : Irreducible (minpoly G F x) :=
(Polynomial.irreducible_of_monic (monic G F x) (ne_one G F x)).2 (irreducible_aux G F x) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | irreducible | null |
isIntegral [Finite G] (x : F) : IsIntegral (FixedPoints.subfield G F) x := by
cases nonempty_fintype G; exact ⟨minpoly G F x, minpoly.monic G F x, minpoly.eval₂ G F x⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | isIntegral | null |
minpoly_eq_minpoly : minpoly G F x = _root_.minpoly (FixedPoints.subfield G F) x :=
minpoly.eq_of_irreducible_of_monic (minpoly.irreducible G F x) (minpoly.eval₂ G F x)
(minpoly.monic G F x) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | minpoly_eq_minpoly | null |
rank_le_card : Module.rank (FixedPoints.subfield G F) F ≤ Fintype.card G :=
rank_le fun s hs => by
simpa only [rank_fun', Cardinal.mk_coe_finset, Finset.coe_sort_coe, Cardinal.lift_natCast,
Nat.cast_le] using
(linearIndependent_smul_of_linearIndependent G F hs).cardinal_lift_le_rank | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | rank_le_card | null |
normal : Normal (FixedPoints.subfield G F) F where
isAlgebraic x := (isIntegral G F x).isAlgebraic
splits' x :=
(Polynomial.splits_id_iff_splits _).1 <| by
cases nonempty_fintype G
rw [← minpoly_eq_minpoly, minpoly, coe_algebraMap, ← Subfield.toSubring_subtype_eq_subtype,
Polynomial.map_toSu... | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | normal | null |
isSeparable : Algebra.IsSeparable (FixedPoints.subfield G F) F := by
classical
exact ⟨fun x => by
cases nonempty_fintype G
rw [IsSeparable, ← minpoly_eq_minpoly,
← Polynomial.separable_map (FixedPoints.subfield G F).subtype, minpoly,
← Subfield.toSubring_subtype_eq_subtype, Polynomial.map_toSubr... | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | isSeparable | null |
finrank_le_card [Fintype G] : finrank (subfield G F) F ≤ Fintype.card G := by
rw [← @Nat.cast_le Cardinal, finrank_eq_rank]
apply rank_le_card | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | finrank_le_card | null |
linearIndependent_toLinearMap (R : Type u) (A : Type v) (B : Type w) [CommSemiring R]
[Semiring A] [Algebra R A] [CommRing B] [IsDomain B] [Algebra R B] :
LinearIndependent B (AlgHom.toLinearMap : (A →ₐ[R] B) → A →ₗ[R] B) :=
have : LinearIndependent B (LinearMap.ltoFun R A B ∘ AlgHom.toLinearMap) :=
((lin... | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | linearIndependent_toLinearMap | null |
cardinalMk_algHom (K : Type u) (V : Type v) (W : Type w) [Field K] [Ring V] [Algebra K V]
[FiniteDimensional K V] [Field W] [Algebra K W] :
Cardinal.mk (V →ₐ[K] W) ≤ finrank W (V →ₗ[K] W) :=
(linearIndependent_toLinearMap K V W).cardinalMk_le_finrank | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | cardinalMk_algHom | null |
noncomputable AlgEquiv.fintype (K : Type u) (V : Type v) [Field K] [Field V] [Algebra K V]
[FiniteDimensional K V] : Fintype (V ≃ₐ[K] V) :=
Fintype.ofEquiv (V →ₐ[K] V) (algEquivEquivAlgHom K V).symm | instance | FieldTheory | [
"Mathlib.Algebra.Polynomial.GroupRingAction",
"Mathlib.Algebra.Ring.Action.Field",
"Mathlib.Algebra.Ring.Action.Invariant",
"Mathlib.FieldTheory.Finiteness",
"Mathlib.FieldTheory.Normal.Defs",
"Mathlib.FieldTheory.Separable",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.FreeModule.Finit... | Mathlib/FieldTheory/Fixed.lean | AlgEquiv.fintype | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.