Division of univariate polynomials

The main defs are divByMonic and modByMonic. The compatibility between these is given by modByMonic_add_div. We also define rootMultiplicity.

theorem Polynomial.X_dvd_iff {R : Type u} [Semiring R] {f : Polynomial R} : Polynomial.X ∣ f ↔ f.coeff 0 = 0

theorem Polynomial.X_pow_dvd_iff {R : Type u} [Semiring R] {f : Polynomial R} {n : ℕ} : Polynomial.X ^ n ∣ f ↔ ∀ d < n, f.coeff d = 0

theorem Polynomial.multiplicity_finite_of_degree_pos_of_monic {R : Type u} [Semiring R] {p : Polynomial R} {q : Polynomial R} (hp : 0 < p.degree) (hmp : p.Monic) (hq : q ≠ 0) : multiplicity.Finite p q

theorem Polynomial.div_wf_lemma {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (h : q.degree ≤ p.degree ∧ p ≠ 0) (hq : q.Monic) : (p - q * (Polynomial.C p.leadingCoeff * Polynomial.X ^ (p.natDegree - q.natDegree))).degree < p.degree

noncomputable def Polynomial.divModByMonicAux {R : Type u} [Ring R] (_p : Polynomial R) {q : Polynomial R} : q.Monic → Polynomial R × Polynomial R

See divByMonic.

Equations

• One or more equations did not get rendered due to their size.

def Polynomial.divByMonic {R : Type u} [Ring R] (p : Polynomial R) (q : Polynomial R) : Polynomial R

divByMonic gives the quotient of p by a monic polynomial q.

Equations

• p.divByMonic q = if hq : q.Monic then (p.divModByMonicAux hq).1 else 0

def Polynomial.modByMonic {R : Type u} [Ring R] (p : Polynomial R) (q : Polynomial R) : Polynomial R

modByMonic gives the remainder of p by a monic polynomial q.

Equations

• p.modByMonic q = if hq : q.Monic then (p.divModByMonicAux hq).2 else p

def Polynomial.«term_/ₘ_» : Lean.TrailingParserDescr

divByMonic gives the quotient of p by a monic polynomial q.

Equations

• Polynomial.«term_/ₘ_» = Lean.ParserDescr.trailingNode `Polynomial.term_/ₘ_ 70 70 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " /ₘ ") (Lean.ParserDescr.cat `term 71))

def Polynomial.«term_%ₘ_» : Lean.TrailingParserDescr

modByMonic gives the remainder of p by a monic polynomial q.

Equations

• Polynomial.«term_%ₘ_» = Lean.ParserDescr.trailingNode `Polynomial.term_%ₘ_ 70 70 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " %ₘ ") (Lean.ParserDescr.cat `term 71))

theorem Polynomial.degree_modByMonic_lt {R : Type u} [Ring R] [Nontrivial R] (p : Polynomial R) {q : Polynomial R} (_hq : q.Monic) : (p.modByMonic q).degree < q.degree

theorem Polynomial.natDegree_modByMonic_lt {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (hmq : q.Monic) (hq : q ≠ 1) : (p.modByMonic q).natDegree < q.natDegree

@[simp]

theorem Polynomial.zero_modByMonic {R : Type u} [Ring R] (p : Polynomial R) : 0 %ₘ p = 0

@[simp]

theorem Polynomial.zero_divByMonic {R : Type u} [Ring R] (p : Polynomial R) : 0 /ₘ p = 0

@[simp]

theorem Polynomial.modByMonic_zero {R : Type u} [Ring R] (p : Polynomial R) : p.modByMonic 0 = p

@[simp]

theorem Polynomial.divByMonic_zero {R : Type u} [Ring R] (p : Polynomial R) : p.divByMonic 0 = 0

theorem Polynomial.divByMonic_eq_of_not_monic {R : Type u} [Ring R] {q : Polynomial R} (p : Polynomial R) (hq : ¬q.Monic) : p.divByMonic q = 0

theorem Polynomial.modByMonic_eq_of_not_monic {R : Type u} [Ring R] {q : Polynomial R} (p : Polynomial R) (hq : ¬q.Monic) : p.modByMonic q = p

theorem Polynomial.modByMonic_eq_self_iff {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} [Nontrivial R] (hq : q.Monic) : p.modByMonic q = p ↔ p.degree < q.degree

theorem Polynomial.degree_modByMonic_le {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (hq : q.Monic) : (p.modByMonic q).degree ≤ q.degree

theorem Polynomial.natDegree_modByMonic_le {R : Type u} [Ring R] (p : Polynomial R) {g : Polynomial R} (hg : g.Monic) : (p.modByMonic g).natDegree ≤ g.natDegree

theorem Polynomial.X_dvd_sub_C {R : Type u} [Ring R] {p : Polynomial R} : Polynomial.X ∣ p - Polynomial.C (p.coeff 0)

theorem Polynomial.modByMonic_eq_sub_mul_div {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (_hq : q.Monic) : p.modByMonic q = p - q * p.divByMonic q

theorem Polynomial.modByMonic_add_div {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (hq : q.Monic) : p.modByMonic q + q * p.divByMonic q = p

theorem Polynomial.divByMonic_eq_zero_iff {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} [Nontrivial R] (hq : q.Monic) : p.divByMonic q = 0 ↔ p.degree < q.degree

theorem Polynomial.degree_add_divByMonic {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) (h : q.degree ≤ p.degree) : q.degree + (p.divByMonic q).degree = p.degree

theorem Polynomial.degree_divByMonic_le {R : Type u} [Ring R] (p : Polynomial R) (q : Polynomial R) : (p.divByMonic q).degree ≤ p.degree

theorem Polynomial.degree_divByMonic_lt {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (hq : q.Monic) (hp0 : p ≠ 0) (h0q : 0 < q.degree) : (p.divByMonic q).degree < p.degree

theorem Polynomial.natDegree_divByMonic {R : Type u} [Ring R] (f : Polynomial R) {g : Polynomial R} (hg : g.Monic) : (f.divByMonic g).natDegree = f.natDegree - g.natDegree

theorem Polynomial.div_modByMonic_unique {R : Type u} [Ring R] {f : Polynomial R} {g : Polynomial R} (q : Polynomial R) (r : Polynomial R) (hg : g.Monic) (h : r + g * q = f ∧ r.degree < g.degree) : f.divByMonic g = q ∧ f.modByMonic g = r

theorem Polynomial.map_mod_divByMonic {R : Type u} {S : Type v} [Ring R] {p : Polynomial R} {q : Polynomial R} [Ring S] (f : R →+* S) (hq : q.Monic) : Polynomial.map f (p.divByMonic q) = (Polynomial.map f p).divByMonic (Polynomial.map f q) ∧ Polynomial.map f (p.modByMonic q) = (Polynomial.map f p).modByMonic (Polynomial.map f q)

theorem Polynomial.map_divByMonic {R : Type u} {S : Type v} [Ring R] {p : Polynomial R} {q : Polynomial R} [Ring S] (f : R →+* S) (hq : q.Monic) : Polynomial.map f (p.divByMonic q) = (Polynomial.map f p).divByMonic (Polynomial.map f q)

theorem Polynomial.map_modByMonic {R : Type u} {S : Type v} [Ring R] {p : Polynomial R} {q : Polynomial R} [Ring S] (f : R →+* S) (hq : q.Monic) : Polynomial.map f (p.modByMonic q) = (Polynomial.map f p).modByMonic (Polynomial.map f q)

theorem Polynomial.modByMonic_eq_zero_iff_dvd {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) : p.modByMonic q = 0 ↔ q ∣ p

@[deprecated Polynomial.modByMonic_eq_zero_iff_dvd]

theorem Polynomial.dvd_iff_modByMonic_eq_zero {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) : p.modByMonic q = 0 ↔ q ∣ p

Alias of Polynomial.modByMonic_eq_zero_iff_dvd.

@[simp]

theorem Polynomial.self_mul_modByMonic {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) : (q * p).modByMonic q = 0

See Polynomial.mul_left_modByMonic for the other multiplication order. That version, unlike this one, requires commutativity.

theorem Polynomial.map_dvd_map {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) (hf : Function.Injective ⇑f) {x : Polynomial R} {y : Polynomial R} (hx : x.Monic) : Polynomial.map f x ∣ Polynomial.map f y ↔ x ∣ y

@[simp]

theorem Polynomial.modByMonic_one {R : Type u} [Ring R] (p : Polynomial R) : p.modByMonic 1 = 0

@[simp]

theorem Polynomial.divByMonic_one {R : Type u} [Ring R] (p : Polynomial R) : p.divByMonic 1 = p

theorem Polynomial.sum_modByMonic_coeff {R : Type u} [Ring R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) {n : ℕ} (hn : q.degree ≤ ↑n) : (Finset.univ.sum fun (i : Fin n) => (Polynomial.monomial ↑i) ((p.modByMonic q).coeff ↑i)) = p.modByMonic q

theorem Polynomial.mul_div_mod_by_monic_cancel_left {R : Type u} [Ring R] (p : Polynomial R) {q : Polynomial R} (hmo : q.Monic) : (q * p).divByMonic q = p

theorem Polynomial.coeff_divByMonic_X_sub_C_rec {R : Type u} [Ring R] (p : Polynomial R) (a : R) (n : ℕ) : (p.divByMonic (Polynomial.X - Polynomial.C a)).coeff n = p.coeff (n + 1) + a * (p.divByMonic (Polynomial.X - Polynomial.C a)).coeff (n + 1)

theorem Polynomial.coeff_divByMonic_X_sub_C {R : Type u} [Ring R] (p : Polynomial R) (a : R) (n : ℕ) : (p.divByMonic (Polynomial.X - Polynomial.C a)).coeff n = (Finset.Icc (n + 1) p.natDegree).sum fun (i : ℕ) => a ^ (i - (n + 1)) * p.coeff i

theorem Polynomial.not_isField (R : Type u) [Ring R] : ¬IsField (Polynomial R)

def Polynomial.decidableDvdMonic {R : Type u} [Ring R] {q : Polynomial R} [DecidableEq R] (p : Polynomial R) (hq : q.Monic) : Decidable (q ∣ p)

An algorithm for deciding polynomial divisibility. The algorithm is "compute p %ₘ q and compare to 0". See polynomial.modByMonic for the algorithm that computes %ₘ.

Equations

• Polynomial.decidableDvdMonic p hq = decidable_of_iff (p.modByMonic q = 0) ⋯

theorem Polynomial.multiplicity_X_sub_C_finite {R : Type u} [Ring R] {p : Polynomial R} (a : R) (h0 : p ≠ 0) : multiplicity.Finite (Polynomial.X - Polynomial.C a) p

def Polynomial.rootMultiplicity {R : Type u} [Ring R] (a : R) (p : Polynomial R) : ℕ

The largest power of X - C a which divides p. This could be computable via the divisibility algorithm Polynomial.decidableDvdMonic, as shown by Polynomial.rootMultiplicity_eq_nat_find_of_nonzero which has a computable RHS.

Equations

• Polynomial.rootMultiplicity a p = if h0 : p = 0 then 0 else let x := fun (n : ℕ) => Not.decidable; Nat.find ⋯

theorem Polynomial.rootMultiplicity_eq_nat_find_of_nonzero {R : Type u} [Ring R] [DecidableEq R] {p : Polynomial R} (p0 : p ≠ 0) {a : R} : Polynomial.rootMultiplicity a p = Nat.find ⋯

theorem Polynomial.rootMultiplicity_eq_multiplicity {R : Type u} [Ring R] [DecidableEq R] [DecidableRel fun (x x_1 : Polynomial R) => x ∣ x_1] (p : Polynomial R) (a : R) : Polynomial.rootMultiplicity a p = if h0 : p = 0 then 0 else (multiplicity (Polynomial.X - Polynomial.C a) p).get ⋯

@[simp]

theorem Polynomial.rootMultiplicity_zero {R : Type u} [Ring R] {x : R} : Polynomial.rootMultiplicity x 0 = 0

@[simp]

theorem Polynomial.rootMultiplicity_C {R : Type u} [Ring R] (r : R) (a : R) : Polynomial.rootMultiplicity a (Polynomial.C r) = 0

theorem Polynomial.pow_rootMultiplicity_dvd {R : Type u} [Ring R] (p : Polynomial R) (a : R) : (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p ∣ p

theorem Polynomial.pow_mul_divByMonic_rootMultiplicity_eq {R : Type u} [Ring R] (p : Polynomial R) (a : R) : (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p * p.divByMonic ((Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p) = p

theorem Polynomial.exists_eq_pow_rootMultiplicity_mul_and_not_dvd {R : Type u} [Ring R] (p : Polynomial R) (hp : p ≠ 0) (a : R) : ∃ (q : Polynomial R), p = (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p * q ∧ ¬Polynomial.X - Polynomial.C a ∣ q

@[simp]

theorem Polynomial.modByMonic_X_sub_C_eq_C_eval {R : Type u} [CommRing R] (p : Polynomial R) (a : R) : p.modByMonic (Polynomial.X - Polynomial.C a) = Polynomial.C (Polynomial.eval a p)

theorem Polynomial.mul_divByMonic_eq_iff_isRoot {R : Type u} {a : R} [CommRing R] {p : Polynomial R} : (Polynomial.X - Polynomial.C a) * p.divByMonic (Polynomial.X - Polynomial.C a) = p ↔ p.IsRoot a

theorem Polynomial.dvd_iff_isRoot {R : Type u} {a : R} [CommRing R] {p : Polynomial R} : Polynomial.X - Polynomial.C a ∣ p ↔ p.IsRoot a

theorem Polynomial.X_sub_C_dvd_sub_C_eval {R : Type u} {a : R} [CommRing R] {p : Polynomial R} : Polynomial.X - Polynomial.C a ∣ p - Polynomial.C (Polynomial.eval a p)

theorem Polynomial.mem_span_C_X_sub_C_X_sub_C_iff_eval_eval_eq_zero {R : Type u} {a : R} [CommRing R] {b : Polynomial R} {P : Polynomial (Polynomial R)} : P ∈ Ideal.span {Polynomial.C (Polynomial.X - Polynomial.C a), Polynomial.X - Polynomial.C b} ↔ Polynomial.eval a (Polynomial.eval b P) = 0

theorem Polynomial.modByMonic_X {R : Type u} [CommRing R] (p : Polynomial R) : p.modByMonic Polynomial.X = Polynomial.C (Polynomial.eval 0 p)

theorem Polynomial.eval₂_modByMonic_eq_self_of_root {R : Type u} {S : Type v} [CommRing R] [CommRing S] {f : R →+* S} {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) {x : S} (hx : Polynomial.eval₂ f x q = 0) : Polynomial.eval₂ f x (p.modByMonic q) = Polynomial.eval₂ f x p

theorem Polynomial.sub_dvd_eval_sub {R : Type u} [CommRing R] (a : R) (b : R) (p : Polynomial R) : a - b ∣ Polynomial.eval a p - Polynomial.eval b p

theorem Polynomial.ker_evalRingHom {R : Type u} [CommRing R] (x : R) : RingHom.ker (Polynomial.evalRingHom x) = Ideal.span {Polynomial.X - Polynomial.C x}

@[simp]

theorem Polynomial.rootMultiplicity_eq_zero_iff {R : Type u} [CommRing R] {p : Polynomial R} {x : R} : Polynomial.rootMultiplicity x p = 0 ↔ p.IsRoot x → p = 0

theorem Polynomial.rootMultiplicity_eq_zero {R : Type u} [CommRing R] {p : Polynomial R} {x : R} (h : ¬p.IsRoot x) : Polynomial.rootMultiplicity x p = 0

@[simp]

theorem Polynomial.rootMultiplicity_pos' {R : Type u} [CommRing R] {p : Polynomial R} {x : R} : 0 < Polynomial.rootMultiplicity x p ↔ p ≠ 0 ∧ p.IsRoot x

theorem Polynomial.rootMultiplicity_pos {R : Type u} [CommRing R] {p : Polynomial R} (hp : p ≠ 0) {x : R} : 0 < Polynomial.rootMultiplicity x p ↔ p.IsRoot x

theorem Polynomial.eval_divByMonic_pow_rootMultiplicity_ne_zero {R : Type u} [CommRing R] {p : Polynomial R} (a : R) (hp : p ≠ 0) : Polynomial.eval a (p.divByMonic ((Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p)) ≠ 0

@[simp]

theorem Polynomial.mul_self_modByMonic {R : Type u} [CommRing R] {p : Polynomial R} {q : Polynomial R} (hq : q.Monic) : (p * q).modByMonic q = 0

See Polynomial.mul_right_modByMonic for the other multiplication order. This version, unlike that one, requires commutativity.