ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- bddAbove_smul_iff_of_neg
@[simp] lemma bddAbove_smul_iff_of_neg (ha : a < 0) : BddAbove (a • s) ↔ BddBelow s 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrderedField α] [OrderedAddCommGroup β] [Module α β] [PosSMulMono α β] {s : Set β} {a : α} (ha : a < 0)
Goal: BddAbove (a • s) ↔ BddBelow s
-- OrderedSMul.smul_lt_smul_of_pos
class OrderedSMul (R M : Type*) [OrderedSemiring R] [OrderedAddCommMonoid M] [SMulWithZero R M] :
  Prop where
    protected smul_lt_smul_of_pos : ∀ {a b : M}, ∀ {c : R}, a < b → 0 < c → c • a < c • b
    protected lt_of_smul_lt_smul_of_pos : ∀ {a b : M}, ∀ {c : R}, c • a < c • b → 0 < c → a < b
Arguments: {R : Type u_1} {M : Type u_2} [OrderedSemiring R] [OrderedAddCommMonoid M] [SMulWithZero R M] [self : OrderedSMul R M] {a b : M} {c : R}
Goal: a < b → 0 < c → c • a < c • b
-- OrderedSMul.lt_of_smul_lt_smul_of_pos
class OrderedSMul (R M : Type*) [OrderedSemiring R] [OrderedAddCommMonoid M] [SMulWithZero R M] :
  Prop where
    protected smul_lt_smul_of_pos : ∀ {a b : M}, ∀ {c : R}, a < b → 0 < c → c • a < c • b
    protected lt_of_smul_lt_smul_of_pos : ∀ {a b : M}, ∀ {c : R}, c • a < c • b → 0 < c → a < b
Arguments: {R : Type u_1} {M : Type u_2} [OrderedSemiring R] [OrderedAddCommMonoid M] [SMulWithZero R M] [self : OrderedSMul R M] {a b : M} {c : R}
Goal: c • a < c • b → 0 < c → a < b
-- OrderedSMul.mk''
theorem OrderedSMul.mk'' [OrderedSemiring 𝕜] [LinearOrderedAddCommMonoid M] [SMulWithZero 𝕜 M]
    (h : ∀ ⦃c : 𝕜⦄, 0 < c → StrictMono fun a : M => c • a) : OrderedSMul 𝕜 M 
Arguments: {𝕜 : Type u_5} {M : Type u_7} [OrderedSemiring 𝕜] [LinearOrderedAddCommMonoid M] [SMulWithZero 𝕜 M] (h : ∀ ⦃c : 𝕜⦄, 0 < c → StrictMono fun a => c • a)
Goal: OrderedSMul 𝕜 M
-- OrderedSMul.mk'
theorem OrderedSMul.mk' (h : ∀ ⦃a b : M⦄ ⦃c : 𝕜⦄, a < b → 0 < c → c • a ≤ c • b) :
    OrderedSMul 𝕜 M 
Arguments: {𝕜 : Type u_5} {M : Type u_7} [LinearOrderedSemifield 𝕜] [OrderedAddCommMonoid M] [MulActionWithZero 𝕜 M] (h : ∀ ⦃a b : M⦄ ⦃c : 𝕜⦄, a < b → 0 < c → c • a ≤ c • b)
Goal: OrderedSMul 𝕜 M
-- inf_eq_half_smul_add_sub_abs_sub
lemma inf_eq_half_smul_add_sub_abs_sub (x y : β) : x ⊓ y = (⅟2 : α) • (x + y - |y - x|) 
Arguments: (α : Type u_9) {β : Type u_10} [Semiring α] [Invertible 2] [Lattice β] [AddCommGroup β] [Module α β] [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (x y : β)
Goal: x ⊓ y = ⅟2 • (x + y - |y - x|)
-- sup_eq_half_smul_add_add_abs_sub
lemma sup_eq_half_smul_add_add_abs_sub (x y : β) : x ⊔ y = (⅟2 : α) • (x + y + |y - x|) 
Arguments: (α : Type u_9) {β : Type u_10} [Semiring α] [Invertible 2] [Lattice β] [AddCommGroup β] [Module α β] [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (x y : β)
Goal: x ⊔ y = ⅟2 • (x + y + |y - x|)
-- inf_eq_half_smul_add_sub_abs_sub'
lemma inf_eq_half_smul_add_sub_abs_sub' (x y : β) : x ⊓ y = (2⁻¹ : α) • (x + y - |y - x|) 
Arguments: (α : Type u_9) {β : Type u_10} [DivisionSemiring α] [NeZero 2] [Lattice β] [AddCommGroup β] [Module α β] [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (x y : β)
Goal: x ⊓ y = 2⁻¹ • (x + y - |y - x|)
-- sup_eq_half_smul_add_add_abs_sub'
lemma sup_eq_half_smul_add_add_abs_sub' (x y : β) : x ⊔ y = (2⁻¹ : α) • (x + y + |y - x|) 
Arguments: (α : Type u_9) {β : Type u_10} [DivisionSemiring α] [NeZero 2] [Lattice β] [AddCommGroup β] [Module α β] [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (x y : β)
Goal: x ⊔ y = 2⁻¹ • (x + y + |y - x|)
-- algebraMap_mono
@[mono] lemma algebraMap_mono : Monotone (algebraMap α β) 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [OrderedSemiring β] [Algebra α β] [SMulPosMono α β]
Goal: Monotone ⇑(algebraMap α β)
-- GCongr.algebraMap_le_algebraMap
@[gcongr] protected lemma GCongr.algebraMap_le_algebraMap {a₁ a₂ : α} (ha : a₁ ≤ a₂) :
    algebraMap α β a₁ ≤ algebraMap α β a₂ 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [OrderedSemiring β] [Algebra α β] [SMulPosMono α β] {a₁ a₂ : α} (ha : a₁ ≤ a₂)
Goal: (algebraMap α β) a₁ ≤ (algebraMap α β) a₂
-- algebraMap_nonneg
lemma algebraMap_nonneg (ha : 0 ≤ a) : 0 ≤ algebraMap α β a 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [OrderedSemiring β] [Algebra α β] [SMulPosMono α β] {a : α} (ha : 0 ≤ a)
Goal: 0 ≤ (algebraMap α β) a
-- algebraMap_le_algebraMap
@[simp] lemma algebraMap_le_algebraMap : algebraMap α β a₁ ≤ algebraMap α β a₂ ↔ a₁ ≤ a₂ 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedCommSemiring α] [StrictOrderedSemiring β] [Algebra α β] [SMulPosMono α β] [SMulPosReflectLE α β] {a₁ a₂ : α}
Goal: (algebraMap α β) a₁ ≤ (algebraMap α β) a₂ ↔ a₁ ≤ a₂
-- algebraMap_strictMono
@[mono] lemma algebraMap_strictMono : StrictMono (algebraMap α β) 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [StrictOrderedSemiring β] [Algebra α β] [SMulPosStrictMono α β]
Goal: StrictMono ⇑(algebraMap α β)
-- GCongr.algebraMap_lt_algebraMap
@[gcongr] protected lemma GCongr.algebraMap_lt_algebraMap {a₁ a₂ : α} (ha : a₁ < a₂) :
    algebraMap α β a₁ < algebraMap α β a₂ 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [StrictOrderedSemiring β] [Algebra α β] [SMulPosStrictMono α β] {a₁ a₂ : α} (ha : a₁ < a₂)
Goal: (algebraMap α β) a₁ < (algebraMap α β) a₂
-- algebraMap_pos
lemma algebraMap_pos (ha : 0 < a) : 0 < algebraMap α β a 
Arguments: {α : Type u_1} (β : Type u_2) [OrderedCommSemiring α] [StrictOrderedSemiring β] [Algebra α β] [SMulPosStrictMono α β] {a : α} (ha : 0 < a)
Goal: 0 < (algebraMap α β) a
-- algebraMap_lt_algebraMap
@[simp] lemma algebraMap_lt_algebraMap : algebraMap α β a₁ < algebraMap α β a₂ ↔ a₁ < a₂ 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedCommSemiring α] [StrictOrderedSemiring β] [Algebra α β] [SMulPosStrictMono α β] {a₁ a₂ : α} [SMulPosReflectLT α β]
Goal: (algebraMap α β) a₁ < (algebraMap α β) a₂ ↔ a₁ < a₂
-- Polynomial.X_dvd_iff
theorem X_dvd_iff {f : R[X]} : X ∣ f ↔ f.coeff 0 = 0 
Arguments: {R : Type u} [Semiring R] {f : R[X]}
Goal: Polynomial.X ∣ f ↔ f.coeff 0 = 0
-- Polynomial.X_pow_dvd_iff
theorem X_pow_dvd_iff {f : R[X]} {n : ℕ} : X ^ n ∣ f ↔ ∀ d < n, f.coeff d = 0 
Arguments: {R : Type u} [Semiring R] {f : R[X]} {n : ℕ}
Goal: Polynomial.X ^ n ∣ f ↔ ∀ d < n, f.coeff d = 0
-- Polynomial.multiplicity_finite_of_degree_pos_of_monic
theorem multiplicity_finite_of_degree_pos_of_monic (hp : (0 : WithBot ℕ) < degree p) (hmp : Monic p)
    (hq : q ≠ 0) : multiplicity.Finite p q 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (hp : 0 < p.degree) (hmp : p.Monic) (hq : q ≠ 0)
Goal: multiplicity.Finite p q
-- Polynomial.div_wf_lemma
theorem div_wf_lemma (h : degree q ≤ degree p ∧ p ≠ 0) (hq : Monic q) :
    degree (p - q * (C (leadingCoeff p) * X ^ (natDegree p - natDegree q))) < degree p 
Arguments: {R : Type u} [Ring R] {p q : R[X]} (h : q.degree ≤ p.degree ∧ p ≠ 0) (hq : q.Monic)
Goal: (p - q * (Polynomial.C p.leadingCoeff * Polynomial.X ^ (p.natDegree - q.natDegree))).degree < p.degree
-- Polynomial.degree_modByMonic_lt
theorem degree_modByMonic_lt [Nontrivial R] :
    ∀ (p : R[X]) {q : R[X]} (_hq : Monic q), degree (p %ₘ q) < degree q
  
Arguments: {R : Type u} [Ring R] [Nontrivial R] (p : R[X]) {q : R[X]} (_hq : q.Monic)
Goal: (p %ₘ q).degree < q.degree
-- Polynomial.natDegree_modByMonic_lt
theorem natDegree_modByMonic_lt (p : R[X]) {q : R[X]} (hmq : Monic q) (hq : q ≠ 1) :
    natDegree (p %ₘ q) < q.natDegree 
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (hmq : q.Monic) (hq : q ≠ 1)
Goal: (p %ₘ q).natDegree < q.natDegree
-- Polynomial.zero_modByMonic
@[simp]
theorem zero_modByMonic (p : R[X]) : 0 %ₘ p = 0 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: 0 %ₘ p = 0
-- Polynomial.zero_divByMonic
@[simp]
theorem zero_divByMonic (p : R[X]) : 0 /ₘ p = 0 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: 0 /ₘ p = 0
-- Polynomial.modByMonic_zero
@[simp]
theorem modByMonic_zero (p : R[X]) : p %ₘ 0 = p 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: p %ₘ 0 = p
-- Polynomial.divByMonic_zero
@[simp]
theorem divByMonic_zero (p : R[X]) : p /ₘ 0 = 0 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: p /ₘ 0 = 0
-- Polynomial.divByMonic_eq_of_not_monic
theorem divByMonic_eq_of_not_monic (p : R[X]) (hq : ¬Monic q) : p /ₘ q = 0 
Arguments: {R : Type u} [Ring R] {q : R[X]} (p : R[X]) (hq : ¬q.Monic)
Goal: p /ₘ q = 0
-- Polynomial.modByMonic_eq_of_not_monic
theorem modByMonic_eq_of_not_monic (p : R[X]) (hq : ¬Monic q) : p %ₘ q = p 
Arguments: {R : Type u} [Ring R] {q : R[X]} (p : R[X]) (hq : ¬q.Monic)
Goal: p %ₘ q = p
-- Polynomial.modByMonic_eq_self_iff
theorem modByMonic_eq_self_iff [Nontrivial R] (hq : Monic q) : p %ₘ q = p ↔ degree p < degree q 
Arguments: {R : Type u} [Ring R] {p q : R[X]} [Nontrivial R] (hq : q.Monic)
Goal: p %ₘ q = p ↔ p.degree < q.degree
-- Polynomial.degree_modByMonic_le
theorem degree_modByMonic_le (p : R[X]) {q : R[X]} (hq : Monic q) : degree (p %ₘ q) ≤ degree q 
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (hq : q.Monic)
Goal: (p %ₘ q).degree ≤ q.degree
-- Polynomial.natDegree_modByMonic_le
theorem natDegree_modByMonic_le (p : Polynomial R) {g : Polynomial R} (hg : g.Monic) :
    natDegree (p %ₘ g) ≤ g.natDegree 
Arguments: {R : Type u} [Ring R] (p : R[X]) {g : R[X]} (hg : g.Monic)
Goal: (p %ₘ g).natDegree ≤ g.natDegree
-- Polynomial.X_dvd_sub_C
theorem X_dvd_sub_C : X ∣ p - C (p.coeff 0) 
Arguments: {R : Type u} [Ring R] {p : R[X]}
Goal: Polynomial.X ∣ p - Polynomial.C (p.coeff 0)
-- Polynomial.modByMonic_eq_sub_mul_div
theorem modByMonic_eq_sub_mul_div :
    ∀ (p : R[X]) {q : R[X]} (_hq : Monic q), p %ₘ q = p - q * (p /ₘ q)
  
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (_hq : q.Monic)
Goal: p %ₘ q = p - q * (p /ₘ q)
-- Polynomial.modByMonic_add_div
theorem modByMonic_add_div (p : R[X]) {q : R[X]} (hq : Monic q) : p %ₘ q + q * (p /ₘ q) = p 
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (hq : q.Monic)
Goal: p %ₘ q + q * (p /ₘ q) = p
-- Polynomial.divByMonic_eq_zero_iff
theorem divByMonic_eq_zero_iff [Nontrivial R] (hq : Monic q) : p /ₘ q = 0 ↔ degree p < degree q 
Arguments: {R : Type u} [Ring R] {p q : R[X]} [Nontrivial R] (hq : q.Monic)
Goal: p /ₘ q = 0 ↔ p.degree < q.degree
-- Polynomial.degree_add_divByMonic
theorem degree_add_divByMonic (hq : Monic q) (h : degree q ≤ degree p) :
    degree q + degree (p /ₘ q) = degree p 
Arguments: {R : Type u} [Ring R] {p q : R[X]} (hq : q.Monic) (h : q.degree ≤ p.degree)
Goal: q.degree + (p /ₘ q).degree = p.degree
-- Polynomial.degree_divByMonic_le
theorem degree_divByMonic_le (p q : R[X]) : degree (p /ₘ q) ≤ degree p 
Arguments: {R : Type u} [Ring R] (p q : R[X])
Goal: (p /ₘ q).degree ≤ p.degree
-- Polynomial.degree_divByMonic_lt
theorem degree_divByMonic_lt (p : R[X]) {q : R[X]} (hq : Monic q) (hp0 : p ≠ 0)
    (h0q : 0 < degree q) : degree (p /ₘ q) < degree p 
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (hq : q.Monic) (hp0 : p ≠ 0) (h0q : 0 < q.degree)
Goal: (p /ₘ q).degree < p.degree
-- Polynomial.natDegree_divByMonic
theorem natDegree_divByMonic (f : R[X]) {g : R[X]} (hg : g.Monic) :
    natDegree (f /ₘ g) = natDegree f - natDegree g 
Arguments: {R : Type u} [Ring R] (f : R[X]) {g : R[X]} (hg : g.Monic)
Goal: (f /ₘ g).natDegree = f.natDegree - g.natDegree
-- Polynomial.div_modByMonic_unique
theorem div_modByMonic_unique {f g} (q r : R[X]) (hg : Monic g)
    (h : r + g * q = f ∧ degree r < degree g) : f /ₘ g = q ∧ f %ₘ g = r 
Arguments: {R : Type u} [Ring R] {f g : R[X]} (q r : R[X]) (hg : g.Monic) (h : r + g * q = f ∧ r.degree < g.degree)
Goal: f /ₘ g = q ∧ f %ₘ g = r
-- Polynomial.map_mod_divByMonic
theorem map_mod_divByMonic [Ring S] (f : R →+* S) (hq : Monic q) :
    (p /ₘ q).map f = p.map f /ₘ q.map f ∧ (p %ₘ q).map f = p.map f %ₘ q.map f 
Arguments: {R : Type u} {S : Type v} [Ring R] {p q : R[X]} [Ring S] (f : R →+* S) (hq : q.Monic)
Goal: Polynomial.map f (p /ₘ q) = Polynomial.map f p /ₘ Polynomial.map f q ∧
  Polynomial.map f (p %ₘ q) = Polynomial.map f p %ₘ Polynomial.map f q
-- Polynomial.map_divByMonic
theorem map_divByMonic [Ring S] (f : R →+* S) (hq : Monic q) :
    (p /ₘ q).map f = p.map f /ₘ q.map f 
Arguments: {R : Type u} {S : Type v} [Ring R] {p q : R[X]} [Ring S] (f : R →+* S) (hq : q.Monic)
Goal: Polynomial.map f (p /ₘ q) = Polynomial.map f p /ₘ Polynomial.map f q
-- Polynomial.map_modByMonic
theorem map_modByMonic [Ring S] (f : R →+* S) (hq : Monic q) :
    (p %ₘ q).map f = p.map f %ₘ q.map f 
Arguments: {R : Type u} {S : Type v} [Ring R] {p q : R[X]} [Ring S] (f : R →+* S) (hq : q.Monic)
Goal: Polynomial.map f (p %ₘ q) = Polynomial.map f p %ₘ Polynomial.map f q
-- Polynomial.modByMonic_eq_zero_iff_dvd
theorem modByMonic_eq_zero_iff_dvd (hq : Monic q) : p %ₘ q = 0 ↔ q ∣ p 
Arguments: {R : Type u} [Ring R] {p q : R[X]} (hq : q.Monic)
Goal: p %ₘ q = 0 ↔ q ∣ p
-- Polynomial.self_mul_modByMonic
@[simp]
lemma self_mul_modByMonic (hq : q.Monic) : (q * p) %ₘ q = 0 
Arguments: {R : Type u} [Ring R] {p q : R[X]} (hq : q.Monic)
Goal: q * p %ₘ q = 0
-- Polynomial.map_dvd_map
theorem map_dvd_map [Ring S] (f : R →+* S) (hf : Function.Injective f) {x y : R[X]}
    (hx : x.Monic) : x.map f ∣ y.map f ↔ x ∣ y 
Arguments: {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) (hf : Function.Injective ⇑f) {x y : R[X]} (hx : x.Monic)
Goal: Polynomial.map f x ∣ Polynomial.map f y ↔ x ∣ y
-- Polynomial.modByMonic_one
@[simp]
theorem modByMonic_one (p : R[X]) : p %ₘ 1 = 0 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: p %ₘ 1 = 0
-- Polynomial.divByMonic_one
@[simp]
theorem divByMonic_one (p : R[X]) : p /ₘ 1 = p 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: p /ₘ 1 = p
-- Polynomial.sum_modByMonic_coeff
theorem sum_modByMonic_coeff (hq : q.Monic) {n : ℕ} (hn : q.degree ≤ n) :
    (∑ i : Fin n, monomial i ((p %ₘ q).coeff i)) = p %ₘ q 
Arguments: {R : Type u} [Ring R] {p q : R[X]} (hq : q.Monic) {n : ℕ} (hn : q.degree ≤ ↑n)
Goal: ∑ i : Fin n, (Polynomial.monomial ↑i) ((p %ₘ q).coeff ↑i) = p %ₘ q
-- Polynomial.mul_divByMonic_cancel_left
theorem mul_divByMonic_cancel_left (p : R[X]) {q : R[X]} (hmo : q.Monic) :
    q * p /ₘ q = p 
Arguments: {R : Type u} [Ring R] (p : R[X]) {q : R[X]} (hmo : q.Monic)
Goal: q * p /ₘ q = p
-- Polynomial.coeff_divByMonic_X_sub_C_rec
lemma coeff_divByMonic_X_sub_C_rec (p : R[X]) (a : R) (n : ℕ) :
    (p /ₘ (X - C a)).coeff n = coeff p (n + 1) + a * (p /ₘ (X - C a)).coeff (n + 1) 
Arguments: {R : Type u} [Ring R] (p : R[X]) (a : R) (n : ℕ)
Goal: (p /ₘ (Polynomial.X - Polynomial.C a)).coeff n =
  p.coeff (n + 1) + a * (p /ₘ (Polynomial.X - Polynomial.C a)).coeff (n + 1)
-- Polynomial.coeff_divByMonic_X_sub_C
theorem coeff_divByMonic_X_sub_C (p : R[X]) (a : R) (n : ℕ) :
    (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i 
Arguments: {R : Type u} [Ring R] (p : R[X]) (a : R) (n : ℕ)
Goal: (p /ₘ (Polynomial.X - Polynomial.C a)).coeff n = ∑ i ∈ Finset.Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i
-- Polynomial.not_isField
theorem not_isField : ¬IsField R[X] 
Arguments: (R : Type u) [Ring R]
Goal: ¬IsField R[X]
-- Polynomial.multiplicity_X_sub_C_finite
theorem multiplicity_X_sub_C_finite (a : R) (h0 : p ≠ 0) : multiplicity.Finite (X - C a) p 
Arguments: {R : Type u} [Ring R] {p : R[X]} (a : R) (h0 : p ≠ 0)
Goal: multiplicity.Finite (Polynomial.X - Polynomial.C a) p
-- Polynomial.rootMultiplicity_eq_nat_find_of_nonzero
theorem rootMultiplicity_eq_nat_find_of_nonzero [DecidableEq R] {p : R[X]} (p0 : p ≠ 0) {a : R} :
    letI : DecidablePred fun n : ℕ => ¬(X - C a) ^ (n + 1) ∣ p := fun n =>
      @Not.decidable _ (decidableDvdMonic p ((monic_X_sub_C a).pow (n + 1)))
    rootMultiplicity a p = Nat.find (multiplicity_X_sub_C_finite a p0) 
Arguments: {R : Type u} [Ring R] [DecidableEq R] {p : R[X]} (p0 : p ≠ 0) {a : R}
Goal: Polynomial.rootMultiplicity a p = Nat.find ⋯
-- Polynomial.rootMultiplicity_eq_multiplicity
theorem rootMultiplicity_eq_multiplicity [DecidableEq R] [@DecidableRel R[X] (· ∣ ·)]
    (p : R[X]) (a : R) :
    rootMultiplicity a p =
      if h0 : p = 0 then 0 else (multiplicity (X - C a) p).get (multiplicity_X_sub_C_finite a h0) 
Arguments: {R : Type u} [Ring R] [DecidableEq R] [DecidableRel fun x x_1 => x ∣ x_1] (p : R[X]) (a : R)
Goal: Polynomial.rootMultiplicity a p = if h0 : p = 0 then 0 else (multiplicity (Polynomial.X - Polynomial.C a) p).get ⋯
-- Polynomial.rootMultiplicity_zero
@[simp]
theorem rootMultiplicity_zero {x : R} : rootMultiplicity x 0 = 0 
Arguments: {R : Type u} [Ring R] {x : R}
Goal: Polynomial.rootMultiplicity x 0 = 0
-- Polynomial.rootMultiplicity_C
@[simp]
theorem rootMultiplicity_C (r a : R) : rootMultiplicity a (C r) = 0 
Arguments: {R : Type u} [Ring R] (r a : R)
Goal: Polynomial.rootMultiplicity a (Polynomial.C r) = 0
-- Polynomial.pow_rootMultiplicity_dvd
theorem pow_rootMultiplicity_dvd (p : R[X]) (a : R) : (X - C a) ^ rootMultiplicity a p ∣ p 
Arguments: {R : Type u} [Ring R] (p : R[X]) (a : R)
Goal: (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p ∣ p
-- Polynomial.pow_mul_divByMonic_rootMultiplicity_eq
theorem pow_mul_divByMonic_rootMultiplicity_eq (p : R[X]) (a : R) :
    (X - C a) ^ rootMultiplicity a p * (p /ₘ (X - C a) ^ rootMultiplicity a p) = p 
Arguments: {R : Type u} [Ring R] (p : R[X]) (a : R)
Goal: (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p *
    (p /ₘ (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p) =
  p
-- Polynomial.exists_eq_pow_rootMultiplicity_mul_and_not_dvd
theorem exists_eq_pow_rootMultiplicity_mul_and_not_dvd (p : R[X]) (hp : p ≠ 0) (a : R) :
    ∃ q : R[X], p = (X - C a) ^ p.rootMultiplicity a * q ∧ ¬ (X - C a) ∣ q 
Arguments: {R : Type u} [Ring R] (p : R[X]) (hp : p ≠ 0) (a : R)
Goal: ∃ q, p = (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p * q ∧ ¬Polynomial.X - Polynomial.C a ∣ q
-- Polynomial.modByMonic_X_sub_C_eq_C_eval
@[simp]
theorem modByMonic_X_sub_C_eq_C_eval (p : R[X]) (a : R) : p %ₘ (X - C a) = C (p.eval a) 
Arguments: {R : Type u} [CommRing R] (p : R[X]) (a : R)
Goal: p %ₘ (Polynomial.X - Polynomial.C a) = Polynomial.C (Polynomial.eval a p)
-- Polynomial.mul_divByMonic_eq_iff_isRoot
theorem mul_divByMonic_eq_iff_isRoot : (X - C a) * (p /ₘ (X - C a)) = p ↔ IsRoot p a 
Arguments: {R : Type u} {a : R} [CommRing R] {p : R[X]}
Goal: (Polynomial.X - Polynomial.C a) * (p /ₘ (Polynomial.X - Polynomial.C a)) = p ↔ p.IsRoot a
-- Polynomial.dvd_iff_isRoot
theorem dvd_iff_isRoot : X - C a ∣ p ↔ IsRoot p a 
Arguments: {R : Type u} {a : R} [CommRing R] {p : R[X]}
Goal: Polynomial.X - Polynomial.C a ∣ p ↔ p.IsRoot a
-- Polynomial.X_sub_C_dvd_sub_C_eval
theorem X_sub_C_dvd_sub_C_eval : X - C a ∣ p - C (p.eval a) 
Arguments: {R : Type u} {a : R} [CommRing R] {p : R[X]}
Goal: Polynomial.X - Polynomial.C a ∣ p - Polynomial.C (Polynomial.eval a p)
-- Polynomial.mem_span_C_X_sub_C_X_sub_C_iff_eval_eval_eq_zero
theorem mem_span_C_X_sub_C_X_sub_C_iff_eval_eval_eq_zero {b : R[X]} {P : R[X][X]} :
    P ∈ Ideal.span {C (X - C a), X - C b} ↔ (P.eval b).eval a = 0 
Arguments: {R : Type u} {a : R} [CommRing R] {b : R[X]} {P : R[X][X]}
Goal: P ∈ Ideal.span {Polynomial.C (Polynomial.X - Polynomial.C a), Polynomial.X - Polynomial.C b} ↔
  Polynomial.eval a (Polynomial.eval b P) = 0
-- Polynomial.modByMonic_X
theorem modByMonic_X (p : R[X]) : p %ₘ X = C (p.eval 0) 
Arguments: {R : Type u} [CommRing R] (p : R[X])
Goal: p %ₘ Polynomial.X = Polynomial.C (Polynomial.eval 0 p)
-- Polynomial.eval₂_modByMonic_eq_self_of_root
theorem eval₂_modByMonic_eq_self_of_root [CommRing S] {f : R →+* S} {p q : R[X]} (hq : q.Monic)
    {x : S} (hx : q.eval₂ f x = 0) : (p %ₘ q).eval₂ f x = p.eval₂ f x 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] {f : R →+* S} {p q : R[X]} (hq : q.Monic) {x : S} (hx : Polynomial.eval₂ f x q = 0)
Goal: Polynomial.eval₂ f x (p %ₘ q) = Polynomial.eval₂ f x p
-- Polynomial.sub_dvd_eval_sub
theorem sub_dvd_eval_sub (a b : R) (p : R[X]) : a - b ∣ p.eval a - p.eval b 
Arguments: {R : Type u} [CommRing R] (a b : R) (p : R[X])
Goal: a - b ∣ Polynomial.eval a p - Polynomial.eval b p
-- Polynomial.ker_evalRingHom
theorem ker_evalRingHom (x : R) : RingHom.ker (evalRingHom x) = Ideal.span {X - C x} 
Arguments: {R : Type u} [CommRing R] (x : R)
Goal: RingHom.ker (Polynomial.evalRingHom x) = Ideal.span {Polynomial.X - Polynomial.C x}
-- Polynomial.rootMultiplicity_eq_zero_iff
@[simp]
theorem rootMultiplicity_eq_zero_iff {p : R[X]} {x : R} :
    rootMultiplicity x p = 0 ↔ IsRoot p x → p = 0 
Arguments: {R : Type u} [CommRing R] {p : R[X]} {x : R}
Goal: Polynomial.rootMultiplicity x p = 0 ↔ p.IsRoot x → p = 0
-- Polynomial.rootMultiplicity_eq_zero
theorem rootMultiplicity_eq_zero {p : R[X]} {x : R} (h : ¬IsRoot p x) : rootMultiplicity x p = 0 
Arguments: {R : Type u} [CommRing R] {p : R[X]} {x : R} (h : ¬p.IsRoot x)
Goal: Polynomial.rootMultiplicity x p = 0
-- Polynomial.rootMultiplicity_pos'
@[simp]
theorem rootMultiplicity_pos' {p : R[X]} {x : R} :
    0 < rootMultiplicity x p ↔ p ≠ 0 ∧ IsRoot p x 
Arguments: {R : Type u} [CommRing R] {p : R[X]} {x : R}
Goal: 0 < Polynomial.rootMultiplicity x p ↔ p ≠ 0 ∧ p.IsRoot x
-- Polynomial.rootMultiplicity_pos
theorem rootMultiplicity_pos {p : R[X]} (hp : p ≠ 0) {x : R} :
    0 < rootMultiplicity x p ↔ IsRoot p x 
Arguments: {R : Type u} [CommRing R] {p : R[X]} (hp : p ≠ 0) {x : R}
Goal: 0 < Polynomial.rootMultiplicity x p ↔ p.IsRoot x
-- Polynomial.eval_divByMonic_pow_rootMultiplicity_ne_zero
theorem eval_divByMonic_pow_rootMultiplicity_ne_zero {p : R[X]} (a : R) (hp : p ≠ 0) :
    eval a (p /ₘ (X - C a) ^ rootMultiplicity a p) ≠ 0 
Arguments: {R : Type u} [CommRing R] {p : R[X]} (a : R) (hp : p ≠ 0)
Goal: Polynomial.eval a (p /ₘ (Polynomial.X - Polynomial.C a) ^ Polynomial.rootMultiplicity a p) ≠ 0
-- Polynomial.mul_self_modByMonic
@[simp]
lemma mul_self_modByMonic (hq : q.Monic) : (p * q) %ₘ q = 0 
Arguments: {R : Type u} [CommRing R] {p q : R[X]} (hq : q.Monic)
Goal: p * q %ₘ q = 0
-- AddUnits.val_le_val
@[to_additive (attr := simp, norm_cast)]
theorem val_le_val [Monoid α] [Preorder α] {a b : αˣ} : (a : α) ≤ b ↔ a ≤ b 
Arguments: {α : Type u_1} [AddMonoid α] [Preorder α] {a b : AddUnits α}
Goal: ↑a ≤ ↑b ↔ a ≤ b
-- Units.val_le_val
@[to_additive (attr := simp, norm_cast)]
theorem val_le_val [Monoid α] [Preorder α] {a b : αˣ} : (a : α) ≤ b ↔ a ≤ b 
Arguments: {α : Type u_1} [Monoid α] [Preorder α] {a b : αˣ}
Goal: ↑a ≤ ↑b ↔ a ≤ b
-- AddUnits.val_lt_val
@[to_additive (attr := simp, norm_cast)]
theorem val_lt_val [Monoid α] [Preorder α] {a b : αˣ} : (a : α) < b ↔ a < b 
Arguments: {α : Type u_1} [AddMonoid α] [Preorder α] {a b : AddUnits α}
Goal: ↑a < ↑b ↔ a < b
-- Units.val_lt_val
@[to_additive (attr := simp, norm_cast)]
theorem val_lt_val [Monoid α] [Preorder α] {a b : αˣ} : (a : α) < b ↔ a < b 
Arguments: {α : Type u_1} [Monoid α] [Preorder α] {a b : αˣ}
Goal: ↑a < ↑b ↔ a < b
-- AddUnits.orderEmbeddingVal_apply
@[to_additive (attr := simps (config := .asFn))
  "`val : add_units α → α` as an order embedding."]
def orderEmbeddingVal [Monoid α] [LinearOrder α] : αˣ ↪o α 
Arguments: {α : Type u_1} [AddMonoid α] [LinearOrder α]
Goal: ⇑AddUnits.orderEmbeddingVal = AddUnits.val
-- Units.orderEmbeddingVal_apply
@[to_additive (attr := simps (config := .asFn))
  "`val : add_units α → α` as an order embedding."]
def orderEmbeddingVal [Monoid α] [LinearOrder α] : αˣ ↪o α 
Arguments: {α : Type u_1} [Monoid α] [LinearOrder α]
Goal: ⇑Units.orderEmbeddingVal = Units.val
-- Units.max_val
@[to_additive (attr := simp, norm_cast)]
theorem max_val [Monoid α] [LinearOrder α] {a b : αˣ} : (max a b).val = max a.val b.val 
Arguments: {α : Type u_1} [Monoid α] [LinearOrder α] {a b : αˣ}
Goal: ↑(max a b) = max ↑a ↑b
-- AddUnits.max_val
@[to_additive (attr := simp, norm_cast)]
theorem max_val [Monoid α] [LinearOrder α] {a b : αˣ} : (max a b).val = max a.val b.val 
Arguments: {α : Type u_1} [AddMonoid α] [LinearOrder α] {a b : AddUnits α}
Goal: ↑(max a b) = max ↑a ↑b
-- Units.min_val
@[to_additive (attr := simp, norm_cast)]
theorem min_val [Monoid α] [LinearOrder α] {a b : αˣ} : (min a b).val = min a.val b.val 
Arguments: {α : Type u_1} [Monoid α] [LinearOrder α] {a b : αˣ}
Goal: ↑(min a b) = min ↑a ↑b
-- AddUnits.min_val
@[to_additive (attr := simp, norm_cast)]
theorem min_val [Monoid α] [LinearOrder α] {a b : αˣ} : (min a b).val = min a.val b.val 
Arguments: {α : Type u_1} [AddMonoid α] [LinearOrder α] {a b : AddUnits α}
Goal: ↑(min a b) = min ↑a ↑b