ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.uncurryObjFlip_inv_app
@[simps!]
def uncurryObjFlip (F : C ⥤ D ⥤ E) : uncurry.obj F.flip ≅ Prod.swap _ _ ⋙ uncurry.obj F 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : D × C)
Goal: (CategoryTheory.uncurryObjFlip F).inv.app X = CategoryTheory.CategoryStruct.id ((F.obj X.2).obj X.1)
-- CategoryTheory.whiskeringRight₂_obj_obj_obj_map
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
Arguments: (B : Type u₁) [CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [CategoryTheory.Category.{v₂, u₂} C] (D : Type u₃) [CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄) [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (X_1 : CategoryTheory.Functor B C) (Y : CategoryTheory.Functor B D) {X_2 Y_1 : B} (f : X_2 ⟶ Y_1),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).obj Y).map f =
    CategoryTheory.CategoryStruct.comp ((X.map (X_1.map f)).app (Y.obj X_2)) ((X.obj (X_1.obj Y_1)).map (Y.map f))
-- CategoryTheory.whiskeringRight₂_map_app_app_app
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
Arguments: (B : Type u₁) [CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [CategoryTheory.Category.{v₂, u₂} C] (D : Type u₃) [CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄) [CategoryTheory.Category.{v₄, u₄} E]
Goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (f : X ⟶ Y) (X_1 : CategoryTheory.Functor B C)
  (Y_1 : CategoryTheory.Functor B D) (c : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).map f).app X_1).app Y_1).app c = (f.app (X_1.obj c)).app (Y_1.obj c)
-- CategoryTheory.whiskeringRight₂_obj_map_app_app
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
Arguments: (B : Type u₁) [CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [CategoryTheory.Category.{v₂, u₂} C] (D : Type u₃) [CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄) [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ {X_1 Y : CategoryTheory.Functor B C} (f : X_1 ⟶ Y) (Y_1 : CategoryTheory.Functor B D) (X_2 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).map f).app Y_1).app X_2 = (X.map (f.app X_2)).app (Y_1.obj X_2)
-- CategoryTheory.whiskeringRight₂_obj_obj_map_app
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
Arguments: (B : Type u₁) [CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [CategoryTheory.Category.{v₂, u₂} C] (D : Type u₃) [CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄) [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (X_1 : CategoryTheory.Functor B C) {X_2 Y : CategoryTheory.Functor B D} (g : X_2 ⟶ Y) (X_3 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).map g).app X_3 = (X.obj (X_1.obj X_3)).map (g.app X_3)
-- CategoryTheory.whiskeringRight₂_obj_obj_obj_obj
@[simps!]
def whiskeringRight₂ : (C ⥤ D ⥤ E) ⥤ (B ⥤ C) ⥤ (B ⥤ D) ⥤ B ⥤ E 
Arguments: (B : Type u₁) [CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [CategoryTheory.Category.{v₂, u₂} C] (D : Type u₃) [CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄) [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (X_1 : CategoryTheory.Functor B C) (Y : CategoryTheory.Functor B D) (X_2 : B),
  ((((CategoryTheory.whiskeringRight₂ B C D E).obj X).obj X_1).obj Y).obj X_2 = (X.obj (X_1.obj X_2)).obj (Y.obj X_2)
-- CategoryTheory.Functor.uncurry_obj_curry_obj
lemma uncurry_obj_curry_obj (F : B × C ⥤ D) : uncurry.obj (curry.obj F) = F 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (F : CategoryTheory.Functor (B × C) D)
Goal: CategoryTheory.uncurry.obj (CategoryTheory.curry.obj F) = F
-- CategoryTheory.Functor.curry_obj_injective
lemma curry_obj_injective {F₁ F₂ : C × D ⥤ E} (h : curry.obj F₁ = curry.obj F₂) :
    F₁ = F₂ 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] {F₁ F₂ : CategoryTheory.Functor (C × D) E} (h : CategoryTheory.curry.obj F₁ = CategoryTheory.curry.obj F₂)
Goal: F₁ = F₂
-- CategoryTheory.Functor.curry_obj_uncurry_obj
lemma curry_obj_uncurry_obj (F : B ⥤ C ⥤ D) : curry.obj (uncurry.obj F) = F 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (F : CategoryTheory.Functor B (CategoryTheory.Functor C D))
Goal: CategoryTheory.curry.obj (CategoryTheory.uncurry.obj F) = F
-- CategoryTheory.Functor.uncurry_obj_injective
lemma uncurry_obj_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : uncurry.obj F₁ = uncurry.obj F₂) :
    F₁ = F₂ 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {F₁ F₂ : CategoryTheory.Functor B (CategoryTheory.Functor C D)} (h : CategoryTheory.uncurry.obj F₁ = CategoryTheory.uncurry.obj F₂)
Goal: F₁ = F₂
-- CategoryTheory.Functor.flip_flip
lemma flip_flip (F : B ⥤ C ⥤ D) : F.flip.flip = F 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] (F : CategoryTheory.Functor B (CategoryTheory.Functor C D))
Goal: F.flip.flip = F
-- CategoryTheory.Functor.flip_injective
lemma flip_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : F₁.flip = F₂.flip) :
    F₁ = F₂ 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {F₁ F₂ : CategoryTheory.Functor B (CategoryTheory.Functor C D)} (h : F₁.flip = F₂.flip)
Goal: F₁ = F₂
-- CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip
lemma uncurry_obj_curry_obj_flip_flip (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
    uncurry.obj (F₂ ⋙ (F₁ ⋙ curry.obj G).flip).flip = (F₁.prod F₂) ⋙ G 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] {H : Type u₅} [CategoryTheory.Category.{v₅, u₅} H] (F₁ : CategoryTheory.Functor B C) (F₂ : CategoryTheory.Functor D E) (G : CategoryTheory.Functor (C × E) H)
Goal: CategoryTheory.uncurry.obj (F₂.comp (F₁.comp (CategoryTheory.curry.obj G)).flip).flip = (F₁.prod F₂).comp G
-- CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip'
lemma uncurry_obj_curry_obj_flip_flip' (F₁ : B ⥤ C) (F₂ : D ⥤ E) (G : C × E ⥤ H) :
    uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip) = (F₁.prod F₂) ⋙ G 
Arguments: {B : Type u₁} [CategoryTheory.Category.{v₁, u₁} B] {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] {H : Type u₅} [CategoryTheory.Category.{v₅, u₅} H] (F₁ : CategoryTheory.Functor B C) (F₂ : CategoryTheory.Functor D E) (G : CategoryTheory.Functor (C × E) H)
Goal: CategoryTheory.uncurry.obj (F₁.comp (F₂.comp (CategoryTheory.curry.obj G).flip).flip) = (F₁.prod F₂).comp G
-- denomsClearable_zero
theorem denomsClearable_zero (N : ℕ) (a : R) (bu : bi * i b = 1) : DenomsClearable a b N 0 i 
Arguments: {R : Type u_1} {K : Type u_2} [Semiring R] [CommSemiring K] {i : R →+* K} {b : R} {bi : K} (N : ℕ) (a : R) (bu : bi * i b = 1)
Goal: DenomsClearable a b N 0 i
-- denomsClearable_C_mul_X_pow
theorem denomsClearable_C_mul_X_pow {N : ℕ} (a : R) (bu : bi * i b = 1) {n : ℕ} (r : R)
    (nN : n ≤ N) : DenomsClearable a b N (C r * X ^ n) i 
Arguments: {R : Type u_1} {K : Type u_2} [Semiring R] [CommSemiring K] {i : R →+* K} {b : R} {bi : K} {N : ℕ} (a : R) (bu : bi * i b = 1) {n : ℕ} (r : R) (nN : n ≤ N)
Goal: DenomsClearable a b N (Polynomial.C r * Polynomial.X ^ n) i
-- DenomsClearable.add
theorem DenomsClearable.add {N : ℕ} {f g : R[X]} :
    DenomsClearable a b N f i → DenomsClearable a b N g i → DenomsClearable a b N (f + g) i 
Arguments: {R : Type u_1} {K : Type u_2} [Semiring R] [CommSemiring K] {i : R →+* K} {a b : R} {N : ℕ} {f g : R[X]}
Goal: DenomsClearable a b N f i → DenomsClearable a b N g i → DenomsClearable a b N (f + g) i
-- denomsClearable_of_natDegree_le
theorem denomsClearable_of_natDegree_le (N : ℕ) (a : R) (bu : bi * i b = 1) :
    ∀ f : R[X], f.natDegree ≤ N → DenomsClearable a b N f i 
Arguments: {R : Type u_1} {K : Type u_2} [Semiring R] [CommSemiring K] {i : R →+* K} {b : R} {bi : K} (N : ℕ) (a : R) (bu : bi * i b = 1) (f : R[X])
Goal: f.natDegree ≤ N → DenomsClearable a b N f i
-- denomsClearable_natDegree
theorem denomsClearable_natDegree (i : R →+* K) (f : R[X]) (a : R) (bu : bi * i b = 1) :
    DenomsClearable a b f.natDegree f i 
Arguments: {R : Type u_1} {K : Type u_2} [Semiring R] [CommSemiring K] {b : R} {bi : K} (i : R →+* K) (f : R[X]) (a : R) (bu : bi * i b = 1)
Goal: DenomsClearable a b f.natDegree f i
-- one_le_pow_mul_abs_eval_div
theorem one_le_pow_mul_abs_eval_div {K : Type*} [LinearOrderedField K] {f : ℤ[X]} {a b : ℤ}
    (b0 : 0 < b) (fab : eval ((a : K) / b) (f.map (algebraMap ℤ K)) ≠ 0) :
    (1 : K) ≤ (b : K) ^ f.natDegree * |eval ((a : K) / b) (f.map (algebraMap ℤ K))| 
Arguments: {K : Type u_1} [LinearOrderedField K] {f : ℤ[X]} {a b : ℤ} (b0 : 0 < b) (fab : Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f) ≠ 0)
Goal: 1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)|
-- Polynomial.cardPowDegree_apply
theorem cardPowDegree_apply [DecidableEq Fq] (p : Fq[X]) :
    cardPowDegree p = if p = 0 then 0 else (Fintype.card Fq : ℤ) ^ natDegree p 
Arguments: {Fq : Type u_1} [Field Fq] [Fintype Fq] [DecidableEq Fq] (p : Polynomial Fq)
Goal: Polynomial.cardPowDegree p = if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree
-- Polynomial.cardPowDegree_zero
@[simp]
theorem cardPowDegree_zero : cardPowDegree (0 : Fq[X]) = 0 
Arguments: {Fq : Type u_1} [Field Fq] [Fintype Fq]
Goal: Polynomial.cardPowDegree 0 = 0
-- Polynomial.cardPowDegree_nonzero
@[simp]
theorem cardPowDegree_nonzero (p : Fq[X]) (hp : p ≠ 0) :
    cardPowDegree p = (Fintype.card Fq : ℤ) ^ p.natDegree 
Arguments: {Fq : Type u_1} [Field Fq] [Fintype Fq] (p : Polynomial Fq) (hp : p ≠ 0)
Goal: Polynomial.cardPowDegree p = ↑(Fintype.card Fq) ^ p.natDegree
-- Polynomial.cardPowDegree_isEuclidean
theorem cardPowDegree_isEuclidean : IsEuclidean (cardPowDegree : AbsoluteValue Fq[X] ℤ) 
Arguments: {Fq : Type u_1} [Field Fq] [Fintype Fq]
Goal: Polynomial.cardPowDegree.IsEuclidean
-- Polynomial.natDegree_comp_le
theorem natDegree_comp_le : natDegree (p.comp q) ≤ natDegree p * natDegree q 
Arguments: {R : Type u} [Semiring R] {p q : R[X]}
Goal: (p.comp q).natDegree ≤ p.natDegree * q.natDegree
-- Polynomial.degree_pos_of_root
theorem degree_pos_of_root {p : R[X]} (hp : p ≠ 0) (h : IsRoot p a) : 0 < degree p 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]} (hp : p ≠ 0) (h : p.IsRoot a)
Goal: 0 < p.degree
-- Polynomial.natDegree_le_iff_coeff_eq_zero
theorem natDegree_le_iff_coeff_eq_zero : p.natDegree ≤ n ↔ ∀ N : ℕ, n < N → p.coeff N = 0 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]}
Goal: p.natDegree ≤ n ↔ ∀ (N : ℕ), n < N → p.coeff N = 0
-- Polynomial.natDegree_add_le_iff_left
theorem natDegree_add_le_iff_left {n : ℕ} (p q : R[X]) (qn : q.natDegree ≤ n) :
    (p + q).natDegree ≤ n ↔ p.natDegree ≤ n 
Arguments: {R : Type u} [Semiring R] {n : ℕ} (p q : R[X]) (qn : q.natDegree ≤ n)
Goal: (p + q).natDegree ≤ n ↔ p.natDegree ≤ n
-- Polynomial.natDegree_add_le_iff_right
theorem natDegree_add_le_iff_right {n : ℕ} (p q : R[X]) (pn : p.natDegree ≤ n) :
    (p + q).natDegree ≤ n ↔ q.natDegree ≤ n 
Arguments: {R : Type u} [Semiring R] {n : ℕ} (p q : R[X]) (pn : p.natDegree ≤ n)
Goal: (p + q).natDegree ≤ n ↔ q.natDegree ≤ n
-- Polynomial.natDegree_C_mul_le
theorem natDegree_C_mul_le (a : R) (f : R[X]) : (C a * f).natDegree ≤ f.natDegree 
Arguments: {R : Type u} [Semiring R] (a : R) (f : R[X])
Goal: (Polynomial.C a * f).natDegree ≤ f.natDegree
-- Polynomial.natDegree_mul_C_le
theorem natDegree_mul_C_le (f : R[X]) (a : R) : (f * C a).natDegree ≤ f.natDegree 
Arguments: {R : Type u} [Semiring R] (f : R[X]) (a : R)
Goal: (f * Polynomial.C a).natDegree ≤ f.natDegree
-- Polynomial.eq_natDegree_of_le_mem_support
theorem eq_natDegree_of_le_mem_support (pn : p.natDegree ≤ n) (ns : n ∈ p.support) :
    p.natDegree = n 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]} (pn : p.natDegree ≤ n) (ns : n ∈ p.support)
Goal: p.natDegree = n
-- Polynomial.natDegree_C_mul_eq_of_mul_eq_one
theorem natDegree_C_mul_eq_of_mul_eq_one {ai : R} (au : ai * a = 1) :
    (C a * p).natDegree = p.natDegree 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]} {ai : R} (au : ai * a = 1)
Goal: (Polynomial.C a * p).natDegree = p.natDegree
-- Polynomial.natDegree_mul_C_eq_of_mul_eq_one
theorem natDegree_mul_C_eq_of_mul_eq_one {ai : R} (au : a * ai = 1) :
    (p * C a).natDegree = p.natDegree 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]} {ai : R} (au : a * ai = 1)
Goal: (p * Polynomial.C a).natDegree = p.natDegree
-- Polynomial.natDegree_mul_C_eq_of_mul_ne_zero
theorem natDegree_mul_C_eq_of_mul_ne_zero (h : p.leadingCoeff * a ≠ 0) :
    (p * C a).natDegree = p.natDegree 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]} (h : p.leadingCoeff * a ≠ 0)
Goal: (p * Polynomial.C a).natDegree = p.natDegree
-- Polynomial.natDegree_C_mul_eq_of_mul_ne_zero
theorem natDegree_C_mul_eq_of_mul_ne_zero (h : a * p.leadingCoeff ≠ 0) :
    (C a * p).natDegree = p.natDegree 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]} (h : a * p.leadingCoeff ≠ 0)
Goal: (Polynomial.C a * p).natDegree = p.natDegree
-- Polynomial.natDegree_add_coeff_mul
theorem natDegree_add_coeff_mul (f g : R[X]) :
    (f * g).coeff (f.natDegree + g.natDegree) = f.coeff f.natDegree * g.coeff g.natDegree 
Arguments: {R : Type u} [Semiring R] (f g : R[X])
Goal: (f * g).coeff (f.natDegree + g.natDegree) = f.coeff f.natDegree * g.coeff g.natDegree
-- Polynomial.natDegree_lt_coeff_mul
theorem natDegree_lt_coeff_mul (h : p.natDegree + q.natDegree < m + n) :
    (p * q).coeff (m + n) = 0 
Arguments: {R : Type u} {m n : ℕ} [Semiring R] {p q : R[X]} (h : p.natDegree + q.natDegree < m + n)
Goal: (p * q).coeff (m + n) = 0
-- Polynomial.coeff_mul_of_natDegree_le
theorem coeff_mul_of_natDegree_le (pm : p.natDegree ≤ m) (qn : q.natDegree ≤ n) :
    (p * q).coeff (m + n) = p.coeff m * q.coeff n 
Arguments: {R : Type u} {m n : ℕ} [Semiring R] {p q : R[X]} (pm : p.natDegree ≤ m) (qn : q.natDegree ≤ n)
Goal: (p * q).coeff (m + n) = p.coeff m * q.coeff n
-- Polynomial.coeff_pow_of_natDegree_le
theorem coeff_pow_of_natDegree_le (pn : p.natDegree ≤ n) :
    (p ^ m).coeff (m * n) = p.coeff n ^ m 
Arguments: {R : Type u} {m n : ℕ} [Semiring R] {p : R[X]} (pn : p.natDegree ≤ n)
Goal: (p ^ m).coeff (m * n) = p.coeff n ^ m
-- Polynomial.coeff_pow_eq_ite_of_natDegree_le_of_le
theorem coeff_pow_eq_ite_of_natDegree_le_of_le {o : ℕ}
    (pn : natDegree p ≤ n) (mno : m * n ≤ o) :
    coeff (p ^ m) o = if o = m * n then (coeff p n) ^ m else 0 
Arguments: {R : Type u} {m n : ℕ} [Semiring R] {p : R[X]} {o : ℕ} (pn : p.natDegree ≤ n) (mno : m * n ≤ o)
Goal: (p ^ m).coeff o = if o = m * n then p.coeff n ^ m else 0
-- Polynomial.coeff_add_eq_left_of_lt
theorem coeff_add_eq_left_of_lt (qn : q.natDegree < n) : (p + q).coeff n = p.coeff n 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p q : R[X]} (qn : q.natDegree < n)
Goal: (p + q).coeff n = p.coeff n
-- Polynomial.coeff_add_eq_right_of_lt
theorem coeff_add_eq_right_of_lt (pn : p.natDegree < n) : (p + q).coeff n = q.coeff n 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p q : R[X]} (pn : p.natDegree < n)
Goal: (p + q).coeff n = q.coeff n
-- Polynomial.degree_sum_eq_of_disjoint
theorem degree_sum_eq_of_disjoint (f : S → R[X]) (s : Finset S)
    (h : Set.Pairwise { i | i ∈ s ∧ f i ≠ 0 } (Ne on degree ∘ f)) :
    degree (s.sum f) = s.sup fun i => degree (f i) 
Arguments: {R : Type u} {S : Type v} [Semiring R] (f : S → R[X]) (s : Finset S) (h : {i | i ∈ s ∧ f i ≠ 0}.Pairwise (Ne on Polynomial.degree ∘ f))
Goal: (s.sum f).degree = s.sup fun i => (f i).degree
-- Polynomial.natDegree_sum_eq_of_disjoint
theorem natDegree_sum_eq_of_disjoint (f : S → R[X]) (s : Finset S)
    (h : Set.Pairwise { i | i ∈ s ∧ f i ≠ 0 } (Ne on natDegree ∘ f)) :
    natDegree (s.sum f) = s.sup fun i => natDegree (f i) 
Arguments: {R : Type u} {S : Type v} [Semiring R] (f : S → R[X]) (s : Finset S) (h : {i | i ∈ s ∧ f i ≠ 0}.Pairwise (Ne on Polynomial.natDegree ∘ f))
Goal: (s.sum f).natDegree = s.sup fun i => (f i).natDegree
-- Polynomial.natDegree_pos_of_eval₂_root
theorem natDegree_pos_of_eval₂_root {p : R[X]} (hp : p ≠ 0) (f : R →+* S) {z : S}
    (hz : eval₂ f z p = 0) (inj : ∀ x : R, f x = 0 → x = 0) : 0 < natDegree p 
Arguments: {R : Type u} {S : Type v} [Semiring R] [Semiring S] {p : R[X]} (hp : p ≠ 0) (f : R →+* S) {z : S} (hz : Polynomial.eval₂ f z p = 0) (inj : ∀ (x : R), f x = 0 → x = 0)
Goal: 0 < p.natDegree
-- Polynomial.degree_pos_of_eval₂_root
theorem degree_pos_of_eval₂_root {p : R[X]} (hp : p ≠ 0) (f : R →+* S) {z : S}
    (hz : eval₂ f z p = 0) (inj : ∀ x : R, f x = 0 → x = 0) : 0 < degree p 
Arguments: {R : Type u} {S : Type v} [Semiring R] [Semiring S] {p : R[X]} (hp : p ≠ 0) (f : R →+* S) {z : S} (hz : Polynomial.eval₂ f z p = 0) (inj : ∀ (x : R), f x = 0 → x = 0)
Goal: 0 < p.degree
-- Polynomial.coe_lt_degree
@[simp]
theorem coe_lt_degree {p : R[X]} {n : ℕ} : (n : WithBot ℕ) < degree p ↔ n < natDegree p 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {n : ℕ}
Goal: ↑n < p.degree ↔ n < p.natDegree
-- Polynomial.degree_map_eq_iff
@[simp]
theorem degree_map_eq_iff {f : R →+* S} {p : Polynomial R} :
    degree (map f p) = degree p ↔ f (leadingCoeff p) ≠ 0 ∨ p = 0 
Arguments: {R : Type u} {S : Type v} [Semiring R] [Semiring S] {f : R →+* S} {p : R[X]}
Goal: (Polynomial.map f p).degree = p.degree ↔ f p.leadingCoeff ≠ 0 ∨ p = 0
-- Polynomial.natDegree_map_eq_iff
@[simp]
theorem natDegree_map_eq_iff {f : R →+* S} {p : Polynomial R} :
    natDegree (map f p) = natDegree p ↔ f (p.leadingCoeff) ≠ 0 ∨ natDegree p = 0 
Arguments: {R : Type u} {S : Type v} [Semiring R] [Semiring S] {f : R →+* S} {p : R[X]}
Goal: (Polynomial.map f p).natDegree = p.natDegree ↔ f p.leadingCoeff ≠ 0 ∨ p.natDegree = 0
-- Polynomial.natDegree_pos_of_nextCoeff_ne_zero
theorem natDegree_pos_of_nextCoeff_ne_zero (h : p.nextCoeff ≠ 0) : 0 < p.natDegree 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (h : p.nextCoeff ≠ 0)
Goal: 0 < p.natDegree
-- Polynomial.natDegree_sub
theorem natDegree_sub : (p - q).natDegree = (q - p).natDegree 
Arguments: {R : Type u} [Ring R] {p q : R[X]}
Goal: (p - q).natDegree = (q - p).natDegree
-- Polynomial.natDegree_sub_le_iff_left
theorem natDegree_sub_le_iff_left (qn : q.natDegree ≤ n) :
    (p - q).natDegree ≤ n ↔ p.natDegree ≤ n 
Arguments: {R : Type u} {n : ℕ} [Ring R] {p q : R[X]} (qn : q.natDegree ≤ n)
Goal: (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
-- Polynomial.natDegree_sub_le_iff_right
theorem natDegree_sub_le_iff_right (pn : p.natDegree ≤ n) :
    (p - q).natDegree ≤ n ↔ q.natDegree ≤ n 
Arguments: {R : Type u} {n : ℕ} [Ring R] {p q : R[X]} (pn : p.natDegree ≤ n)
Goal: (p - q).natDegree ≤ n ↔ q.natDegree ≤ n
-- Polynomial.coeff_sub_eq_left_of_lt
theorem coeff_sub_eq_left_of_lt (dg : q.natDegree < n) : (p - q).coeff n = p.coeff n 
Arguments: {R : Type u} {n : ℕ} [Ring R] {p q : R[X]} (dg : q.natDegree < n)
Goal: (p - q).coeff n = p.coeff n
-- Polynomial.coeff_sub_eq_neg_right_of_lt
theorem coeff_sub_eq_neg_right_of_lt (df : p.natDegree < n) : (p - q).coeff n = -q.coeff n 
Arguments: {R : Type u} {n : ℕ} [Ring R] {p q : R[X]} (df : p.natDegree < n)
Goal: (p - q).coeff n = -q.coeff n
-- Polynomial.degree_mul_C
theorem degree_mul_C (a0 : a ≠ 0) : (p * C a).degree = p.degree 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p : R[X]} {a : R} (a0 : a ≠ 0)
Goal: (p * Polynomial.C a).degree = p.degree
-- Polynomial.degree_C_mul
theorem degree_C_mul (a0 : a ≠ 0) : (C a * p).degree = p.degree 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p : R[X]} {a : R} (a0 : a ≠ 0)
Goal: (Polynomial.C a * p).degree = p.degree
-- Polynomial.natDegree_mul_C
theorem natDegree_mul_C (a0 : a ≠ 0) : (p * C a).natDegree = p.natDegree 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p : R[X]} {a : R} (a0 : a ≠ 0)
Goal: (p * Polynomial.C a).natDegree = p.natDegree
-- Polynomial.natDegree_C_mul
theorem natDegree_C_mul (a0 : a ≠ 0) : (C a * p).natDegree = p.natDegree 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p : R[X]} {a : R} (a0 : a ≠ 0)
Goal: (Polynomial.C a * p).natDegree = p.natDegree
-- Polynomial.nextCoeff_C_mul_X_add_C
@[simp]
lemma nextCoeff_C_mul_X_add_C (ha : a ≠ 0) (c : R) : nextCoeff (C a * X + C c) = c 
Arguments: {R : Type u} [Semiring R] {a : R} (ha : a ≠ 0) (c : R)
Goal: (Polynomial.C a * Polynomial.X + Polynomial.C c).nextCoeff = c
-- Polynomial.natDegree_eq_one
lemma natDegree_eq_one : p.natDegree = 1 ↔ ∃ a ≠ 0, ∃ b, C a * X + C b = p 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.natDegree = 1 ↔ ∃ a, a ≠ 0 ∧ ∃ b, Polynomial.C a * Polynomial.X + Polynomial.C b = p
-- Polynomial.natDegree_comp
theorem natDegree_comp : natDegree (p.comp q) = natDegree p * natDegree q 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p q : R[X]}
Goal: (p.comp q).natDegree = p.natDegree * q.natDegree
-- Polynomial.natDegree_iterate_comp
@[simp]
theorem natDegree_iterate_comp (k : ℕ) :
    (p.comp^[k] q).natDegree = p.natDegree ^ k * q.natDegree 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p q : R[X]} (k : ℕ)
Goal: (p.comp^[k] q).natDegree = p.natDegree ^ k * q.natDegree
-- Polynomial.leadingCoeff_comp
theorem leadingCoeff_comp (hq : natDegree q ≠ 0) :
    leadingCoeff (p.comp q) = leadingCoeff p * leadingCoeff q ^ natDegree p 
Arguments: {R : Type u} [Semiring R] [NoZeroDivisors R] {p q : R[X]} (hq : q.natDegree ≠ 0)
Goal: (p.comp q).leadingCoeff = p.leadingCoeff * q.leadingCoeff ^ p.natDegree
-- Polynomial.irreducible_mul_leadingCoeff_inv
@[simp]
theorem irreducible_mul_leadingCoeff_inv {p : K[X]} :
    Irreducible (p * C (leadingCoeff p)⁻¹) ↔ Irreducible p 
Arguments: {K : Type u_1} [DivisionRing K] {p : K[X]}
Goal: Irreducible (p * Polynomial.C p.leadingCoeff⁻¹) ↔ Irreducible p
-- Polynomial.dvd_mul_leadingCoeff_inv
@[simp] lemma dvd_mul_leadingCoeff_inv {p q : K[X]} (hp0 : p ≠ 0) :
    q ∣ p * C (leadingCoeff p)⁻¹ ↔ q ∣ p 
Arguments: {K : Type u_1} [DivisionRing K] {p q : K[X]} (hp0 : p ≠ 0)
Goal: q ∣ p * Polynomial.C p.leadingCoeff⁻¹ ↔ q ∣ p
-- Polynomial.monic_mul_leadingCoeff_inv
theorem monic_mul_leadingCoeff_inv {p : K[X]} (h : p ≠ 0) : Monic (p * C (leadingCoeff p)⁻¹) 
Arguments: {K : Type u_1} [DivisionRing K] {p : K[X]} (h : p ≠ 0)
Goal: (p * Polynomial.C p.leadingCoeff⁻¹).Monic
-- Polynomial.degree_leadingCoeff_inv
@[simp] lemma degree_leadingCoeff_inv {p : K[X]} (hp0 : p ≠ 0) :
    degree (C (leadingCoeff p)⁻¹) = 0 
Arguments: {K : Type u_1} [DivisionRing K] {p : K[X]} (hp0 : p ≠ 0)
Goal: (Polynomial.C p.leadingCoeff⁻¹).degree = 0
-- Polynomial.degree_mul_leadingCoeff_inv
theorem degree_mul_leadingCoeff_inv (p : K[X]) {q : K[X]} (h : q ≠ 0) :
    degree (p * C (leadingCoeff q)⁻¹) = degree p 
Arguments: {K : Type u_1} [DivisionRing K] (p : K[X]) {q : K[X]} (h : q ≠ 0)
Goal: (p * Polynomial.C q.leadingCoeff⁻¹).degree = p.degree
-- Polynomial.natDegree_mul_leadingCoeff_inv
theorem natDegree_mul_leadingCoeff_inv (p : K[X]) {q : K[X]} (h : q ≠ 0) :
    natDegree (p * C (leadingCoeff q)⁻¹) = natDegree p 
Arguments: {K : Type u_1} [DivisionRing K] (p : K[X]) {q : K[X]} (h : q ≠ 0)
Goal: (p * Polynomial.C q.leadingCoeff⁻¹).natDegree = p.natDegree
-- Polynomial.degree_mul_leadingCoeff_self_inv
theorem degree_mul_leadingCoeff_self_inv (p : K[X]) :
    degree (p * C (leadingCoeff p)⁻¹) = degree p 
Arguments: {K : Type u_1} [DivisionRing K] (p : K[X])
Goal: (p * Polynomial.C p.leadingCoeff⁻¹).degree = p.degree