File: Mathlib/FieldTheory/Normal.lean

full_name: Normal
code: /-- Typeclass for normal field extension: `K` is a normal extension of `F` iff the minimal
polynomial of every element `x` in `K` splits in `K`, i.e. every conjugate of `x` is in `K`. -/
class Normal extends Algebra.IsAlgebraic F K : Prop where
  splits' (x : K) : Splits (algebraMap F K) (minpoly F x)
goal: Prop

full_name: Normal.splits'
code: /-- Typeclass for normal field extension: `K` is a normal extension of `F` iff the minimal
polynomial of every element `x` in `K` splits in `K`, i.e. every conjugate of `x` is in `K`. -/
class Normal extends Algebra.IsAlgebraic F K : Prop where
  splits' (x : K) : Splits (algebraMap F K) (minpoly F x)
goal: Polynomial.Splits (algebraMap F K) (minpoly F x)

full_name: Normal.isIntegral
code: theorem Normal.isIntegral (_ : Normal F K) (x : K) : IsIntegral F x 
goal: Normal F K → ∀ (x : K), IsIntegral F x

full_name: Normal.splits
code: theorem Normal.splits (_ : Normal F K) (x : K) : Splits (algebraMap F K) (minpoly F x) 
goal: Normal F K → ∀ (x : K), Polynomial.Splits (algebraMap F K) (minpoly F x)

full_name: normal_iff
code: theorem normal_iff : Normal F K ↔ ∀ x : K, IsIntegral F x ∧ Splits (algebraMap F K) (minpoly F x) 
goal: Normal F K ↔ ∀ (x : K), IsIntegral F x ∧ Polynomial.Splits (algebraMap F K) (minpoly F x)

full_name: Normal.out
code: theorem Normal.out : Normal F K → ∀ x : K, IsIntegral F x ∧ Splits (algebraMap F K) (minpoly F x) 
goal: Normal F K → ∀ (x : K), IsIntegral F x ∧ Polynomial.Splits (algebraMap F K) (minpoly F x)

full_name: normal_self
code: instance normal_self : Normal F F 
goal: Normal F F

full_name: Normal.exists_isSplittingField
code: theorem Normal.exists_isSplittingField [h : Normal F K] [FiniteDimensional F K] :
    ∃ p : F[X], IsSplittingField F K p 
goal: ∃ p, Polynomial.IsSplittingField F K p

full_name: Normal.tower_top_of_normal
code: theorem Normal.tower_top_of_normal [h : Normal F E] : Normal K E 
goal: Normal K E

full_name: AlgHom.normal_bijective
code: theorem AlgHom.normal_bijective [h : Normal F E] (ϕ : E →ₐ[F] K) : Function.Bijective ϕ 
goal: Function.Bijective ⇑ϕ

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

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

full_name: Normal.of_isSplittingField
code: theorem Normal.of_isSplittingField (p : F[X]) [hFEp : IsSplittingField F E p] : Normal F E 
goal: Normal F E

full_name: Polynomial.SplittingField.instNormal
code: instance Polynomial.SplittingField.instNormal (p : F[X]) : Normal F p.SplittingField 
goal: Normal F p.SplittingField

full_name: IntermediateField.normal_iSup
code: /-- A compositum of normal extensions is normal -/
instance normal_iSup {ι : Type*} (t : ι → IntermediateField F K) [h : ∀ i, Normal F (t i)] :
    Normal F (⨆ i, t i : IntermediateField F K) 
goal: Normal F ↥(⨆ i, t i)

full_name: IntermediateField.splits_of_mem_adjoin
code: /-- If a set of algebraic elements in a field extension `K/F` have minimal polynomials that
  split in another extension `L/F`, then all minimal polynomials in the intermediate field
  generated by the set also split in `L/F`. -/
theorem splits_of_mem_adjoin {L} [Field L] [Algebra F L] {S : Set K}
    (splits : ∀ x ∈ S, IsIntegral F x ∧ (minpoly F x).Splits (algebraMap F L)) {x : K}
    (hx : x ∈ adjoin F S) : (minpoly F x).Splits (algebraMap F L) 
goal: Polynomial.Splits (algebraMap F L) (minpoly F x)

full_name: IntermediateField.normal_sup
code: instance normal_sup
    (E E' : IntermediateField F K) [Normal F E] [Normal F E'] :
    Normal F (E ⊔ E' : IntermediateField F K) 
goal: Normal F ↥(E ⊔ E')

full_name: IntermediateField.restrictScalars_normal
code: @[simp]
theorem restrictScalars_normal {E : IntermediateField K L} :
    Normal F (E.restrictScalars F) ↔ Normal F E 
goal: Normal F ↥(IntermediateField.restrictScalars F E) ↔ Normal F ↥E

full_name: AlgHom.restrictNormalAux
code: /-- Restrict algebra homomorphism to image of normal subfield -/
def AlgHom.restrictNormalAux [h : Normal F E] :
    (toAlgHom F E K₁).range →ₐ[F] (toAlgHom F E K₂).range 
goal: ↥(IsScalarTower.toAlgHom F E K₁).range →ₐ[F] ↥(IsScalarTower.toAlgHom F E K₂).range

full_name: AlgHom.restrictNormal
code: /-- Restrict algebra homomorphism to normal subfield -/
def AlgHom.restrictNormal [Normal F E] : E →ₐ[F] E 
goal: E →ₐ[F] E

full_name: AlgHom.restrictNormal'
code: /-- Restrict algebra homomorphism to normal subfield (`AlgEquiv` version) -/
def AlgHom.restrictNormal' [Normal F E] : E ≃ₐ[F] E 
goal: E ≃ₐ[F] E

full_name: AlgHom.restrictNormal_commutes
code: @[simp]
theorem AlgHom.restrictNormal_commutes [Normal F E] (x : E) :
    algebraMap E K₂ (ϕ.restrictNormal E x) = ϕ (algebraMap E K₁ x) 
goal: (algebraMap E K₂) ((ϕ.restrictNormal E) x) = ϕ ((algebraMap E K₁) x)

full_name: AlgHom.restrictNormal_comp
code: theorem AlgHom.restrictNormal_comp [Normal F E] :
    (ψ.restrictNormal E).comp (ϕ.restrictNormal E) = (ψ.comp ϕ).restrictNormal E 
goal: (ψ.restrictNormal E).comp (ϕ.restrictNormal E) = (ψ.comp ϕ).restrictNormal E

full_name: AlgHom.fieldRange_of_normal
code: theorem AlgHom.fieldRange_of_normal [Algebra F K] {E : IntermediateField F K} [Normal F E]
    (f : E →ₐ[F] K) : f.fieldRange = E 
goal: f.fieldRange = E

full_name: AlgEquiv.restrictNormal
code: /-- Restrict algebra isomorphism to a normal subfield -/
def AlgEquiv.restrictNormal [Normal F E] : E ≃ₐ[F] E 
goal: E ≃ₐ[F] E

full_name: AlgEquiv.restrictNormal_commutes
code: @[simp]
theorem AlgEquiv.restrictNormal_commutes [Normal F E] (x : E) :
    algebraMap E K₂ (χ.restrictNormal E x) = χ (algebraMap E K₁ x) 
goal: (algebraMap E K₂) ((χ.restrictNormal E) x) = χ ((algebraMap E K₁) x)

full_name: AlgEquiv.restrictNormal_trans
code: theorem AlgEquiv.restrictNormal_trans [Normal F E] :
    (χ.trans ω).restrictNormal E = (χ.restrictNormal E).trans (ω.restrictNormal E) 
goal: (χ.trans ω).restrictNormal E = (χ.restrictNormal E).trans (ω.restrictNormal E)

full_name: AlgEquiv.restrictNormalHom
code: /-- Restriction to a normal subfield as a group homomorphism -/
def AlgEquiv.restrictNormalHom [Normal F E] : (K₁ ≃ₐ[F] K₁) →* E ≃ₐ[F] E 
goal: (K₁ ≃ₐ[F] K₁) →* E ≃ₐ[F] E

full_name: Normal.algHomEquivAut_symm_apply
code: /-- If `K₁/E/F` is a tower of fields with `E/F` normal then `AlgHom.restrictNormal'` is an
 equivalence. -/
@[simps]
def Normal.algHomEquivAut [Normal F E] : (E →ₐ[F] K₁) ≃ E ≃ₐ[F] E 
goal: (Normal.algHomEquivAut F K₁ E).symm σ = (IsScalarTower.toAlgHom F E K₁).comp ↑σ

full_name: Normal.algHomEquivAut_apply
code: /-- If `K₁/E/F` is a tower of fields with `E/F` normal then `AlgHom.restrictNormal'` is an
 equivalence. -/
@[simps]
def Normal.algHomEquivAut [Normal F E] : (E →ₐ[F] K₁) ≃ E ≃ₐ[F] E 
goal: (Normal.algHomEquivAut F K₁ E) σ = σ.restrictNormal' E

full_name: Normal.algHomEquivAut
code: /-- If `K₁/E/F` is a tower of fields with `E/F` normal then `AlgHom.restrictNormal'` is an
 equivalence. -/
@[simps]
def Normal.algHomEquivAut [Normal F E] : (E →ₐ[F] K₁) ≃ E ≃ₐ[F] E 
goal: (E →ₐ[F] K₁) ≃ E ≃ₐ[F] E

full_name: AlgHom.liftNormal
code: /-- If `E/Kᵢ/F` are towers of fields with `E/F` normal then we can lift
  an algebra homomorphism `ϕ : K₁ →ₐ[F] K₂` to `ϕ.liftNormal E : E →ₐ[F] E`. -/
noncomputable def AlgHom.liftNormal [h : Normal F E] : E →ₐ[F] E 
goal: E →ₐ[F] E

full_name: AlgHom.liftNormal_commutes
code: @[simp]
theorem AlgHom.liftNormal_commutes [Normal F E] (x : K₁) :
    ϕ.liftNormal E (algebraMap K₁ E x) = algebraMap K₂ E (ϕ x) 
goal: (ϕ.liftNormal E) ((algebraMap K₁ E) x) = (algebraMap K₂ E) (ϕ x)

full_name: AlgHom.restrict_liftNormal
code: @[simp]
theorem AlgHom.restrict_liftNormal (ϕ : K₁ →ₐ[F] K₁) [Normal F K₁] [Normal F E] :
    (ϕ.liftNormal E).restrictNormal K₁ = ϕ 
goal: (ϕ.liftNormal E).restrictNormal K₁ = ϕ

full_name: AlgEquiv.liftNormal
code: /-- If `E/Kᵢ/F` are towers of fields with `E/F` normal then we can lift
  an algebra isomorphism `ϕ : K₁ ≃ₐ[F] K₂` to `ϕ.liftNormal E : E ≃ₐ[F] E`. -/
noncomputable def AlgEquiv.liftNormal [Normal F E] : E ≃ₐ[F] E 
goal: E ≃ₐ[F] E

full_name: AlgEquiv.liftNormal_commutes
code: @[simp]
theorem AlgEquiv.liftNormal_commutes [Normal F E] (x : K₁) :
    χ.liftNormal E (algebraMap K₁ E x) = algebraMap K₂ E (χ x) 
goal: (χ.liftNormal E) ((algebraMap K₁ E) x) = (algebraMap K₂ E) (χ x)

full_name: AlgEquiv.restrict_liftNormal
code: @[simp]
theorem AlgEquiv.restrict_liftNormal (χ : K₁ ≃ₐ[F] K₁) [Normal F K₁] [Normal F E] :
    (χ.liftNormal E).restrictNormal K₁ = χ 
goal: (χ.liftNormal E).restrictNormal K₁ = χ

full_name: AlgEquiv.restrictNormalHom_surjective
code: theorem AlgEquiv.restrictNormalHom_surjective [Normal F K₁] [Normal F E] :
    Function.Surjective (AlgEquiv.restrictNormalHom K₁ : (E ≃ₐ[F] E) → K₁ ≃ₐ[F] K₁) 
goal: Function.Surjective ⇑(AlgEquiv.restrictNormalHom K₁)

full_name: Normal.minpoly_eq_iff_mem_orbit
code: theorem Normal.minpoly_eq_iff_mem_orbit [h : Normal F E] {x y : E} :
    minpoly F x = minpoly F y ↔ x ∈ MulAction.orbit (E ≃ₐ[F] E) y 
goal: minpoly F x = minpoly F y ↔ x ∈ MulAction.orbit (E ≃ₐ[F] E) y

full_name: isSolvable_of_isScalarTower
code: theorem isSolvable_of_isScalarTower [Normal F K₁] [h1 : IsSolvable (K₁ ≃ₐ[F] K₁)]
    [h2 : IsSolvable (E ≃ₐ[K₁] E)] : IsSolvable (E ≃ₐ[F] E) 
goal: IsSolvable (E ≃ₐ[F] E)

full_name: minpoly.exists_algEquiv_of_root
code: /-- If `x : L` is a root of `minpoly K y`, then we can find `(σ : L ≃ₐ[K] L)` with `σ x = y`.
  That is, `x` and `y` are Galois conjugates. -/
theorem exists_algEquiv_of_root [Normal K L] {x y : L} (hy : IsAlgebraic K y)
    (h_ev : (Polynomial.aeval x) (minpoly K y) = 0) : ∃ σ : L ≃ₐ[K] L, σ x = y 
goal: ∃ σ, σ x = y

full_name: minpoly.exists_algEquiv_of_root'
code: /-- If `x : L` is a root of `minpoly K y`, then we can find `(σ : L ≃ₐ[K] L)` with `σ y = x`.
  That is, `x` and `y` are Galois conjugates. -/
theorem exists_algEquiv_of_root' [Normal K L]{x y : L} (hy : IsAlgebraic K y)
    (h_ev : (Polynomial.aeval x) (minpoly K y) = 0) : ∃ σ : L ≃ₐ[K] L, σ y = x 
goal: ∃ σ, σ y = x