File: Mathlib/RingTheory/Polynomial/Basic.lean

full_name: Polynomial.instCharP
code: instance instCharP (p : ℕ) [h : CharP R p] : CharP R[X] p 
goal: CharP R[X] p

full_name: Polynomial.instExpChar
code: instance instExpChar (p : ℕ) [h : ExpChar R p] : ExpChar R[X] p 
goal: ExpChar R[X] p

full_name: Polynomial.degreeLE
code: /-- The `R`-submodule of `R[X]` consisting of polynomials of degree ≤ `n`. -/
def degreeLE (n : WithBot ℕ) : Submodule R R[X] 
goal: Submodule R R[X]

full_name: Polynomial.degreeLT
code: /-- The `R`-submodule of `R[X]` consisting of polynomials of degree < `n`. -/
def degreeLT (n : ℕ) : Submodule R R[X] 
goal: Submodule R R[X]

full_name: Polynomial.mem_degreeLE
code: theorem mem_degreeLE {n : WithBot ℕ} {f : R[X]} : f ∈ degreeLE R n ↔ degree f ≤ n 
goal: f ∈ Polynomial.degreeLE R n ↔ f.degree ≤ n

full_name: Polynomial.degreeLE_mono
code: @[mono]
theorem degreeLE_mono {m n : WithBot ℕ} (H : m ≤ n) : degreeLE R m ≤ degreeLE R n 
goal: Polynomial.degreeLE R m ≤ Polynomial.degreeLE R n

full_name: Polynomial.degreeLE_eq_span_X_pow
code: theorem degreeLE_eq_span_X_pow [DecidableEq R] {n : ℕ} :
    degreeLE R n = Submodule.span R ↑((Finset.range (n + 1)).image fun n => (X : R[X]) ^ n) 
goal: Polynomial.degreeLE R ↑n = Submodule.span R ↑(Finset.image (fun n => Polynomial.X ^ n) (Finset.range (n + 1)))

full_name: Polynomial.mem_degreeLT
code: theorem mem_degreeLT {n : ℕ} {f : R[X]} : f ∈ degreeLT R n ↔ degree f < n 
goal: f ∈ Polynomial.degreeLT R n ↔ f.degree < ↑n

full_name: Polynomial.degreeLT_mono
code: @[mono]
theorem degreeLT_mono {m n : ℕ} (H : m ≤ n) : degreeLT R m ≤ degreeLT R n 
goal: Polynomial.degreeLT R m ≤ Polynomial.degreeLT R n

full_name: Polynomial.degreeLT_eq_span_X_pow
code: theorem degreeLT_eq_span_X_pow [DecidableEq R] {n : ℕ} :
    degreeLT R n = Submodule.span R ↑((Finset.range n).image fun n => X ^ n : Finset R[X]) 
goal: Polynomial.degreeLT R n = Submodule.span R ↑(Finset.image (fun n => Polynomial.X ^ n) (Finset.range n))

full_name: Polynomial.degreeLTEquiv
code: /-- The first `n` coefficients on `degreeLT n` form a linear equivalence with `Fin n → R`. -/
def degreeLTEquiv (R) [Semiring R] (n : ℕ) : degreeLT R n ≃ₗ[R] Fin n → R 
goal: ↥(Polynomial.degreeLT R n) ≃ₗ[R] Fin n → R

full_name: Polynomial.degreeLTEquiv_eq_zero_iff_eq_zero
code: theorem degreeLTEquiv_eq_zero_iff_eq_zero {n : ℕ} {p : R[X]} (hp : p ∈ degreeLT R n) :
    degreeLTEquiv _ _ ⟨p, hp⟩ = 0 ↔ p = 0 
goal: (Polynomial.degreeLTEquiv R n) ⟨p, hp⟩ = 0 ↔ p = 0

full_name: Polynomial.eval_eq_sum_degreeLTEquiv
code: theorem eval_eq_sum_degreeLTEquiv {n : ℕ} {p : R[X]} (hp : p ∈ degreeLT R n) (x : R) :
    p.eval x = ∑ i, degreeLTEquiv _ _ ⟨p, hp⟩ i * x ^ (i : ℕ) 
goal: Polynomial.eval x p = ∑ i : Fin n, (Polynomial.degreeLTEquiv R n) ⟨p, hp⟩ i * x ^ ↑i

full_name: Polynomial.degreeLT_succ_eq_degreeLE
code: theorem degreeLT_succ_eq_degreeLE {n : ℕ} : degreeLT R (n + 1) = degreeLE R n 
goal: Polynomial.degreeLT R (n + 1) = Polynomial.degreeLE R ↑n

full_name: Polynomial.exists_degree_le_of_mem_span
code: /-- For every polynomial `p` in the span of a set `s : Set R[X]`, there exists a polynomial of
  `p' ∈ s` with higher degree. See also `Polynomial.exists_degree_le_of_mem_span_of_finite`. -/
theorem exists_degree_le_of_mem_span {s : Set R[X]} {p : R[X]}
    (hs : s.Nonempty) (hp : p ∈ Submodule.span R s) :
    ∃ p' ∈ s, degree p ≤ degree p' 
goal: ∃ p' ∈ s, p.degree ≤ p'.degree

full_name: Polynomial.exists_degree_le_of_mem_span_of_finite
code: /-- A stronger version of `Polynomial.exists_degree_le_of_mem_span` under the assumption that the
  set `s : R[X]` is finite. There exists a polynomial `p' ∈ s` whose degree dominates the degree of
  every element of `p ∈ span R s`-/
theorem exists_degree_le_of_mem_span_of_finite {s : Set R[X]} (s_fin : s.Finite) (hs : s.Nonempty) :
    ∃ p' ∈ s, ∀ (p : R[X]), p ∈ Submodule.span R s → degree p ≤ degree p' 
goal: ∃ p' ∈ s, ∀ p ∈ Submodule.span R s, p.degree ≤ p'.degree

full_name: Polynomial.span_le_degreeLE_of_finite
code: /-- The span of every finite set of polynomials is contained in a `degreeLE n` for some `n`. -/
theorem span_le_degreeLE_of_finite {s : Set R[X]} (s_fin : s.Finite) :
    ∃ n : ℕ, Submodule.span R s ≤ degreeLE R n 
goal: ∃ n, Submodule.span R s ≤ Polynomial.degreeLE R ↑n

full_name: Polynomial.span_of_finite_le_degreeLT
code: /-- The span of every finite set of polynomials is contained in a `degreeLT n` for some `n`. -/
theorem span_of_finite_le_degreeLT {s : Set R[X]} (s_fin : s.Finite) :
    ∃ n : ℕ, Submodule.span R s ≤ degreeLT R n 
goal: ∃ n, Submodule.span R s ≤ Polynomial.degreeLT R n

full_name: Polynomial.not_finite
code: /-- If `R` is a nontrivial ring, the polynomials `R[X]` are not finite as an `R`-module. When `R` is
a field, this is equivalent to `R[X]` being an infinite-dimensional vector space over `R`.  -/
theorem not_finite [Nontrivial R] : ¬ Module.Finite R R[X] 
goal: ¬Module.Finite R R[X]

full_name: Polynomial.coeffs
code: /-- The finset of nonzero coefficients of a polynomial. -/
def coeffs (p : R[X]) : Finset R 
goal: Finset R

full_name: Polynomial.coeffs_zero
code: theorem coeffs_zero : coeffs (0 : R[X]) = ∅ 
goal: Polynomial.coeffs 0 = ∅

full_name: Polynomial.mem_coeffs_iff
code: theorem mem_coeffs_iff {p : R[X]} {c : R} : c ∈ p.coeffs ↔ ∃ n ∈ p.support, c = p.coeff n 
goal: c ∈ p.coeffs ↔ ∃ n ∈ p.support, c = p.coeff n

full_name: Polynomial.coeffs_one
code: theorem coeffs_one : coeffs (1 : R[X]) ⊆ {1} 
goal: Polynomial.coeffs 1 ⊆ {1}

full_name: Polynomial.coeff_mem_coeffs
code: theorem coeff_mem_coeffs (p : R[X]) (n : ℕ) (h : p.coeff n ≠ 0) : p.coeff n ∈ p.coeffs 
goal: p.coeff n ∈ p.coeffs

full_name: Polynomial.geom_sum_X_comp_X_add_one_eq_sum
code: theorem geom_sum_X_comp_X_add_one_eq_sum (n : ℕ) :
    (∑ i ∈ range n, (X : R[X]) ^ i).comp (X + 1) =
      (Finset.range n).sum fun i : ℕ => (n.choose (i + 1) : R[X]) * X ^ i 
goal: (∑ i ∈ Finset.range n, Polynomial.X ^ i).comp (Polynomial.X + 1) =
  ∑ i ∈ Finset.range n, ↑(n.choose (i + 1)) * Polynomial.X ^ i

full_name: Polynomial.Monic.geom_sum
code: theorem Monic.geom_sum {P : R[X]} (hP : P.Monic) (hdeg : 0 < P.natDegree) {n : ℕ} (hn : n ≠ 0) :
    (∑ i ∈ range n, P ^ i).Monic 
goal: (∑ i ∈ Finset.range n, P ^ i).Monic

full_name: Polynomial.Monic.geom_sum'
code: theorem Monic.geom_sum' {P : R[X]} (hP : P.Monic) (hdeg : 0 < P.degree) {n : ℕ} (hn : n ≠ 0) :
    (∑ i ∈ range n, P ^ i).Monic 
goal: (∑ i ∈ Finset.range n, P ^ i).Monic

full_name: Polynomial.monic_geom_sum_X
code: theorem monic_geom_sum_X {n : ℕ} (hn : n ≠ 0) : (∑ i ∈ range n, (X : R[X]) ^ i).Monic 
goal: (∑ i ∈ Finset.range n, Polynomial.X ^ i).Monic

full_name: Polynomial.restriction
code: /-- Given a polynomial, return the polynomial whose coefficients are in
the ring closure of the original coefficients. -/
def restriction (p : R[X]) : Polynomial (Subring.closure (↑p.coeffs : Set R)) 
goal: (↥(Subring.closure ↑p.coeffs))[X]

full_name: Polynomial.coeff_restriction
code: @[simp]
theorem coeff_restriction {p : R[X]} {n : ℕ} : ↑(coeff (restriction p) n) = coeff p n 
goal: ↑(p.restriction.coeff n) = p.coeff n

full_name: Polynomial.coeff_restriction'
code: theorem coeff_restriction' {p : R[X]} {n : ℕ} : (coeff (restriction p) n).1 = coeff p n 
goal: ↑(p.restriction.coeff n) = p.coeff n

full_name: Polynomial.support_restriction
code: @[simp]
theorem support_restriction (p : R[X]) : support (restriction p) = support p 
goal: p.restriction.support = p.support

full_name: Polynomial.map_restriction
code: @[simp]
theorem map_restriction {R : Type u} [CommRing R] (p : R[X]) :
    p.restriction.map (algebraMap _ _) = p 
goal: Polynomial.map (algebraMap (↥(Subring.closure ↑p.coeffs)) R) p.restriction = p

full_name: Polynomial.degree_restriction
code: @[simp]
theorem degree_restriction {p : R[X]} : (restriction p).degree = p.degree 
goal: p.restriction.degree = p.degree

full_name: Polynomial.natDegree_restriction
code: @[simp]
theorem natDegree_restriction {p : R[X]} : (restriction p).natDegree = p.natDegree 
goal: p.restriction.natDegree = p.natDegree

full_name: Polynomial.monic_restriction
code: @[simp]
theorem monic_restriction {p : R[X]} : Monic (restriction p) ↔ Monic p 
goal: p.restriction.Monic ↔ p.Monic

full_name: Polynomial.restriction_zero
code: @[simp]
theorem restriction_zero : restriction (0 : R[X]) = 0 
goal: Polynomial.restriction 0 = 0

full_name: Polynomial.restriction_one
code: @[simp]
theorem restriction_one : restriction (1 : R[X]) = 1 
goal: Polynomial.restriction 1 = 1

full_name: Polynomial.eval₂_restriction
code: theorem eval₂_restriction {p : R[X]} :
    eval₂ f x p =
      eval₂ (f.comp (Subring.subtype (Subring.closure (p.coeffs : Set R)))) x p.restriction 
goal: Polynomial.eval₂ f x p = Polynomial.eval₂ (f.comp (Subring.closure ↑p.coeffs).subtype) x p.restriction

full_name: Polynomial.toSubring
code: /-- Given a polynomial `p` and a subring `T` that contains the coefficients of `p`,
return the corresponding polynomial whose coefficients are in `T`. -/
def toSubring (hp : (↑p.coeffs : Set R) ⊆ T) : T[X] 
goal: (↥T)[X]

full_name: Polynomial.coeff_toSubring
code: @[simp]
theorem coeff_toSubring {n : ℕ} : ↑(coeff (toSubring p T hp) n) = coeff p n 
goal: ↑((p.toSubring T hp).coeff n) = p.coeff n

full_name: Polynomial.coeff_toSubring'
code: theorem coeff_toSubring' {n : ℕ} : (coeff (toSubring p T hp) n).1 = coeff p n 
goal: ↑((p.toSubring T hp).coeff n) = p.coeff n

full_name: Polynomial.support_toSubring
code: @[simp]
theorem support_toSubring : support (toSubring p T hp) = support p 
goal: (p.toSubring T hp).support = p.support

full_name: Polynomial.degree_toSubring
code: @[simp]
theorem degree_toSubring : (toSubring p T hp).degree = p.degree 
goal: (p.toSubring T hp).degree = p.degree

full_name: Polynomial.natDegree_toSubring
code: @[simp]
theorem natDegree_toSubring : (toSubring p T hp).natDegree = p.natDegree 
goal: (p.toSubring T hp).natDegree = p.natDegree

full_name: Polynomial.monic_toSubring
code: @[simp]
theorem monic_toSubring : Monic (toSubring p T hp) ↔ Monic p 
goal: (p.toSubring T hp).Monic ↔ p.Monic

full_name: Polynomial.toSubring_zero
code: @[simp]
theorem toSubring_zero : toSubring (0 : R[X]) T (by simp [coeffs]) = 0 
goal: Polynomial.toSubring 0 T ⋯ = 0

full_name: Polynomial.toSubring_one
code: @[simp]
theorem toSubring_one :
    toSubring (1 : R[X]) T
        (Set.Subset.trans coeffs_one <| Finset.singleton_subset_set_iff.2 T.one_mem) =
      1 
goal: Polynomial.toSubring 1 T ⋯ = 1

full_name: Polynomial.map_toSubring
code: @[simp]
theorem map_toSubring : (p.toSubring T hp).map (Subring.subtype T) = p 
goal: Polynomial.map T.subtype (p.toSubring T hp) = p

full_name: Polynomial.ofSubring
code: /-- Given a polynomial whose coefficients are in some subring, return
the corresponding polynomial whose coefficients are in the ambient ring. -/
def ofSubring (p : T[X]) : R[X] 
goal: R[X]

full_name: Polynomial.coeff_ofSubring
code: theorem coeff_ofSubring (p : T[X]) (n : ℕ) : coeff (ofSubring T p) n = (coeff p n : T) 
goal: (Polynomial.ofSubring T p).coeff n = ↑(p.coeff n)

full_name: Polynomial.coeffs_ofSubring
code: @[simp]
theorem coeffs_ofSubring {p : T[X]} : (↑(p.ofSubring T).coeffs : Set R) ⊆ T 
goal: ↑(Polynomial.ofSubring T p).coeffs ⊆ ↑T

full_name: Polynomial.mem_ker_modByMonic
code: theorem mem_ker_modByMonic (hq : q.Monic) {p : R[X]} :
    p ∈ LinearMap.ker (modByMonicHom q) ↔ q ∣ p 
goal: p ∈ LinearMap.ker q.modByMonicHom ↔ q ∣ p

full_name: Polynomial.ker_modByMonicHom
code: @[simp]
theorem ker_modByMonicHom (hq : q.Monic) :
    LinearMap.ker (Polynomial.modByMonicHom q) = (Ideal.span {q}).restrictScalars R 
goal: LinearMap.ker q.modByMonicHom = Submodule.restrictScalars R (Ideal.span {q})

full_name: Ideal.ofPolynomial
code: /-- Transport an ideal of `R[X]` to an `R`-submodule of `R[X]`. -/
def ofPolynomial (I : Ideal R[X]) : Submodule R R[X] 
goal: Submodule R R[X]

full_name: Ideal.mem_ofPolynomial
code: theorem mem_ofPolynomial (x) : x ∈ I.ofPolynomial ↔ x ∈ I 
goal: x ∈ I.ofPolynomial ↔ x ∈ I

full_name: Ideal.degreeLE
code: /-- Given an ideal `I` of `R[X]`, make the `R`-submodule of `I`
consisting of polynomials of degree ≤ `n`. -/
def degreeLE (n : WithBot ℕ) : Submodule R R[X] 
goal: Submodule R R[X]

full_name: Ideal.leadingCoeffNth
code: /-- Given an ideal `I` of `R[X]`, make the ideal in `R` of
leading coefficients of polynomials in `I` with degree ≤ `n`. -/
def leadingCoeffNth (n : ℕ) : Ideal R 
goal: Ideal R

full_name: Ideal.leadingCoeff
code: /-- Given an ideal `I` in `R[X]`, make the ideal in `R` of the
leading coefficients in `I`. -/
def leadingCoeff : Ideal R 
goal: Ideal R

full_name: Ideal.polynomial_mem_ideal_of_coeff_mem_ideal
code: /-- If every coefficient of a polynomial is in an ideal `I`, then so is the polynomial itself -/
theorem polynomial_mem_ideal_of_coeff_mem_ideal (I : Ideal R[X]) (p : R[X])
    (hp : ∀ n : ℕ, p.coeff n ∈ I.comap (C : R →+* R[X])) : p ∈ I 
goal: p ∈ I

full_name: Ideal.mem_map_C_iff
code: /-- The push-forward of an ideal `I` of `R` to `R[X]` via inclusion
 is exactly the set of polynomials whose coefficients are in `I` -/
theorem mem_map_C_iff {I : Ideal R} {f : R[X]} :
    f ∈ (Ideal.map (C : R →+* R[X]) I : Ideal R[X]) ↔ ∀ n : ℕ, f.coeff n ∈ I 
goal: f ∈ Ideal.map Polynomial.C I ↔ ∀ (n : ℕ), f.coeff n ∈ I

full_name: Polynomial.ker_mapRingHom
code: theorem _root_.Polynomial.ker_mapRingHom (f : R →+* S) :
    LinearMap.ker (Polynomial.mapRingHom f).toSemilinearMap = f.ker.map (C : R →+* R[X]) 
goal: LinearMap.ker (Polynomial.mapRingHom f).toSemilinearMap = Ideal.map Polynomial.C (RingHom.ker f)

full_name: Ideal.mem_leadingCoeffNth
code: theorem mem_leadingCoeffNth (n : ℕ) (x) :
    x ∈ I.leadingCoeffNth n ↔ ∃ p ∈ I, degree p ≤ n ∧ p.leadingCoeff = x 
goal: x ∈ I.leadingCoeffNth n ↔ ∃ p ∈ I, p.degree ≤ ↑n ∧ p.leadingCoeff = x

full_name: Ideal.mem_leadingCoeffNth_zero
code: theorem mem_leadingCoeffNth_zero (x) : x ∈ I.leadingCoeffNth 0 ↔ C x ∈ I 
goal: x ∈ I.leadingCoeffNth 0 ↔ Polynomial.C x ∈ I

full_name: Ideal.leadingCoeffNth_mono
code: theorem leadingCoeffNth_mono {m n : ℕ} (H : m ≤ n) : I.leadingCoeffNth m ≤ I.leadingCoeffNth n 
goal: I.leadingCoeffNth m ≤ I.leadingCoeffNth n

full_name: Ideal.mem_leadingCoeff
code: theorem mem_leadingCoeff (x) : x ∈ I.leadingCoeff ↔ ∃ p ∈ I, Polynomial.leadingCoeff p = x 
goal: x ∈ I.leadingCoeff ↔ ∃ p ∈ I, p.leadingCoeff = x

full_name: Polynomial.coeff_prod_mem_ideal_pow_tsub
code: /-- If `I` is an ideal, and `pᵢ` is a finite family of polynomials each satisfying
`∀ k, (pᵢ)ₖ ∈ Iⁿⁱ⁻ᵏ` for some `nᵢ`, then `p = ∏ pᵢ` also satisfies `∀ k, pₖ ∈ Iⁿ⁻ᵏ` with `n = ∑ nᵢ`.
-/
theorem _root_.Polynomial.coeff_prod_mem_ideal_pow_tsub {ι : Type*} (s : Finset ι) (f : ι → R[X])
    (I : Ideal R) (n : ι → ℕ) (h : ∀ i ∈ s, ∀ (k), (f i).coeff k ∈ I ^ (n i - k)) (k : ℕ) :
    (s.prod f).coeff k ∈ I ^ (s.sum n - k) 
goal: (s.prod f).coeff k ∈ I ^ (s.sum n - k)

full_name: Ideal.polynomial_not_isField
code: /-- `R[X]` is never a field for any ring `R`. -/
theorem polynomial_not_isField : ¬IsField R[X] 
goal: ¬IsField R[X]

full_name: Ideal.eq_zero_of_constant_mem_of_maximal
code: /-- The only constant in a maximal ideal over a field is `0`. -/
theorem eq_zero_of_constant_mem_of_maximal (hR : IsField R) (I : Ideal R[X]) [hI : I.IsMaximal]
    (x : R) (hx : C x ∈ I) : x = 0 
goal: x = 0

full_name: Ideal.isPrime_map_C_iff_isPrime
code: /-- If `P` is a prime ideal of `R`, then `P.R[x]` is a prime ideal of `R[x]`. -/
theorem isPrime_map_C_iff_isPrime (P : Ideal R) :
    IsPrime (map (C : R →+* R[X]) P : Ideal R[X]) ↔ IsPrime P 
goal: (Ideal.map Polynomial.C P).IsPrime ↔ P.IsPrime

full_name: Ideal.isPrime_map_C_of_isPrime
code: /-- If `P` is a prime ideal of `R`, then `P.R[x]` is a prime ideal of `R[x]`. -/
theorem isPrime_map_C_of_isPrime {P : Ideal R} (H : IsPrime P) :
    IsPrime (map (C : R →+* R[X]) P : Ideal R[X]) 
goal: (Ideal.map Polynomial.C P).IsPrime

full_name: Ideal.is_fg_degreeLE
code: theorem is_fg_degreeLE [IsNoetherianRing R] (I : Ideal R[X]) (n : ℕ) :
    Submodule.FG (I.degreeLE n) 
goal: (I.degreeLE ↑n).FG

full_name: Polynomial.prime_C_iff
code: theorem prime_C_iff : Prime (C r) ↔ Prime r 
goal: Prime (Polynomial.C r) ↔ Prime r

full_name: _private.Mathlib.RingTheory.Polynomial.Basic.0.MvPolynomial.prime_C_iff_of_fintype
code: private theorem prime_C_iff_of_fintype {R : Type u} (σ : Type v) {r : R} [CommRing R] [Fintype σ] :
    Prime (C r : MvPolynomial σ R) ↔ Prime r 
goal: Prime (MvPolynomial.C r) ↔ Prime r

full_name: MvPolynomial.prime_C_iff
code: theorem prime_C_iff : Prime (C r : MvPolynomial σ R) ↔ Prime r 
goal: Prime (MvPolynomial.C r) ↔ Prime r

full_name: MvPolynomial.prime_rename_iff
code: theorem prime_rename_iff (s : Set σ) {p : MvPolynomial s R} :
    Prime (rename ((↑) : s → σ) p) ↔ Prime (p : MvPolynomial s R) 
goal: Prime ((MvPolynomial.rename Subtype.val) p) ↔ Prime p

full_name: Polynomial.wfDvdMonoid
code: instance (priority := 100) wfDvdMonoid {R : Type*} [CommRing R] [IsDomain R] [WfDvdMonoid R] :
    WfDvdMonoid R[X] 
goal: WfDvdMonoid R[X]

full_name: Polynomial.isNoetherianRing
code: /-- Hilbert basis theorem: a polynomial ring over a noetherian ring is a noetherian ring. -/
protected theorem Polynomial.isNoetherianRing [inst : IsNoetherianRing R] : IsNoetherianRing R[X] 
goal: IsNoetherianRing R[X]

full_name: Polynomial.exists_irreducible_of_degree_pos
code: theorem exists_irreducible_of_degree_pos {R : Type u} [CommRing R] [IsDomain R] [WfDvdMonoid R]
    {f : R[X]} (hf : 0 < f.degree) : ∃ g, Irreducible g ∧ g ∣ f 
goal: ∃ g, Irreducible g ∧ g ∣ f

full_name: Polynomial.exists_irreducible_of_natDegree_pos
code: theorem exists_irreducible_of_natDegree_pos {R : Type u} [CommRing R] [IsDomain R] [WfDvdMonoid R]
    {f : R[X]} (hf : 0 < f.natDegree) : ∃ g, Irreducible g ∧ g ∣ f 
goal: ∃ g, Irreducible g ∧ g ∣ f

full_name: Polynomial.exists_irreducible_of_natDegree_ne_zero
code: theorem exists_irreducible_of_natDegree_ne_zero {R : Type u} [CommRing R] [IsDomain R]
    [WfDvdMonoid R] {f : R[X]} (hf : f.natDegree ≠ 0) : ∃ g, Irreducible g ∧ g ∣ f 
goal: ∃ g, Irreducible g ∧ g ∣ f

full_name: Polynomial.linearIndependent_powers_iff_aeval
code: theorem linearIndependent_powers_iff_aeval (f : M →ₗ[R] M) (v : M) :
    (LinearIndependent R fun n : ℕ => (f ^ n) v) ↔ ∀ p : R[X], aeval f p v = 0 → p = 0 
goal: (LinearIndependent R fun n => (f ^ n) v) ↔ ∀ (p : R[X]), ((Polynomial.aeval f) p) v = 0 → p = 0

full_name: Polynomial.disjoint_ker_aeval_of_coprime
code: theorem disjoint_ker_aeval_of_coprime (f : M →ₗ[R] M) {p q : R[X]} (hpq : IsCoprime p q) :
    Disjoint (LinearMap.ker (aeval f p)) (LinearMap.ker (aeval f q)) 
goal: Disjoint (LinearMap.ker ((Polynomial.aeval f) p)) (LinearMap.ker ((Polynomial.aeval f) q))

full_name: Polynomial.sup_aeval_range_eq_top_of_coprime
code: theorem sup_aeval_range_eq_top_of_coprime (f : M →ₗ[R] M) {p q : R[X]} (hpq : IsCoprime p q) :
    LinearMap.range (aeval f p) ⊔ LinearMap.range (aeval f q) = ⊤ 
goal: LinearMap.range ((Polynomial.aeval f) p) ⊔ LinearMap.range ((Polynomial.aeval f) q) = ⊤

full_name: Polynomial.sup_ker_aeval_le_ker_aeval_mul
code: theorem sup_ker_aeval_le_ker_aeval_mul {f : M →ₗ[R] M} {p q : R[X]} :
    LinearMap.ker (aeval f p) ⊔ LinearMap.ker (aeval f q) ≤ LinearMap.ker (aeval f (p * q)) 
goal: LinearMap.ker ((Polynomial.aeval f) p) ⊔ LinearMap.ker ((Polynomial.aeval f) q) ≤
  LinearMap.ker ((Polynomial.aeval f) (p * q))

full_name: Polynomial.sup_ker_aeval_eq_ker_aeval_mul_of_coprime
code: theorem sup_ker_aeval_eq_ker_aeval_mul_of_coprime (f : M →ₗ[R] M) {p q : R[X]}
    (hpq : IsCoprime p q) :
    LinearMap.ker (aeval f p) ⊔ LinearMap.ker (aeval f q) = LinearMap.ker (aeval f (p * q)) 
goal: LinearMap.ker ((Polynomial.aeval f) p) ⊔ LinearMap.ker ((Polynomial.aeval f) q) =
  LinearMap.ker ((Polynomial.aeval f) (p * q))

full_name: MvPolynomial.aeval_natDegree_le
code: lemma aeval_natDegree_le {R : Type*} [CommSemiring R] {m n : ℕ}
    (F : MvPolynomial σ R) (hF : F.totalDegree ≤ m)
    (f : σ → Polynomial R) (hf : ∀ i, (f i).natDegree ≤ n) :
    (MvPolynomial.aeval f F).natDegree ≤ m * n 
goal: ((MvPolynomial.aeval f) F).natDegree ≤ m * n

full_name: MvPolynomial.isNoetherianRing_fin_0
code: theorem isNoetherianRing_fin_0 [IsNoetherianRing R] :
    IsNoetherianRing (MvPolynomial (Fin 0) R) 
goal: IsNoetherianRing (MvPolynomial (Fin 0) R)

full_name: MvPolynomial.isNoetherianRing_fin
code: theorem isNoetherianRing_fin [IsNoetherianRing R] :
    ∀ {n : ℕ}, IsNoetherianRing (MvPolynomial (Fin n) R)
  
goal: IsNoetherianRing (MvPolynomial (Fin n) R)

full_name: MvPolynomial.isNoetherianRing
code: /-- The multivariate polynomial ring in finitely many variables over a noetherian ring
is itself a noetherian ring. -/
instance isNoetherianRing [Finite σ] [IsNoetherianRing R] :
    IsNoetherianRing (MvPolynomial σ R) 
goal: IsNoetherianRing (MvPolynomial σ R)

full_name: MvPolynomial.noZeroDivisors_fin
code: /-- Auxiliary lemma:
Multivariate polynomials over an integral domain
with variables indexed by `Fin n` form an integral domain.
This fact is proven inductively,
and then used to prove the general case without any finiteness hypotheses.
See `MvPolynomial.noZeroDivisors` for the general case. -/
theorem noZeroDivisors_fin (R : Type u) [CommSemiring R] [NoZeroDivisors R] :
    ∀ n : ℕ, NoZeroDivisors (MvPolynomial (Fin n) R)
  
goal: NoZeroDivisors (MvPolynomial (Fin n) R)

full_name: MvPolynomial.noZeroDivisors_of_finite
code: /-- Auxiliary definition:
Multivariate polynomials in finitely many variables over an integral domain form an integral domain.
This fact is proven by transport of structure from the `MvPolynomial.noZeroDivisors_fin`,
and then used to prove the general case without finiteness hypotheses.
See `MvPolynomial.noZeroDivisors` for the general case. -/
theorem noZeroDivisors_of_finite (R : Type u) (σ : Type v) [CommSemiring R] [Finite σ]
    [NoZeroDivisors R] : NoZeroDivisors (MvPolynomial σ R) 
goal: NoZeroDivisors (MvPolynomial σ R)

full_name: MvPolynomial.instNoZeroDivisors
code: instance {R : Type u} [CommSemiring R] [NoZeroDivisors R] {σ : Type v} :
    NoZeroDivisors (MvPolynomial σ R) 
goal: NoZeroDivisors (MvPolynomial σ R)

full_name: MvPolynomial.isDomain
code: /-- The multivariate polynomial ring over an integral domain is an integral domain. -/
instance isDomain {R : Type u} {σ : Type v} [CommRing R] [IsDomain R] :
    IsDomain (MvPolynomial σ R) 
goal: IsDomain (MvPolynomial σ R)

full_name: MvPolynomial.map_mvPolynomial_eq_eval₂
code: theorem map_mvPolynomial_eq_eval₂ {S : Type*} [CommRing S] [Finite σ] (ϕ : MvPolynomial σ R →+* S)
    (p : MvPolynomial σ R) :
    ϕ p = MvPolynomial.eval₂ (ϕ.comp MvPolynomial.C) (fun s => ϕ (MvPolynomial.X s)) p 
goal: ϕ p = MvPolynomial.eval₂ (ϕ.comp MvPolynomial.C) (fun s => ϕ (MvPolynomial.X s)) p

full_name: MvPolynomial.mem_ideal_of_coeff_mem_ideal
code: /-- If every coefficient of a polynomial is in an ideal `I`, then so is the polynomial itself,
multivariate version. -/
theorem mem_ideal_of_coeff_mem_ideal (I : Ideal (MvPolynomial σ R)) (p : MvPolynomial σ R)
    (hcoe : ∀ m : σ →₀ ℕ, p.coeff m ∈ I.comap (C : R →+* MvPolynomial σ R)) : p ∈ I 
goal: p ∈ I

full_name: MvPolynomial.mem_map_C_iff
code: /-- The push-forward of an ideal `I` of `R` to `MvPolynomial σ R` via inclusion
 is exactly the set of polynomials whose coefficients are in `I` -/
theorem mem_map_C_iff {I : Ideal R} {f : MvPolynomial σ R} :
    f ∈ (Ideal.map (C : R →+* MvPolynomial σ R) I : Ideal (MvPolynomial σ R)) ↔
      ∀ m : σ →₀ ℕ, f.coeff m ∈ I 
goal: f ∈ Ideal.map MvPolynomial.C I ↔ ∀ (m : σ →₀ ℕ), MvPolynomial.coeff m f ∈ I

full_name: MvPolynomial.ker_map
code: theorem ker_map (f : R →+* S) :
    RingHom.ker (map f : MvPolynomial σ R →+* MvPolynomial σ S) =
    Ideal.map (C : R →+* MvPolynomial σ R) (RingHom.ker f) 
goal: RingHom.ker (MvPolynomial.map f) = Ideal.map MvPolynomial.C (RingHom.ker f)

full_name: Polynomial.uniqueFactorizationMonoid
code: instance (priority := 100) uniqueFactorizationMonoid : UniqueFactorizationMonoid D[X] 
goal: UniqueFactorizationMonoid D[X]

full_name: Polynomial.fintypeSubtypeMonicDvd
code: /-- If `D` is a unique factorization domain, `f` is a non-zero polynomial in `D[X]`, then `f` has
only finitely many monic factors.
(Note that its factors up to unit may be more than monic factors.)
See also `UniqueFactorizationMonoid.fintypeSubtypeDvd`. -/
noncomputable def fintypeSubtypeMonicDvd (f : D[X]) (hf : f ≠ 0) :
    Fintype { g : D[X] // g.Monic ∧ g ∣ f } 
goal: Fintype { g // g.Monic ∧ g ∣ f }

full_name: _private.Mathlib.RingTheory.Polynomial.Basic.0.MvPolynomial.uniqueFactorizationMonoid_of_fintype
code: private theorem uniqueFactorizationMonoid_of_fintype [Fintype σ] :
    UniqueFactorizationMonoid (MvPolynomial σ D) 
goal: UniqueFactorizationMonoid (MvPolynomial σ D)

full_name: MvPolynomial.uniqueFactorizationMonoid
code: instance (priority := 100) uniqueFactorizationMonoid :
    UniqueFactorizationMonoid (MvPolynomial σ D) 
goal: UniqueFactorizationMonoid (MvPolynomial σ D)

full_name: Polynomial.exists_monic_irreducible_factor
code: /-- A polynomial over a field which is not a unit must have a monic irreducible factor.
See also `WfDvdMonoid.exists_irreducible_factor`. -/
theorem Polynomial.exists_monic_irreducible_factor {F : Type*} [Field F] (f : F[X])
    (hu : ¬IsUnit f) : ∃ g : F[X], g.Monic ∧ Irreducible g ∧ g ∣ f 
goal: ∃ g, g.Monic ∧ Irreducible g ∧ g ∣ f