File: Mathlib/Algebra/Polynomial/BigOperators.lean

full_name: Polynomial.natDegree_list_sum_le
code: theorem natDegree_list_sum_le (l : List S[X]) : natDegree l.sum ≤ (l.map natDegree).foldr max 0 
goal: l.sum.natDegree ≤ List.foldr max 0 (List.map Polynomial.natDegree l)

full_name: Polynomial.natDegree_multiset_sum_le
code: theorem natDegree_multiset_sum_le (l : Multiset S[X]) :
    natDegree l.sum ≤ (l.map natDegree).foldr max max_left_comm 0 
goal: l.sum.natDegree ≤ Multiset.foldr max ⋯ 0 (Multiset.map Polynomial.natDegree l)

full_name: Polynomial.natDegree_sum_le
code: theorem natDegree_sum_le (f : ι → S[X]) :
    natDegree (∑ i ∈ s, f i) ≤ s.fold max 0 (natDegree ∘ f) 
goal: (∑ i ∈ s, f i).natDegree ≤ Finset.fold max 0 (Polynomial.natDegree ∘ f) s

full_name: Polynomial.natDegree_sum_le_of_forall_le
code: lemma natDegree_sum_le_of_forall_le {n : ℕ} (f : ι → S[X]) (h : ∀ i ∈ s, natDegree (f i) ≤ n) :
    natDegree (∑ i ∈ s, f i) ≤ n 
goal: (∑ i ∈ s, f i).natDegree ≤ n

full_name: Polynomial.degree_list_sum_le
code: theorem degree_list_sum_le (l : List S[X]) : degree l.sum ≤ (l.map natDegree).maximum 
goal: l.sum.degree ≤ (List.map Polynomial.natDegree l).maximum

full_name: Polynomial.natDegree_list_prod_le
code: theorem natDegree_list_prod_le (l : List S[X]) : natDegree l.prod ≤ (l.map natDegree).sum 
goal: l.prod.natDegree ≤ (List.map Polynomial.natDegree l).sum

full_name: Polynomial.degree_list_prod_le
code: theorem degree_list_prod_le (l : List S[X]) : degree l.prod ≤ (l.map degree).sum 
goal: l.prod.degree ≤ (List.map Polynomial.degree l).sum

full_name: Polynomial.coeff_list_prod_of_natDegree_le
code: theorem coeff_list_prod_of_natDegree_le (l : List S[X]) (n : ℕ) (hl : ∀ p ∈ l, natDegree p ≤ n) :
    coeff (List.prod l) (l.length * n) = (l.map fun p => coeff p n).prod 
goal: l.prod.coeff (l.length * n) = (List.map (fun p => p.coeff n) l).prod

full_name: Polynomial.natDegree_multiset_prod_le
code: theorem natDegree_multiset_prod_le : t.prod.natDegree ≤ (t.map natDegree).sum 
goal: t.prod.natDegree ≤ (Multiset.map Polynomial.natDegree t).sum

full_name: Polynomial.natDegree_prod_le
code: theorem natDegree_prod_le : (∏ i ∈ s, f i).natDegree ≤ ∑ i ∈ s, (f i).natDegree 
goal: (∏ i ∈ s, f i).natDegree ≤ ∑ i ∈ s, (f i).natDegree

full_name: Polynomial.degree_multiset_prod_le
code: /-- The degree of a product of polynomials is at most the sum of the degrees,
where the degree of the zero polynomial is ⊥.
-/
theorem degree_multiset_prod_le : t.prod.degree ≤ (t.map Polynomial.degree).sum 
goal: t.prod.degree ≤ (Multiset.map Polynomial.degree t).sum

full_name: Polynomial.degree_prod_le
code: theorem degree_prod_le : (∏ i ∈ s, f i).degree ≤ ∑ i ∈ s, (f i).degree 
goal: (∏ i ∈ s, f i).degree ≤ ∑ i ∈ s, (f i).degree

full_name: Polynomial.leadingCoeff_multiset_prod'
code: /-- The leading coefficient of a product of polynomials is equal to
the product of the leading coefficients, provided that this product is nonzero.

See `Polynomial.leadingCoeff_multiset_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem leadingCoeff_multiset_prod' (h : (t.map leadingCoeff).prod ≠ 0) :
    t.prod.leadingCoeff = (t.map leadingCoeff).prod 
goal: t.prod.leadingCoeff = (Multiset.map Polynomial.leadingCoeff t).prod

full_name: Polynomial.leadingCoeff_prod'
code: /-- The leading coefficient of a product of polynomials is equal to
the product of the leading coefficients, provided that this product is nonzero.

See `Polynomial.leadingCoeff_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem leadingCoeff_prod' (h : (∏ i ∈ s, (f i).leadingCoeff) ≠ 0) :
    (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff 
goal: (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff

full_name: Polynomial.natDegree_multiset_prod'
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees, provided that the product of leading coefficients is nonzero.

See `Polynomial.natDegree_multiset_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem natDegree_multiset_prod' (h : (t.map fun f => leadingCoeff f).prod ≠ 0) :
    t.prod.natDegree = (t.map fun f => natDegree f).sum 
goal: t.prod.natDegree = (Multiset.map (fun f => f.natDegree) t).sum

full_name: Polynomial.natDegree_prod'
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees, provided that the product of leading coefficients is nonzero.

See `Polynomial.natDegree_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem natDegree_prod' (h : (∏ i ∈ s, (f i).leadingCoeff) ≠ 0) :
    (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree 
goal: (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree

full_name: Polynomial.natDegree_multiset_prod_of_monic
code: theorem natDegree_multiset_prod_of_monic (h : ∀ f ∈ t, Monic f) :
    t.prod.natDegree = (t.map natDegree).sum 
goal: t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum

full_name: Polynomial.natDegree_prod_of_monic
code: theorem natDegree_prod_of_monic (h : ∀ i ∈ s, (f i).Monic) :
    (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree 
goal: (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree

full_name: Polynomial.coeff_multiset_prod_of_natDegree_le
code: theorem coeff_multiset_prod_of_natDegree_le (n : ℕ) (hl : ∀ p ∈ t, natDegree p ≤ n) :
    coeff t.prod ((Multiset.card t) * n) = (t.map fun p => coeff p n).prod 
goal: t.prod.coeff (Multiset.card t * n) = (Multiset.map (fun p => p.coeff n) t).prod

full_name: Polynomial.coeff_prod_of_natDegree_le
code: theorem coeff_prod_of_natDegree_le (f : ι → R[X]) (n : ℕ) (h : ∀ p ∈ s, natDegree (f p) ≤ n) :
    coeff (∏ i ∈ s, f i) (s.card * n) = ∏ i ∈ s, coeff (f i) n 
goal: (∏ i ∈ s, f i).coeff (s.card * n) = ∏ i ∈ s, (f i).coeff n

full_name: Polynomial.coeff_zero_multiset_prod
code: theorem coeff_zero_multiset_prod : t.prod.coeff 0 = (t.map fun f => coeff f 0).prod 
goal: t.prod.coeff 0 = (Multiset.map (fun f => f.coeff 0) t).prod

full_name: Polynomial.coeff_zero_prod
code: theorem coeff_zero_prod : (∏ i ∈ s, f i).coeff 0 = ∏ i ∈ s, (f i).coeff 0 
goal: (∏ i ∈ s, f i).coeff 0 = ∏ i ∈ s, (f i).coeff 0

full_name: Polynomial.multiset_prod_X_sub_C_nextCoeff
code: theorem multiset_prod_X_sub_C_nextCoeff (t : Multiset R) :
    nextCoeff (t.map fun x => X - C x).prod = -t.sum 
goal: (Multiset.map (fun x => Polynomial.X - Polynomial.C x) t).prod.nextCoeff = -t.sum

full_name: Polynomial.prod_X_sub_C_nextCoeff
code: theorem prod_X_sub_C_nextCoeff {s : Finset ι} (f : ι → R) :
    nextCoeff (∏ i ∈ s, (X - C (f i))) = -∑ i ∈ s, f i 
goal: (∏ i ∈ s, (Polynomial.X - Polynomial.C (f i))).nextCoeff = -∑ i ∈ s, f i

full_name: Polynomial.multiset_prod_X_sub_C_coeff_card_pred
code: theorem multiset_prod_X_sub_C_coeff_card_pred (t : Multiset R) (ht : 0 < Multiset.card t) :
    (t.map fun x => X - C x).prod.coeff ((Multiset.card t) - 1) = -t.sum 
goal: (Multiset.map (fun x => Polynomial.X - Polynomial.C x) t).prod.coeff (Multiset.card t - 1) = -t.sum

full_name: Polynomial.prod_X_sub_C_coeff_card_pred
code: theorem prod_X_sub_C_coeff_card_pred (s : Finset ι) (f : ι → R) (hs : 0 < s.card) :
    (∏ i ∈ s, (X - C (f i))).coeff (s.card - 1) = -∑ i ∈ s, f i 
goal: (∏ i ∈ s, (Polynomial.X - Polynomial.C (f i))).coeff (s.card - 1) = -∑ i ∈ s, f i

full_name: Polynomial.degree_list_prod
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees, where the degree of the zero polynomial is ⊥.
`[Nontrivial R]` is needed, otherwise for `l = []` we have `⊥` in the LHS and `0` in the RHS.
-/
theorem degree_list_prod [Nontrivial R] (l : List R[X]) : l.prod.degree = (l.map degree).sum 
goal: l.prod.degree = (List.map Polynomial.degree l).sum

full_name: Polynomial.natDegree_prod
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees.

See `Polynomial.natDegree_prod'` (with a `'`) for a version for commutative semirings,
where additionally, the product of the leading coefficients must be nonzero.
-/
theorem natDegree_prod (h : ∀ i ∈ s, f i ≠ 0) :
    (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree 
goal: (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree

full_name: Polynomial.natDegree_multiset_prod
code: theorem natDegree_multiset_prod (h : (0 : R[X]) ∉ t) :
    natDegree t.prod = (t.map natDegree).sum 
goal: t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum

full_name: Polynomial.degree_multiset_prod
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees, where the degree of the zero polynomial is ⊥.
-/
theorem degree_multiset_prod [Nontrivial R] : t.prod.degree = (t.map fun f => degree f).sum 
goal: t.prod.degree = (Multiset.map (fun f => f.degree) t).sum

full_name: Polynomial.degree_prod
code: /-- The degree of a product of polynomials is equal to
the sum of the degrees, where the degree of the zero polynomial is ⊥.
-/
theorem degree_prod [Nontrivial R] : (∏ i ∈ s, f i).degree = ∑ i ∈ s, (f i).degree 
goal: (∏ i ∈ s, f i).degree = ∑ i ∈ s, (f i).degree

full_name: Polynomial.leadingCoeff_multiset_prod
code: /-- The leading coefficient of a product of polynomials is equal to
the product of the leading coefficients.

See `Polynomial.leadingCoeff_multiset_prod'` (with a `'`) for a version for commutative semirings,
where additionally, the product of the leading coefficients must be nonzero.
-/
theorem leadingCoeff_multiset_prod :
    t.prod.leadingCoeff = (t.map fun f => leadingCoeff f).prod 
goal: t.prod.leadingCoeff = (Multiset.map (fun f => f.leadingCoeff) t).prod

full_name: Polynomial.leadingCoeff_prod
code: /-- The leading coefficient of a product of polynomials is equal to
the product of the leading coefficients.

See `Polynomial.leadingCoeff_prod'` (with a `'`) for a version for commutative semirings,
where additionally, the product of the leading coefficients must be nonzero.
-/
theorem leadingCoeff_prod : (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff 
goal: (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff