File: Mathlib/Algebra/Polynomial/Monic.lean

full_name: Polynomial.monic_zero_iff_subsingleton
code: theorem monic_zero_iff_subsingleton : Monic (0 : R[X]) ↔ Subsingleton R 
goal: Polynomial.Monic 0 ↔ Subsingleton R

full_name: Polynomial.not_monic_zero_iff
code: theorem not_monic_zero_iff : ¬Monic (0 : R[X]) ↔ (0 : R) ≠ 1 
goal: ¬Polynomial.Monic 0 ↔ 0 ≠ 1

full_name: Polynomial.monic_zero_iff_subsingleton'
code: theorem monic_zero_iff_subsingleton' :
    Monic (0 : R[X]) ↔ (∀ f g : R[X], f = g) ∧ ∀ a b : R, a = b 
goal: Polynomial.Monic 0 ↔ (∀ (f g : R[X]), f = g) ∧ ∀ (a b : R), a = b

full_name: Polynomial.Monic.as_sum
code: theorem Monic.as_sum (hp : p.Monic) :
    p = X ^ p.natDegree + ∑ i ∈ range p.natDegree, C (p.coeff i) * X ^ i 
goal: p = Polynomial.X ^ p.natDegree + ∑ i ∈ Finset.range p.natDegree, Polynomial.C (p.coeff i) * Polynomial.X ^ i

full_name: Polynomial.ne_zero_of_ne_zero_of_monic
code: theorem ne_zero_of_ne_zero_of_monic (hp : p ≠ 0) (hq : Monic q) : q ≠ 0 
goal: q ≠ 0

full_name: Polynomial.Monic.map
code: theorem Monic.map [Semiring S] (f : R →+* S) (hp : Monic p) : Monic (p.map f) 
goal: (Polynomial.map f p).Monic

full_name: Polynomial.monic_C_mul_of_mul_leadingCoeff_eq_one
code: theorem monic_C_mul_of_mul_leadingCoeff_eq_one {b : R} (hp : b * p.leadingCoeff = 1) :
    Monic (C b * p) 
goal: (Polynomial.C b * p).Monic

full_name: Polynomial.monic_mul_C_of_leadingCoeff_mul_eq_one
code: theorem monic_mul_C_of_leadingCoeff_mul_eq_one {b : R} (hp : p.leadingCoeff * b = 1) :
    Monic (p * C b) 
goal: (p * Polynomial.C b).Monic

full_name: Polynomial.monic_of_degree_le
code: theorem monic_of_degree_le (n : ℕ) (H1 : degree p ≤ n) (H2 : coeff p n = 1) : Monic p 
goal: p.Monic

full_name: Polynomial.monic_X_pow_add
code: theorem monic_X_pow_add {n : ℕ} (H : degree p ≤ n) : Monic (X ^ (n + 1) + p) 
goal: (Polynomial.X ^ (n + 1) + p).Monic

full_name: Polynomial.monic_X_pow_add_C
code: theorem monic_X_pow_add_C {n : ℕ} (h : n ≠ 0) : (X ^ n + C a).Monic 
goal: (Polynomial.X ^ n + Polynomial.C a).Monic

full_name: Polynomial.monic_X_add_C
code: theorem monic_X_add_C (x : R) : Monic (X + C x) 
goal: (Polynomial.X + Polynomial.C x).Monic

full_name: Polynomial.Monic.mul
code: theorem Monic.mul (hp : Monic p) (hq : Monic q) : Monic (p * q) 
goal: (p * q).Monic

full_name: Polynomial.Monic.pow
code: theorem Monic.pow (hp : Monic p) : ∀ n : ℕ, Monic (p ^ n)
  
goal: (p ^ n).Monic

full_name: Polynomial.Monic.add_of_left
code: theorem Monic.add_of_left (hp : Monic p) (hpq : degree q < degree p) : Monic (p + q) 
goal: (p + q).Monic

full_name: Polynomial.Monic.add_of_right
code: theorem Monic.add_of_right (hq : Monic q) (hpq : degree p < degree q) : Monic (p + q) 
goal: (p + q).Monic

full_name: Polynomial.Monic.of_mul_monic_left
code: theorem Monic.of_mul_monic_left (hp : p.Monic) (hpq : (p * q).Monic) : q.Monic 
goal: q.Monic

full_name: Polynomial.Monic.of_mul_monic_right
code: theorem Monic.of_mul_monic_right (hq : q.Monic) (hpq : (p * q).Monic) : p.Monic 
goal: p.Monic

full_name: Polynomial.Monic.natDegree_eq_zero_iff_eq_one
code: @[simp]
theorem natDegree_eq_zero_iff_eq_one (hp : p.Monic) : p.natDegree = 0 ↔ p = 1 
goal: p.natDegree = 0 ↔ p = 1

full_name: Polynomial.Monic.degree_le_zero_iff_eq_one
code: @[simp]
theorem degree_le_zero_iff_eq_one (hp : p.Monic) : p.degree ≤ 0 ↔ p = 1 
goal: p.degree ≤ 0 ↔ p = 1

full_name: Polynomial.Monic.natDegree_mul
code: theorem natDegree_mul (hp : p.Monic) (hq : q.Monic) :
    (p * q).natDegree = p.natDegree + q.natDegree 
goal: (p * q).natDegree = p.natDegree + q.natDegree

full_name: Polynomial.Monic.degree_mul_comm
code: theorem degree_mul_comm (hp : p.Monic) (q : R[X]) : (p * q).degree = (q * p).degree 
goal: (p * q).degree = (q * p).degree

full_name: Polynomial.Monic.natDegree_mul'
code: nonrec theorem natDegree_mul' (hp : p.Monic) (hq : q ≠ 0) :
    (p * q).natDegree = p.natDegree + q.natDegree 
goal: (p * q).natDegree = p.natDegree + q.natDegree

full_name: Polynomial.Monic.natDegree_mul_comm
code: theorem natDegree_mul_comm (hp : p.Monic) (q : R[X]) : (p * q).natDegree = (q * p).natDegree 
goal: (p * q).natDegree = (q * p).natDegree

full_name: Polynomial.Monic.not_dvd_of_natDegree_lt
code: theorem not_dvd_of_natDegree_lt (hp : Monic p) (h0 : q ≠ 0) (hl : natDegree q < natDegree p) :
    ¬p ∣ q 
goal: ¬p ∣ q

full_name: Polynomial.Monic.not_dvd_of_degree_lt
code: theorem not_dvd_of_degree_lt (hp : Monic p) (h0 : q ≠ 0) (hl : degree q < degree p) : ¬p ∣ q 
goal: ¬p ∣ q

full_name: Polynomial.Monic.nextCoeff_mul
code: theorem nextCoeff_mul (hp : Monic p) (hq : Monic q) :
    nextCoeff (p * q) = nextCoeff p + nextCoeff q 
goal: (p * q).nextCoeff = p.nextCoeff + q.nextCoeff

full_name: Polynomial.Monic.nextCoeff_pow
code: theorem nextCoeff_pow (hp : p.Monic) (n : ℕ) : (p ^ n).nextCoeff = n • p.nextCoeff 
goal: (p ^ n).nextCoeff = n • p.nextCoeff

full_name: Polynomial.Monic.eq_one_of_map_eq_one
code: theorem eq_one_of_map_eq_one {S : Type*} [Semiring S] [Nontrivial S] (f : R →+* S) (hp : p.Monic)
    (map_eq : p.map f = 1) : p = 1 
goal: p = 1

full_name: Polynomial.Monic.natDegree_pow
code: theorem natDegree_pow (hp : p.Monic) (n : ℕ) : (p ^ n).natDegree = n * p.natDegree 
goal: (p ^ n).natDegree = n * p.natDegree

full_name: Polynomial.natDegree_pow_X_add_C
code: @[simp]
theorem natDegree_pow_X_add_C [Nontrivial R] (n : ℕ) (r : R) : ((X + C r) ^ n).natDegree = n 
goal: ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n

full_name: Polynomial.Monic.eq_one_of_isUnit
code: theorem Monic.eq_one_of_isUnit (hm : Monic p) (hpu : IsUnit p) : p = 1 
goal: p = 1

full_name: Polynomial.Monic.isUnit_iff
code: theorem Monic.isUnit_iff (hm : p.Monic) : IsUnit p ↔ p = 1 
goal: IsUnit p ↔ p = 1

full_name: Polynomial.eq_of_monic_of_associated
code: theorem eq_of_monic_of_associated (hp : p.Monic) (hq : q.Monic) (hpq : Associated p q) : p = q 
goal: p = q

full_name: Polynomial.monic_multiset_prod_of_monic
code: theorem monic_multiset_prod_of_monic (t : Multiset ι) (f : ι → R[X]) (ht : ∀ i ∈ t, Monic (f i)) :
    Monic (t.map f).prod 
goal: (Multiset.map f t).prod.Monic

full_name: Polynomial.monic_prod_of_monic
code: theorem monic_prod_of_monic (s : Finset ι) (f : ι → R[X]) (hs : ∀ i ∈ s, Monic (f i)) :
    Monic (∏ i ∈ s, f i) 
goal: (∏ i ∈ s, f i).Monic

full_name: Polynomial.Monic.nextCoeff_multiset_prod
code: theorem Monic.nextCoeff_multiset_prod (t : Multiset ι) (f : ι → R[X]) (h : ∀ i ∈ t, Monic (f i)) :
    nextCoeff (t.map f).prod = (t.map fun i => nextCoeff (f i)).sum 
goal: (Multiset.map f t).prod.nextCoeff = (Multiset.map (fun i => (f i).nextCoeff) t).sum

full_name: Polynomial.Monic.nextCoeff_prod
code: theorem Monic.nextCoeff_prod (s : Finset ι) (f : ι → R[X]) (h : ∀ i ∈ s, Monic (f i)) :
    nextCoeff (∏ i ∈ s, f i) = ∑ i ∈ s, nextCoeff (f i) 
goal: (∏ i ∈ s, f i).nextCoeff = ∑ i ∈ s, (f i).nextCoeff

full_name: Polynomial.Monic.natDegree_map
code: @[simp]
theorem Monic.natDegree_map [Semiring S] [Nontrivial S] {P : R[X]} (hmo : P.Monic) (f : R →+* S) :
    (P.map f).natDegree = P.natDegree 
goal: (Polynomial.map f P).natDegree = P.natDegree

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

full_name: Polynomial.degree_map_eq_of_injective
code: theorem degree_map_eq_of_injective (hf : Injective f) (p : R[X]) : degree (p.map f) = degree p 
goal: (Polynomial.map f p).degree = p.degree

full_name: Polynomial.natDegree_map_eq_of_injective
code: theorem natDegree_map_eq_of_injective (hf : Injective f) (p : R[X]) :
    natDegree (p.map f) = natDegree p 
goal: (Polynomial.map f p).natDegree = p.natDegree

full_name: Polynomial.leadingCoeff_map'
code: theorem leadingCoeff_map' (hf : Injective f) (p : R[X]) :
    leadingCoeff (p.map f) = f (leadingCoeff p) 
goal: (Polynomial.map f p).leadingCoeff = f p.leadingCoeff

full_name: Polynomial.nextCoeff_map
code: theorem nextCoeff_map (hf : Injective f) (p : R[X]) : (p.map f).nextCoeff = f p.nextCoeff 
goal: (Polynomial.map f p).nextCoeff = f p.nextCoeff

full_name: Polynomial.leadingCoeff_of_injective
code: theorem leadingCoeff_of_injective (hf : Injective f) (p : R[X]) :
    leadingCoeff (p.map f) = f (leadingCoeff p) 
goal: (Polynomial.map f p).leadingCoeff = f p.leadingCoeff

full_name: Polynomial.monic_of_injective
code: theorem monic_of_injective (hf : Injective f) {p : R[X]} (hp : (p.map f).Monic) : p.Monic 
goal: p.Monic

full_name: Function.Injective.monic_map_iff
code: theorem _root_.Function.Injective.monic_map_iff (hf : Injective f) {p : R[X]} :
    p.Monic ↔ (p.map f).Monic 
goal: p.Monic ↔ (Polynomial.map f p).Monic

full_name: Polynomial.monic_X_sub_C
code: theorem monic_X_sub_C (x : R) : Monic (X - C x) 
goal: (Polynomial.X - Polynomial.C x).Monic

full_name: Polynomial.monic_X_pow_sub
code: theorem monic_X_pow_sub {n : ℕ} (H : degree p ≤ n) : Monic (X ^ (n + 1) - p) 
goal: (Polynomial.X ^ (n + 1) - p).Monic

full_name: Polynomial.monic_X_pow_sub_C
code: /-- `X ^ n - a` is monic. -/
theorem monic_X_pow_sub_C {R : Type u} [Ring R] (a : R) {n : ℕ} (h : n ≠ 0) :
    (X ^ n - C a).Monic 
goal: (Polynomial.X ^ n - Polynomial.C a).Monic

full_name: Polynomial.not_isUnit_X_pow_sub_one
code: theorem not_isUnit_X_pow_sub_one (R : Type*) [CommRing R] [Nontrivial R] (n : ℕ) :
    ¬IsUnit (X ^ n - 1 : R[X]) 
goal: ¬IsUnit (Polynomial.X ^ n - 1)

full_name: Polynomial.Monic.sub_of_left
code: theorem Monic.sub_of_left {p q : R[X]} (hp : Monic p) (hpq : degree q < degree p) :
    Monic (p - q) 
goal: (p - q).Monic

full_name: Polynomial.Monic.sub_of_right
code: theorem Monic.sub_of_right {p q : R[X]} (hq : q.leadingCoeff = -1) (hpq : degree p < degree q) :
    Monic (p - q) 
goal: (p - q).Monic

full_name: Polynomial.not_monic_zero
code: @[simp]
theorem not_monic_zero : ¬Monic (0 : R[X]) 
goal: ¬Polynomial.Monic 0

full_name: Polynomial.Monic.mul_left_ne_zero
code: theorem Monic.mul_left_ne_zero (hp : Monic p) {q : R[X]} (hq : q ≠ 0) : q * p ≠ 0 
goal: q * p ≠ 0

full_name: Polynomial.Monic.mul_right_ne_zero
code: theorem Monic.mul_right_ne_zero (hp : Monic p) {q : R[X]} (hq : q ≠ 0) : p * q ≠ 0 
goal: p * q ≠ 0

full_name: Polynomial.Monic.mul_natDegree_lt_iff
code: theorem Monic.mul_natDegree_lt_iff (h : Monic p) {q : R[X]} :
    (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0 
goal: (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0

full_name: Polynomial.Monic.mul_right_eq_zero_iff
code: theorem Monic.mul_right_eq_zero_iff (h : Monic p) {q : R[X]} : p * q = 0 ↔ q = 0 
goal: p * q = 0 ↔ q = 0

full_name: Polynomial.Monic.mul_left_eq_zero_iff
code: theorem Monic.mul_left_eq_zero_iff (h : Monic p) {q : R[X]} : q * p = 0 ↔ q = 0 
goal: q * p = 0 ↔ q = 0

full_name: Polynomial.Monic.isRegular
code: theorem Monic.isRegular {R : Type*} [Ring R] {p : R[X]} (hp : Monic p) : IsRegular p 
goal: IsRegular p

full_name: Polynomial.degree_smul_of_smul_regular
code: theorem degree_smul_of_smul_regular {S : Type*} [Monoid S] [DistribMulAction S R] {k : S}
    (p : R[X]) (h : IsSMulRegular R k) : (k • p).degree = p.degree 
goal: (k • p).degree = p.degree

full_name: Polynomial.natDegree_smul_of_smul_regular
code: theorem natDegree_smul_of_smul_regular {S : Type*} [Monoid S] [DistribMulAction S R] {k : S}
    (p : R[X]) (h : IsSMulRegular R k) : (k • p).natDegree = p.natDegree 
goal: (k • p).natDegree = p.natDegree

full_name: Polynomial.leadingCoeff_smul_of_smul_regular
code: theorem leadingCoeff_smul_of_smul_regular {S : Type*} [Monoid S] [DistribMulAction S R] {k : S}
    (p : R[X]) (h : IsSMulRegular R k) : (k • p).leadingCoeff = k • p.leadingCoeff 
goal: (k • p).leadingCoeff = k • p.leadingCoeff

full_name: Polynomial.monic_of_isUnit_leadingCoeff_inv_smul
code: theorem monic_of_isUnit_leadingCoeff_inv_smul (h : IsUnit p.leadingCoeff) :
    Monic (h.unit⁻¹ • p) 
goal: (h.unit⁻¹ • p).Monic

full_name: Polynomial.isUnit_leadingCoeff_mul_right_eq_zero_iff
code: theorem isUnit_leadingCoeff_mul_right_eq_zero_iff (h : IsUnit p.leadingCoeff) {q : R[X]} :
    p * q = 0 ↔ q = 0 
goal: p * q = 0 ↔ q = 0

full_name: Polynomial.isUnit_leadingCoeff_mul_left_eq_zero_iff
code: theorem isUnit_leadingCoeff_mul_left_eq_zero_iff (h : IsUnit p.leadingCoeff) {q : R[X]} :
    q * p = 0 ↔ q = 0 
goal: q * p = 0 ↔ q = 0