File: Mathlib/FieldTheory/SeparableDegree.lean

full_name: Field.Emb
code: /-- `Field.Emb F E` is the type of `F`-algebra homomorphisms from `E` to the algebraic closure
of `E`. -/
def Emb 
goal: Type v

full_name: Field.finSepDegree
code: /-- If `E / F` is an algebraic extension, then the (finite) separable degree of `E / F`
is the number of `F`-algebra homomorphisms from `E` to the algebraic closure of `E`,
as a natural number. It is defined to be zero if there are infinitely many of them.
Note that if `E / F` is not algebraic, then this definition makes no mathematical sense. -/
def finSepDegree : ℕ 
goal: ℕ

full_name: Field.instInhabitedEmb
code: instance instInhabitedEmb : Inhabited (Emb F E) 
goal: Inhabited (Field.Emb F E)

full_name: Field.instNeZeroFinSepDegree
code: instance instNeZeroFinSepDegree [FiniteDimensional F E] : NeZero (finSepDegree F E) 
goal: NeZero (Field.finSepDegree F E)

full_name: Field.embEquivOfEquiv
code: /-- A random bijection between `Field.Emb F E` and `Field.Emb F K` when `E` and `K` are isomorphic
as `F`-algebras. -/
def embEquivOfEquiv (i : E ≃ₐ[F] K) :
    Emb F E ≃ Emb F K 
goal: Field.Emb F E ≃ Field.Emb F K

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

full_name: Field.finSepDegree_self
code: @[simp]
theorem finSepDegree_self : finSepDegree F F = 1 
goal: Field.finSepDegree F F = 1

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

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

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

full_name: Field.embEquivOfAdjoinSplits
code: /-- A random bijection between `Field.Emb F E` and `E →ₐ[F] K` if `E = F(S)` such that every
element `s` of `S` is integral (= algebraic) over `F` and whose minimal polynomial splits in `K`.
Combined with `Field.instInhabitedEmb`, it can be viewed as a stronger version of
`IntermediateField.nonempty_algHom_of_adjoin_splits`. -/
def embEquivOfAdjoinSplits {S : Set E} (hS : adjoin F S = ⊤)
    (hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)) :
    Emb F E ≃ (E →ₐ[F] K) 
goal: Field.Emb F E ≃ (E →ₐ[F] K)

full_name: Field.finSepDegree_eq_of_adjoin_splits
code: /-- The `Field.finSepDegree F E` is equal to the cardinality of `E →ₐ[F] K`
if `E = F(S)` such that every element
`s` of `S` is integral (= algebraic) over `F` and whose minimal polynomial splits in `K`. -/
theorem finSepDegree_eq_of_adjoin_splits {S : Set E} (hS : adjoin F S = ⊤)
    (hK : ∀ s ∈ S, IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)) :
    finSepDegree F E = Nat.card (E →ₐ[F] K) 
goal: Field.finSepDegree F E = Nat.card (E →ₐ[F] K)

full_name: Field.embEquivOfIsAlgClosed
code: /-- A random bijection between `Field.Emb F E` and `E →ₐ[F] K` when `E / F` is algebraic
and `K / F` is algebraically closed. -/
def embEquivOfIsAlgClosed [Algebra.IsAlgebraic F E] [IsAlgClosed K] :
    Emb F E ≃ (E →ₐ[F] K) 
goal: Field.Emb F E ≃ (E →ₐ[F] K)

full_name: Field.finSepDegree_eq_of_isAlgClosed
code: /-- The `Field.finSepDegree F E` is equal to the cardinality of `E →ₐ[F] K` as a natural number,
when `E / F` is algebraic and `K / F` is algebraically closed. -/
theorem finSepDegree_eq_of_isAlgClosed [Algebra.IsAlgebraic F E] [IsAlgClosed K] :
    finSepDegree F E = Nat.card (E →ₐ[F] K) 
goal: Field.finSepDegree F E = Nat.card (E →ₐ[F] K)

full_name: Field.embProdEmbOfIsAlgebraic
code: /-- If `K / E / F` is a field extension tower, such that `K / E` is algebraic,
then there is a non-canonical bijection
`Field.Emb F E × Field.Emb E K ≃ Field.Emb F K`. A corollary of `algHomEquivSigma`. -/
def embProdEmbOfIsAlgebraic [Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic E K] :
    Emb F E × Emb E K ≃ Emb F K 
goal: Field.Emb F E × Field.Emb E K ≃ Field.Emb F K

full_name: Field.finSepDegree_mul_finSepDegree_of_isAlgebraic
code: /-- If `K / E / F` is a field extension tower, such that `K / E` is algebraic, then their
separable degrees satisfy the tower law
$[E:F]_s [K:E]_s = [K:F]_s$. See also `FiniteDimensional.finrank_mul_finrank`. -/
theorem finSepDegree_mul_finSepDegree_of_isAlgebraic
    [Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic E K] :
    finSepDegree F E * finSepDegree E K = finSepDegree F K 
goal: Field.finSepDegree F E * Field.finSepDegree E K = Field.finSepDegree F K

full_name: Polynomial.natSepDegree
code: /-- The separable degree `Polynomial.natSepDegree` of a polynomial is a natural number,
defined to be the number of distinct roots of it over its splitting field.
This is similar to `Polynomial.natDegree` but not to `Polynomial.degree`, namely, the separable
degree of `0` is `0`, not negative infinity. -/
def natSepDegree : ℕ 
goal: ℕ

full_name: Polynomial.natSepDegree_le_natDegree
code: /-- The separable degree of a polynomial is smaller than its degree. -/
theorem natSepDegree_le_natDegree : f.natSepDegree ≤ f.natDegree 
goal: f.natSepDegree ≤ f.natDegree

full_name: Polynomial.natSepDegree_X_sub_C
code: @[simp]
theorem natSepDegree_X_sub_C (x : F) : (X - C x).natSepDegree = 1 
goal: (Polynomial.X - Polynomial.C x).natSepDegree = 1

full_name: Polynomial.natSepDegree_X
code: @[simp]
theorem natSepDegree_X : (X : F[X]).natSepDegree = 1 
goal: Polynomial.X.natSepDegree = 1

full_name: Polynomial.natSepDegree_eq_zero
code: /-- A constant polynomial has zero separable degree. -/
theorem natSepDegree_eq_zero (h : f.natDegree = 0) : f.natSepDegree = 0 
goal: f.natSepDegree = 0

full_name: Polynomial.natSepDegree_C
code: @[simp]
theorem natSepDegree_C (x : F) : (C x).natSepDegree = 0 
goal: (Polynomial.C x).natSepDegree = 0

full_name: Polynomial.natSepDegree_zero
code: @[simp]
theorem natSepDegree_zero : (0 : F[X]).natSepDegree = 0 
goal: Polynomial.natSepDegree 0 = 0

full_name: Polynomial.natSepDegree_one
code: @[simp]
theorem natSepDegree_one : (1 : F[X]).natSepDegree = 0 
goal: Polynomial.natSepDegree 1 = 0

full_name: Polynomial.natSepDegree_ne_zero
code: /-- A non-constant polynomial has non-zero separable degree. -/
theorem natSepDegree_ne_zero (h : f.natDegree ≠ 0) : f.natSepDegree ≠ 0 
goal: f.natSepDegree ≠ 0

full_name: Polynomial.natSepDegree_eq_zero_iff
code: /-- A polynomial has zero separable degree if and only if it is constant. -/
theorem natSepDegree_eq_zero_iff : f.natSepDegree = 0 ↔ f.natDegree = 0 
goal: f.natSepDegree = 0 ↔ f.natDegree = 0

full_name: Polynomial.natSepDegree_ne_zero_iff
code: /-- A polynomial has non-zero separable degree if and only if it is non-constant. -/
theorem natSepDegree_ne_zero_iff : f.natSepDegree ≠ 0 ↔ f.natDegree ≠ 0 
goal: f.natSepDegree ≠ 0 ↔ f.natDegree ≠ 0

full_name: Polynomial.natSepDegree_eq_natDegree_iff
code: /-- The separable degree of a non-zero polynomial is equal to its degree if and only if
it is separable. -/
theorem natSepDegree_eq_natDegree_iff (hf : f ≠ 0) :
    f.natSepDegree = f.natDegree ↔ f.Separable 
goal: f.natSepDegree = f.natDegree ↔ f.Separable

full_name: Polynomial.natSepDegree_eq_natDegree_of_separable
code: /-- If a polynomial is separable, then its separable degree is equal to its degree. -/
theorem natSepDegree_eq_natDegree_of_separable (h : f.Separable) :
    f.natSepDegree = f.natDegree 
goal: f.natSepDegree = f.natDegree

full_name: Polynomial.Separable.natSepDegree_eq_natDegree
code: /-- Same as `Polynomial.natSepDegree_eq_natDegree_of_separable`, but enables the use of
dot notation. -/
theorem Separable.natSepDegree_eq_natDegree (h : f.Separable) :
    f.natSepDegree = f.natDegree 
goal: f.natSepDegree = f.natDegree

full_name: Polynomial.natSepDegree_eq_of_splits
code: /-- If a polynomial splits over `E`, then its separable degree is equal to
the number of distinct roots of it over `E`. -/
theorem natSepDegree_eq_of_splits (h : f.Splits (algebraMap F E)) :
    f.natSepDegree = (f.aroots E).toFinset.card 
goal: f.natSepDegree = (f.aroots E).toFinset.card

full_name: Polynomial.natSepDegree_eq_of_isAlgClosed
code: /-- The separable degree of a polynomial is equal to
the number of distinct roots of it over any algebraically closed field. -/
theorem natSepDegree_eq_of_isAlgClosed [IsAlgClosed E] :
    f.natSepDegree = (f.aroots E).toFinset.card 
goal: f.natSepDegree = (f.aroots E).toFinset.card

full_name: Polynomial.natSepDegree_map
code: theorem natSepDegree_map : (f.map (algebraMap F E)).natSepDegree = f.natSepDegree 
goal: (Polynomial.map (algebraMap F E) f).natSepDegree = f.natSepDegree

full_name: Polynomial.natSepDegree_C_mul
code: @[simp]
theorem natSepDegree_C_mul {x : F} (hx : x ≠ 0) :
    (C x * f).natSepDegree = f.natSepDegree 
goal: (Polynomial.C x * f).natSepDegree = f.natSepDegree

full_name: Polynomial.natSepDegree_smul_nonzero
code: @[simp]
theorem natSepDegree_smul_nonzero {x : F} (hx : x ≠ 0) :
    (x • f).natSepDegree = f.natSepDegree 
goal: (x • f).natSepDegree = f.natSepDegree

full_name: Polynomial.natSepDegree_pow
code: @[simp]
theorem natSepDegree_pow {n : ℕ} : (f ^ n).natSepDegree = if n = 0 then 0 else f.natSepDegree 
goal: (f ^ n).natSepDegree = if n = 0 then 0 else f.natSepDegree

full_name: Polynomial.natSepDegree_pow_of_ne_zero
code: theorem natSepDegree_pow_of_ne_zero {n : ℕ} (hn : n ≠ 0) :
    (f ^ n).natSepDegree = f.natSepDegree 
goal: (f ^ n).natSepDegree = f.natSepDegree

full_name: Polynomial.natSepDegree_X_pow
code: theorem natSepDegree_X_pow {n : ℕ} : (X ^ n : F[X]).natSepDegree = if n = 0 then 0 else 1 
goal: (Polynomial.X ^ n).natSepDegree = if n = 0 then 0 else 1

full_name: Polynomial.natSepDegree_X_sub_C_pow
code: theorem natSepDegree_X_sub_C_pow {x : F} {n : ℕ} :
    ((X - C x) ^ n).natSepDegree = if n = 0 then 0 else 1 
goal: ((Polynomial.X - Polynomial.C x) ^ n).natSepDegree = if n = 0 then 0 else 1

full_name: Polynomial.natSepDegree_C_mul_X_sub_C_pow
code: theorem natSepDegree_C_mul_X_sub_C_pow {x y : F} {n : ℕ} (hx : x ≠ 0) :
    (C x * (X - C y) ^ n).natSepDegree = if n = 0 then 0 else 1 
goal: (Polynomial.C x * (Polynomial.X - Polynomial.C y) ^ n).natSepDegree = if n = 0 then 0 else 1

full_name: Polynomial.natSepDegree_mul
code: theorem natSepDegree_mul (g : F[X]) :
    (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree 
goal: (f * g).natSepDegree ≤ f.natSepDegree + g.natSepDegree

full_name: Polynomial.natSepDegree_mul_eq_iff
code: theorem natSepDegree_mul_eq_iff (g : F[X]) :
    (f * g).natSepDegree = f.natSepDegree + g.natSepDegree ↔ (f = 0 ∧ g = 0) ∨ IsCoprime f g 
goal: (f * g).natSepDegree = f.natSepDegree + g.natSepDegree ↔ f = 0 ∧ g = 0 ∨ IsCoprime f g

full_name: Polynomial.natSepDegree_mul_of_isCoprime
code: theorem natSepDegree_mul_of_isCoprime (g : F[X]) (hc : IsCoprime f g) :
    (f * g).natSepDegree = f.natSepDegree + g.natSepDegree 
goal: (f * g).natSepDegree = f.natSepDegree + g.natSepDegree

full_name: Polynomial.natSepDegree_le_of_dvd
code: theorem natSepDegree_le_of_dvd (g : F[X]) (h1 : f ∣ g) (h2 : g ≠ 0) :
    f.natSepDegree ≤ g.natSepDegree 
goal: f.natSepDegree ≤ g.natSepDegree

full_name: Polynomial.natSepDegree_expand
code: /-- If a field `F` is of exponential characteristic `q`, then `Polynomial.expand F (q ^ n) f`
and `f` have the same separable degree. -/
theorem natSepDegree_expand (q : ℕ) [hF : ExpChar F q] {n : ℕ} :
    (expand F (q ^ n) f).natSepDegree = f.natSepDegree 
goal: ((Polynomial.expand F (q ^ n)) f).natSepDegree = f.natSepDegree

full_name: Polynomial.natSepDegree_X_pow_char_pow_sub_C
code: theorem natSepDegree_X_pow_char_pow_sub_C (q : ℕ) [ExpChar F q] (n : ℕ) (y : F) :
    (X ^ q ^ n - C y).natSepDegree = 1 
goal: (Polynomial.X ^ q ^ n - Polynomial.C y).natSepDegree = 1

full_name: Polynomial.IsSeparableContraction.natSepDegree_eq
code: /-- If `g` is a separable contraction of `f`, then the separable degree of `f` is equal to
the degree of `g`. -/
theorem IsSeparableContraction.natSepDegree_eq {g : Polynomial F} {q : ℕ} [ExpChar F q]
    (h : IsSeparableContraction q f g) : f.natSepDegree = g.natDegree 
goal: f.natSepDegree = g.natDegree

full_name: Polynomial.HasSeparableContraction.natSepDegree_eq
code: /-- If a polynomial has separable contraction, then its separable degree is equal to the degree of
the given separable contraction. -/
theorem HasSeparableContraction.natSepDegree_eq
    {q : ℕ} [ExpChar F q] (hf : f.HasSeparableContraction q) :
    f.natSepDegree = hf.degree 
goal: f.natSepDegree = hf.degree

full_name: Irreducible.natSepDegree_dvd_natDegree
code: /-- The separable degree of an irreducible polynomial divides its degree. -/
theorem natSepDegree_dvd_natDegree (h : Irreducible f) :
    f.natSepDegree ∣ f.natDegree 
goal: f.natSepDegree ∣ f.natDegree

full_name: Irreducible.natSepDegree_eq_one_iff_of_monic'
code: /-- A monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one if and only if it is of the form `Polynomial.expand F (q ^ n) (X - C y)`
for some `n : ℕ` and `y : F`. -/
theorem natSepDegree_eq_one_iff_of_monic' (q : ℕ) [ExpChar F q] (hm : f.Monic)
    (hi : Irreducible f) : f.natSepDegree = 1 ↔
    ∃ (n : ℕ) (y : F), f = expand F (q ^ n) (X - C y) 
goal: f.natSepDegree = 1 ↔ ∃ n y, f = (Polynomial.expand F (q ^ n)) (Polynomial.X - Polynomial.C y)

full_name: Irreducible.natSepDegree_eq_one_iff_of_monic
code: /-- A monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one if and only if it is of the form `X ^ (q ^ n) - C y`
for some `n : ℕ` and `y : F`. -/
theorem natSepDegree_eq_one_iff_of_monic (q : ℕ) [ExpChar F q] (hm : f.Monic)
    (hi : Irreducible f) : f.natSepDegree = 1 ↔ ∃ (n : ℕ) (y : F), f = X ^ q ^ n - C y 
goal: f.natSepDegree = 1 ↔ ∃ n y, f = Polynomial.X ^ q ^ n - Polynomial.C y

full_name: Polynomial.Monic.eq_X_sub_C_pow_of_natSepDegree_eq_one_of_splits
code: /-- If a monic polynomial of separable degree one splits, then it is of form `(X - C y) ^ m` for
some non-zero natural number `m` and some element `y` of `F`. -/
theorem eq_X_sub_C_pow_of_natSepDegree_eq_one_of_splits (hm : f.Monic)
    (hs : f.Splits (RingHom.id F))
    (h : f.natSepDegree = 1) : ∃ (m : ℕ) (y : F), m ≠ 0 ∧ f = (X - C y) ^ m 
goal: ∃ m y, m ≠ 0 ∧ f = (Polynomial.X - Polynomial.C y) ^ m

full_name: Polynomial.Monic.eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible
code: /-- If a monic irreducible polynomial over a field `F` of exponential characteristic `q` has
separable degree one, then it is of the form `X ^ (q ^ n) - C y` for some natural number `n`,
and some element `y` of `F`, such that either `n = 0` or `y` has no `q`-th root in `F`. -/
theorem eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible (q : ℕ) [ExpChar F q]
    (hm : f.Monic) (hi : Irreducible f) (h : f.natSepDegree = 1) : ∃ (n : ℕ) (y : F),
      (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = X ^ q ^ n - C y 
goal: ∃ n y, (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = Polynomial.X ^ q ^ n - Polynomial.C y

full_name: Polynomial.Monic.eq_X_pow_char_pow_sub_C_pow_of_natSepDegree_eq_one
code: /-- If a monic polynomial over a field `F` of exponential characteristic `q` has separable degree
one, then it is of the form `(X ^ (q ^ n) - C y) ^ m` for some non-zero natural number `m`,
some natural number `n`, and some element `y` of `F`, such that either `n = 0` or `y` has no
`q`-th root in `F`. -/
theorem eq_X_pow_char_pow_sub_C_pow_of_natSepDegree_eq_one (q : ℕ) [ExpChar F q] (hm : f.Monic)
    (h : f.natSepDegree = 1) : ∃ (m n : ℕ) (y : F),
      m ≠ 0 ∧ (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = (X ^ q ^ n - C y) ^ m 
goal: ∃ m n y, m ≠ 0 ∧ (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = (Polynomial.X ^ q ^ n - Polynomial.C y) ^ m

full_name: Polynomial.Monic.natSepDegree_eq_one_iff
code: /-- A monic polynomial over a field `F` of exponential characteristic `q` has separable degree one
if and only if it is of the form `(X ^ (q ^ n) - C y) ^ m` for some non-zero natural number `m`,
some natural number `n`, and some element `y` of `F`. -/
theorem natSepDegree_eq_one_iff (q : ℕ) [ExpChar F q] (hm : f.Monic) :
    f.natSepDegree = 1 ↔ ∃ (m n : ℕ) (y : F), m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m 
goal: f.natSepDegree = 1 ↔ ∃ m n y, m ≠ 0 ∧ f = (Polynomial.X ^ q ^ n - Polynomial.C y) ^ m

full_name: minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C
code: /-- The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`Polynomial.expand F (q ^ n) (X - C y)` for some `n : ℕ` and `y : F`. -/
theorem natSepDegree_eq_one_iff_eq_expand_X_sub_C : (minpoly F x).natSepDegree = 1 ↔
    ∃ (n : ℕ) (y : F), minpoly F x = expand F (q ^ n) (X - C y) 
goal: (minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = (Polynomial.expand F (q ^ n)) (Polynomial.X - Polynomial.C y)

full_name: minpoly.natSepDegree_eq_one_iff_eq_X_pow_sub_C
code: /-- The minimal polynomial of an element of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`X ^ (q ^ n) - C y` for some `n : ℕ` and `y : F`. -/
theorem natSepDegree_eq_one_iff_eq_X_pow_sub_C : (minpoly F x).natSepDegree = 1 ↔
    ∃ (n : ℕ) (y : F), minpoly F x = X ^ q ^ n - C y 
goal: (minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = Polynomial.X ^ q ^ n - Polynomial.C y

full_name: minpoly.natSepDegree_eq_one_iff_pow_mem
code: /-- The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if `x ^ (q ^ n) ∈ F` for some `n : ℕ`. -/
theorem natSepDegree_eq_one_iff_pow_mem : (minpoly F x).natSepDegree = 1 ↔
    ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range 
goal: (minpoly F x).natSepDegree = 1 ↔ ∃ n, x ^ q ^ n ∈ (algebraMap F E).range

full_name: minpoly.natSepDegree_eq_one_iff_eq_X_sub_C_pow
code: /-- The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`(X - x) ^ (q ^ n)` for some `n : ℕ`. -/
theorem natSepDegree_eq_one_iff_eq_X_sub_C_pow : (minpoly F x).natSepDegree = 1 ↔
    ∃ n : ℕ, (minpoly F x).map (algebraMap F E) = (X - C x) ^ q ^ n 
goal: (minpoly F x).natSepDegree = 1 ↔
  ∃ n, Polynomial.map (algebraMap F E) (minpoly F x) = (Polynomial.X - Polynomial.C x) ^ q ^ n

full_name: IntermediateField.finSepDegree_adjoin_simple_eq_natSepDegree
code: /-- The separable degree of `F⟮α⟯ / F` is equal to the separable degree of the
minimal polynomial of `α` over `F`. -/
theorem finSepDegree_adjoin_simple_eq_natSepDegree {α : E} (halg : IsAlgebraic F α) :
    finSepDegree F F⟮α⟯ = (minpoly F α).natSepDegree 
goal: Field.finSepDegree F ↥F⟮α⟯ = (minpoly F α).natSepDegree

full_name: _private.Mathlib.FieldTheory.SeparableDegree.0.IntermediateField.finSepDegree_adjoin_simple_dvd_finrank
code: private theorem finSepDegree_adjoin_simple_dvd_finrank (α : E) :
    finSepDegree F F⟮α⟯ ∣ finrank F F⟮α⟯ 
goal: Field.finSepDegree F ↥F⟮α⟯ ∣ FiniteDimensional.finrank F ↥F⟮α⟯

full_name: IntermediateField.finSepDegree_adjoin_simple_le_finrank
code: /-- The separable degree of `F⟮α⟯ / F` is smaller than the degree of `F⟮α⟯ / F` if `α` is
algebraic over `F`. -/
theorem finSepDegree_adjoin_simple_le_finrank (α : E) (halg : IsAlgebraic F α) :
    finSepDegree F F⟮α⟯ ≤ finrank F F⟮α⟯ 
goal: Field.finSepDegree F ↥F⟮α⟯ ≤ FiniteDimensional.finrank F ↥F⟮α⟯

full_name: IntermediateField.finSepDegree_adjoin_simple_eq_finrank_iff
code: /-- If `α` is algebraic over `F`, then the separable degree of `F⟮α⟯ / F` is equal to the degree
of `F⟮α⟯ / F` if and only if `α` is a separable element. -/
theorem finSepDegree_adjoin_simple_eq_finrank_iff (α : E) (halg : IsAlgebraic F α) :
    finSepDegree F F⟮α⟯ = finrank F F⟮α⟯ ↔ IsSeparable F α 
goal: Field.finSepDegree F ↥F⟮α⟯ = FiniteDimensional.finrank F ↥F⟮α⟯ ↔ IsSeparable F α

full_name: Field.finSepDegree_dvd_finrank
code: /-- The separable degree of any field extension `E / F` divides the degree of `E / F`. -/
theorem finSepDegree_dvd_finrank : finSepDegree F E ∣ finrank F E 
goal: Field.finSepDegree F E ∣ FiniteDimensional.finrank F E

full_name: Field.finSepDegree_le_finrank
code: /-- The separable degree of a finite extension `E / F` is smaller than the degree of `E / F`. -/
theorem finSepDegree_le_finrank [FiniteDimensional F E] :
    finSepDegree F E ≤ finrank F E 
goal: Field.finSepDegree F E ≤ FiniteDimensional.finrank F E

full_name: Field.finSepDegree_eq_finrank_of_isSeparable
code: /-- If `E / F` is a separable extension, then its separable degree is equal to its degree.
When `E / F` is infinite, it means that `Field.Emb F E` has infinitely many elements.
(But the cardinality of `Field.Emb F E` is not equal to `Module.rank F E` in general!) -/
theorem finSepDegree_eq_finrank_of_isSeparable [Algebra.IsSeparable F E] :
    finSepDegree F E = finrank F E 
goal: Field.finSepDegree F E = FiniteDimensional.finrank F E

full_name: Field.finSepDegree_eq_finrank_iff
code: /-- If `E / F` is a finite extension, then its separable degree is equal to its degree if and
only if it is a separable extension. -/
theorem finSepDegree_eq_finrank_iff [FiniteDimensional F E] :
    finSepDegree F E = finrank F E ↔ Algebra.IsSeparable F E 
goal: Field.finSepDegree F E = FiniteDimensional.finrank F E ↔ Algebra.IsSeparable F E

full_name: IntermediateField.isSeparable_of_mem_isSeparable
code: lemma IntermediateField.isSeparable_of_mem_isSeparable {L : IntermediateField F E}
    [Algebra.IsSeparable F L] {x : E} (h : x ∈ L) : IsSeparable F x 
goal: IsSeparable F x

full_name: IntermediateField.isSeparable_adjoin_simple_iff_isSeparable
code: /-- `F⟮x⟯ / F` is a separable extension if and only if `x` is a separable element.
As a consequence, any rational function of `x` is also a separable element. -/
theorem IntermediateField.isSeparable_adjoin_simple_iff_isSeparable {x : E} :
    Algebra.IsSeparable F F⟮x⟯ ↔ IsSeparable F x 
goal: Algebra.IsSeparable F ↥F⟮x⟯ ↔ IsSeparable F x

full_name: IsSeparable.of_algebra_isSeparable_of_isSeparable
code: /-- If `K / E / F` is an extension tower such that `E / F` is separable,
`x : K` is separable over `E`, then it's also separable over `F`. -/
theorem IsSeparable.of_algebra_isSeparable_of_isSeparable [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] {x : K} (hsep : IsSeparable E x) : IsSeparable F x 
goal: IsSeparable F x

full_name: Algebra.IsSeparable.trans
code: /-- If `E / F` and `K / E` are both separable extensions, then `K / F` is also separable. -/
theorem Algebra.IsSeparable.trans [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] [Algebra.IsSeparable E K] : Algebra.IsSeparable F K 
goal: Algebra.IsSeparable F K

full_name: IntermediateField.isSeparable_adjoin_pair_of_isSeparable
code: /-- If `x` and `y` are both separable elements, then `F⟮x, y⟯ / F` is a separable extension.
As a consequence, any rational function of `x` and `y` is also a separable element. -/
theorem IntermediateField.isSeparable_adjoin_pair_of_isSeparable {x y : E}
    (hx : IsSeparable F x) (hy : IsSeparable F y) :
    Algebra.IsSeparable F F⟮x, y⟯ 
goal: Algebra.IsSeparable F ↥F⟮x, y⟯

full_name: Field.isSeparable_algebraMap
code: /-- Any element `x` of `F` is a separable element of `E / F` when embedded into `E`. -/
theorem isSeparable_algebraMap (x : F) : IsSeparable F ((algebraMap F E) x) 
goal: IsSeparable F ((algebraMap F E) x)

full_name: Field.isSeparable_mul
code: /-- If `x` and `y` are both separable elements, then `x * y` is also a separable element. -/
theorem isSeparable_mul {x y : E} (hx : IsSeparable F x) (hy : IsSeparable F y) :
    IsSeparable F (x * y) 
goal: IsSeparable F (x * y)

full_name: Field.isSeparable_add
code: /-- If `x` and `y` are both separable elements, then `x + y` is also a separable element. -/
theorem isSeparable_add {x y : E} (hx : IsSeparable F x) (hy : IsSeparable F y) :
    IsSeparable F (x + y) 
goal: IsSeparable F (x + y)

full_name: Field.isSeparable_inv
code: /-- If `x` is a separable element, then `x⁻¹` is also a separable element. -/
theorem isSeparable_inv {x : E} (hx : IsSeparable F x) : IsSeparable F x⁻¹ 
goal: IsSeparable F x⁻¹

full_name: perfectField_iff_splits_of_natSepDegree_eq_one
code: /-- A field is a perfect field (which means that any irreducible polynomial is separable)
if and only if every separable degree one polynomial splits. -/
theorem perfectField_iff_splits_of_natSepDegree_eq_one (F : Type*) [Field F] :
    PerfectField F ↔ ∀ f : F[X], f.natSepDegree = 1 → f.Splits (RingHom.id F) 
goal: PerfectField F ↔ ∀ (f : F[X]), f.natSepDegree = 1 → Polynomial.Splits (RingHom.id F) f