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 ⌀ |
|---|---|---|---|---|---|---|
galAction [Fact (p.Splits (algebraMap F E))] : MulAction p.Gal (rootSet p E) where
one_smul _ := by simp only [smul_def, Equiv.apply_symm_apply, one_smul]
mul_smul _ _ _ := by
simp only [smul_def, Equiv.symm_apply_apply, mul_smul] | instance | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | galAction | The action of `gal p` on the roots of `p` in `E`. |
galAction_isPretransitive [Fact (p.Splits (algebraMap F E))] (hp : Irreducible p) :
MulAction.IsPretransitive p.Gal (p.rootSet E) := by
refine ⟨fun x y ↦ ?_⟩
have hx := minpoly.eq_of_irreducible hp (mem_rootSet.mp ((rootsEquivRoots p E).symm x).2).2
have hy := minpoly.eq_of_irreducible hp (mem_rootSet.mp ((ro... | lemma | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | galAction_isPretransitive | null |
@[simp]
restrict_smul [Fact (p.Splits (algebraMap F E))] (ϕ : E ≃ₐ[F] E) (x : rootSet p E) :
↑(restrict p E ϕ • x) = ϕ x := by
let ψ := AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F p.SplittingField E)
change ↑(ψ (ψ.symm _)) = ϕ x
rw [AlgEquiv.apply_symm_apply ψ]
change ϕ (rootsEquivRoots p E ((rootsE... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrict_smul | `Polynomial.Gal.restrict p E` is compatible with `Polynomial.Gal.galAction p E`. |
galActionHom [Fact (p.Splits (algebraMap F E))] : p.Gal →* Equiv.Perm (rootSet p E) :=
MulAction.toPermHom _ _ | def | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | galActionHom | `Polynomial.Gal.galAction` as a permutation representation |
galActionHom_restrict [Fact (p.Splits (algebraMap F E))] (ϕ : E ≃ₐ[F] E) (x : rootSet p E) :
↑(galActionHom p E (restrict p E ϕ) x) = ϕ x :=
restrict_smul ϕ x | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | galActionHom_restrict | null |
galActionHom_injective [Fact (p.Splits (algebraMap F E))] :
Function.Injective (galActionHom p E) := by
rw [injective_iff_map_eq_one]
intro ϕ hϕ
ext (x hx)
have key := Equiv.Perm.ext_iff.mp hϕ (rootsEquivRoots p E ⟨x, hx⟩)
change
rootsEquivRoots p E (ϕ • (rootsEquivRoots p E).symm (rootsEquivRoots p E... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | galActionHom_injective | `gal p` embeds as a subgroup of permutations of the roots of `p` in `E`. |
restrictDvd (hpq : p ∣ q) : q.Gal →* p.Gal :=
haveI := Classical.dec (q = 0)
if hq : q = 0 then 1
else
@restrict F _ p _ _ _
⟨splits_of_splits_of_dvd (algebraMap F q.SplittingField) hq (SplittingField.splits q) hpq⟩ | def | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictDvd | `Polynomial.Gal.restrict`, when both fields are splitting fields of polynomials. |
restrictDvd_def [Decidable (q = 0)] (hpq : p ∣ q) :
restrictDvd hpq =
if hq : q = 0 then 1
else
@restrict F _ p _ _ _
⟨splits_of_splits_of_dvd (algebraMap F q.SplittingField) hq (SplittingField.splits q)
hpq⟩ := by
unfold restrictDvd
congr | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictDvd_def | null |
restrictDvd_surjective (hpq : p ∣ q) (hq : q ≠ 0) :
Function.Surjective (restrictDvd hpq) := by
classical
haveI := Fact.mk <|
splits_of_splits_of_dvd (algebraMap F q.SplittingField) hq (SplittingField.splits q) hpq
simpa only [restrictDvd_def, dif_neg hq] using restrict_surjective _ _
variable (p q) | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictDvd_surjective | null |
restrictProd : (p * q).Gal →* p.Gal × q.Gal :=
MonoidHom.prod (restrictDvd (dvd_mul_right p q)) (restrictDvd (dvd_mul_left q p)) | def | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictProd | The Galois group of a product maps into the product of the Galois groups. |
restrictProd_injective : Function.Injective (restrictProd p q) := by
by_cases hpq : p * q = 0
· have : Unique (p * q).Gal := by rw [hpq]; infer_instance
exact fun f g _ => Eq.trans (Unique.eq_default f) (Unique.eq_default g).symm
intro f g hfg
classical
simp only [restrictProd, restrictDvd_def] at hfg
s... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictProd_injective | `Polynomial.Gal.restrictProd` is actually a subgroup embedding. |
mul_splits_in_splittingField_of_mul {p₁ q₁ p₂ q₂ : F[X]} (hq₁ : q₁ ≠ 0) (hq₂ : q₂ ≠ 0)
(h₁ : p₁.Splits (algebraMap F q₁.SplittingField))
(h₂ : p₂.Splits (algebraMap F q₂.SplittingField)) :
(p₁ * p₂).Splits (algebraMap F (q₁ * q₂).SplittingField) := by
apply splits_mul
· rw [←
(SplittingField.lift ... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | mul_splits_in_splittingField_of_mul | null |
splits_in_splittingField_of_comp (hq : q.natDegree ≠ 0) :
p.Splits (algebraMap F (p.comp q).SplittingField) := by
let P : F[X] → Prop := fun r => r.Splits (algebraMap F (r.comp q).SplittingField)
have key1 : ∀ {r : F[X]}, Irreducible r → P r := by
intro r hr
by_cases hr' : natDegree r = 0
· exact sp... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | splits_in_splittingField_of_comp | `p` splits in the splitting field of `p ∘ q`, for `q` non-constant. |
restrictComp (hq : q.natDegree ≠ 0) : (p.comp q).Gal →* p.Gal :=
let h : Fact (Splits (algebraMap F (p.comp q).SplittingField) p) :=
⟨splits_in_splittingField_of_comp p q hq⟩
@restrict F _ p _ _ _ h | def | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictComp | `Polynomial.Gal.restrict` for the composition of polynomials. |
restrictComp_surjective (hq : q.natDegree ≠ 0) :
Function.Surjective (restrictComp p q hq) := by
haveI : Fact (Splits (algebraMap F (SplittingField (comp p q))) p) :=
⟨splits_in_splittingField_of_comp p q hq⟩
simpa only [restrictComp] using restrict_surjective _ _
variable {p q}
open scoped IntermediateFiel... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | restrictComp_surjective | null |
card_of_separable (hp : p.Separable) : Nat.card p.Gal = finrank F p.SplittingField :=
haveI : IsGalois F p.SplittingField := IsGalois.of_separable_splitting_field hp
IsGalois.card_aut_eq_finrank F p.SplittingField | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | card_of_separable | For a separable polynomial, its Galois group has cardinality
equal to the dimension of its splitting field over `F`. |
prime_degree_dvd_card [CharZero F] (p_irr : Irreducible p) (p_deg : p.natDegree.Prime) :
p.natDegree ∣ Nat.card p.Gal := by
rw [Gal.card_of_separable p_irr.separable]
have hp : p.degree ≠ 0 := fun h =>
Nat.Prime.ne_zero p_deg (natDegree_eq_zero_iff_degree_le_zero.mpr (le_of_eq h))
let α : p.SplittingField... | theorem | FieldTheory | [
"Mathlib.FieldTheory.Galois.Basic"
] | Mathlib/FieldTheory/PolynomialGaloisGroup.lean | prime_degree_dvd_card | null |
@[stacks 09HY "second part"]
exists_primitive_element_of_finite_top [Finite E] : ∃ α : E, F⟮α⟯ = ⊤ := by
obtain ⟨α, hα⟩ := @IsCyclic.exists_generator Eˣ _ _
use α
rw [eq_top_iff]
rintro x -
by_cases hx : x = 0
· rw [hx]
exact F⟮α.val⟯.zero_mem
· obtain ⟨n, hn⟩ := Set.mem_range.mp (hα (Units.mk0 x hx))... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | exists_primitive_element_of_finite_top | **Primitive element theorem** assuming E is finite. |
exists_primitive_element_of_finite_bot [Finite F] [FiniteDimensional F E] :
∃ α : E, F⟮α⟯ = ⊤ :=
haveI : Finite E := Module.finite_of_finite F
exists_primitive_element_of_finite_top F E | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | exists_primitive_element_of_finite_bot | Primitive element theorem for finite-dimensional extension of a finite field. |
primitive_element_inf_aux_exists_c (f g : F[X]) :
∃ c : F, ∀ α' ∈ (f.map ϕ).roots, ∀ β' ∈ (g.map ϕ).roots, -(α' - α) / (β' - β) ≠ ϕ c := by
classical
let sf := (f.map ϕ).roots
let sg := (g.map ϕ).roots
classical
let s := (sf.bind fun α' => sg.map fun β' => -(α' - α) / (β' - β)).toFinset
let s' := s.prei... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_inf_aux_exists_c | null |
primitive_element_inf_aux [Algebra.IsSeparable F E] : ∃ γ : E, F⟮α, β⟯ = F⟮γ⟯ := by
classical
have hα := Algebra.IsSeparable.isIntegral F α
have hβ := Algebra.IsSeparable.isIntegral F β
let f := minpoly F α
let g := minpoly F β
let ιFE := algebraMap F E
let ιEE' := algebraMap E (SplittingField (g.map ιFE)... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_inf_aux | This is the heart of the proof of the primitive element theorem. It shows that if `F` is
infinite and `α` and `β` are separable over `F` then `F⟮α, β⟯` is generated by a single element. |
private primitive_element_inf_aux_of_finite_intermediateField
[Finite (IntermediateField F E)] : ∃ γ : E, F⟮α, β⟯ = F⟮γ⟯ := by
let f : F → IntermediateField F E := fun x ↦ F⟮α + x • β⟯
obtain ⟨x, y, hneq, heq⟩ := Finite.exists_ne_map_eq_of_infinite f
use α + x • β
apply le_antisymm
· rw [adjoin_le_iff]
... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_inf_aux_of_finite_intermediateField | null |
@[stacks 030N "The moreover part"]
exists_primitive_element : ∃ α : E, F⟮α⟯ = ⊤ := by
rcases isEmpty_or_nonempty (Fintype F) with (F_inf | ⟨⟨F_finite⟩⟩)
· let P : IntermediateField F E → Prop := fun K => ∃ α : E, F⟮α⟯ = K
have base : P ⊥ := ⟨0, adjoin_zero⟩
have ih : ∀ (K : IntermediateField F E) (x : E), P... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | exists_primitive_element | **Primitive element theorem**: a finite separable field extension `E` of `F` has a
primitive element, i.e. there is an `α ∈ E` such that `F⟮α⟯ = (⊤ : Subalgebra F E)`. |
noncomputable powerBasisOfFiniteOfSeparable : PowerBasis F E :=
let α := (exists_primitive_element F E).choose
let pb := adjoin.powerBasis (Algebra.IsSeparable.isIntegral F α)
have e : F⟮α⟯ = ⊤ := (exists_primitive_element F E).choose_spec
pb.map ((IntermediateField.equivOfEq e).trans IntermediateField.topEquiv... | def | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | powerBasisOfFiniteOfSeparable | Alternative phrasing of primitive element theorem:
a finite separable field extension has a basis `1, α, α^2, ..., α^n`.
See also `exists_primitive_element`. |
isAlgebraic_of_adjoin_eq_adjoin {α : E} {m n : ℕ} (hneq : m ≠ n)
(heq : F⟮α ^ m⟯ = F⟮α ^ n⟯) : IsAlgebraic F α := by
wlog hmn : m < n
· exact this F E hneq.symm heq.symm (hneq.lt_or_gt.resolve_left hmn)
by_cases hm : m = 0
· rw [hm] at heq hmn
simp only [pow_zero, adjoin_one] at heq
obtain ⟨y, h⟩ :=... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | isAlgebraic_of_adjoin_eq_adjoin | null |
isAlgebraic_of_finite_intermediateField
[Finite (IntermediateField F E)] : Algebra.IsAlgebraic F E := ⟨fun α ↦
have ⟨_m, _n, hneq, heq⟩ := Finite.exists_ne_map_eq_of_infinite fun n ↦ F⟮α ^ n⟯
isAlgebraic_of_adjoin_eq_adjoin F E hneq heq⟩ | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | isAlgebraic_of_finite_intermediateField | null |
FiniteDimensional.of_finite_intermediateField
[Finite (IntermediateField F E)] : FiniteDimensional F E := by
let IF := { K : IntermediateField F E // ∃ x, K = F⟮x⟯ }
have := isAlgebraic_of_finite_intermediateField F E
haveI : ∀ K : IF, FiniteDimensional F K.1 := fun ⟨_, x, rfl⟩ ↦ adjoin.finiteDimensional
... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | FiniteDimensional.of_finite_intermediateField | null |
exists_primitive_element_of_finite_intermediateField
[Finite (IntermediateField F E)] (K : IntermediateField F E) : ∃ α : E, F⟮α⟯ = K := by
haveI := FiniteDimensional.of_finite_intermediateField F E
rcases finite_or_infinite F with (_ | _)
· obtain ⟨α, h⟩ := exists_primitive_element_of_finite_bot F K
exac... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | exists_primitive_element_of_finite_intermediateField | null |
FiniteDimensional.of_exists_primitive_element [Algebra.IsAlgebraic F E]
(h : ∃ α : E, F⟮α⟯ = ⊤) : FiniteDimensional F E := by
obtain ⟨α, hprim⟩ := h
have hfin := adjoin.finiteDimensional (Algebra.IsIntegral.isIntegral (R := F) α)
rw [hprim] at hfin
exact topEquiv.toLinearEquiv.finiteDimensional | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | FiniteDimensional.of_exists_primitive_element | null |
finite_intermediateField_of_exists_primitive_element [Algebra.IsAlgebraic F E]
(h : ∃ α : E, F⟮α⟯ = ⊤) : Finite (IntermediateField F E) := by
haveI := FiniteDimensional.of_exists_primitive_element F E h
obtain ⟨α, hprim⟩ := h
let f : F[X] := minpoly F α
let G := { g : E[X] // g.Monic ∧ g ∣ f.map (algebraMap... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | finite_intermediateField_of_exists_primitive_element | null |
@[stacks 030N "Equivalence of (1) & (2)"]
exists_primitive_element_iff_finite_intermediateField :
(Algebra.IsAlgebraic F E ∧ ∃ α : E, F⟮α⟯ = ⊤) ↔ Finite (IntermediateField F E) :=
⟨fun ⟨_, h⟩ ↦ finite_intermediateField_of_exists_primitive_element F E h,
fun _ ↦ ⟨isAlgebraic_of_finite_intermediateField F E,
... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | exists_primitive_element_iff_finite_intermediateField | **Steinitz theorem**: an algebraic extension `E` of `F` has a
primitive element (i.e. there is an `α ∈ E` such that `F⟮α⟯ = (⊤ : Subalgebra F E)`)
if and only if there exist only finitely many intermediate fields between `E` and `F`. |
AlgHom.natCard_of_splits (L : Type*) [Field L] [Algebra F L]
(hL : ∀ x : E, (minpoly F x).Splits (algebraMap F L)) :
Nat.card (E →ₐ[F] L) = finrank F E :=
(AlgHom.natCard_of_powerBasis (L := L) (Field.powerBasisOfFiniteOfSeparable F E)
(Algebra.IsSeparable.isSeparable _ _) <| hL _).trans
(PowerBasis... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | AlgHom.natCard_of_splits | null |
AlgHom.card_of_splits (L : Type*) [Field L] [Algebra F L]
(hL : ∀ x : E, (minpoly F x).Splits (algebraMap F L)) :
Fintype.card (E →ₐ[F] L) = finrank F E := by
rw [Fintype.card_eq_nat_card, AlgHom.natCard_of_splits F E L hL]
@[simp] | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | AlgHom.card_of_splits | null |
AlgHom.card (K : Type*) [Field K] [IsAlgClosed K] [Algebra F K] :
Fintype.card (E →ₐ[F] K) = finrank F E :=
AlgHom.card_of_splits _ _ _ (fun _ ↦ IsAlgClosed.splits_codomain _) | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | AlgHom.card | null |
primitive_element_iff_minpoly_natDegree_eq (α : E) :
F⟮α⟯ = ⊤ ↔ (minpoly F α).natDegree = finrank F E := by
rw [← adjoin.finrank (IsIntegral.of_finite F α), ← finrank_top F E]
refine ⟨fun h => ?_, fun h => eq_of_le_of_finrank_eq le_top h⟩
exact congr_arg (fun K : IntermediateField F E => finrank F K) h | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_iff_minpoly_natDegree_eq | null |
primitive_element_iff_minpoly_degree_eq (α : E) :
F⟮α⟯ = ⊤ ↔ (minpoly F α).degree = finrank F E := by
rw [degree_eq_iff_natDegree_eq, primitive_element_iff_minpoly_natDegree_eq]
exact minpoly.ne_zero_of_finite F α
variable [Algebra.IsSeparable F E] (A : Type*) [Field A] [Algebra F A]
(hA : ∀ x : E, (minpoly F... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_iff_minpoly_degree_eq | null |
primitive_element_iff_algHom_eq_of_eval' (α : E) :
F⟮α⟯ = ⊤ ↔ Function.Injective fun φ : E →ₐ[F] A ↦ φ α := by
classical
simp_rw [primitive_element_iff_minpoly_natDegree_eq, ← card_rootSet_eq_natDegree (K := A)
(Algebra.IsSeparable.isSeparable F α) (hA _), ← toFinset_card,
← (Algebra.IsAlgebraic.of_fini... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_iff_algHom_eq_of_eval' | null |
primitive_element_iff_algHom_eq_of_eval (α : E)
(φ : E →ₐ[F] A) : F⟮α⟯ = ⊤ ↔ ∀ ψ : E →ₐ[F] A, φ α = ψ α → φ = ψ := by
refine ⟨fun h ψ hψ ↦ (Field.primitive_element_iff_algHom_eq_of_eval' F A hA α).mp h hψ,
fun h ↦ eq_of_le_of_finrank_eq' le_top ?_⟩
letI : Algebra F⟮α⟯ A := (φ.comp F⟮α⟯.val).toAlgebra
have... | theorem | FieldTheory | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.FieldTheory.SplittingField.Construction",
"Mathlib.RingTheory.IntegralDomain",
"Mathlib.RingTheory.Polynomial.UniqueFactorization"
] | Mathlib/FieldTheory/PrimitiveElement.lean | primitive_element_iff_algHom_eq_of_eval | null |
noncomputable relrank := Module.rank ↥(A ⊓ B) (extendScalars (inf_le_right : A ⊓ B ≤ B)) | def | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank | `Subfield.relrank A B` is defined to be `[B : A ⊓ B]` as a `Cardinal`, in particular,
when `A ≤ B` it is `[B : A]`, the degree of the field extension `B / A`.
This is similar to `Subgroup.relIndex` but it is `Cardinal` valued. |
noncomputable relfinrank := finrank ↥(A ⊓ B) (extendScalars (inf_le_right : A ⊓ B ≤ B)) | def | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank | The `Nat` version of `Subfield.relrank`.
If `B / A ⊓ B` is an infinite extension, then it is zero. |
relfinrank_eq_toNat_relrank : relfinrank A B = toNat (relrank A B) := rfl
variable {A B C} | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_toNat_relrank | null |
relrank_eq_of_inf_eq (h : A ⊓ C = B ⊓ C) : relrank A C = relrank B C := by
simp_rw [relrank]
congr! | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_of_inf_eq | null |
relfinrank_eq_of_inf_eq (h : A ⊓ C = B ⊓ C) : relfinrank A C = relfinrank B C :=
congr(toNat $(relrank_eq_of_inf_eq h)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_of_inf_eq | null |
relrank_eq_rank_of_le (h : A ≤ B) : relrank A B = Module.rank A (extendScalars h) := by
rw [relrank]
have := inf_of_le_left h
congr! | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_rank_of_le | If `A ≤ B`, then `Subfield.relrank A B` is `[B : A]`. |
relfinrank_eq_finrank_of_le (h : A ≤ B) : relfinrank A B = finrank A (extendScalars h) :=
congr(toNat $(relrank_eq_rank_of_le h))
variable (A B C) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_finrank_of_le | If `A ≤ B`, then `Subfield.relfinrank A B` is `[B : A]`. |
inf_relrank_right : relrank (A ⊓ B) B = relrank A B :=
relrank_eq_rank_of_le (inf_le_right : A ⊓ B ≤ B) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relrank_right | null |
inf_relfinrank_right : relfinrank (A ⊓ B) B = relfinrank A B :=
congr(toNat $(inf_relrank_right A B)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relfinrank_right | null |
inf_relrank_left : relrank (A ⊓ B) A = relrank B A := by
rw [inf_comm, inf_relrank_right] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relrank_left | null |
inf_relfinrank_left : relfinrank (A ⊓ B) A = relfinrank B A :=
congr(toNat $(inf_relrank_left A B))
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relfinrank_left | null |
relrank_self : relrank A A = 1 := by
rw [relrank_eq_rank_of_le (le_refl A), extendScalars_self, IntermediateField.rank_bot]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_self | null |
relfinrank_self : relfinrank A A = 1 := by
simp [relfinrank_eq_toNat_relrank]
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_self | null |
relrank_eq_one_of_le (h : B ≤ A) : relrank A B = 1 := by
rw [← inf_relrank_right, inf_eq_right.2 h, relrank_self]
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_one_of_le | null |
relfinrank_eq_one_of_le (h : B ≤ A) : relfinrank A B = 1 := by
simp [relfinrank_eq_toNat_relrank, relrank_eq_one_of_le h]
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_one_of_le | null |
relrank_mul_rank_top (h : A ≤ B) : relrank A B * Module.rank B E = Module.rank A E := by
rw [relrank_eq_rank_of_le h]
letI : Algebra A B := (inclusion h).toAlgebra
haveI : IsScalarTower A B E := IsScalarTower.of_algebraMap_eq' rfl
exact rank_mul_rank A B E
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_rank_top | null |
relfinrank_mul_finrank_top (h : A ≤ B) : relfinrank A B * finrank B E = finrank A E := by
simpa using congr(toNat $(relrank_mul_rank_top h))
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_finrank_top | null |
relrank_top_left : relrank ⊤ A = 1 := relrank_eq_one_of_le le_top
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_top_left | null |
relfinrank_top_left : relfinrank ⊤ A = 1 := relfinrank_eq_one_of_le le_top
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_top_left | null |
relrank_top_right : relrank A ⊤ = Module.rank A E := by
let _ : AddCommMonoid (⊤ : IntermediateField A E) := inferInstance
rw [relrank_eq_rank_of_le (show A ≤ ⊤ from le_top), extendScalars_top,
IntermediateField.topEquiv.toLinearEquiv.rank_eq]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_top_right | null |
relfinrank_top_right : relfinrank A ⊤ = finrank A E := by
simp [relfinrank_eq_toNat_relrank, finrank] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_top_right | null |
lift_relrank_map_map (f : E →+* L) :
lift.{v} (relrank (A.map f) (B.map f)) = lift.{w} (relrank A B) :=
.symm <| Algebra.lift_rank_eq_of_equiv_equiv (((A ⊓ B).equivMapOfInjective f f.injective).trans
<| .subringCongr <| by rw [← map_inf]; rfl) (B.equivMapOfInjective f f.injective) rfl | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_map_map | null |
relrank_map_map {L : Type v} [Field L] (f : E →+* L) :
relrank (A.map f) (B.map f) = relrank A B := by
simpa only [lift_id] using lift_relrank_map_map A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_map_map | null |
lift_relrank_comap (f : L →+* E) (B : Subfield L) :
lift.{v} (relrank (A.comap f) B) = lift.{w} (relrank A (B.map f)) :=
(lift_relrank_map_map _ _ f).symm.trans <| congr_arg lift <| relrank_eq_of_inf_eq <| by
rw [map_comap_eq, f.fieldRange_eq_map, inf_assoc, ← map_inf, top_inf_eq] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap | null |
relrank_comap {L : Type v} [Field L] (f : L →+* E)
(B : Subfield L) : relrank (A.comap f) B = relrank A (B.map f) := by
simpa only [lift_id] using A.lift_relrank_comap f B | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap | null |
relfinrank_comap (f : L →+* E) (B : Subfield L) :
relfinrank (A.comap f) B = relfinrank A (B.map f) := by
simpa using congr(toNat $(lift_relrank_comap A f B)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap | null |
lift_rank_comap (f : L →+* E) :
lift.{v} (Module.rank (A.comap f) L) = lift.{w} (relrank A f.fieldRange) := by
simpa only [relrank_top_right, ← RingHom.fieldRange_eq_map] using lift_relrank_comap A f ⊤ | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_rank_comap | null |
rank_comap {L : Type v} [Field L] (f : L →+* E) :
Module.rank (A.comap f) L = relrank A f.fieldRange := by
simpa only [lift_id] using A.lift_rank_comap f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | rank_comap | null |
finrank_comap (f : L →+* E) : finrank (A.comap f) L = relfinrank A f.fieldRange := by
simpa using congr(toNat $(lift_rank_comap A f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | finrank_comap | null |
relfinrank_map_map (f : E →+* L) :
relfinrank (A.map f) (B.map f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_map_map A B f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_map_map | null |
lift_relrank_comap_comap_eq_lift_relrank_inf (f : L →+* E) :
lift.{v} (relrank (A.comap f) (B.comap f)) =
lift.{w} (relrank A (B ⊓ f.fieldRange)) := by
conv_lhs => rw [← lift_relrank_map_map _ _ f, map_comap_eq, map_comap_eq]
congr 1
apply relrank_eq_of_inf_eq
rw [inf_assoc, inf_left_comm _ B, inf_of_le... | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_inf | null |
relrank_comap_comap_eq_relrank_inf
{L : Type v} [Field L] (f : L →+* E) :
relrank (A.comap f) (B.comap f) = relrank A (B ⊓ f.fieldRange) := by
simpa only [lift_id] using lift_relrank_comap_comap_eq_lift_relrank_inf A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_inf | null |
relfinrank_comap_comap_eq_relfinrank_inf (f : L →+* E) :
relfinrank (A.comap f) (B.comap f) = relfinrank A (B ⊓ f.fieldRange) := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_inf A B f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_inf | null |
lift_relrank_comap_comap_eq_lift_relrank_of_le (f : L →+* E) (h : B ≤ f.fieldRange) :
lift.{v} (relrank (A.comap f) (B.comap f)) =
lift.{w} (relrank A B) := by
simpa only [inf_of_le_left h] using lift_relrank_comap_comap_eq_lift_relrank_inf A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_of_le | null |
relrank_comap_comap_eq_relrank_of_le
{L : Type v} [Field L] (f : L →+* E) (h : B ≤ f.fieldRange) :
relrank (A.comap f) (B.comap f) = relrank A B := by
simpa only [lift_id] using lift_relrank_comap_comap_eq_lift_relrank_of_le A B f h | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_of_le | null |
relfinrank_comap_comap_eq_relfinrank_of_le (f : L →+* E) (h : B ≤ f.fieldRange) :
relfinrank (A.comap f) (B.comap f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_of_le A B f h)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_of_le | null |
lift_relrank_comap_comap_eq_lift_relrank_of_surjective
(f : L →+* E) (h : Function.Surjective f) :
lift.{v} (relrank (A.comap f) (B.comap f)) =
lift.{w} (relrank A B) :=
lift_relrank_comap_comap_eq_lift_relrank_of_le A B f fun x _ ↦ h x | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_of_surjective | null |
relrank_comap_comap_eq_relrank_of_surjective
{L : Type v} [Field L] (f : L →+* E) (h : Function.Surjective f) :
relrank (A.comap f) (B.comap f) = relrank A B := by
simpa using lift_relrank_comap_comap_eq_lift_relrank_of_surjective A B f h | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_of_surjective | null |
relfinrank_comap_comap_eq_relfinrank_of_surjective
(f : L →+* E) (h : Function.Surjective f) :
relfinrank (A.comap f) (B.comap f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_of_surjective A B f h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_of_surjective | null |
relrank_dvd_rank_top_of_le (h : A ≤ B) : relrank A B ∣ Module.rank A E :=
dvd_of_mul_right_eq _ (relrank_mul_rank_top h)
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_dvd_rank_top_of_le | null |
relfinrank_dvd_finrank_top_of_le (h : A ≤ B) : relfinrank A B ∣ finrank A E :=
dvd_of_mul_right_eq _ (relfinrank_mul_finrank_top h)
variable {A B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_dvd_finrank_top_of_le | null |
relrank_mul_relrank (h1 : A ≤ B) (h2 : B ≤ C) :
relrank A B * relrank B C = relrank A C := by
have h3 := h1.trans h2
rw [relrank_eq_rank_of_le h1, relrank_eq_rank_of_le h2, relrank_eq_rank_of_le h3]
letI : Algebra A B := (inclusion h1).toAlgebra
letI : Algebra B C := (inclusion h2).toAlgebra
letI : Algebr... | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_relrank | null |
relfinrank_mul_relfinrank (h1 : A ≤ B) (h2 : B ≤ C) :
relfinrank A B * relfinrank B C = relfinrank A C := by
simpa using congr(toNat $(relrank_mul_relrank h1 h2)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_relfinrank | null |
relrank_inf_mul_relrank : A.relrank (B ⊓ C) * B.relrank C = (A ⊓ B).relrank C := by
rw [← inf_relrank_right A (B ⊓ C), ← inf_relrank_right B C, ← inf_relrank_right (A ⊓ B) C,
inf_assoc, relrank_mul_relrank inf_le_right inf_le_right] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_inf_mul_relrank | null |
relfinrank_inf_mul_relfinrank :
A.relfinrank (B ⊓ C) * B.relfinrank C = (A ⊓ B).relfinrank C := by
simpa using congr(toNat $(relrank_inf_mul_relrank A B C))
variable {B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_inf_mul_relfinrank | null |
relrank_mul_relrank_eq_inf_relrank (h : B ≤ C) :
relrank A B * relrank B C = (A ⊓ B).relrank C := by
simpa only [inf_of_le_left h] using relrank_inf_mul_relrank A B C
variable {B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_relrank_eq_inf_relrank | null |
relfinrank_mul_relfinrank_eq_inf_relfinrank (h : B ≤ C) :
relfinrank A B * relfinrank B C = (A ⊓ B).relfinrank C := by
simpa using congr(toNat $(relrank_mul_relrank_eq_inf_relrank A h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_relfinrank_eq_inf_relfinrank | null |
relrank_inf_mul_relrank_of_le (h : A ≤ B) :
A.relrank (B ⊓ C) * B.relrank C = A.relrank C := by
simpa only [inf_of_le_left h] using relrank_inf_mul_relrank A B C
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_inf_mul_relrank_of_le | null |
relfinrank_inf_mul_relfinrank_of_le (h : A ≤ B) :
A.relfinrank (B ⊓ C) * B.relfinrank C = A.relfinrank C := by
simpa using congr(toNat $(relrank_inf_mul_relrank_of_le C h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_inf_mul_relfinrank_of_le | null |
relrank_dvd_of_le_left (h : A ≤ B) : B.relrank C ∣ A.relrank C :=
dvd_of_mul_left_eq _ (relrank_inf_mul_relrank_of_le C h)
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_dvd_of_le_left | null |
relfinrank_dvd_of_le_left (h : A ≤ B) : B.relfinrank C ∣ A.relfinrank C :=
dvd_of_mul_left_eq _ (relfinrank_inf_mul_relfinrank_of_le C h) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_dvd_of_le_left | null |
noncomputable relrank := A.toSubfield.relrank B.toSubfield | def | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank | `IntermediateField.relrank A B` is defined to be `[B : A ⊓ B]` as a `Cardinal`, in particular,
when `A ≤ B` it is `[B : A]`, the degree of the field extension `B / A`.
This is similar to `Subgroup.relIndex` but it is `Cardinal` valued. |
noncomputable relfinrank := A.toSubfield.relfinrank B.toSubfield | def | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank | The `Nat` version of `IntermediateField.relrank`.
If `B / A ⊓ B` is an infinite extension, then it is zero. |
relfinrank_eq_toNat_relrank : relfinrank A B = toNat (relrank A B) := rfl
variable {A B C} | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_toNat_relrank | null |
relrank_eq_of_inf_eq (h : A ⊓ C = B ⊓ C) : relrank A C = relrank B C :=
Subfield.relrank_eq_of_inf_eq congr(toSubfield $h) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_of_inf_eq | null |
relfinrank_eq_of_inf_eq (h : A ⊓ C = B ⊓ C) : relfinrank A C = relfinrank B C :=
congr(toNat $(relrank_eq_of_inf_eq h)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_of_inf_eq | null |
relrank_eq_rank_of_le (h : A ≤ B) : relrank A B = Module.rank A (extendScalars h) :=
Subfield.relrank_eq_rank_of_le h | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_rank_of_le | If `A ≤ B`, then `IntermediateField.relrank A B` is `[B : A]` |
relfinrank_eq_finrank_of_le (h : A ≤ B) : relfinrank A B = finrank A (extendScalars h) :=
congr(toNat $(relrank_eq_rank_of_le h))
variable (A B C) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_finrank_of_le | If `A ≤ B`, then `IntermediateField.relrank A B` is `[B : A]` |
inf_relrank_right : relrank (A ⊓ B) B = relrank A B :=
relrank_eq_rank_of_le (inf_le_right : A ⊓ B ≤ B) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relrank_right | null |
inf_relfinrank_right : relfinrank (A ⊓ B) B = relfinrank A B :=
congr(toNat $(inf_relrank_right A B)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relfinrank_right | null |
inf_relrank_left : relrank (A ⊓ B) A = relrank B A := by
rw [inf_comm, inf_relrank_right] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relrank_left | null |
inf_relfinrank_left : relfinrank (A ⊓ B) A = relfinrank B A :=
congr(toNat $(inf_relrank_left A B))
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | inf_relfinrank_left | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.