File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

full_name: Polynomial.Gal
code: /-- The Galois group of a polynomial. -/
def Gal 
goal: Type u_1

full_name: Polynomial.Gal.instGroup
code: instance instGroup : Group (Gal p) 
goal: Group p.Gal

full_name: Polynomial.Gal.instFintype
code: instance instFintype : Fintype (Gal p) 
goal: Fintype p.Gal

full_name: Polynomial.Gal.instEquivLikeSplittingField
code: instance : EquivLike p.Gal p.SplittingField p.SplittingField 
goal: EquivLike p.Gal p.SplittingField p.SplittingField

full_name: Polynomial.Gal.instAlgEquivClassSplittingField
code: instance : AlgEquivClass p.Gal F p.SplittingField p.SplittingField 
goal: AlgEquivClass p.Gal F p.SplittingField p.SplittingField

full_name: Polynomial.Gal.applyMulSemiringAction
code: instance applyMulSemiringAction : MulSemiringAction p.Gal p.SplittingField 
goal: MulSemiringAction p.Gal p.SplittingField

full_name: Polynomial.Gal.ext
code: @[ext]
theorem ext {σ τ : p.Gal} (h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x) : σ = τ 
goal: σ = τ

full_name: Polynomial.Gal.uniqueGalOfSplits
code: /-- If `p` splits in `F` then the `p.gal` is trivial. -/
def uniqueGalOfSplits (h : p.Splits (RingHom.id F)) : Unique p.Gal 
goal: Unique p.Gal

full_name: Polynomial.Gal.instUniqueOfFactSplitsId
code: instance [h : Fact (p.Splits (RingHom.id F))] : Unique p.Gal 
goal: Unique p.Gal

full_name: Polynomial.Gal.uniqueGalZero
code: instance uniqueGalZero : Unique (0 : F[X]).Gal 
goal: Unique (Polynomial.Gal 0)

full_name: Polynomial.Gal.uniqueGalOne
code: instance uniqueGalOne : Unique (1 : F[X]).Gal 
goal: Unique (Polynomial.Gal 1)

full_name: Polynomial.Gal.uniqueGalC
code: instance uniqueGalC (x : F) : Unique (C x).Gal 
goal: Unique (Polynomial.C x).Gal

full_name: Polynomial.Gal.uniqueGalX
code: instance uniqueGalX : Unique (X : F[X]).Gal 
goal: Unique Polynomial.X.Gal

full_name: Polynomial.Gal.uniqueGalXSubC
code: instance uniqueGalXSubC (x : F) : Unique (X - C x).Gal 
goal: Unique (Polynomial.X - Polynomial.C x).Gal

full_name: Polynomial.Gal.uniqueGalXPow
code: instance uniqueGalXPow (n : ℕ) : Unique (X ^ n : F[X]).Gal 
goal: Unique (Polynomial.X ^ n).Gal

full_name: Polynomial.Gal.instAlgebraSplittingFieldOfFactSplitsAlgebraMap
code: instance [h : Fact (p.Splits (algebraMap F E))] : Algebra p.SplittingField E 
goal: Algebra p.SplittingField E

full_name: Polynomial.Gal.instIsScalarTowerSplittingField
code: instance [h : Fact (p.Splits (algebraMap F E))] : IsScalarTower F p.SplittingField E 
goal: IsScalarTower F p.SplittingField E

full_name: Polynomial.Gal.restrict
code: /-- Restrict from a superfield automorphism into a member of `gal p`. -/
def restrict [Fact (p.Splits (algebraMap F E))] : (E ≃ₐ[F] E) →* p.Gal 
goal: (E ≃ₐ[F] E) →* p.Gal

full_name: Polynomial.Gal.restrict_surjective
code: theorem restrict_surjective [Fact (p.Splits (algebraMap F E))] [Normal F E] :
    Function.Surjective (restrict p E) 
goal: Function.Surjective ⇑(Polynomial.Gal.restrict p E)

full_name: Polynomial.Gal.mapRoots
code: /-- The function taking `rootSet p p.SplittingField` to `rootSet p E`. This is actually a bijection,
see `Polynomial.Gal.mapRoots_bijective`. -/
def mapRoots [Fact (p.Splits (algebraMap F E))] : rootSet p p.SplittingField → rootSet p E 
goal: ↑(p.rootSet p.SplittingField) → ↑(p.rootSet E)

full_name: Polynomial.Gal.mapRoots_bijective
code: theorem mapRoots_bijective [h : Fact (p.Splits (algebraMap F E))] :
    Function.Bijective (mapRoots p E) 
goal: Function.Bijective (Polynomial.Gal.mapRoots p E)

full_name: Polynomial.Gal.rootsEquivRoots
code: /-- The bijection between `rootSet p p.SplittingField` and `rootSet p E`. -/
def rootsEquivRoots [Fact (p.Splits (algebraMap F E))] : rootSet p p.SplittingField ≃ rootSet p E 
goal: ↑(p.rootSet p.SplittingField) ≃ ↑(p.rootSet E)

full_name: Polynomial.Gal.galActionAux
code: instance galActionAux : MulAction p.Gal (rootSet p p.SplittingField) 
goal: MulAction p.Gal ↑(p.rootSet p.SplittingField)

full_name: Polynomial.Gal.smul
code: instance smul [Fact (p.Splits (algebraMap F E))] : SMul p.Gal (rootSet p E) 
goal: SMul p.Gal ↑(p.rootSet E)

full_name: Polynomial.Gal.smul_def
code: theorem smul_def [Fact (p.Splits (algebraMap F E))] (ϕ : p.Gal) (x : rootSet p E) :
    ϕ • x = rootsEquivRoots p E (ϕ • (rootsEquivRoots p E).symm x) 
goal: ϕ • x = (Polynomial.Gal.rootsEquivRoots p E) (ϕ • (Polynomial.Gal.rootsEquivRoots p E).symm x)

full_name: Polynomial.Gal.galAction
code: /-- The action of `gal p` on the roots of `p` in `E`. -/
instance galAction [Fact (p.Splits (algebraMap F E))] : MulAction p.Gal (rootSet p E) 
goal: MulAction p.Gal ↑(p.rootSet E)

full_name: Polynomial.Gal.galAction_isPretransitive
code: lemma galAction_isPretransitive [Fact (p.Splits (algebraMap F E))] (hp : Irreducible p) :
    MulAction.IsPretransitive p.Gal (p.rootSet E) 
goal: MulAction.IsPretransitive p.Gal ↑(p.rootSet E)

full_name: Polynomial.Gal.restrict_smul
code: /-- `Polynomial.Gal.restrict p E` is compatible with `Polynomial.Gal.galAction p E`. -/
@[simp]
theorem restrict_smul [Fact (p.Splits (algebraMap F E))] (ϕ : E ≃ₐ[F] E) (x : rootSet p E) :
    ↑(restrict p E ϕ • x) = ϕ x 
goal: ↑((Polynomial.Gal.restrict p E) ϕ • x) = ϕ ↑x

full_name: Polynomial.Gal.galActionHom
code: /-- `Polynomial.Gal.galAction` as a permutation representation -/
def galActionHom [Fact (p.Splits (algebraMap F E))] : p.Gal →* Equiv.Perm (rootSet p E) 
goal: p.Gal →* Equiv.Perm ↑(p.rootSet E)

full_name: Polynomial.Gal.galActionHom_restrict
code: theorem galActionHom_restrict [Fact (p.Splits (algebraMap F E))] (ϕ : E ≃ₐ[F] E) (x : rootSet p E) :
    ↑(galActionHom p E (restrict p E ϕ) x) = ϕ x 
goal: ↑(((Polynomial.Gal.galActionHom p E) ((Polynomial.Gal.restrict p E) ϕ)) x) = ϕ ↑x

full_name: Polynomial.Gal.galActionHom_injective
code: /-- `gal p` embeds as a subgroup of permutations of the roots of `p` in `E`. -/
theorem galActionHom_injective [Fact (p.Splits (algebraMap F E))] :
    Function.Injective (galActionHom p E) 
goal: Function.Injective ⇑(Polynomial.Gal.galActionHom p E)

full_name: Polynomial.Gal.restrictDvd
code: /-- `Polynomial.Gal.restrict`, when both fields are splitting fields of polynomials. -/
def restrictDvd (hpq : p ∣ q) : q.Gal →* p.Gal 
goal: q.Gal →* p.Gal

full_name: Polynomial.Gal.restrictDvd_def
code: theorem 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⟩ 
goal: Polynomial.Gal.restrictDvd hpq = if hq : q = 0 then 1 else Polynomial.Gal.restrict p q.SplittingField

full_name: Polynomial.Gal.restrictDvd_surjective
code: theorem restrictDvd_surjective (hpq : p ∣ q) (hq : q ≠ 0) :
    Function.Surjective (restrictDvd hpq) 
goal: Function.Surjective ⇑(Polynomial.Gal.restrictDvd hpq)

full_name: Polynomial.Gal.restrictProd
code: /-- The Galois group of a product maps into the product of the Galois groups.  -/
def restrictProd : (p * q).Gal →* p.Gal × q.Gal 
goal: (p * q).Gal →* p.Gal × q.Gal

full_name: Polynomial.Gal.restrictProd_injective
code: /-- `Polynomial.Gal.restrictProd` is actually a subgroup embedding. -/
theorem restrictProd_injective : Function.Injective (restrictProd p q) 
goal: Function.Injective ⇑(Polynomial.Gal.restrictProd p q)

full_name: Polynomial.Gal.mul_splits_in_splittingField_of_mul
code: theorem 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) 
goal: Polynomial.Splits (algebraMap F (q₁ * q₂).SplittingField) (p₁ * p₂)

full_name: Polynomial.Gal.splits_in_splittingField_of_comp
code: /-- `p` splits in the splitting field of `p ∘ q`, for `q` non-constant. -/
theorem splits_in_splittingField_of_comp (hq : q.natDegree ≠ 0) :
    p.Splits (algebraMap F (p.comp q).SplittingField) 
goal: Polynomial.Splits (algebraMap F (p.comp q).SplittingField) p

full_name: Polynomial.Gal.restrictComp
code: /-- `Polynomial.Gal.restrict` for the composition of polynomials. -/
def restrictComp (hq : q.natDegree ≠ 0) : (p.comp q).Gal →* p.Gal 
goal: (p.comp q).Gal →* p.Gal

full_name: Polynomial.Gal.restrictComp_surjective
code: theorem restrictComp_surjective (hq : q.natDegree ≠ 0) :
    Function.Surjective (restrictComp p q hq) 
goal: Function.Surjective ⇑(Polynomial.Gal.restrictComp p q hq)

full_name: Polynomial.Gal.card_of_separable
code: /-- For a separable polynomial, its Galois group has cardinality
equal to the dimension of its splitting field over `F`. -/
theorem card_of_separable (hp : p.Separable) : Fintype.card p.Gal = finrank F p.SplittingField 
goal: Fintype.card p.Gal = FiniteDimensional.finrank F p.SplittingField

full_name: Polynomial.Gal.prime_degree_dvd_card
code: theorem prime_degree_dvd_card [CharZero F] (p_irr : Irreducible p) (p_deg : p.natDegree.Prime) :
    p.natDegree ∣ Fintype.card p.Gal 
goal: p.natDegree ∣ Fintype.card p.Gal