File: Mathlib/Algebra/Polynomial/FieldDivision.lean

full_name: Polynomial.rootMultiplicity_sub_one_le_derivative_rootMultiplicity_of_ne_zero
code: theorem rootMultiplicity_sub_one_le_derivative_rootMultiplicity_of_ne_zero
    (p : R[X]) (t : R) (hnezero : derivative p ≠ 0) :
    p.rootMultiplicity t - 1 ≤ p.derivative.rootMultiplicity t 
goal: Polynomial.rootMultiplicity t p - 1 ≤ Polynomial.rootMultiplicity t (Polynomial.derivative p)

full_name: Polynomial.derivative_rootMultiplicity_of_root_of_mem_nonZeroDivisors
code: theorem derivative_rootMultiplicity_of_root_of_mem_nonZeroDivisors
    {p : R[X]} {t : R} (hpt : Polynomial.IsRoot p t)
    (hnzd : (p.rootMultiplicity t : R) ∈ nonZeroDivisors R) :
    (derivative p).rootMultiplicity t = p.rootMultiplicity t - 1 
goal: Polynomial.rootMultiplicity t (Polynomial.derivative p) = Polynomial.rootMultiplicity t p - 1

full_name: Polynomial.isRoot_iterate_derivative_of_lt_rootMultiplicity
code: theorem isRoot_iterate_derivative_of_lt_rootMultiplicity {p : R[X]} {t : R} {n : ℕ}
    (hn : n < p.rootMultiplicity t) : (derivative^[n] p).IsRoot t 
goal: ((⇑Polynomial.derivative)^[n] p).IsRoot t

full_name: Polynomial.eval_iterate_derivative_rootMultiplicity
code: theorem eval_iterate_derivative_rootMultiplicity {p : R[X]} {t : R} :
    (derivative^[p.rootMultiplicity t] p).eval t =
      (p.rootMultiplicity t).factorial • (p /ₘ (X - C t) ^ p.rootMultiplicity t).eval t 
goal: Polynomial.eval t ((⇑Polynomial.derivative)^[Polynomial.rootMultiplicity t p] p) =
  (Polynomial.rootMultiplicity t p).factorial •
    Polynomial.eval t (p /ₘ (Polynomial.X - Polynomial.C t) ^ Polynomial.rootMultiplicity t p)

full_name: Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors
code: theorem lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors
    {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hroot : ∀ m ≤ n, (derivative^[m] p).IsRoot t)
    (hnzd : (n.factorial : R) ∈ nonZeroDivisors R) :
    n < p.rootMultiplicity t 
goal: n < Polynomial.rootMultiplicity t p

full_name: Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
code: theorem lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
    {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hroot : ∀ m ≤ n, (derivative^[m] p).IsRoot t)
    (hnzd : ∀ m ≤ n, m ≠ 0 → (m : R) ∈ nonZeroDivisors R) :
    n < p.rootMultiplicity t 
goal: n < Polynomial.rootMultiplicity t p

full_name: Polynomial.lt_rootMultiplicity_iff_isRoot_iterate_derivative_of_mem_nonZeroDivisors
code: theorem lt_rootMultiplicity_iff_isRoot_iterate_derivative_of_mem_nonZeroDivisors
    {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hnzd : (n.factorial : R) ∈ nonZeroDivisors R) :
    n < p.rootMultiplicity t ↔ ∀ m ≤ n, (derivative^[m] p).IsRoot t 
goal: n < Polynomial.rootMultiplicity t p ↔ ∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t

full_name: Polynomial.lt_rootMultiplicity_iff_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
code: theorem lt_rootMultiplicity_iff_isRoot_iterate_derivative_of_mem_nonZeroDivisors'
    {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hnzd : ∀ m ≤ n, m ≠ 0 → (m : R) ∈ nonZeroDivisors R) :
    n < p.rootMultiplicity t ↔ ∀ m ≤ n, (derivative^[m] p).IsRoot t 
goal: n < Polynomial.rootMultiplicity t p ↔ ∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t

full_name: Polynomial.one_lt_rootMultiplicity_iff_isRoot_iterate_derivative
code: theorem one_lt_rootMultiplicity_iff_isRoot_iterate_derivative
    {p : R[X]} {t : R} (h : p ≠ 0) :
    1 < p.rootMultiplicity t ↔ ∀ m ≤ 1, (derivative^[m] p).IsRoot t 
goal: 1 < Polynomial.rootMultiplicity t p ↔ ∀ m ≤ 1, ((⇑Polynomial.derivative)^[m] p).IsRoot t

full_name: Polynomial.one_lt_rootMultiplicity_iff_isRoot
code: theorem one_lt_rootMultiplicity_iff_isRoot
    {p : R[X]} {t : R} (h : p ≠ 0) :
    1 < p.rootMultiplicity t ↔ p.IsRoot t ∧ (derivative p).IsRoot t 
goal: 1 < Polynomial.rootMultiplicity t p ↔ p.IsRoot t ∧ (Polynomial.derivative p).IsRoot t

full_name: Polynomial.one_lt_rootMultiplicity_iff_isRoot_gcd
code: theorem one_lt_rootMultiplicity_iff_isRoot_gcd
    [GCDMonoid R[X]] {p : R[X]} {t : R} (h : p ≠ 0) :
    1 < p.rootMultiplicity t ↔ (gcd p (derivative p)).IsRoot t 
goal: 1 < Polynomial.rootMultiplicity t p ↔ (gcd p (Polynomial.derivative p)).IsRoot t

full_name: Polynomial.derivative_rootMultiplicity_of_root
code: theorem derivative_rootMultiplicity_of_root [CharZero R] {p : R[X]} {t : R} (hpt : p.IsRoot t) :
    p.derivative.rootMultiplicity t = p.rootMultiplicity t - 1 
goal: Polynomial.rootMultiplicity t (Polynomial.derivative p) = Polynomial.rootMultiplicity t p - 1

full_name: Polynomial.rootMultiplicity_sub_one_le_derivative_rootMultiplicity
code: theorem rootMultiplicity_sub_one_le_derivative_rootMultiplicity [CharZero R] (p : R[X]) (t : R) :
    p.rootMultiplicity t - 1 ≤ p.derivative.rootMultiplicity t 
goal: Polynomial.rootMultiplicity t p - 1 ≤ Polynomial.rootMultiplicity t (Polynomial.derivative p)

full_name: Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative
code: theorem lt_rootMultiplicity_of_isRoot_iterate_derivative
    [CharZero R] {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0)
    (hroot : ∀ m ≤ n, (derivative^[m] p).IsRoot t) :
    n < p.rootMultiplicity t 
goal: n < Polynomial.rootMultiplicity t p

full_name: Polynomial.lt_rootMultiplicity_iff_isRoot_iterate_derivative
code: theorem lt_rootMultiplicity_iff_isRoot_iterate_derivative
    [CharZero R] {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0) :
    n < p.rootMultiplicity t ↔ ∀ m ≤ n, (derivative^[m] p).IsRoot t 
goal: n < Polynomial.rootMultiplicity t p ↔ ∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t

full_name: Polynomial.instNormalizationMonoid
code: instance instNormalizationMonoid : NormalizationMonoid R[X] 
goal: NormalizationMonoid R[X]

full_name: Polynomial.coe_normUnit
code: @[simp]
theorem coe_normUnit {p : R[X]} : (normUnit p : R[X]) = C ↑(normUnit p.leadingCoeff) 
goal: ↑(normUnit p) = Polynomial.C ↑(normUnit p.leadingCoeff)

full_name: Polynomial.leadingCoeff_normalize
code: theorem leadingCoeff_normalize (p : R[X]) :
    leadingCoeff (normalize p) = normalize (leadingCoeff p) 
goal: (normalize p).leadingCoeff = normalize p.leadingCoeff

full_name: Polynomial.Monic.normalize_eq_self
code: theorem Monic.normalize_eq_self {p : R[X]} (hp : p.Monic) : normalize p = p 
goal: normalize p = p

full_name: Polynomial.roots_normalize
code: theorem roots_normalize {p : R[X]} : (normalize p).roots = p.roots 
goal: (normalize p).roots = p.roots

full_name: Polynomial.normUnit_X
code: theorem normUnit_X : normUnit (X : Polynomial R) = 1 
goal: normUnit Polynomial.X = 1

full_name: Polynomial.X_eq_normalize
code: theorem X_eq_normalize : (X : Polynomial R) = normalize X 
goal: Polynomial.X = normalize Polynomial.X

full_name: Polynomial.degree_pos_of_ne_zero_of_nonunit
code: theorem degree_pos_of_ne_zero_of_nonunit (hp0 : p ≠ 0) (hp : ¬IsUnit p) : 0 < degree p 
goal: 0 < p.degree

full_name: Polynomial.map_eq_zero
code: @[simp]
theorem map_eq_zero [Semiring S] [Nontrivial S] (f : R →+* S) : p.map f = 0 ↔ p = 0 
goal: Polynomial.map f p = 0 ↔ p = 0

full_name: Polynomial.map_ne_zero
code: theorem map_ne_zero [Semiring S] [Nontrivial S] {f : R →+* S} (hp : p ≠ 0) : p.map f ≠ 0 
goal: Polynomial.map f p ≠ 0

full_name: Polynomial.degree_map
code: @[simp]
theorem degree_map [Semiring S] [Nontrivial S] (p : R[X]) (f : R →+* S) :
    degree (p.map f) = degree p 
goal: (Polynomial.map f p).degree = p.degree

full_name: Polynomial.natDegree_map
code: @[simp]
theorem natDegree_map [Semiring S] [Nontrivial S] (f : R →+* S) :
    natDegree (p.map f) = natDegree p 
goal: (Polynomial.map f p).natDegree = p.natDegree

full_name: Polynomial.leadingCoeff_map
code: @[simp]
theorem leadingCoeff_map [Semiring S] [Nontrivial S] (f : R →+* S) :
    leadingCoeff (p.map f) = f (leadingCoeff p) 
goal: (Polynomial.map f p).leadingCoeff = f p.leadingCoeff

full_name: Polynomial.monic_map_iff
code: theorem monic_map_iff [Semiring S] [Nontrivial S] {f : R →+* S} {p : R[X]} :
    (p.map f).Monic ↔ p.Monic 
goal: (Polynomial.map f p).Monic ↔ p.Monic

full_name: Polynomial.isUnit_iff_degree_eq_zero
code: theorem isUnit_iff_degree_eq_zero : IsUnit p ↔ degree p = 0 
goal: IsUnit p ↔ p.degree = 0

full_name: Polynomial.div
code: /-- Division of polynomials. See `Polynomial.divByMonic` for more details. -/
def div (p q : R[X]) 
goal: R[X]

full_name: Polynomial.mod
code: /-- Remainder of polynomial division. See `Polynomial.modByMonic` for more details. -/
def mod (p q : R[X]) 
goal: R[X]

full_name: _private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.quotient_mul_add_remainder_eq_aux
code: private theorem quotient_mul_add_remainder_eq_aux (p q : R[X]) : q * div p q + mod p q = p 
goal: q * p.div q + p.mod q = p

full_name: _private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.remainder_lt_aux
code: private theorem remainder_lt_aux (p : R[X]) (hq : q ≠ 0) : degree (mod p q) < degree q 
goal: (p.mod q).degree < q.degree

full_name: Polynomial.instDiv
code: instance : Div R[X] 
goal: Div R[X]

full_name: Polynomial.instMod
code: instance : Mod R[X] 
goal: Mod R[X]

full_name: Polynomial.div_def
code: theorem div_def : p / q = C (leadingCoeff q)⁻¹ * (p /ₘ (q * C (leadingCoeff q)⁻¹)) 
goal: p / q = Polynomial.C q.leadingCoeff⁻¹ * (p /ₘ (q * Polynomial.C q.leadingCoeff⁻¹))

full_name: Polynomial.mod_def
code: theorem mod_def : p % q = p %ₘ (q * C (leadingCoeff q)⁻¹) 
goal: p % q = p %ₘ (q * Polynomial.C q.leadingCoeff⁻¹)

full_name: Polynomial.modByMonic_eq_mod
code: theorem modByMonic_eq_mod (p : R[X]) (hq : Monic q) : p %ₘ q = p % q 
goal: p %ₘ q = p % q

full_name: Polynomial.divByMonic_eq_div
code: theorem divByMonic_eq_div (p : R[X]) (hq : Monic q) : p /ₘ q = p / q 
goal: p /ₘ q = p / q

full_name: Polynomial.mod_X_sub_C_eq_C_eval
code: theorem mod_X_sub_C_eq_C_eval (p : R[X]) (a : R) : p % (X - C a) = C (p.eval a) 
goal: p % (Polynomial.X - Polynomial.C a) = Polynomial.C (Polynomial.eval a p)

full_name: Polynomial.mul_div_eq_iff_isRoot
code: theorem mul_div_eq_iff_isRoot : (X - C a) * (p / (X - C a)) = p ↔ IsRoot p a 
goal: (Polynomial.X - Polynomial.C a) * (p / (Polynomial.X - Polynomial.C a)) = p ↔ p.IsRoot a

full_name: Polynomial.instEuclideanDomain
code: instance instEuclideanDomain : EuclideanDomain R[X] 
goal: EuclideanDomain R[X]

full_name: Polynomial.mod_eq_self_iff
code: theorem mod_eq_self_iff (hq0 : q ≠ 0) : p % q = p ↔ degree p < degree q 
goal: p % q = p ↔ p.degree < q.degree

full_name: Polynomial.div_eq_zero_iff
code: theorem div_eq_zero_iff (hq0 : q ≠ 0) : p / q = 0 ↔ degree p < degree q 
goal: p / q = 0 ↔ p.degree < q.degree

full_name: Polynomial.degree_add_div
code: theorem degree_add_div (hq0 : q ≠ 0) (hpq : degree q ≤ degree p) :
    degree q + degree (p / q) = degree p 
goal: q.degree + (p / q).degree = p.degree

full_name: Polynomial.degree_div_le
code: theorem degree_div_le (p q : R[X]) : degree (p / q) ≤ degree p 
goal: (p / q).degree ≤ p.degree

full_name: Polynomial.degree_div_lt
code: theorem degree_div_lt (hp : p ≠ 0) (hq : 0 < degree q) : degree (p / q) < degree p 
goal: (p / q).degree < p.degree

full_name: Polynomial.isUnit_map
code: theorem isUnit_map [Field k] (f : R →+* k) : IsUnit (p.map f) ↔ IsUnit p 
goal: IsUnit (Polynomial.map f p) ↔ IsUnit p

full_name: Polynomial.map_div
code: theorem map_div [Field k] (f : R →+* k) : (p / q).map f = p.map f / q.map f 
goal: Polynomial.map f (p / q) = Polynomial.map f p / Polynomial.map f q

full_name: Polynomial.map_mod
code: theorem map_mod [Field k] (f : R →+* k) : (p % q).map f = p.map f % q.map f 
goal: Polynomial.map f (p % q) = Polynomial.map f p % Polynomial.map f q

full_name: Polynomial.gcd_map
code: theorem gcd_map [Field k] [DecidableEq R] [DecidableEq k] (f : R →+* k) :
    gcd (p.map f) (q.map f) = (gcd p q).map f 
goal: EuclideanDomain.gcd (Polynomial.map f p) (Polynomial.map f q) = Polynomial.map f (EuclideanDomain.gcd p q)

full_name: Polynomial.eval₂_gcd_eq_zero
code: theorem eval₂_gcd_eq_zero [CommSemiring k] [DecidableEq R]
    {ϕ : R →+* k} {f g : R[X]} {α : k} (hf : f.eval₂ ϕ α = 0)
    (hg : g.eval₂ ϕ α = 0) : (EuclideanDomain.gcd f g).eval₂ ϕ α = 0 
goal: Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0

full_name: Polynomial.eval_gcd_eq_zero
code: theorem eval_gcd_eq_zero [DecidableEq R] {f g : R[X]} {α : R}
    (hf : f.eval α = 0) (hg : g.eval α = 0) : (EuclideanDomain.gcd f g).eval α = 0 
goal: Polynomial.eval α (EuclideanDomain.gcd f g) = 0

full_name: Polynomial.root_left_of_root_gcd
code: theorem root_left_of_root_gcd [CommSemiring k] [DecidableEq R] {ϕ : R →+* k} {f g : R[X]} {α : k}
    (hα : (EuclideanDomain.gcd f g).eval₂ ϕ α = 0) : f.eval₂ ϕ α = 0 
goal: Polynomial.eval₂ ϕ α f = 0

full_name: Polynomial.root_right_of_root_gcd
code: theorem root_right_of_root_gcd [CommSemiring k] [DecidableEq R] {ϕ : R →+* k} {f g : R[X]} {α : k}
    (hα : (EuclideanDomain.gcd f g).eval₂ ϕ α = 0) : g.eval₂ ϕ α = 0 
goal: Polynomial.eval₂ ϕ α g = 0

full_name: Polynomial.root_gcd_iff_root_left_right
code: theorem root_gcd_iff_root_left_right [CommSemiring k] [DecidableEq R]
    {ϕ : R →+* k} {f g : R[X]} {α : k} :
    (EuclideanDomain.gcd f g).eval₂ ϕ α = 0 ↔ f.eval₂ ϕ α = 0 ∧ g.eval₂ ϕ α = 0 
goal: Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0 ↔ Polynomial.eval₂ ϕ α f = 0 ∧ Polynomial.eval₂ ϕ α g = 0

full_name: Polynomial.isRoot_gcd_iff_isRoot_left_right
code: theorem isRoot_gcd_iff_isRoot_left_right [DecidableEq R] {f g : R[X]} {α : R} :
    (EuclideanDomain.gcd f g).IsRoot α ↔ f.IsRoot α ∧ g.IsRoot α 
goal: (EuclideanDomain.gcd f g).IsRoot α ↔ f.IsRoot α ∧ g.IsRoot α

full_name: Polynomial.isCoprime_map
code: theorem isCoprime_map [Field k] (f : R →+* k) : IsCoprime (p.map f) (q.map f) ↔ IsCoprime p q 
goal: IsCoprime (Polynomial.map f p) (Polynomial.map f q) ↔ IsCoprime p q

full_name: Polynomial.mem_roots_map
code: theorem mem_roots_map [CommRing k] [IsDomain k] {f : R →+* k} {x : k} (hp : p ≠ 0) :
    x ∈ (p.map f).roots ↔ p.eval₂ f x = 0 
goal: x ∈ (Polynomial.map f p).roots ↔ Polynomial.eval₂ f x p = 0

full_name: Polynomial.rootSet_monomial
code: theorem rootSet_monomial [CommRing S] [IsDomain S] [Algebra R S] {n : ℕ} (hn : n ≠ 0) {a : R}
    (ha : a ≠ 0) : (monomial n a).rootSet S = {0} 
goal: ((Polynomial.monomial n) a).rootSet S = {0}

full_name: Polynomial.rootSet_C_mul_X_pow
code: theorem rootSet_C_mul_X_pow [CommRing S] [IsDomain S] [Algebra R S] {n : ℕ} (hn : n ≠ 0) {a : R}
    (ha : a ≠ 0) : rootSet (C a * X ^ n) S = {0} 
goal: (Polynomial.C a * Polynomial.X ^ n).rootSet S = {0}

full_name: Polynomial.rootSet_X_pow
code: theorem rootSet_X_pow [CommRing S] [IsDomain S] [Algebra R S] {n : ℕ} (hn : n ≠ 0) :
    (X ^ n : R[X]).rootSet S = {0} 
goal: (Polynomial.X ^ n).rootSet S = {0}

full_name: Polynomial.rootSet_prod
code: theorem rootSet_prod [CommRing S] [IsDomain S] [Algebra R S] {ι : Type*} (f : ι → R[X])
    (s : Finset ι) (h : s.prod f ≠ 0) : (s.prod f).rootSet S = ⋃ i ∈ s, (f i).rootSet S 
goal: (s.prod f).rootSet S = ⋃ i ∈ s, (f i).rootSet S

full_name: Polynomial.exists_root_of_degree_eq_one
code: theorem exists_root_of_degree_eq_one (h : degree p = 1) : ∃ x, IsRoot p x 
goal: ∃ x, p.IsRoot x

full_name: Polynomial.coeff_inv_units
code: theorem coeff_inv_units (u : R[X]ˣ) (n : ℕ) : ((↑u : R[X]).coeff n)⁻¹ = (↑u⁻¹ : R[X]).coeff n 
goal: ((↑u).coeff n)⁻¹ = (↑u⁻¹).coeff n

full_name: Polynomial.monic_normalize
code: theorem monic_normalize [DecidableEq R] (hp0 : p ≠ 0) : Monic (normalize p) 
goal: (normalize p).Monic

full_name: Polynomial.leadingCoeff_div
code: theorem leadingCoeff_div (hpq : q.degree ≤ p.degree) :
    (p / q).leadingCoeff = p.leadingCoeff / q.leadingCoeff 
goal: (p / q).leadingCoeff = p.leadingCoeff / q.leadingCoeff

full_name: Polynomial.div_C_mul
code: theorem div_C_mul : p / (C a * q) = C a⁻¹ * (p / q) 
goal: p / (Polynomial.C a * q) = Polynomial.C a⁻¹ * (p / q)

full_name: Polynomial.C_mul_dvd
code: theorem C_mul_dvd (ha : a ≠ 0) : C a * p ∣ q ↔ p ∣ q 
goal: Polynomial.C a * p ∣ q ↔ p ∣ q

full_name: Polynomial.dvd_C_mul
code: theorem dvd_C_mul (ha : a ≠ 0) : p ∣ Polynomial.C a * q ↔ p ∣ q 
goal: p ∣ Polynomial.C a * q ↔ p ∣ q

full_name: Polynomial.coe_normUnit_of_ne_zero
code: theorem coe_normUnit_of_ne_zero [DecidableEq R] (hp : p ≠ 0) :
    (normUnit p : R[X]) = C p.leadingCoeff⁻¹ 
goal: ↑(normUnit p) = Polynomial.C p.leadingCoeff⁻¹

full_name: Polynomial.normalize_monic
code: theorem normalize_monic [DecidableEq R] (h : Monic p) : normalize p = p 
goal: normalize p = p

full_name: Polynomial.map_dvd_map'
code: theorem map_dvd_map' [Field k] (f : R →+* k) {x y : R[X]} : x.map f ∣ y.map f ↔ x ∣ y 
goal: Polynomial.map f x ∣ Polynomial.map f y ↔ x ∣ y

full_name: Polynomial.degree_normalize
code: theorem degree_normalize [DecidableEq R] : degree (normalize p) = degree p 
goal: (normalize p).degree = p.degree

full_name: Polynomial.prime_of_degree_eq_one
code: theorem prime_of_degree_eq_one (hp1 : degree p = 1) : Prime p 
goal: Prime p

full_name: Polynomial.irreducible_of_degree_eq_one
code: theorem irreducible_of_degree_eq_one (hp1 : degree p = 1) : Irreducible p 
goal: Irreducible p

full_name: Polynomial.not_irreducible_C
code: theorem not_irreducible_C (x : R) : ¬Irreducible (C x) 
goal: ¬Irreducible (Polynomial.C x)

full_name: Polynomial.degree_pos_of_irreducible
code: theorem degree_pos_of_irreducible (hp : Irreducible p) : 0 < p.degree 
goal: 0 < p.degree

full_name: Polynomial.X_sub_C_mul_divByMonic_eq_sub_modByMonic
code: theorem X_sub_C_mul_divByMonic_eq_sub_modByMonic {K : Type*} [Field K] (f : K[X]) (a : K) :
    (X - C a) * (f /ₘ (X - C a)) = f - f %ₘ (X - C a) 
goal: (Polynomial.X - Polynomial.C a) * (f /ₘ (Polynomial.X - Polynomial.C a)) = f - f %ₘ (Polynomial.X - Polynomial.C a)

full_name: Polynomial.divByMonic_add_X_sub_C_mul_derivate_divByMonic_eq_derivative
code: theorem divByMonic_add_X_sub_C_mul_derivate_divByMonic_eq_derivative
    {K : Type*} [Field K] (f : K[X]) (a : K) :
    f /ₘ (X - C a) + (X - C a) * derivative (f /ₘ (X - C a)) = derivative f 
goal: f /ₘ (Polynomial.X - Polynomial.C a) +
    (Polynomial.X - Polynomial.C a) * Polynomial.derivative (f /ₘ (Polynomial.X - Polynomial.C a)) =
  Polynomial.derivative f

full_name: Polynomial.X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic
code: theorem X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic {K : Type*} [Field K] (f : K[X]) {a : K}
    (hf : (X - C a) ∣ f /ₘ (X - C a)) : X - C a ∣ derivative f 
goal: Polynomial.X - Polynomial.C a ∣ Polynomial.derivative f

full_name: Polynomial.isCoprime_of_is_root_of_eval_derivative_ne_zero
code: /-- If `f` is a polynomial over a field, and `a : K` satisfies `f' a ≠ 0`,
then `f / (X - a)` is coprime with `X - a`.
Note that we do not assume `f a = 0`, because `f / (X - a) = (f - f a) / (X - a)`. -/
theorem isCoprime_of_is_root_of_eval_derivative_ne_zero {K : Type*} [Field K] (f : K[X]) (a : K)
    (hf' : f.derivative.eval a ≠ 0) : IsCoprime (X - C a : K[X]) (f /ₘ (X - C a)) 
goal: IsCoprime (Polynomial.X - Polynomial.C a) (f /ₘ (Polynomial.X - Polynomial.C a))

full_name: Polynomial.irreducible_iff_degree_lt
code: /-- To check a polynomial over a field is irreducible, it suffices to check only for
divisors that have smaller degree.

See also: `Polynomial.Monic.irreducible_iff_natDegree`.
-/
theorem irreducible_iff_degree_lt (p : R[X]) (hp0 : p ≠ 0) (hpu : ¬ IsUnit p) :
    Irreducible p ↔ ∀ q, q.degree ≤ ↑(natDegree p / 2) → q ∣ p → IsUnit q 
goal: Irreducible p ↔ ∀ (q : R[X]), q.degree ≤ ↑(p.natDegree / 2) → q ∣ p → IsUnit q

full_name: Polynomial.irreducible_iff_lt_natDegree_lt
code: /-- To check a polynomial `p` over a field is irreducible, it suffices to check there are no
divisors of degree `0 < d ≤ degree p / 2`.

See also: `Polynomial.Monic.irreducible_iff_natDegree'`.
-/
theorem irreducible_iff_lt_natDegree_lt {p : R[X]} (hp0 : p ≠ 0) (hpu : ¬ IsUnit p) :
    Irreducible p ↔ ∀ q, Monic q → natDegree q ∈ Finset.Ioc 0 (natDegree p / 2) → ¬ q ∣ p 
goal: Irreducible p ↔ ∀ (q : R[X]), q.Monic → q.natDegree ∈ Finset.Ioc 0 (p.natDegree / 2) → ¬q ∣ p

full_name: Irreducible.natDegree_pos
code: /-- An irreducible polynomial over a field must have positive degree. -/
theorem Irreducible.natDegree_pos {F : Type*} [Field F] {f : F[X]} (h : Irreducible f) :
    0 < f.natDegree 
goal: 0 < f.natDegree