File: Mathlib/Algebra/Polynomial/Splits.lean

full_name: Polynomial.Splits
code: /-- A polynomial `Splits` iff it is zero or all of its irreducible factors have `degree` 1. -/
def Splits (f : K[X]) : Prop 
goal: Prop

full_name: Polynomial.splits_zero
code: @[simp]
theorem splits_zero : Splits i (0 : K[X]) 
goal: Polynomial.Splits i 0

full_name: Polynomial.splits_of_map_eq_C
code: theorem splits_of_map_eq_C {f : K[X]} {a : L} (h : f.map i = C a) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_C
code: @[simp]
theorem splits_C (a : K) : Splits i (C a) 
goal: Polynomial.Splits i (Polynomial.C a)

full_name: Polynomial.splits_of_map_degree_eq_one
code: theorem splits_of_map_degree_eq_one {f : K[X]} (hf : degree (f.map i) = 1) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_of_degree_le_one
code: theorem splits_of_degree_le_one {f : K[X]} (hf : degree f ≤ 1) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_of_degree_eq_one
code: theorem splits_of_degree_eq_one {f : K[X]} (hf : degree f = 1) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_of_natDegree_le_one
code: theorem splits_of_natDegree_le_one {f : K[X]} (hf : natDegree f ≤ 1) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_of_natDegree_eq_one
code: theorem splits_of_natDegree_eq_one {f : K[X]} (hf : natDegree f = 1) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_mul
code: theorem splits_mul {f g : K[X]} (hf : Splits i f) (hg : Splits i g) : Splits i (f * g) 
goal: Polynomial.Splits i (f * g)

full_name: Polynomial.splits_of_splits_mul'
code: theorem splits_of_splits_mul' {f g : K[X]} (hfg : (f * g).map i ≠ 0) (h : Splits i (f * g)) :
    Splits i f ∧ Splits i g 
goal: Polynomial.Splits i f ∧ Polynomial.Splits i g

full_name: Polynomial.splits_map_iff
code: theorem splits_map_iff (j : L →+* F) {f : K[X]} : Splits j (f.map i) ↔ Splits (j.comp i) f 
goal: Polynomial.Splits j (Polynomial.map i f) ↔ Polynomial.Splits (j.comp i) f

full_name: Polynomial.splits_one
code: theorem splits_one : Splits i 1 
goal: Polynomial.Splits i 1

full_name: Polynomial.splits_of_isUnit
code: theorem splits_of_isUnit [IsDomain K] {u : K[X]} (hu : IsUnit u) : u.Splits i 
goal: Polynomial.Splits i u

full_name: Polynomial.splits_X_sub_C
code: theorem splits_X_sub_C {x : K} : (X - C x).Splits i 
goal: Polynomial.Splits i (Polynomial.X - Polynomial.C x)

full_name: Polynomial.splits_X
code: theorem splits_X : X.Splits i 
goal: Polynomial.Splits i Polynomial.X

full_name: Polynomial.splits_prod
code: theorem splits_prod {ι : Type u} {s : ι → K[X]} {t : Finset ι} :
    (∀ j ∈ t, (s j).Splits i) → (∏ x ∈ t, s x).Splits i 
goal: (∀ j ∈ t, Polynomial.Splits i (s j)) → Polynomial.Splits i (∏ x ∈ t, s x)

full_name: Polynomial.splits_pow
code: theorem splits_pow {f : K[X]} (hf : f.Splits i) (n : ℕ) : (f ^ n).Splits i 
goal: Polynomial.Splits i (f ^ n)

full_name: Polynomial.splits_X_pow
code: theorem splits_X_pow (n : ℕ) : (X ^ n).Splits i 
goal: Polynomial.Splits i (Polynomial.X ^ n)

full_name: Polynomial.splits_id_iff_splits
code: theorem splits_id_iff_splits {f : K[X]} : (f.map i).Splits (RingHom.id L) ↔ f.Splits i 
goal: Polynomial.Splits (RingHom.id L) (Polynomial.map i f) ↔ Polynomial.Splits i f

full_name: Polynomial.exists_root_of_splits'
code: theorem exists_root_of_splits' {f : K[X]} (hs : Splits i f) (hf0 : degree (f.map i) ≠ 0) :
    ∃ x, eval₂ i x f = 0 
goal: ∃ x, Polynomial.eval₂ i x f = 0

full_name: Polynomial.roots_ne_zero_of_splits'
code: theorem roots_ne_zero_of_splits' {f : K[X]} (hs : Splits i f) (hf0 : natDegree (f.map i) ≠ 0) :
    (f.map i).roots ≠ 0 
goal: (Polynomial.map i f).roots ≠ 0

full_name: Polynomial.rootOfSplits'
code: /-- Pick a root of a polynomial that splits. See `rootOfSplits` for polynomials over a field
which has simpler assumptions. -/
def rootOfSplits' {f : K[X]} (hf : f.Splits i) (hfd : (f.map i).degree ≠ 0) : L 
goal: L

full_name: Polynomial.map_rootOfSplits'
code: theorem map_rootOfSplits' {f : K[X]} (hf : f.Splits i) (hfd) :
    f.eval₂ i (rootOfSplits' i hf hfd) = 0 
goal: Polynomial.eval₂ i (Polynomial.rootOfSplits' i hf hfd) f = 0

full_name: Polynomial.natDegree_eq_card_roots'
code: theorem natDegree_eq_card_roots' {p : K[X]} {i : K →+* L} (hsplit : Splits i p) :
    (p.map i).natDegree = Multiset.card (p.map i).roots 
goal: (Polynomial.map i p).natDegree = Multiset.card (Polynomial.map i p).roots

full_name: Polynomial.degree_eq_card_roots'
code: theorem degree_eq_card_roots' {p : K[X]} {i : K →+* L} (p_ne_zero : p.map i ≠ 0)
    (hsplit : Splits i p) : (p.map i).degree = Multiset.card (p.map i).roots 
goal: (Polynomial.map i p).degree = ↑(Multiset.card (Polynomial.map i p).roots)

full_name: Polynomial.splits_iff
code: /-- This lemma is for polynomials over a field. -/
theorem splits_iff (f : K[X]) :
    Splits i f ↔ f = 0 ∨ ∀ {g : L[X]}, Irreducible g → g ∣ f.map i → degree g = 1 
goal: Polynomial.Splits i f ↔ f = 0 ∨ ∀ {g : L[X]}, Irreducible g → g ∣ Polynomial.map i f → g.degree = 1

full_name: Polynomial.Splits.def
code: /-- This lemma is for polynomials over a field. -/
theorem Splits.def {i : K →+* L} {f : K[X]} (h : Splits i f) :
    f = 0 ∨ ∀ {g : L[X]}, Irreducible g → g ∣ f.map i → degree g = 1 
goal: f = 0 ∨ ∀ {g : L[X]}, Irreducible g → g ∣ Polynomial.map i f → g.degree = 1

full_name: Polynomial.splits_of_splits_mul
code: theorem splits_of_splits_mul {f g : K[X]} (hfg : f * g ≠ 0) (h : Splits i (f * g)) :
    Splits i f ∧ Splits i g 
goal: Polynomial.Splits i f ∧ Polynomial.Splits i g

full_name: Polynomial.splits_of_splits_of_dvd
code: theorem splits_of_splits_of_dvd {f g : K[X]} (hf0 : f ≠ 0) (hf : Splits i f) (hgf : g ∣ f) :
    Splits i g 
goal: Polynomial.Splits i g

full_name: Polynomial.splits_of_splits_gcd_left
code: theorem splits_of_splits_gcd_left [DecidableEq K] {f g : K[X]} (hf0 : f ≠ 0) (hf : Splits i f) :
    Splits i (EuclideanDomain.gcd f g) 
goal: Polynomial.Splits i (EuclideanDomain.gcd f g)

full_name: Polynomial.splits_of_splits_gcd_right
code: theorem splits_of_splits_gcd_right [DecidableEq K] {f g : K[X]} (hg0 : g ≠ 0) (hg : Splits i g) :
    Splits i (EuclideanDomain.gcd f g) 
goal: Polynomial.Splits i (EuclideanDomain.gcd f g)

full_name: Polynomial.splits_mul_iff
code: theorem splits_mul_iff {f g : K[X]} (hf : f ≠ 0) (hg : g ≠ 0) :
    (f * g).Splits i ↔ f.Splits i ∧ g.Splits i 
goal: Polynomial.Splits i (f * g) ↔ Polynomial.Splits i f ∧ Polynomial.Splits i g

full_name: Polynomial.splits_prod_iff
code: theorem splits_prod_iff {ι : Type u} {s : ι → K[X]} {t : Finset ι} :
    (∀ j ∈ t, s j ≠ 0) → ((∏ x ∈ t, s x).Splits i ↔ ∀ j ∈ t, (s j).Splits i) 
goal: (∀ j ∈ t, s j ≠ 0) → (Polynomial.Splits i (∏ x ∈ t, s x) ↔ ∀ j ∈ t, Polynomial.Splits i (s j))

full_name: Polynomial.degree_eq_one_of_irreducible_of_splits
code: theorem degree_eq_one_of_irreducible_of_splits {p : K[X]} (hp : Irreducible p)
    (hp_splits : Splits (RingHom.id K) p) : p.degree = 1 
goal: p.degree = 1

full_name: Polynomial.exists_root_of_splits
code: theorem exists_root_of_splits {f : K[X]} (hs : Splits i f) (hf0 : degree f ≠ 0) :
    ∃ x, eval₂ i x f = 0 
goal: ∃ x, Polynomial.eval₂ i x f = 0

full_name: Polynomial.roots_ne_zero_of_splits
code: theorem roots_ne_zero_of_splits {f : K[X]} (hs : Splits i f) (hf0 : natDegree f ≠ 0) :
    (f.map i).roots ≠ 0 
goal: (Polynomial.map i f).roots ≠ 0

full_name: Polynomial.rootOfSplits
code: /-- Pick a root of a polynomial that splits. This version is for polynomials over a field and has
simpler assumptions. -/
def rootOfSplits {f : K[X]} (hf : f.Splits i) (hfd : f.degree ≠ 0) : L 
goal: L

full_name: Polynomial.rootOfSplits'_eq_rootOfSplits
code: /-- `rootOfSplits'` is definitionally equal to `rootOfSplits`. -/
theorem rootOfSplits'_eq_rootOfSplits {f : K[X]} (hf : f.Splits i) (hfd) :
    rootOfSplits' i hf hfd = rootOfSplits i hf (f.degree_map i ▸ hfd) 
goal: Polynomial.rootOfSplits' i hf hfd = Polynomial.rootOfSplits i hf ⋯

full_name: Polynomial.map_rootOfSplits
code: theorem map_rootOfSplits {f : K[X]} (hf : f.Splits i) (hfd) :
    f.eval₂ i (rootOfSplits i hf hfd) = 0 
goal: Polynomial.eval₂ i (Polynomial.rootOfSplits i hf hfd) f = 0

full_name: Polynomial.natDegree_eq_card_roots
code: theorem natDegree_eq_card_roots {p : K[X]} {i : K →+* L} (hsplit : Splits i p) :
    p.natDegree = Multiset.card (p.map i).roots 
goal: p.natDegree = Multiset.card (Polynomial.map i p).roots

full_name: Polynomial.degree_eq_card_roots
code: theorem degree_eq_card_roots {p : K[X]} {i : K →+* L} (p_ne_zero : p ≠ 0) (hsplit : Splits i p) :
    p.degree = Multiset.card (p.map i).roots 
goal: p.degree = ↑(Multiset.card (Polynomial.map i p).roots)

full_name: Polynomial.roots_map
code: theorem roots_map {f : K[X]} (hf : f.Splits <| RingHom.id K) : (f.map i).roots = f.roots.map i 
goal: (Polynomial.map i f).roots = Multiset.map (⇑i) f.roots

full_name: Polynomial.image_rootSet
code: theorem image_rootSet [Algebra R K] [Algebra R L] {p : R[X]} (h : p.Splits (algebraMap R K))
    (f : K →ₐ[R] L) : f '' p.rootSet K = p.rootSet L 
goal: ⇑f '' p.rootSet K = p.rootSet L

full_name: Polynomial.adjoin_rootSet_eq_range
code: theorem adjoin_rootSet_eq_range [Algebra R K] [Algebra R L] {p : R[X]}
    (h : p.Splits (algebraMap R K)) (f : K →ₐ[R] L) :
    Algebra.adjoin R (p.rootSet L) = f.range ↔ Algebra.adjoin R (p.rootSet K) = ⊤ 
goal: Algebra.adjoin R (p.rootSet L) = f.range ↔ Algebra.adjoin R (p.rootSet K) = ⊤

full_name: Polynomial.eq_prod_roots_of_splits
code: theorem eq_prod_roots_of_splits {p : K[X]} {i : K →+* L} (hsplit : Splits i p) :
    p.map i = C (i p.leadingCoeff) * ((p.map i).roots.map fun a => X - C a).prod 
goal: Polynomial.map i p =
  Polynomial.C (i p.leadingCoeff) *
    (Multiset.map (fun a => Polynomial.X - Polynomial.C a) (Polynomial.map i p).roots).prod

full_name: Polynomial.eq_prod_roots_of_splits_id
code: theorem eq_prod_roots_of_splits_id {p : K[X]} (hsplit : Splits (RingHom.id K) p) :
    p = C p.leadingCoeff * (p.roots.map fun a => X - C a).prod 
goal: p = Polynomial.C p.leadingCoeff * (Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod

full_name: Polynomial.eq_prod_roots_of_monic_of_splits_id
code: theorem eq_prod_roots_of_monic_of_splits_id {p : K[X]} (m : Monic p)
    (hsplit : Splits (RingHom.id K) p) : p = (p.roots.map fun a => X - C a).prod 
goal: p = (Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod

full_name: Polynomial.eq_X_sub_C_of_splits_of_single_root
code: theorem eq_X_sub_C_of_splits_of_single_root {x : K} {h : K[X]} (h_splits : Splits i h)
    (h_roots : (h.map i).roots = {i x}) : h = C h.leadingCoeff * (X - C x) 
goal: h = Polynomial.C h.leadingCoeff * (Polynomial.X - Polynomial.C x)

full_name: Polynomial.mem_lift_of_splits_of_roots_mem_range
code: theorem mem_lift_of_splits_of_roots_mem_range [Algebra R K] {f : K[X]}
    (hs : f.Splits (RingHom.id K)) (hm : f.Monic) (hr : ∀ a ∈ f.roots, a ∈ (algebraMap R K).range) :
    f ∈ Polynomial.lifts (algebraMap R K) 
goal: f ∈ Polynomial.lifts (algebraMap R K)

full_name: Polynomial._aux_Mathlib_Algebra_Polynomial_Splits___unexpand_Associated_1
code: local infixl:50 " ~ᵤ " => Associated
goal: Lean.PrettyPrinter.Unexpander

full_name: Polynomial.«_aux_Mathlib_Algebra_Polynomial_Splits___macroRules_Polynomial_term_~ᵤ__1»
code: local infixl:50 " ~ᵤ " => Associated
goal: Lean.Macro

full_name: Polynomial.splits_of_exists_multiset
code: theorem splits_of_exists_multiset {f : K[X]} {s : Multiset L}
    (hs : f.map i = C (i f.leadingCoeff) * (s.map fun a : L => X - C a).prod) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_of_splits_id
code: theorem splits_of_splits_id {f : K[X]} : Splits (RingHom.id K) f → Splits i f 
goal: Polynomial.Splits (RingHom.id K) f → Polynomial.Splits i f

full_name: Polynomial.splits_iff_exists_multiset
code: theorem splits_iff_exists_multiset {f : K[X]} :
    Splits i f ↔
      ∃ s : Multiset L, f.map i = C (i f.leadingCoeff) * (s.map fun a : L => X - C a).prod 
goal: Polynomial.Splits i f ↔
  ∃ s,
    Polynomial.map i f =
      Polynomial.C (i f.leadingCoeff) * (Multiset.map (fun a => Polynomial.X - Polynomial.C a) s).prod

full_name: Polynomial.splits_of_comp
code: theorem splits_of_comp (j : L →+* F) {f : K[X]} (h : Splits (j.comp i) f)
    (roots_mem_range : ∀ a ∈ (f.map (j.comp i)).roots, a ∈ j.range) : Splits i f 
goal: Polynomial.Splits i f

full_name: Polynomial.splits_id_of_splits
code: theorem splits_id_of_splits {f : K[X]} (h : Splits i f)
    (roots_mem_range : ∀ a ∈ (f.map i).roots, a ∈ i.range) : Splits (RingHom.id K) f 
goal: Polynomial.Splits (RingHom.id K) f

full_name: Polynomial.splits_comp_of_splits
code: theorem splits_comp_of_splits (i : R →+* K) (j : K →+* L) {f : R[X]} (h : Splits i f) :
    Splits (j.comp i) f 
goal: Polynomial.Splits (j.comp i) f

full_name: Polynomial.splits_of_algHom
code: theorem splits_of_algHom {f : R[X]} (h : Splits (algebraMap R K) f) (e : K →ₐ[R] L) :
    Splits (algebraMap R L) f 
goal: Polynomial.Splits (algebraMap R L) f

full_name: Polynomial.splits_of_isScalarTower
code: theorem splits_of_isScalarTower {f : R[X]} [Algebra K L] [IsScalarTower R K L]
    (h : Splits (algebraMap R K) f) : Splits (algebraMap R L) f 
goal: Polynomial.Splits (algebraMap R L) f

full_name: Polynomial.splits_iff_card_roots
code: /-- A polynomial splits if and only if it has as many roots as its degree. -/
theorem splits_iff_card_roots {p : K[X]} :
    Splits (RingHom.id K) p ↔ Multiset.card p.roots = p.natDegree 
goal: Polynomial.Splits (RingHom.id K) p ↔ Multiset.card p.roots = p.natDegree

full_name: Polynomial.aeval_root_derivative_of_splits
code: theorem aeval_root_derivative_of_splits [Algebra K L] [DecidableEq L] {P : K[X]} (hmo : P.Monic)
    (hP : P.Splits (algebraMap K L)) {r : L} (hr : r ∈ P.aroots L) :
    aeval r (Polynomial.derivative P) =
    (((P.aroots L).erase r).map fun a => r - a).prod 
goal: (Polynomial.aeval r) (Polynomial.derivative P) = (Multiset.map (fun a => r - a) ((P.aroots L).erase r)).prod

full_name: Polynomial.prod_roots_eq_coeff_zero_of_monic_of_split
code: /-- If `P` is a monic polynomial that splits, then `coeff P 0` equals the product of the roots. -/
theorem prod_roots_eq_coeff_zero_of_monic_of_split {P : K[X]} (hmo : P.Monic)
    (hP : P.Splits (RingHom.id K)) : coeff P 0 = (-1) ^ P.natDegree * P.roots.prod 
goal: P.coeff 0 = (-1) ^ P.natDegree * P.roots.prod

full_name: Polynomial.sum_roots_eq_nextCoeff_of_monic_of_split
code: /-- If `P` is a monic polynomial that splits, then `P.nextCoeff` equals the sum of the roots. -/
theorem sum_roots_eq_nextCoeff_of_monic_of_split {P : K[X]} (hmo : P.Monic)
    (hP : P.Splits (RingHom.id K)) : P.nextCoeff = -P.roots.sum 
goal: P.nextCoeff = -P.roots.sum