File: Mathlib/FieldTheory/SeparableClosure.lean

full_name: separableClosure
code: /-- The (relative) separable closure of `F` in `E`, or called maximal separable subextension
of `E / F`, is defined to be the intermediate field of `E / F` consisting of all separable
elements. The previous results prove that these elements are closed under field operations. -/
def separableClosure : IntermediateField F E 
goal: IntermediateField F E

full_name: mem_separableClosure_iff
code: /-- An element is contained in the separable closure of `F` in `E` if and only if
it is a separable element. -/
theorem mem_separableClosure_iff {x : E} :
    x ∈ separableClosure F E ↔ IsSeparable F x 
goal: x ∈ separableClosure F E ↔ IsSeparable F x

full_name: map_mem_separableClosure_iff
code: /-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`separableClosure F K` if and only if `x` is contained in `separableClosure F E`. -/
theorem map_mem_separableClosure_iff (i : E →ₐ[F] K) {x : E} :
    i x ∈ separableClosure F K ↔ x ∈ separableClosure F E 
goal: i x ∈ separableClosure F K ↔ x ∈ separableClosure F E

full_name: separableClosure.comap_eq_of_algHom
code: /-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then the preimage of
`separableClosure F K` under the map `i` is equal to `separableClosure F E`. -/
theorem separableClosure.comap_eq_of_algHom (i : E →ₐ[F] K) :
    (separableClosure F K).comap i = separableClosure F E 
goal: IntermediateField.comap i (separableClosure F K) = separableClosure F E

full_name: separableClosure.map_le_of_algHom
code: /-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then the image of `separableClosure F E`
under the map `i` is contained in `separableClosure F K`. -/
theorem separableClosure.map_le_of_algHom (i : E →ₐ[F] K) :
    (separableClosure F E).map i ≤ separableClosure F K 
goal: IntermediateField.map i (separableClosure F E) ≤ separableClosure F K

full_name: separableClosure.map_eq_of_separableClosure_eq_bot
code: /-- If `K / E / F` is a field extension tower, such that `K / E` has no non-trivial separable
subextensions (when `K / E` is algebraic, this means that it is purely inseparable),
then the image of `separableClosure F E` in `K` is equal to `separableClosure F K`. -/
theorem separableClosure.map_eq_of_separableClosure_eq_bot [Algebra E K] [IsScalarTower F E K]
    (h : separableClosure E K = ⊥) :
    (separableClosure F E).map (IsScalarTower.toAlgHom F E K) = separableClosure F K 
goal: IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E) = separableClosure F K

full_name: separableClosure.map_eq_of_algEquiv
code: /-- If `i` is an `F`-algebra isomorphism of `E` and `K`, then the image of `separableClosure F E`
under the map `i` is equal to `separableClosure F K`. -/
theorem separableClosure.map_eq_of_algEquiv (i : E ≃ₐ[F] K) :
    (separableClosure F E).map i = separableClosure F K 
goal: IntermediateField.map (↑i) (separableClosure F E) = separableClosure F K

full_name: separableClosure.algEquivOfAlgEquiv
code: /-- If `E` and `K` are isomorphic as `F`-algebras, then `separableClosure F E` and
`separableClosure F K` are also isomorphic as `F`-algebras. -/
def separableClosure.algEquivOfAlgEquiv (i : E ≃ₐ[F] K) :
    separableClosure F E ≃ₐ[F] separableClosure F K 
goal: ↥(separableClosure F E) ≃ₐ[F] ↥(separableClosure F K)

full_name: separableClosure.isAlgebraic
code: /-- The separable closure of `F` in `E` is algebraic over `F`. -/
instance separableClosure.isAlgebraic : Algebra.IsAlgebraic F (separableClosure F E) 
goal: Algebra.IsAlgebraic F ↥(separableClosure F E)

full_name: separableClosure.isSeparable
code: /-- The separable closure of `F` in `E` is separable over `F`. -/
instance separableClosure.isSeparable : Algebra.IsSeparable F (separableClosure F E) 
goal: Algebra.IsSeparable F ↥(separableClosure F E)

full_name: le_separableClosure'
code: /-- An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if all of its elements are separable over `F`. -/
theorem le_separableClosure' {L : IntermediateField F E} (hs : ∀ x : L, IsSeparable F x) :
    L ≤ separableClosure F E 
goal: L ≤ separableClosure F E

full_name: le_separableClosure
code: /-- An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if it is separable over `F`. -/
theorem le_separableClosure (L : IntermediateField F E) [Algebra.IsSeparable F L] :
    L ≤ separableClosure F E 
goal: L ≤ separableClosure F E

full_name: le_separableClosure_iff
code: /-- An intermediate field of `E / F` is contained in the separable closure of `F` in `E`
if and only if it is separable over `F`. -/
theorem le_separableClosure_iff (L : IntermediateField F E) :
    L ≤ separableClosure F E ↔ Algebra.IsSeparable F L 
goal: L ≤ separableClosure F E ↔ Algebra.IsSeparable F ↥L

full_name: separableClosure.separableClosure_eq_bot
code: /-- The separable closure in `E` of the separable closure of `F` in `E` is equal to itself. -/
theorem separableClosure.separableClosure_eq_bot :
    separableClosure (separableClosure F E) E = ⊥ 
goal: separableClosure (↥(separableClosure F E)) E = ⊥

full_name: separableClosure.normalClosure_eq_self
code: /-- The normal closure in `E/F` of the separable closure of `F` in `E` is equal to itself. -/
theorem separableClosure.normalClosure_eq_self :
    normalClosure F (separableClosure F E) E = separableClosure F E 
goal: normalClosure F (↥(separableClosure F E)) E = separableClosure F E

full_name: separableClosure.isGalois
code: /-- If `E` is normal over `F`, then the separable closure of `F` in `E` is Galois (i.e.
normal and separable) over `F`. -/
instance separableClosure.isGalois [Normal F E] : IsGalois F (separableClosure F E) 
goal: IsGalois F ↥(separableClosure F E)

full_name: IsSepClosed.separableClosure_eq_bot_iff
code: /-- If `E / F` is a field extension and `E` is separably closed, then the separable closure
of `F` in `E` is equal to `F` if and only if `F` is separably closed. -/
theorem IsSepClosed.separableClosure_eq_bot_iff [IsSepClosed E] :
    separableClosure F E = ⊥ ↔ IsSepClosed F 
goal: separableClosure F E = ⊥ ↔ IsSepClosed F

full_name: separableClosure.isSepClosure
code: /-- If `E` is separably closed, then the separable closure of `F` in `E` is an absolute
separable closure of `F`. -/
instance separableClosure.isSepClosure [IsSepClosed E] : IsSepClosure F (separableClosure F E) 
goal: IsSepClosure F ↥(separableClosure F E)

full_name: SeparableClosure
code: /-- The absolute separable closure is defined to be the relative separable closure inside the
algebraic closure. It is indeed a separable closure (`IsSepClosure`) by
`separableClosure.isSepClosure`, and it is Galois (`IsGalois`) by `separableClosure.isGalois`
or `IsSepClosure.isGalois`, and every separable extension embeds into it (`IsSepClosed.lift`). -/
abbrev SeparableClosure : Type _ 
goal: Type u

full_name: IntermediateField.isSeparable_adjoin_iff_isSeparable
code: /-- `F(S) / F` is a separable extension if and only if all elements of `S` are
separable elements. -/
theorem IntermediateField.isSeparable_adjoin_iff_isSeparable {S : Set E} :
    Algebra.IsSeparable F (adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x 
goal: Algebra.IsSeparable F ↥(IntermediateField.adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x

full_name: separableClosure.eq_top_iff
code: /-- The separable closure of `F` in `E` is equal to `E` if and only if `E / F` is
separable. -/
theorem separableClosure.eq_top_iff : separableClosure F E = ⊤ ↔ Algebra.IsSeparable F E 
goal: separableClosure F E = ⊤ ↔ Algebra.IsSeparable F E

full_name: separableClosure.le_restrictScalars
code: /-- If `K / E / F` is a field extension tower, then `separableClosure F K` is contained in
`separableClosure E K`. -/
theorem separableClosure.le_restrictScalars [Algebra E K] [IsScalarTower F E K] :
    separableClosure F K ≤ (separableClosure E K).restrictScalars F 
goal: separableClosure F K ≤ IntermediateField.restrictScalars F (separableClosure E K)

full_name: separableClosure.eq_restrictScalars_of_isSeparable
code: /-- If `K / E / F` is a field extension tower, such that `E / F` is separable, then
`separableClosure F K` is equal to `separableClosure E K`. -/
theorem separableClosure.eq_restrictScalars_of_isSeparable [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] : separableClosure F K = (separableClosure E K).restrictScalars F 
goal: separableClosure F K = IntermediateField.restrictScalars F (separableClosure E K)

full_name: separableClosure.adjoin_le
code: /-- If `K / E / F` is a field extension tower, then `E` adjoin `separableClosure F K` is contained
in `separableClosure E K`. -/
theorem separableClosure.adjoin_le [Algebra E K] [IsScalarTower F E K] :
    adjoin E (separableClosure F K) ≤ separableClosure E K 
goal: IntermediateField.adjoin E ↑(separableClosure F K) ≤ separableClosure E K

full_name: IntermediateField.isSeparable_sup
code: /-- A compositum of two separable extensions is separable. -/
instance IntermediateField.isSeparable_sup (L1 L2 : IntermediateField F E)
    [h1 : Algebra.IsSeparable F L1] [h2 : Algebra.IsSeparable F L2] :
    Algebra.IsSeparable F (L1 ⊔ L2 : IntermediateField F E) 
goal: Algebra.IsSeparable F ↥(L1 ⊔ L2)

full_name: IntermediateField.isSeparable_iSup
code: /-- A compositum of separable extensions is separable. -/
instance IntermediateField.isSeparable_iSup {ι : Type*} {t : ι → IntermediateField F E}
    [h : ∀ i, Algebra.IsSeparable F (t i)] :
    Algebra.IsSeparable F (⨆ i, t i : IntermediateField F E) 
goal: Algebra.IsSeparable F ↥(⨆ i, t i)

full_name: Field.sepDegree
code: /-- The (infinite) separable degree for a general field extension `E / F` is defined
to be the degree of `separableClosure F E / F`. -/
def sepDegree 
goal: Cardinal.{v}

full_name: Field.insepDegree
code: /-- The (infinite) inseparable degree for a general field extension `E / F` is defined
to be the degree of `E / separableClosure F E`. -/
def insepDegree 
goal: Cardinal.{v}

full_name: Field.finInsepDegree
code: /-- The finite inseparable degree for a general field extension `E / F` is defined
to be the degree of `E / separableClosure F E` as a natural number. It is defined to be zero
if such field extension is infinite. -/
def finInsepDegree : ℕ 
goal: ℕ

full_name: Field.finInsepDegree_def'
code: theorem finInsepDegree_def' : finInsepDegree F E = Cardinal.toNat (insepDegree F E) 
goal: Field.finInsepDegree F E = Cardinal.toNat (Field.insepDegree F E)

full_name: Field.instNeZeroSepDegree
code: instance instNeZeroSepDegree : NeZero (sepDegree F E) 
goal: NeZero (Field.sepDegree F E)

full_name: Field.instNeZeroInsepDegree
code: instance instNeZeroInsepDegree : NeZero (insepDegree F E) 
goal: NeZero (Field.insepDegree F E)

full_name: Field.instNeZeroFinInsepDegree
code: instance instNeZeroFinInsepDegree [FiniteDimensional F E] :
    NeZero (finInsepDegree F E) 
goal: NeZero (Field.finInsepDegree F E)

full_name: Field.lift_sepDegree_eq_of_equiv
code: /-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same
separable degree over `F`. -/
theorem lift_sepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    Cardinal.lift.{w} (sepDegree F E) = Cardinal.lift.{v} (sepDegree F K) 
goal: Cardinal.lift.{w, v} (Field.sepDegree F E) = Cardinal.lift.{v, w} (Field.sepDegree F K)

full_name: Field.sepDegree_eq_of_equiv
code: /-- The same-universe version of `Field.lift_sepDegree_eq_of_equiv`. -/
theorem sepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
    sepDegree F E = sepDegree F K 
goal: Field.sepDegree F E = Field.sepDegree F K

full_name: Field.sepDegree_mul_insepDegree
code: /-- The separable degree multiplied by the inseparable degree is equal
to the (infinite) field extension degree. -/
theorem sepDegree_mul_insepDegree : sepDegree F E * insepDegree F E = Module.rank F E 
goal: Field.sepDegree F E * Field.insepDegree F E = Module.rank F E

full_name: Field.lift_insepDegree_eq_of_equiv
code: /-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same
inseparable degree over `F`. -/
theorem lift_insepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    Cardinal.lift.{w} (insepDegree F E) = Cardinal.lift.{v} (insepDegree F K) 
goal: Cardinal.lift.{w, v} (Field.insepDegree F E) = Cardinal.lift.{v, w} (Field.insepDegree F K)

full_name: Field.insepDegree_eq_of_equiv
code: /-- The same-universe version of `Field.lift_insepDegree_eq_of_equiv`. -/
theorem insepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
    insepDegree F E = insepDegree F K 
goal: Field.insepDegree F E = Field.insepDegree F K

full_name: Field.finInsepDegree_eq_of_equiv
code: /-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same finite
inseparable degree over `F`. -/
theorem finInsepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    finInsepDegree F E = finInsepDegree F K 
goal: Field.finInsepDegree F E = Field.finInsepDegree F K

full_name: Field.sepDegree_self
code: @[simp]
theorem sepDegree_self : sepDegree F F = 1 
goal: Field.sepDegree F F = 1

full_name: Field.insepDegree_self
code: @[simp]
theorem insepDegree_self : insepDegree F F = 1 
goal: Field.insepDegree F F = 1

full_name: Field.finInsepDegree_self
code: @[simp]
theorem finInsepDegree_self : finInsepDegree F F = 1 
goal: Field.finInsepDegree F F = 1

full_name: IntermediateField.sepDegree_bot
code: @[simp]
theorem sepDegree_bot : sepDegree F (⊥ : IntermediateField F E) = 1 
goal: Field.sepDegree F ↥⊥ = 1

full_name: IntermediateField.insepDegree_bot
code: @[simp]
theorem insepDegree_bot : insepDegree F (⊥ : IntermediateField F E) = 1 
goal: Field.insepDegree F ↥⊥ = 1

full_name: IntermediateField.finInsepDegree_bot
code: @[simp]
theorem finInsepDegree_bot : finInsepDegree F (⊥ : IntermediateField F E) = 1 
goal: Field.finInsepDegree F ↥⊥ = 1

full_name: IntermediateField.lift_sepDegree_bot'
code: theorem lift_sepDegree_bot' : Cardinal.lift.{v} (sepDegree F (⊥ : IntermediateField E K)) =
    Cardinal.lift.{w} (sepDegree F E) 
goal: Cardinal.lift.{v, w} (Field.sepDegree F ↥⊥) = Cardinal.lift.{w, v} (Field.sepDegree F E)

full_name: IntermediateField.lift_insepDegree_bot'
code: theorem lift_insepDegree_bot' : Cardinal.lift.{v} (insepDegree F (⊥ : IntermediateField E K)) =
    Cardinal.lift.{w} (insepDegree F E) 
goal: Cardinal.lift.{v, w} (Field.insepDegree F ↥⊥) = Cardinal.lift.{w, v} (Field.insepDegree F E)

full_name: IntermediateField.finInsepDegree_bot'
code: @[simp]
theorem finInsepDegree_bot' :
    finInsepDegree F (⊥ : IntermediateField E K) = finInsepDegree F E 
goal: Field.finInsepDegree F ↥⊥ = Field.finInsepDegree F E

full_name: IntermediateField.sepDegree_top
code: @[simp]
theorem sepDegree_top : sepDegree F (⊤ : IntermediateField E K) = sepDegree F K 
goal: Field.sepDegree F ↥⊤ = Field.sepDegree F K

full_name: IntermediateField.insepDegree_top
code: @[simp]
theorem insepDegree_top : insepDegree F (⊤ : IntermediateField E K) = insepDegree F K 
goal: Field.insepDegree F ↥⊤ = Field.insepDegree F K

full_name: IntermediateField.finInsepDegree_top
code: @[simp]
theorem finInsepDegree_top : finInsepDegree F (⊤ : IntermediateField E K) = finInsepDegree F K 
goal: Field.finInsepDegree F ↥⊤ = Field.finInsepDegree F K

full_name: IntermediateField.sepDegree_bot'
code: @[simp]
theorem sepDegree_bot' : sepDegree F (⊥ : IntermediateField E K) = sepDegree F E 
goal: Field.sepDegree F ↥⊥ = Field.sepDegree F E

full_name: IntermediateField.insepDegree_bot'
code: @[simp]
theorem insepDegree_bot' : insepDegree F (⊥ : IntermediateField E K) = insepDegree F E 
goal: Field.insepDegree F ↥⊥ = Field.insepDegree F E

full_name: Algebra.IsSeparable.sepDegree_eq
code: /-- A separable extension has separable degree equal to degree. -/
theorem Algebra.IsSeparable.sepDegree_eq [Algebra.IsSeparable F E] :
    sepDegree F E = Module.rank F E 
goal: Field.sepDegree F E = Module.rank F E

full_name: Algebra.IsSeparable.insepDegree_eq
code: /-- A separable extension has inseparable degree one. -/
theorem Algebra.IsSeparable.insepDegree_eq [Algebra.IsSeparable F E] : insepDegree F E = 1 
goal: Field.insepDegree F E = 1

full_name: Algebra.IsSeparable.finInsepDegree_eq
code: /-- A separable extension has finite inseparable degree one. -/
theorem Algebra.IsSeparable.finInsepDegree_eq [Algebra.IsSeparable F E] : finInsepDegree F E = 1 
goal: Field.finInsepDegree F E = 1