File: Mathlib/FieldTheory/Galois.lean

full_name: IsGalois
code: /-- A field extension E/F is Galois if it is both separable and normal. Note that in mathlib
a separable extension of fields is by definition algebraic. -/
class IsGalois : Prop where
  [to_isSeparable : Algebra.IsSeparable F E]
  [to_normal : Normal F E]
goal: Prop

full_name: IsGalois.to_normal
code: /-- A field extension E/F is Galois if it is both separable and normal. Note that in mathlib
a separable extension of fields is by definition algebraic. -/
class IsGalois : Prop where
  [to_isSeparable : Algebra.IsSeparable F E]
  [to_normal : Normal F E]
goal: Normal F E

full_name: IsGalois.to_isSeparable
code: /-- A field extension E/F is Galois if it is both separable and normal. Note that in mathlib
a separable extension of fields is by definition algebraic. -/
class IsGalois : Prop where
  [to_isSeparable : Algebra.IsSeparable F E]
  [to_normal : Normal F E]
goal: Algebra.IsSeparable F E

full_name: isGalois_iff
code: theorem isGalois_iff : IsGalois F E ↔ Algebra.IsSeparable F E ∧ Normal F E 
goal: IsGalois F E ↔ Algebra.IsSeparable F E ∧ Normal F E

full_name: IsGalois.self
code: instance self : IsGalois F F 
goal: IsGalois F F

full_name: IsGalois.integral
code: theorem integral [IsGalois F E] (x : E) : IsIntegral F x 
goal: IsIntegral F x

full_name: IsGalois.separable
code: theorem separable [IsGalois F E] (x : E) : IsSeparable F x 
goal: IsSeparable F x

full_name: IsGalois.splits
code: theorem splits [IsGalois F E] (x : E) : (minpoly F x).Splits (algebraMap F E) 
goal: Polynomial.Splits (algebraMap F E) (minpoly F x)

full_name: IsGalois.of_fixed_field
code: instance of_fixed_field (G : Type*) [Group G] [Finite G] [MulSemiringAction G E] :
    IsGalois (FixedPoints.subfield G E) E 
goal: IsGalois (↥(FixedPoints.subfield G E)) E

full_name: IsGalois.IntermediateField.AdjoinSimple.card_aut_eq_finrank
code: theorem IntermediateField.AdjoinSimple.card_aut_eq_finrank [FiniteDimensional F E] {α : E}
    (hα : IsIntegral F α) (h_sep : IsSeparable F α)
    (h_splits : (minpoly F α).Splits (algebraMap F F⟮α⟯)) :
    Fintype.card (F⟮α⟯ ≃ₐ[F] F⟮α⟯) = finrank F F⟮α⟯ 
goal: Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = FiniteDimensional.finrank F ↥F⟮α⟯

full_name: IsGalois.card_aut_eq_finrank
code: theorem card_aut_eq_finrank [FiniteDimensional F E] [IsGalois F E] :
    Fintype.card (E ≃ₐ[F] E) = finrank F E 
goal: Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E

full_name: IsGalois.tower_top_of_isGalois
code: theorem IsGalois.tower_top_of_isGalois [IsGalois F E] : IsGalois K E 
goal: IsGalois K E

full_name: IsGalois.tower_top_intermediateField
code: instance (priority := 100) IsGalois.tower_top_intermediateField (K : IntermediateField F E)
    [IsGalois F E] : IsGalois K E 
goal: IsGalois (↥K) E

full_name: isGalois_iff_isGalois_bot
code: theorem isGalois_iff_isGalois_bot : IsGalois (⊥ : IntermediateField F E) E ↔ IsGalois F E 
goal: IsGalois (↥⊥) E ↔ IsGalois F E

full_name: IsGalois.of_algEquiv
code: theorem IsGalois.of_algEquiv [IsGalois F E] (f : E ≃ₐ[F] E') : IsGalois F E' 
goal: IsGalois F E'

full_name: AlgEquiv.transfer_galois
code: theorem AlgEquiv.transfer_galois (f : E ≃ₐ[F] E') : IsGalois F E ↔ IsGalois F E' 
goal: IsGalois F E ↔ IsGalois F E'

full_name: isGalois_iff_isGalois_top
code: theorem isGalois_iff_isGalois_top : IsGalois F (⊤ : IntermediateField F E) ↔ IsGalois F E 
goal: IsGalois F ↥⊤ ↔ IsGalois F E

full_name: isGalois_bot
code: instance isGalois_bot : IsGalois F (⊥ : IntermediateField F E) 
goal: IsGalois F ↥⊥

full_name: FixedPoints.intermediateField
code: /-- The intermediate field of fixed points fixed by a monoid action that commutes with the
`F`-action on `E`. -/
def FixedPoints.intermediateField (M : Type*) [Monoid M] [MulSemiringAction M E]
    [SMulCommClass M F E] : IntermediateField F E 
goal: IntermediateField F E

full_name: IntermediateField.fixedField
code: /-- The intermediate field fixed by a subgroup -/
def fixedField : IntermediateField F E 
goal: IntermediateField F E

full_name: IntermediateField.finrank_fixedField_eq_card
code: theorem finrank_fixedField_eq_card [FiniteDimensional F E] [DecidablePred (· ∈ H)] :
    finrank (fixedField H) E = Fintype.card H 
goal: FiniteDimensional.finrank (↥(IntermediateField.fixedField H)) E = Fintype.card ↥H

full_name: IntermediateField.fixingSubgroup
code: /-- The subgroup fixing an intermediate field -/
nonrec def fixingSubgroup : Subgroup (E ≃ₐ[F] E) 
goal: Subgroup (E ≃ₐ[F] E)

full_name: IntermediateField.le_iff_le
code: theorem le_iff_le : K ≤ fixedField H ↔ H ≤ fixingSubgroup K 
goal: K ≤ IntermediateField.fixedField H ↔ H ≤ K.fixingSubgroup

full_name: IntermediateField.fixingSubgroupEquiv
code: /-- The fixing subgroup of `K : IntermediateField F E` is isomorphic to `E ≃ₐ[K] E` -/
def fixingSubgroupEquiv : fixingSubgroup K ≃* E ≃ₐ[K] E 
goal: ↥K.fixingSubgroup ≃* E ≃ₐ[↥K] E

full_name: IntermediateField.fixingSubgroup_fixedField
code: theorem fixingSubgroup_fixedField [FiniteDimensional F E] : fixingSubgroup (fixedField H) = H 
goal: (IntermediateField.fixedField H).fixingSubgroup = H

full_name: IntermediateField.fixedField.smul
code: instance fixedField.smul : SMul K (fixedField (fixingSubgroup K)) 
goal: SMul ↥K ↥(IntermediateField.fixedField K.fixingSubgroup)

full_name: IntermediateField.fixedField.algebra
code: instance fixedField.algebra : Algebra K (fixedField (fixingSubgroup K)) 
goal: Algebra ↥K ↥(IntermediateField.fixedField K.fixingSubgroup)

full_name: IntermediateField.fixedField.isScalarTower
code: instance fixedField.isScalarTower : IsScalarTower K (fixedField (fixingSubgroup K)) E 
goal: IsScalarTower (↥K) (↥(IntermediateField.fixedField K.fixingSubgroup)) E

full_name: IsGalois.fixedField_fixingSubgroup
code: theorem fixedField_fixingSubgroup [FiniteDimensional F E] [h : IsGalois F E] :
    IntermediateField.fixedField (IntermediateField.fixingSubgroup K) = K 
goal: IntermediateField.fixedField K.fixingSubgroup = K

full_name: IsGalois.card_fixingSubgroup_eq_finrank
code: theorem card_fixingSubgroup_eq_finrank [DecidablePred (· ∈ IntermediateField.fixingSubgroup K)]
    [FiniteDimensional F E] [IsGalois F E] :
    Fintype.card (IntermediateField.fixingSubgroup K) = finrank K E 
goal: Fintype.card ↥K.fixingSubgroup = FiniteDimensional.finrank (↥K) E

full_name: IsGalois.intermediateFieldEquivSubgroup
code: /-- The Galois correspondence from intermediate fields to subgroups -/
def intermediateFieldEquivSubgroup [FiniteDimensional F E] [IsGalois F E] :
    IntermediateField F E ≃o (Subgroup (E ≃ₐ[F] E))ᵒᵈ 
goal: IntermediateField F E ≃o (Subgroup (E ≃ₐ[F] E))ᵒᵈ

full_name: IsGalois.galoisInsertionIntermediateFieldSubgroup
code: /-- The Galois correspondence as a `GaloisInsertion` -/
def galoisInsertionIntermediateFieldSubgroup [FiniteDimensional F E] :
    GaloisInsertion (OrderDual.toDual ∘
      (IntermediateField.fixingSubgroup : IntermediateField F E → Subgroup (E ≃ₐ[F] E)))
      ((IntermediateField.fixedField : Subgroup (E ≃ₐ[F] E) → IntermediateField F E) ∘
        OrderDual.toDual) 
goal: GaloisInsertion (⇑OrderDual.toDual ∘ IntermediateField.fixingSubgroup)
  (IntermediateField.fixedField ∘ ⇑OrderDual.toDual)

full_name: IsGalois.galoisCoinsertionIntermediateFieldSubgroup
code: /-- The Galois correspondence as a `GaloisCoinsertion` -/
def galoisCoinsertionIntermediateFieldSubgroup [FiniteDimensional F E] [IsGalois F E] :
    GaloisCoinsertion (OrderDual.toDual ∘
      (IntermediateField.fixingSubgroup : IntermediateField F E → Subgroup (E ≃ₐ[F] E)))
      ((IntermediateField.fixedField : Subgroup (E ≃ₐ[F] E) → IntermediateField F E) ∘
        OrderDual.toDual) 
goal: GaloisCoinsertion (⇑OrderDual.toDual ∘ IntermediateField.fixingSubgroup)
  (IntermediateField.fixedField ∘ ⇑OrderDual.toDual)

full_name: IsGalois.is_separable_splitting_field
code: theorem is_separable_splitting_field [FiniteDimensional F E] [IsGalois F E] :
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E 
goal: ∃ p, p.Separable ∧ Polynomial.IsSplittingField F E p

full_name: IsGalois.of_fixedField_eq_bot
code: theorem of_fixedField_eq_bot [FiniteDimensional F E]
    (h : IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥) : IsGalois F E 
goal: IsGalois F E

full_name: IsGalois.of_card_aut_eq_finrank
code: theorem of_card_aut_eq_finrank [FiniteDimensional F E]
    (h : Fintype.card (E ≃ₐ[F] E) = finrank F E) : IsGalois F E 
goal: IsGalois F E

full_name: IsGalois.of_separable_splitting_field_aux
code: theorem of_separable_splitting_field_aux [hFE : FiniteDimensional F E] [sp : p.IsSplittingField F E]
    (hp : p.Separable) (K : Type*) [Field K] [Algebra F K] [Algebra K E] [IsScalarTower F K E]
    {x : E} (hx : x ∈ p.aroots E)
    -- these are both implied by `hFE`, but as they carry data this makes the lemma more general
    [Fintype (K →ₐ[F] E)]
    [Fintype (K⟮x⟯.restrictScalars F →ₐ[F] E)] :
    Fintype.card (K⟮x⟯.restrictScalars F →ₐ[F] E) = Fintype.card (K →ₐ[F] E) * finrank K K⟮x⟯ 
goal: Fintype.card (↥(IntermediateField.restrictScalars F K⟮x⟯) →ₐ[F] E) =
  Fintype.card (K →ₐ[F] E) * FiniteDimensional.finrank K ↥K⟮x⟯

full_name: IsGalois.of_separable_splitting_field
code: theorem of_separable_splitting_field [sp : p.IsSplittingField F E] (hp : p.Separable) :
    IsGalois F E 
goal: IsGalois F E

full_name: IsGalois.tfae
code: /-- Equivalent characterizations of a Galois extension of finite degree-/
theorem tfae [FiniteDimensional F E] : List.TFAE [
    IsGalois F E,
    IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥,
    Fintype.card (E ≃ₐ[F] E) = finrank F E,
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E] 
goal: [IsGalois F E, IntermediateField.fixedField ⊤ = ⊥, Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E,
    ∃ p, p.Separable ∧ Polynomial.IsSplittingField F E p].TFAE

full_name: IsGalois.normalClosure
code: instance IsGalois.normalClosure : IsGalois k (normalClosure k K F) 
goal: IsGalois k ↥(normalClosure k K F)

full_name: IsAlgClosure.isGalois
code: instance (priority := 100) IsAlgClosure.isGalois (k K : Type*) [Field k] [Field K] [Algebra k K]
    [IsAlgClosure k K] [CharZero k] : IsGalois k K 
goal: IsGalois k K