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.tower_top (K := F) _).of_injective (val _) Subtype.val_injective).symm | 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_lt_top _).ne
exact strictMono_filtration (coe_lt_coe.mp 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 | 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.finrank_pos)
refine (isLeast_leastExt i).1 (hx ▸ ?_)
exact x.2 | 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_adjoin F _ ?_)
exacts [⟨j, lt_succ j, rfl⟩, hi.succ_lt (coe_lt_coe.mpr hj)]
open WithTop | 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 hj⟩).elim
open Classical in | lemma | FieldTheory | [
"Mathlib.FieldTheory.SeparableClosure",
"Mathlib.FieldTheory.PurelyInseparable.Basic",
"Mathlib.LinearAlgebra.FreeAlgebra",
"Mathlib.Order.Interval.Set.WithBotTop",
"Mathlib.Order.DirectedInverseSystem"
] | Mathlib/FieldTheory/CardinalEmb.lean | 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_filtration hi, toSubalgebra_iSup_of_directed directed_filtration]
else (Algebra.ofId F Ē).comp ((equivOfEq (eq_bot_of_not_nonempty hi h)).trans <| botEquiv F E)
left_inv f := by
split_ifs with h
· ext ⟨x, hx⟩
rw [← iSup_filtration hi, mem_toSubalgebra, ← SetLike.mem_coe,
coe_iSup_of_directed directed_filtration, mem_iUnion] at hx
rw [Subalgebra.iSupLift_of_mem _ _ (by exact hx.choose_spec)]; rfl
· apply AlgHom.ext
rw [((equivOfEq (eq_bot_of_not_nonempty hi h)).trans <| botEquiv F E).forall_congr_left]
simp
right_inv f := Subtype.ext <| funext fun j ↦ by
have := Nonempty.intro j
simp_rw [dif_pos this]
apply Subalgebra.iSupLift_comp_inclusion | 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 _ WithTop.coe_injective) fun _ ↦ .refl _ | 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 => rw [← mk_ord_toType (Module.rank F E), ← prod_const']
exact prod_le_prod _ _ fun i ↦ (Emb.Cardinal.deg_lt_aleph0 _).le
· conv_lhs => rw [← mk_ord_toType (Module.rank F E), ← prod_const']
exact prod_le_prod _ _ Emb.Cardinal.two_le_deg | 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.finrank_pos.ne',
← Nat.card, ← finSepDegree, finSepDegree_eq_finrank_of_isSeparable] | 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
(((Fintype.card_eq_nat_card).trans (GaloisField.card p n hn.ne')).trans hα)).symm.field⟩ | 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 [← Cardinal.infinite_iff, h, true_or, iff_true] using Infinite.nonempty_field | 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 : σ → K, f.coeff d * ∏ i, x i ^ d i := sum_comm
_ = 0 := sum_eq_zero ?_
intro d hd
obtain ⟨i, hi⟩ : ∃ i, d i < q - 1 := f.exists_degree_lt (q - 1) h hd
calc
(∑ x : σ → K, f.coeff d * ∏ i, x i ^ d i) = f.coeff d * ∑ x : σ → K, ∏ i, x i ^ d i :=
(mul_sum ..).symm
_ = 0 := (mul_eq_zero.mpr ∘ Or.inr) ?_
calc
(∑ x : σ → K, ∏ i, x i ^ d i) =
∑ x₀ : { j // j ≠ i } → K, ∑ x : { x : σ → K // x ∘ (↑) = x₀ }, ∏ j, (x : σ → K) j ^ d j :=
(Fintype.sum_fiberwise _ _).symm
_ = 0 := Fintype.sum_eq_zero _ ?_
intro x₀
let e : K ≃ { x // x ∘ ((↑) : _ → σ) = x₀ } := (Equiv.subtypeEquivCodomain _).symm
calc
(∑ x : { x : σ → K // x ∘ (↑) = x₀ }, ∏ j, (x : σ → K) j ^ d j) =
∑ a : K, ∏ j : σ, (e a : σ → K) j ^ d j := (e.sum_comp _).symm
_ = ∑ a : K, (∏ j, x₀ j ^ d j) * a ^ d i := Fintype.sum_congr _ _ ?_
_ = (∏ j, x₀ j ^ d j) * ∑ a : K, a ^ d i := by rw [mul_sum]
_ = 0 := by rw [sum_pow_lt_card_sub_one K _ hi, mul_zero]
intro a
let e' : { j // j = i } ⊕ { j // j ≠ i } ≃ σ := Equiv.sumCompl _
letI : Unique { j // j = i } :=
{ default := ⟨i, rfl⟩
uniq := fun ⟨j, h⟩ => Subtype.val_injective h }
calc
(∏ j : σ, (e a : σ → K) j ^ d j) =
(e a : σ → K) i ^ d i * ∏ j : { j // j ≠ i }, (e a : σ → K) j ^ d j := by
rw [← e'.prod_comp, Fintype.prod_sum_type, univ_unique, prod_singleton]; rfl
_ = a ^ d i * ∏ j : { j // j ≠ i }, (e a : σ → K) j ^ d j := by
rw [Equiv.subtypeEquivCodomain_symm_apply_eq]
_ = a ^ d i * ∏ j, x₀ j ^ d j := congr_arg _ (Fintype.prod_congr _ _ ?_)
_ = (∏ j, x₀ j ^ d j) * a ^ d i := mul_comm _ _
rintro ⟨j, hj⟩
change (e a : σ → K) j ^ d j = x₀ ⟨j, hj⟩ ^ d j
rw [Equiv.subtypeEquivCodomain_symm_apply_ne]
variable [DecidableEq K] (p : ℕ) [CharP K p] | 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) := {x | ∀ i ∈ s, eval x (f i) = 0}
have hS (x : σ → K) : x ∈ S ↔ ∀ i ∈ s, eval x (f i) = 0 := by simp [S]
/- The polynomial `F = ∏ i ∈ s, (1 - (f i)^(q - 1))` has the nice property
that it takes the value `1` on elements of `{x : σ → K // ∀ i ∈ s, (f i).eval x = 0}`
while it is `0` outside that locus.
Hence the sum of its values is equal to the cardinality of
`{x : σ → K // ∀ i ∈ s, (f i).eval x = 0}` modulo `p`. -/
let F : MvPolynomial σ K := ∏ i ∈ s, (1 - f i ^ (q - 1))
have hF : ∀ x, eval x F = if x ∈ S then 1 else 0 := by
intro x
calc
eval x F = ∏ i ∈ s, eval x (1 - f i ^ (q - 1)) := eval_prod s _ x
_ = if x ∈ S then 1 else 0 := ?_
simp only [(eval x).map_sub, (eval x).map_pow, (eval x).map_one]
split_ifs with hx
· apply Finset.prod_eq_one
intro i hi
rw [hS] at hx
rw [hx i hi, zero_pow hq.ne', sub_zero]
· obtain ⟨i, hi, hx⟩ : ∃ i ∈ s, eval x (f i) ≠ 0 := by
simpa [hS, not_forall, Classical.not_imp] using hx
apply Finset.prod_eq_zero hi
rw [pow_card_sub_one_eq_one (eval x (f i)) hx, sub_self]
have key : ∑ x, eval x F = Fintype.card { x : σ → K // ∀ i ∈ s, eval x (f i) = 0 } := by
rw [Fintype.card_of_subtype S hS, card_eq_sum_ones, Nat.cast_sum, Nat.cast_one, ←
Fintype.sum_extend_by_zero S, sum_congr rfl fun x _ => hF x]
change p ∣ Fintype.card { x // ∀ i : ι, i ∈ s → eval x (f i) = 0 }
rw [← CharP.cast_eq_zero_iff K, ← key]
change (∑ x, eval x F) = 0
apply F.sum_eval_eq_zero
show F.totalDegree < (q - 1) * Fintype.card σ
calc
F.totalDegree ≤ ∑ i ∈ s, (1 - f i ^ (q - 1)).totalDegree := totalDegree_finset_prod s _
_ ≤ ∑ i ∈ s, (q - 1) * (f i).totalDegree := sum_le_sum fun i _ => ?_
_ = (q - 1) * ∑ i ∈ s, (f i).totalDegree := (mul_sum ..).symm
_ < (q - 1) * Fintype.card σ := by gcongr
change (1 - f i ^ (q - 1)).totalDegree ≤ (q - 1) * (f i).totalDegree
calc
(1 - f i ^ (q - 1)).totalDegree ≤
max (1 : MvPolynomial σ K).totalDegree (f i ^ (q - 1)).totalDegree := totalDegree_sub _ _
_ ≤ (f i ^ (q - 1)).totalDegree := by simp
_ ≤ (q - 1) * (f i).totalDegree := totalDegree_pow _ _ | 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 solutions of the `f i` is divisible by `p`. |
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 solutions of the `f i` is divisible by `p`. |
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_card_solutions_of_sum_lt` for a version that takes a family of polynomials `f i`. |
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_comm _ _).trans_lt h
simpa only [Bool.forall_bool] using char_dvd_card_solutions_of_fintype_sum_lt p this | 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 the `f₁` and `f₂` is divisible by `p`. |
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 <| iSup_eq_adjoin _ _) fun x hx ↦
have ⟨i, hx⟩ := Set.mem_iUnion.mp hx
((hτ i).2 ⟨x, hx⟩).trans ((hσ i).2 ⟨x, hx⟩).symm⟩ | 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` (which is the case in our main application).
We also allow the domain of the extension to be an intermediate field that properly contains `M`,
since one can always restrict the domain to `M`. |
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 x ↦ (hc.total i.2 j.2).elim (fun hij ↦ (hij.snd x).symm) fun hji ↦ by
rw [AlgHom.comp_apply, ← inclusion]
dsimp only [coe_type_toSubalgebra]
rw [← hji.snd (inclusion h x), inclusion_inclusion, inclusion_self, AlgHom.id_apply x])
_ rfl).comp
(Subalgebra.equivOfEq _ _ <| toSubalgebra_iSup_of_directed dir)⟩ | 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 (toSubalgebra <| t ·) ⟨σ, hσ⟩)⟩ | 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 this
have := finiteDimensional_adjoin (S := (S : Set E)) fun _ _ ↦ (alg.isIntegral).1 _
have ⟨π₀, hπ₀⟩ := hc.directed.finite_le π
have ⟨θ, hθπ, hθ⟩ := hext _ π₀.2 S
rw [← adjoin_le_iff] at hθ
let θ₀ := θ.emb.comp (inclusion hθ)
have := (hπ₀ θ₀).trans hθπ
exact hπ θ₀ ⟨_, θ.emb.comp <| inclusion <| sup_le this.1 hθ⟩
⟨le_sup_left, this.2⟩ ⟨le_sup_right, fun _ ↦ rfl⟩ rfl
choose θ ge hθ eq using hω
have : IsChain (· ≤ ·) (Set.range θ) := by
simp_rw [← restrictScalars_adjoin_eq_sup, restrictScalars_adjoin] at eq
rintro _ ⟨π₁, rfl⟩ _ ⟨π₂, rfl⟩ -
wlog h : π₁ ≤ π₂ generalizing π₁ π₂
· exact (this _ _ <| (hc.total π₁.2 π₂.2).resolve_left h).symm
refine .inl (le_iff.mpr ⟨?_, algHom_ext_of_eq_adjoin _ (eq _) ?_⟩)
· rw [eq, eq]; exact adjoin.mono _ _ _ (Set.union_subset_union_left _ h.1)
rintro x (hx|hx)
· change (θ π₂).emb (inclusion (ge π₂).1 <| inclusion h.1 ⟨x, hx⟩) =
(θ π₁).emb (inclusion (ge π₁).1 ⟨x, hx⟩)
rw [(ge π₁).2, (ge π₂).2, h.2]
· change (θ π₂).emb (inclusion (hθ π₂).1 ⟨x, subset_adjoin _ _ hx⟩) =
(θ π₁).emb (inclusion (hθ π₁).1 ⟨x, subset_adjoin _ _ hx⟩)
rw [(hθ π₁).2, (hθ π₂).2]
refine ⟨union _ this, le_of_carrier_le_iSup (fun π ↦ le_union c hc π.2)
(fun π ↦ (ge π).trans <| le_union _ _ ⟨_, rfl⟩) (carrier_union _ _).le, ?_⟩
simp_rw [carrier_union, iSup_range', eq]
exact (subset_adjoin _ _).trans (SetLike.coe_subset_coe.mpr <|
le_sup_right.trans <| le_iSup_of_le (Classical.arbitrary _) le_rfl) | 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}
fun c hext hc ↦ (isEmpty_or_nonempty c).elim
(fun _ ↦ ⟨⊥, this, fun ϕ hϕ ↦ isEmptyElim (⟨ϕ, hϕ⟩ : c)⟩)
fun _ ↦ ⟨_, union_isExtendible c hc hext, le_union c hc⟩
suffices ϕ.carrier = ⊤ from ⟨ϕ.emb.comp <| ((equivOfEq this).trans topEquiv).symm⟩
by_contra!
obtain ⟨α, -, hα⟩ := SetLike.exists_of_lt this.lt_top
let _ : Algebra ϕ.carrier K := ϕ.emb.toAlgebra
let Λ := ϕ.carrier⟮α⟯ →ₐ[ϕ.carrier] K
have := finiteDimensional_adjoin (S := {α}) fun _ _ ↦ ((alg.tower_top ϕ.carrier).isIntegral).1 _
let L (σ : Λ) : Lifts F E K := ⟨ϕ.carrier⟮α⟯.restrictScalars F, σ.restrictScalars F⟩
have hL (σ : Λ) : ϕ < L σ := lt_iff.mpr
⟨by simpa only [L, restrictScalars_adjoin_eq_sup, left_lt_sup, adjoin_simple_le_iff],
AlgHom.coe_ringHom_injective σ.comp_algebraMap⟩
have ⟨(ϕ_ext : ϕ.IsExtendible), ϕ_max⟩ := maximal_iff_forall_gt.mp hϕ
simp_rw [Set.mem_setOf, IsExtendible] at ϕ_max; push_neg at ϕ_max
choose S hS using fun σ : Λ ↦ ϕ_max (hL σ)
classical
have ⟨θ, hθϕ, hθ⟩ := ϕ_ext ({α} ∪ Finset.univ.biUnion S)
simp_rw [Finset.coe_union, Set.union_subset_iff, Finset.coe_singleton, Set.singleton_subset_iff,
Finset.coe_biUnion, Finset.coe_univ, Set.mem_univ, Set.iUnion_true, Set.iUnion_subset_iff] at hθ
have : ϕ.carrier⟮α⟯.restrictScalars F ≤ θ.carrier := by
rw [restrictScalars_adjoin_eq_sup, sup_le_iff, adjoin_simple_le_iff]; exact ⟨hθϕ.1, hθ.1⟩
exact hS ⟨(θ.emb.comp <| inclusion this).toRingHom, hθϕ.2⟩ θ ⟨this, fun _ ↦ rfl⟩ (hθ.2 _) | 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 : Algebra x.carrier carrier := x.carrier⟮s⟯.toSubalgebra.algebra
let φ : carrier →ₐ[x.carrier] K := ((algHomAdjoinIntegralEquiv x.carrier h1).symm
⟨rootOfSplits x.emb.toRingHom h2 I2, by
rw [mem_aroots, and_iff_right (minpoly.ne_zero h1)]
exact map_rootOfSplits x.emb.toRingHom h2 I2⟩)
⟨⟨carrier, (@algHomEquivSigma F x.carrier carrier K _ _ _ _ _ _ _ _
(IsScalarTower.of_algebraMap_eq fun _ ↦ rfl)).symm ⟨x.emb, φ⟩⟩,
⟨fun z hz ↦ algebraMap_mem x.carrier⟮s⟯ ⟨z, hz⟩, φ.commutes⟩,
mem_adjoin_simple_self x.carrier s⟩ | 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, f⟩ le_rfl
refine ⟨φ.emb.comp (inclusion <| (le_extendScalars_iff hfφ.1 <| adjoin L S).mp <|
adjoin_le_iff.mpr fun s h ↦ ?_), AlgHom.ext hfφ.2⟩
letI := (inclusion hfφ.1).toAlgebra
letI : SMul L φ.carrier := Algebra.toSMul
have : IsScalarTower L φ.carrier E := ⟨fun x y ↦ smul_assoc x (y : E)⟩
have := φ.exists_lift_of_splits' (hK s h).1.tower_top ((hK s h).1.minpoly_splits_tower_top' ?_)
· obtain ⟨y, h1, h2⟩ := this
exact (hφ h1).1 h2
· convert (hK s h).2; ext; apply hfφ.2
variable {L : Type*} [Field L] [Algebra F L] [Algebra L E] [IsScalarTower F L E]
(f : L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral L s ∧ (minpoly L s).Splits f.toRingHom)
include hK in | 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; refine ⟨φ.comp <|
inclusion (?_ : (adjoin L S).restrictScalars F ≤ (adjoin L' S).restrictScalars F), ?_⟩
· simp_rw [← SetLike.coe_subset_coe, coe_restrictScalars, adjoin_subset_adjoin_iff]
exact ⟨subset_adjoin_of_subset_left S (F := L'.toSubfield) le_rfl, subset_adjoin _ _⟩
· ext x
let y := (AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)) x
refine Eq.trans congr($hφ y) ?_
simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.coe_comp, AlgHom.coe_coe, Function.comp_apply, f']
exact congr_arg f (AlgEquiv.symm_apply_apply _ _)
letI : Algebra L L' := (AlgEquiv.ofInjectiveField _).toRingHom.toAlgebra
have : IsScalarTower L L' E := IsScalarTower.of_algebraMap_eq' rfl
refine ⟨(hK s hs).1.tower_top, (hK s hs).1.minpoly_splits_tower_top' ?_⟩
convert (hK s hs).2
ext
simp only [AlgEquiv.toAlgHom_eq_coe, AlgHom.toRingHom_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
AlgHom.coe_comp, AlgHom.coe_coe, Function.comp_apply, f']
exact congr_arg f (AlgEquiv.symm_apply_apply _ _)
include hK in | 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 hs).1 (hK s hs).2 with ⟨y, h1, h2⟩
exact (hφ h1).1 h2
· ext; apply hfφ.2 | 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_adjoin_of_splits hK ((algHomAdjoinIntegralEquiv F ix).symm
⟨y, mem_aroots.mpr ⟨minpoly.ne_zero ix, hy⟩⟩) (adjoin_simple_le_iff.mpr hx)
exact ⟨φ, (DFunLike.congr_fun hφ <| AdjoinSimple.gen F x).trans <|
algHomAdjoinIntegralEquiv_symm_apply_gen F ix _⟩
include hS in | 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
ext a
rw [mem_rootSet_of_ne (minpoly.ne_zero (Algebra.IsIntegral.isIntegral x))]
refine ⟨fun ⟨ψ, hψ⟩ ↦ ?_, fun ha ↦ IntermediateField.exists_algHom_of_splits_of_aeval
(fun x ↦ ⟨Algebra.IsIntegral.isIntegral x, hA x⟩) ha⟩
rw [← hψ, Polynomial.aeval_algHom_apply ψ x, minpoly.aeval, map_zero] | 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_linearEquiv K (⊤ : Submodule K V) V _ _ _ _ _ (LinearEquiv.ofTop _ rfl)
(id ?_)
refine isNoetherian_of_fg_of_noetherian _ ⟨Set.Finite.toFinset hbfinite, ?_⟩
rw [Set.Finite.coe_toFinset, ← b.span_eq, Basis.coe_ofVectorSpace, Subtype.range_coe] | 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 set is finite. |
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_finrank | 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_aleph0 | 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 := (smul_inv'' m x).trans <| congr_arg _ 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
smul_zero m := Subtype.eq <| smul_zero m
smul_one m := Subtype.eq <| smul_one m
smul_mul m s₁ s₂ := Subtype.eq <| smul_mul' m s₁.1 s₂.1 | 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 has ih hs => ?_
rw [coe_insert] at hs ⊢
rw [linearIndepOn_insert (mt mem_coe.1 has)] at hs
rw [linearIndepOn_insert (mt mem_coe.1 has)]; refine ⟨ih hs.1, fun ha => ?_⟩
rw [Finsupp.mem_span_image_iff_linearCombination] at ha; rcases ha with ⟨l, hl, hla⟩
rw [Finsupp.linearCombination_apply_of_mem_supported F hl] at hla
suffices ∀ i ∈ s, l i ∈ FixedPoints.subfield G F by
replace hla := (sum_apply _ _ fun i => l i • toFun G F i).symm.trans (congr_fun hla 1)
simp_rw [Pi.smul_apply, toFun_apply, one_smul] at hla
refine hs.2 (hla ▸ Submodule.sum_mem _ fun c hcs => ?_)
change (⟨l c, this c hcs⟩ : FixedPoints.subfield G F) • c ∈ _
exact Submodule.smul_mem _ _ <| Submodule.subset_span <| by simpa
intro i his g
refine
eq_of_sub_eq_zero
(linearIndependent_iff'.1 (ih hs.1) s.attach (fun i => g • l i - l i) ?_ ⟨i, his⟩
(mem_attach _ _) :
_)
refine (sum_attach s fun i ↦ (g • l i - l i) • MulAction.toFun G F i).trans ?_
ext g'; dsimp only
conv_lhs =>
rw [sum_apply]
congr
· skip
· ext
rw [Pi.smul_apply, sub_smul, smul_eq_mul]
rw [sum_sub_distrib, Pi.zero_apply, sub_eq_zero]
conv_lhs =>
congr
· skip
· ext x
rw [toFun_apply, ← mul_inv_cancel_left g g', mul_smul, ← smul_mul', ← toFun_apply _ x]
change
(∑ x ∈ s, g • (fun y => l y • MulAction.toFun G F y) x (g⁻¹ * g')) =
∑ x ∈ s, (fun y => l y • MulAction.toFun G F y) x g'
rw [← smul_sum, ← sum_apply _ _ fun y => l y • toFun G F y, ←
sum_apply _ _ fun y => l y • toFun G F y]
rw [hla, toFun_apply, toFun_apply, smul_smul, mul_inv_cancel_left] | 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, Polynomial.map_toSubring _ _, prodXSubSMul]
refine
Fintype.prod_dvd_of_coprime
(Polynomial.pairwise_coprime_X_sub_C <| MulAction.injective_ofQuotientStabilizer G x) fun y =>
QuotientGroup.induction_on y fun g => ?_
rw [Polynomial.dvd_iff_isRoot, Polynomial.IsRoot.def, MulAction.ofQuotientStabilizer_mk,
Polynomial.eval_smul',
← IsInvariantSubring.coe_subtypeHom' G (FixedPoints.subfield G F).toSubring,
← MulSemiringActionHom.coe_polynomial, ← MulSemiringActionHom.map_smul, smul_polynomial,
MulSemiringActionHom.coe_polynomial, IsInvariantSubring.coe_subtypeHom',
Polynomial.eval_map, Subfield.toSubring_subtype_eq_subtype, hf, smul_zero] | 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 [← hfg, Polynomial.eval₂_mul, mul_eq_zero] at this
rcases this with this | this
· right
have hf3 : f = minpoly G F x :=
Polynomial.eq_of_monic_of_associated hf (monic G F x)
(associated_of_dvd_dvd hf2 <| @of_eval₂ G _ F _ _ _ x f this)
rwa [← mul_one (minpoly G F x), hf3, mul_right_inj' (monic G F x).ne_zero] at hfg
· left
have hg3 : g = minpoly G F x :=
Polynomial.eq_of_monic_of_associated hg (monic G F x)
(associated_of_dvd_dvd hg2 <| @of_eval₂ G _ F _ _ _ x g this)
rwa [← one_mul (minpoly G F x), hg3, mul_left_inj' (monic G F x).ne_zero] at hfg | 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_toSubring _ (subfield G F).toSubring, prodXSubSMul]
exact Polynomial.splits_prod _ fun _ _ => Polynomial.splits_X_sub_C _ | 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_toSubring _ (subfield G F).toSubring]
exact Polynomial.separable_prod_X_sub_C_iff.2 (injective_ofQuotientStabilizer G x)⟩ | 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) :=
((linearIndependent_monoidHom A B).comp ((↑) : (A →ₐ[R] B) → A →* B) fun _ _ hfg =>
AlgHom.ext fun _ => DFunLike.ext_iff.1 hfg _ :
_)
this.of_comp _ | 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.