File: Mathlib/FieldTheory/Separable.lean

full_name: Polynomial.Separable
code: /-- A polynomial is separable iff it is coprime with its derivative. -/
def Separable (f : R[X]) : Prop 
goal: Prop

full_name: Polynomial.separable_def
code: theorem separable_def (f : R[X]) : f.Separable ↔ IsCoprime f (derivative f) 
goal: f.Separable ↔ IsCoprime f (Polynomial.derivative f)

full_name: Polynomial.separable_def'
code: theorem separable_def' (f : R[X]) : f.Separable ↔ ∃ a b : R[X], a * f + b * (derivative f) = 1 
goal: f.Separable ↔ ∃ a b, a * f + b * Polynomial.derivative f = 1

full_name: Polynomial.not_separable_zero
code: theorem not_separable_zero [Nontrivial R] : ¬Separable (0 : R[X]) 
goal: ¬Polynomial.Separable 0

full_name: Polynomial.Separable.ne_zero
code: theorem Separable.ne_zero [Nontrivial R] {f : R[X]} (h : f.Separable) : f ≠ 0 
goal: f ≠ 0

full_name: Polynomial.separable_one
code: @[simp]
theorem separable_one : (1 : R[X]).Separable 
goal: Polynomial.Separable 1

full_name: Polynomial.separable_of_subsingleton
code: @[nontriviality]
theorem separable_of_subsingleton [Subsingleton R] (f : R[X]) : f.Separable 
goal: f.Separable

full_name: Polynomial.separable_X_add_C
code: theorem separable_X_add_C (a : R) : (X + C a).Separable 
goal: (Polynomial.X + Polynomial.C a).Separable

full_name: Polynomial.separable_X
code: theorem separable_X : (X : R[X]).Separable 
goal: Polynomial.X.Separable

full_name: Polynomial.separable_C
code: theorem separable_C (r : R) : (C r).Separable ↔ IsUnit r 
goal: (Polynomial.C r).Separable ↔ IsUnit r

full_name: Polynomial.Separable.of_mul_left
code: theorem Separable.of_mul_left {f g : R[X]} (h : (f * g).Separable) : f.Separable 
goal: f.Separable

full_name: Polynomial.Separable.of_mul_right
code: theorem Separable.of_mul_right {f g : R[X]} (h : (f * g).Separable) : g.Separable 
goal: g.Separable

full_name: Polynomial.Separable.of_dvd
code: theorem Separable.of_dvd {f g : R[X]} (hf : f.Separable) (hfg : g ∣ f) : g.Separable 
goal: g.Separable

full_name: Polynomial.separable_gcd_left
code: theorem separable_gcd_left {F : Type*} [Field F] {f : F[X]} (hf : f.Separable) (g : F[X]) :
    (EuclideanDomain.gcd f g).Separable 
goal: (EuclideanDomain.gcd f g).Separable

full_name: Polynomial.separable_gcd_right
code: theorem separable_gcd_right {F : Type*} [Field F] {g : F[X]} (f : F[X]) (hg : g.Separable) :
    (EuclideanDomain.gcd f g).Separable 
goal: (EuclideanDomain.gcd f g).Separable

full_name: Polynomial.Separable.isCoprime
code: theorem Separable.isCoprime {f g : R[X]} (h : (f * g).Separable) : IsCoprime f g 
goal: IsCoprime f g

full_name: Polynomial.Separable.of_pow'
code: theorem Separable.of_pow' {f : R[X]} :
    ∀ {n : ℕ} (_h : (f ^ n).Separable), IsUnit f ∨ f.Separable ∧ n = 1 ∨ n = 0
  
goal: IsUnit f ∨ f.Separable ∧ n = 1 ∨ n = 0

full_name: Polynomial.Separable.of_pow
code: theorem Separable.of_pow {f : R[X]} (hf : ¬IsUnit f) {n : ℕ} (hn : n ≠ 0)
    (hfs : (f ^ n).Separable) : f.Separable ∧ n = 1 
goal: f.Separable ∧ n = 1

full_name: Polynomial.Separable.map
code: theorem Separable.map {p : R[X]} (h : p.Separable) {f : R →+* S} : (p.map f).Separable 
goal: (Polynomial.map f p).Separable

full_name: Associated.separable
code: theorem _root_.Associated.separable {f g : R[X]}
    (ha : Associated f g) (h : f.Separable) : g.Separable 
goal: g.Separable

full_name: Associated.separable_iff
code: theorem _root_.Associated.separable_iff {f g : R[X]}
    (ha : Associated f g) : f.Separable ↔ g.Separable 
goal: f.Separable ↔ g.Separable

full_name: Polynomial.Separable.mul_unit
code: theorem Separable.mul_unit {f g : R[X]} (hf : f.Separable) (hg : IsUnit g) : (f * g).Separable 
goal: (f * g).Separable

full_name: Polynomial.Separable.unit_mul
code: theorem Separable.unit_mul {f g : R[X]} (hf : IsUnit f) (hg : g.Separable) : (f * g).Separable 
goal: (f * g).Separable

full_name: Polynomial.Separable.eval₂_derivative_ne_zero
code: theorem Separable.eval₂_derivative_ne_zero [Nontrivial S] (f : R →+* S) {p : R[X]}
    (h : p.Separable) {x : S} (hx : p.eval₂ f x = 0) :
    (derivative p).eval₂ f x ≠ 0 
goal: Polynomial.eval₂ f x (Polynomial.derivative p) ≠ 0

full_name: Polynomial.Separable.aeval_derivative_ne_zero
code: theorem Separable.aeval_derivative_ne_zero [Nontrivial S] [Algebra R S] {p : R[X]}
    (h : p.Separable) {x : S} (hx : aeval x p = 0) :
    aeval x (derivative p) ≠ 0 
goal: (Polynomial.aeval x) (Polynomial.derivative p) ≠ 0

full_name: Polynomial.isUnit_of_self_mul_dvd_separable
code: theorem isUnit_of_self_mul_dvd_separable {p q : R[X]} (hp : p.Separable) (hq : q * q ∣ p) :
    IsUnit q 
goal: IsUnit q

full_name: Polynomial.multiplicity_le_one_of_separable
code: theorem multiplicity_le_one_of_separable {p q : R[X]} (hq : ¬IsUnit q) (hsep : Separable p) :
    multiplicity q p ≤ 1 
goal: multiplicity q p ≤ 1

full_name: Polynomial.Separable.squarefree
code: /-- A separable polynomial is square-free.

See `PerfectField.separable_iff_squarefree` for the converse when the coefficients are a perfect
field. -/
theorem Separable.squarefree {p : R[X]} (hsep : Separable p) : Squarefree p 
goal: Squarefree p

full_name: Polynomial.separable_X_sub_C
code: theorem separable_X_sub_C {x : R} : Separable (X - C x) 
goal: (Polynomial.X - Polynomial.C x).Separable

full_name: Polynomial.Separable.mul
code: theorem Separable.mul {f g : R[X]} (hf : f.Separable) (hg : g.Separable) (h : IsCoprime f g) :
    (f * g).Separable 
goal: (f * g).Separable

full_name: Polynomial.separable_prod'
code: theorem separable_prod' {ι : Sort _} {f : ι → R[X]} {s : Finset ι} :
    (∀ x ∈ s, ∀ y ∈ s, x ≠ y → IsCoprime (f x) (f y)) →
      (∀ x ∈ s, (f x).Separable) → (∏ x ∈ s, f x).Separable 
goal: (∀ x ∈ s, ∀ y ∈ s, x ≠ y → IsCoprime (f x) (f y)) → (∀ x ∈ s, (f x).Separable) → (∏ x ∈ s, f x).Separable

full_name: Polynomial.separable_prod
code: theorem separable_prod {ι : Sort _} [Fintype ι] {f : ι → R[X]} (h1 : Pairwise (IsCoprime on f))
    (h2 : ∀ x, (f x).Separable) : (∏ x, f x).Separable 
goal: (∏ x : ι, f x).Separable

full_name: Polynomial.Separable.inj_of_prod_X_sub_C
code: theorem Separable.inj_of_prod_X_sub_C [Nontrivial R] {ι : Sort _} {f : ι → R} {s : Finset ι}
    (hfs : (∏ i ∈ s, (X - C (f i))).Separable) {x y : ι} (hx : x ∈ s) (hy : y ∈ s)
    (hfxy : f x = f y) : x = y 
goal: x = y

full_name: Polynomial.Separable.injective_of_prod_X_sub_C
code: theorem Separable.injective_of_prod_X_sub_C [Nontrivial R] {ι : Sort _} [Fintype ι] {f : ι → R}
    (hfs : (∏ i, (X - C (f i))).Separable) : Function.Injective f 
goal: Function.Injective f

full_name: Polynomial.nodup_of_separable_prod
code: theorem nodup_of_separable_prod [Nontrivial R] {s : Multiset R}
    (hs : Separable (Multiset.map (fun a => X - C a) s).prod) : s.Nodup 
goal: s.Nodup

full_name: Polynomial.separable_X_pow_sub_C_unit
code: /-- If `IsUnit n` in a `CommRing R`, then `X ^ n - u` is separable for any unit `u`. -/
theorem separable_X_pow_sub_C_unit {n : ℕ} (u : Rˣ) (hn : IsUnit (n : R)) :
    Separable (X ^ n - C (u : R)) 
goal: (Polynomial.X ^ n - Polynomial.C ↑u).Separable

full_name: Polynomial.rootMultiplicity_le_one_of_separable
code: theorem rootMultiplicity_le_one_of_separable [Nontrivial R] {p : R[X]} (hsep : Separable p)
    (x : R) : rootMultiplicity x p ≤ 1 
goal: Polynomial.rootMultiplicity x p ≤ 1

full_name: Polynomial.count_roots_le_one
code: theorem count_roots_le_one {p : R[X]} (hsep : Separable p) (x : R) : p.roots.count x ≤ 1 
goal: Multiset.count x p.roots ≤ 1

full_name: Polynomial.nodup_roots
code: theorem nodup_roots {p : R[X]} (hsep : Separable p) : p.roots.Nodup 
goal: p.roots.Nodup

full_name: Polynomial.separable_iff_derivative_ne_zero
code: theorem separable_iff_derivative_ne_zero {f : F[X]} (hf : Irreducible f) :
    f.Separable ↔ derivative f ≠ 0 
goal: f.Separable ↔ Polynomial.derivative f ≠ 0

full_name: Polynomial.separable_map
code: theorem separable_map {S} [CommRing S] [Nontrivial S] (f : F →+* S) {p : F[X]} :
    (p.map f).Separable ↔ p.Separable 
goal: (Polynomial.map f p).Separable ↔ p.Separable

full_name: Polynomial.separable_prod_X_sub_C_iff'
code: theorem separable_prod_X_sub_C_iff' {ι : Sort _} {f : ι → F} {s : Finset ι} :
    (∏ i ∈ s, (X - C (f i))).Separable ↔ ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y 
goal: (∏ i ∈ s, (Polynomial.X - Polynomial.C (f i))).Separable ↔ ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y

full_name: Polynomial.separable_prod_X_sub_C_iff
code: theorem separable_prod_X_sub_C_iff {ι : Sort _} [Fintype ι] {f : ι → F} :
    (∏ i, (X - C (f i))).Separable ↔ Function.Injective f 
goal: (∏ i : ι, (Polynomial.X - Polynomial.C (f i))).Separable ↔ Function.Injective f

full_name: Polynomial.separable_or
code: theorem separable_or {f : F[X]} (hf : Irreducible f) :
    f.Separable ∨ ¬f.Separable ∧ ∃ g : F[X], Irreducible g ∧ expand F p g = f 
goal: f.Separable ∨ ¬f.Separable ∧ ∃ g, Irreducible g ∧ (Polynomial.expand F p) g = f

full_name: Polynomial.exists_separable_of_irreducible
code: theorem exists_separable_of_irreducible {f : F[X]} (hf : Irreducible f) (hp : p ≠ 0) :
    ∃ (n : ℕ) (g : F[X]), g.Separable ∧ expand F (p ^ n) g = f 
goal: ∃ n g, g.Separable ∧ (Polynomial.expand F (p ^ n)) g = f

full_name: Polynomial.isUnit_or_eq_zero_of_separable_expand
code: theorem isUnit_or_eq_zero_of_separable_expand {f : F[X]} (n : ℕ) (hp : 0 < p)
    (hf : (expand F (p ^ n) f).Separable) : IsUnit f ∨ n = 0 
goal: IsUnit f ∨ n = 0

full_name: Polynomial.unique_separable_of_irreducible
code: theorem unique_separable_of_irreducible {f : F[X]} (hf : Irreducible f) (hp : 0 < p) (n₁ : ℕ)
    (g₁ : F[X]) (hg₁ : g₁.Separable) (hgf₁ : expand F (p ^ n₁) g₁ = f) (n₂ : ℕ) (g₂ : F[X])
    (hg₂ : g₂.Separable) (hgf₂ : expand F (p ^ n₂) g₂ = f) : n₁ = n₂ ∧ g₁ = g₂ 
goal: n₁ = n₂ ∧ g₁ = g₂

full_name: Polynomial.separable_X_pow_sub_C
code: /-- If `n ≠ 0` in `F`, then `X ^ n - a` is separable for any `a ≠ 0`. -/
theorem separable_X_pow_sub_C {n : ℕ} (a : F) (hn : (n : F) ≠ 0) (ha : a ≠ 0) :
    Separable (X ^ n - C a) 
goal: (Polynomial.X ^ n - Polynomial.C a).Separable

full_name: Polynomial.X_pow_sub_one_separable_iff
code: /-- In a field `F`, `X ^ n - 1` is separable iff `↑n ≠ 0`. -/
theorem X_pow_sub_one_separable_iff {n : ℕ} : (X ^ n - 1 : F[X]).Separable ↔ (n : F) ≠ 0 
goal: (Polynomial.X ^ n - 1).Separable ↔ ↑n ≠ 0

full_name: Polynomial.card_rootSet_eq_natDegree
code: theorem card_rootSet_eq_natDegree [Algebra F K] {p : F[X]} (hsep : p.Separable)
    (hsplit : Splits (algebraMap F K) p) : Fintype.card (p.rootSet K) = p.natDegree 
goal: Fintype.card ↑(p.rootSet K) = p.natDegree

full_name: Polynomial.nodup_roots_iff_of_splits
code: /-- If a non-zero polynomial splits, then it has no repeated roots on that field
if and only if it is separable. -/
theorem nodup_roots_iff_of_splits {f : F[X]} (hf : f ≠ 0) (h : f.Splits (RingHom.id F)) :
    f.roots.Nodup ↔ f.Separable 
goal: f.roots.Nodup ↔ f.Separable

full_name: Polynomial.nodup_aroots_iff_of_splits
code: /-- If a non-zero polynomial over `F` splits in `K`, then it has no repeated roots on `K`
if and only if it is separable. -/
theorem nodup_aroots_iff_of_splits [Algebra F K] {f : F[X]} (hf : f ≠ 0)
    (h : f.Splits (algebraMap F K)) : (f.aroots K).Nodup ↔ f.Separable 
goal: (f.aroots K).Nodup ↔ f.Separable

full_name: Polynomial.card_rootSet_eq_natDegree_iff_of_splits
code: theorem card_rootSet_eq_natDegree_iff_of_splits [Algebra F K] {f : F[X]} (hf : f ≠ 0)
    (h : f.Splits (algebraMap F K)) : Fintype.card (f.rootSet K) = f.natDegree ↔ f.Separable 
goal: Fintype.card ↑(f.rootSet K) = f.natDegree ↔ f.Separable

full_name: Polynomial.eq_X_sub_C_of_separable_of_root_eq
code: theorem eq_X_sub_C_of_separable_of_root_eq {x : F} {h : F[X]} (h_sep : h.Separable)
    (h_root : h.eval x = 0) (h_splits : Splits i h) (h_roots : ∀ y ∈ (h.map i).roots, y = i x) :
    h = C (leadingCoeff h) * (X - C x) 
goal: h = Polynomial.C h.leadingCoeff * (Polynomial.X - Polynomial.C x)

full_name: Polynomial.exists_finset_of_splits
code: theorem exists_finset_of_splits (i : F →+* K) {f : F[X]} (sep : Separable f) (sp : Splits i f) :
    ∃ s : Finset K, f.map i = C (i f.leadingCoeff) * s.prod fun a : K => X - C a 
goal: ∃ s, Polynomial.map i f = Polynomial.C (i f.leadingCoeff) * ∏ a ∈ s, (Polynomial.X - Polynomial.C a)

full_name: Irreducible.separable
code: theorem _root_.Irreducible.separable [CharZero F] {f : F[X]} (hf : Irreducible f) :
    f.Separable 
goal: f.Separable

full_name: IsSeparable
code: /--
An element `x` of an algebra `K` over a commutative ring `F` is said to be *separable*, if its
minimal polynamial over `K` is separable. Note that the minimal polynomial of any element not
integral over `F` is defined to be `0`, which is not a separable polynomial.
-/
def IsSeparable (x : K) : Prop 
goal: Prop

full_name: Algebra.isSeparable_def
code: /-- Typeclass for separable field extension: `K` is a separable field extension of `F` iff
the minimal polynomial of every `x : K` is separable. This implies that `K/F` is an algebraic
extension, because the minimal polynomial of a non-integral element is `0`, which is not
separable.

We define this for general (commutative) rings and only assume `F` and `K` are fields if this
is needed for a proof.
-/
@[mk_iff isSeparable_def] protected class Algebra.IsSeparable : Prop where
  isSeparable' : ∀ x : K, IsSeparable F x
goal: Algebra.IsSeparable F K ↔ ∀ (x : K), IsSeparable F x

full_name: Algebra.IsSeparable.isSeparable'
code: /-- Typeclass for separable field extension: `K` is a separable field extension of `F` iff
the minimal polynomial of every `x : K` is separable. This implies that `K/F` is an algebraic
extension, because the minimal polynomial of a non-integral element is `0`, which is not
separable.

We define this for general (commutative) rings and only assume `F` and `K` are fields if this
is needed for a proof.
-/
@[mk_iff isSeparable_def] protected class Algebra.IsSeparable : Prop where
  isSeparable' : ∀ x : K, IsSeparable F x
goal: IsSeparable F x

full_name: Algebra.IsSeparable
code: /-- Typeclass for separable field extension: `K` is a separable field extension of `F` iff
the minimal polynomial of every `x : K` is separable. This implies that `K/F` is an algebraic
extension, because the minimal polynomial of a non-integral element is `0`, which is not
separable.

We define this for general (commutative) rings and only assume `F` and `K` are fields if this
is needed for a proof.
-/
@[mk_iff isSeparable_def] protected class Algebra.IsSeparable : Prop where
  isSeparable' : ∀ x : K, IsSeparable F x
goal: Prop

full_name: Algebra.IsSeparable.isSeparable
code: theorem Algebra.IsSeparable.isSeparable [Algebra.IsSeparable F K] : ∀ x : K, IsSeparable F x 
goal: IsSeparable F x

full_name: IsSeparable.isIntegral
code: /-- If the minimal polynomial of `x : K` over `F` is separable, then `x` is integral over `F`,
because the minimal polynomial of a non-integral element is `0`, which is not separable. -/
theorem IsSeparable.isIntegral {x : K} (h : IsSeparable F x) : IsIntegral F x 
goal: IsIntegral F x

full_name: Algebra.IsSeparable.isIntegral
code: theorem Algebra.IsSeparable.isIntegral [Algebra.IsSeparable F K] : ∀ x : K, IsIntegral F x 
goal: IsIntegral F x

full_name: Algebra.isSeparable_iff
code: theorem Algebra.isSeparable_iff :
    Algebra.IsSeparable F K ↔ ∀ x : K, IsIntegral F x ∧ IsSeparable F x 
goal: Algebra.IsSeparable F K ↔ ∀ (x : K), IsIntegral F x ∧ IsSeparable F x

full_name: AlgEquiv.isSeparable
code: /-- Transfer `Algebra.IsSeparable` across an `AlgEquiv`. -/
theorem AlgEquiv.isSeparable [Algebra.IsSeparable F K] : Algebra.IsSeparable F E 
goal: Algebra.IsSeparable F E

full_name: AlgEquiv.isSeparable_iff
code: theorem AlgEquiv.isSeparable_iff : Algebra.IsSeparable F K ↔ Algebra.IsSeparable F E 
goal: Algebra.IsSeparable F K ↔ Algebra.IsSeparable F E

full_name: Algebra.IsSeparable.isAlgebraic
code: instance Algebra.IsSeparable.isAlgebraic [Nontrivial F] [Algebra.IsSeparable F K] :
    Algebra.IsAlgebraic F K 
goal: Algebra.IsAlgebraic F K

full_name: Algebra.isSeparable_self
code: instance Algebra.isSeparable_self (F : Type*) [Field F] : Algebra.IsSeparable F F 
goal: Algebra.IsSeparable F F

full_name: Algebra.IsSeparable.of_finite
code: /-- A finite field extension in characteristic 0 is separable. -/
instance (priority := 100) Algebra.IsSeparable.of_finite (F K : Type*) [Field F] [Field K]
    [Algebra F K] [FiniteDimensional F K] [CharZero F] : Algebra.IsSeparable F K 
goal: Algebra.IsSeparable F K

full_name: IsSeparable.of_isScalarTower
code: /-- If `R / K / A` is an extension tower, `x : R` is separable over `A`, then it's also separable
over `K`. -/
theorem IsSeparable.of_isScalarTower {A : Type*} [CommRing A]
    (K : Type*) [Field K] [Algebra A K] {R : Type*} [CommRing R] [Algebra A R] [Algebra K R]
    [IsScalarTower A K R] {x : R} (h : IsSeparable A x) : IsSeparable K x 
goal: IsSeparable K x

full_name: Algebra.isSeparable_tower_top_of_isSeparable
code: theorem Algebra.isSeparable_tower_top_of_isSeparable [Algebra.IsSeparable F E] :
    Algebra.IsSeparable K E 
goal: Algebra.IsSeparable K E

full_name: Algebra.isSeparable_tower_bot_of_isSeparable
code: theorem Algebra.isSeparable_tower_bot_of_isSeparable [h : Algebra.IsSeparable F E] :
    Algebra.IsSeparable F K 
goal: Algebra.IsSeparable F K

full_name: Algebra.IsSeparable.of_algHom
code: theorem Algebra.IsSeparable.of_algHom (E' : Type*) [Field E'] [Algebra F E'] (f : E →ₐ[F] E')
    [Algebra.IsSeparable F E'] : Algebra.IsSeparable F E 
goal: Algebra.IsSeparable F E

full_name: Algebra.IsSeparable.of_equiv_equiv
code: lemma Algebra.IsSeparable.of_equiv_equiv {A₁ B₁ A₂ B₂ : Type*} [Field A₁] [Field B₁]
    [Field A₂] [Field B₂] [Algebra A₁ B₁] [Algebra A₂ B₂] (e₁ : A₁ ≃+* A₂) (e₂ : B₁ ≃+* B₂)
    (he : RingHom.comp (algebraMap A₂ B₂) ↑e₁ = RingHom.comp ↑e₂ (algebraMap A₁ B₁))
    [Algebra.IsSeparable A₁ B₁] : Algebra.IsSeparable A₂ B₂ 
goal: Algebra.IsSeparable A₂ B₂

full_name: AlgHom.card_of_powerBasis
code: theorem AlgHom.card_of_powerBasis (pb : PowerBasis K S) (h_sep : IsSeparable K pb.gen)
    (h_splits : (minpoly K pb.gen).Splits (algebraMap K L)) :
    @Fintype.card (S →ₐ[K] L) (PowerBasis.AlgHom.fintype pb) = pb.dim 
goal: Fintype.card (S →ₐ[K] L) = pb.dim