Module docstring
{"# Evaluation of polynomials
This file contains results on the interaction of Polynomial.eval and Polynomial.coeff
"}
{"# Evaluation of polynomials
This file contains results on the interaction of Polynomial.eval and Polynomial.coeff
"}
Polynomial.eval₂_at_zero
theorem
: p.eval₂ f 0 = f (coeff p 0)
@[simp]
theorem eval₂_at_zero : p.eval₂ f 0 = f (coeff p 0) := by
simp +contextual only [eval₂_eq_sum, zero_pow_eq, mul_ite, mul_zero,
mul_one, sum, Classical.not_not, mem_support_iff, sum_ite_eq', ite_eq_left_iff,
RingHom.map_zero, imp_true_iff, eq_self_iff_true]
Polynomial.eval₂_C_X
theorem
: eval₂ C X p = p
@[simp]
theorem eval₂_C_X : eval₂ C X p = p :=
Polynomial.induction_on' p (fun p q hp hq => by simp [hp, hq]) fun n x => by
rw [eval₂_monomial, ← smul_X_eq_monomial, C_mul']
Polynomial.coeff_zero_eq_eval_zero
theorem
(p : R[X]) : coeff p 0 = p.eval 0
theorem coeff_zero_eq_eval_zero (p : R[X]) : coeff p 0 = p.eval 0 :=
calc
coeff p 0 = coeff p 0 * 0 ^ 0 := by simp
_ = p.eval 0 := by
symm
rw [eval_eq_sum]
exact Finset.sum_eq_single _ (fun b _ hb => by simp [zero_pow hb]) (by simp)
Polynomial.zero_isRoot_of_coeff_zero_eq_zero
theorem
{p : R[X]} (hp : p.coeff 0 = 0) : IsRoot p 0
theorem zero_isRoot_of_coeff_zero_eq_zero {p : R[X]} (hp : p.coeff 0 = 0) : IsRoot p 0 := by
rwa [coeff_zero_eq_eval_zero] at hp
Polynomial.coeff_map
theorem
(n : ℕ) : coeff (p.map f) n = f (coeff p n)
@[simp]
theorem coeff_map (n : ℕ) : coeff (p.map f) n = f (coeff p n) := by
rw [map, eval₂_def, coeff_sum, sum]
conv_rhs => rw [← sum_C_mul_X_pow_eq p, coeff_sum, sum, map_sum]
refine Finset.sum_congr rfl fun x _hx => ?_
simp only [RingHom.coe_comp, Function.comp, coeff_C_mul_X_pow]
split_ifs <;> simp [f.map_zero]
Polynomial.coeff_map_eq_comp
theorem
(p : R[X]) (f : R →+* S) : (p.map f).coeff = f ∘ p.coeff
lemma coeff_map_eq_comp (p : R[X]) (f : R →+* S) : (p.map f).coeff = f ∘ p.coeff := by
ext n; exact coeff_map ..
Polynomial.map_map
theorem
[Semiring T] (g : S →+* T) (p : R[X]) : (p.map f).map g = p.map (g.comp f)
Polynomial.map_id
theorem
: p.map (RingHom.id _) = p
@[simp]
theorem map_id : p.map (RingHom.id _) = p := by simp [Polynomial.ext_iff, coeff_map]
Polynomial.piEquiv
definition
{ι} [Finite ι] (R : ι → Type*) [∀ i, Semiring (R i)] : (∀ i, R i)[X] ≃+* ∀ i, (R i)[X]
/-- The polynomial ring over a finite product of rings is isomorphic to
the product of polynomial rings over individual rings. -/
def piEquiv {ι} [Finite ι] (R : ι → Type*) [∀ i, Semiring (R i)] :
(∀ i, R i)[X](∀ i, R i)[X] ≃+* ∀ i, (R i)[X] :=
.ofBijective (Pi.ringHom fun i ↦ mapRingHom (Pi.evalRingHom R i))
⟨fun p q h ↦ by ext n i; simpa using congr_arg (fun p ↦ coeff (p i) n) h,
fun p ↦ ⟨.ofFinsupp (.ofSupportFinite (fun n i ↦ coeff (p i) n) <|
(Set.finite_iUnion fun i ↦ (p i).support.finite_toSet).subset fun n hn ↦ by
simp only [Set.mem_iUnion, Finset.mem_coe, mem_support_iff, Function.mem_support] at hn ⊢
contrapose! hn; exact funext hn), by ext i n; exact coeff_map _ _⟩⟩
Polynomial.map_injective
theorem
(hf : Function.Injective f) : Function.Injective (map f)
theorem map_injective (hf : Function.Injective f) : Function.Injective (map f) := fun p q h =>
ext fun m => hf <| by rw [← coeff_map f, ← coeff_map f, h]
Polynomial.map_injective_iff
theorem
: Function.Injective (map f) ↔ Function.Injective f
Polynomial.map_surjective
theorem
(hf : Function.Surjective f) : Function.Surjective (map f)
theorem map_surjective (hf : Function.Surjective f) : Function.Surjective (map f) := fun p =>
p.induction_on'
(by rintro _ _ ⟨p, rfl⟩ ⟨q, rfl⟩; exact ⟨p + q, Polynomial.map_add f⟩)
fun n s ↦
let ⟨r, hr⟩ := hf s
⟨monomial n r, by rw [map_monomial f, hr]⟩
Polynomial.map_surjective_iff
theorem
: Function.Surjective (map f) ↔ Function.Surjective f
Polynomial.map_eq_zero_iff
theorem
(hf : Function.Injective f) : p.map f = 0 ↔ p = 0
protected theorem map_eq_zero_iff (hf : Function.Injective f) : p.map f = 0 ↔ p = 0 :=
map_eq_zero_iff (mapRingHom f) (map_injective f hf)
Polynomial.map_ne_zero_iff
theorem
(hf : Function.Injective f) : p.map f ≠ 0 ↔ p ≠ 0
protected theorem map_ne_zero_iff (hf : Function.Injective f) : p.map f ≠ 0p.map f ≠ 0 ↔ p ≠ 0 :=
(Polynomial.map_eq_zero_iff hf).not
Polynomial.mapRingHom_id
theorem
: mapRingHom (RingHom.id R) = RingHom.id R[X]
@[simp]
theorem mapRingHom_id : mapRingHom (RingHom.id R) = RingHom.id R[X] :=
RingHom.ext fun _x => map_id
Polynomial.mapRingHom_comp
theorem
[Semiring T] (f : S →+* T) (g : R →+* S) : (mapRingHom f).comp (mapRingHom g) = mapRingHom (f.comp g)
@[simp]
theorem mapRingHom_comp [Semiring T] (f : S →+* T) (g : R →+* S) :
(mapRingHom f).comp (mapRingHom g) = mapRingHom (f.comp g) :=
RingHom.ext <| Polynomial.map_map g f
Polynomial.eval₂_map
theorem
[Semiring T] (g : S →+* T) (x : T) : (p.map f).eval₂ g x = p.eval₂ (g.comp f) x
theorem eval₂_map [Semiring T] (g : S →+* T) (x : T) :
(p.map f).eval₂ g x = p.eval₂ (g.comp f) x := by
rw [eval₂_eq_eval_map, eval₂_eq_eval_map, map_map]
Polynomial.eval_zero_map
theorem
(f : R →+* S) (p : R[X]) : (p.map f).eval 0 = f (p.eval 0)
@[simp]
theorem eval_zero_map (f : R →+* S) (p : R[X]) : (p.map f).eval 0 = f (p.eval 0) := by
simp [← coeff_zero_eq_eval_zero]
Polynomial.eval_one_map
theorem
(f : R →+* S) (p : R[X]) : (p.map f).eval 1 = f (p.eval 1)
@[simp]
theorem eval_one_map (f : R →+* S) (p : R[X]) : (p.map f).eval 1 = f (p.eval 1) := by
induction p using Polynomial.induction_on' with
| add p q hp hq => simp only [hp, hq, Polynomial.map_add, RingHom.map_add, eval_add]
| monomial n r => simp only [one_pow, mul_one, eval_monomial, map_monomial]
Polynomial.eval_natCast_map
theorem
(f : R →+* S) (p : R[X]) (n : ℕ) : (p.map f).eval (n : S) = f (p.eval n)
@[simp]
theorem eval_natCast_map (f : R →+* S) (p : R[X]) (n : ℕ) :
(p.map f).eval (n : S) = f (p.eval n) := by
induction p using Polynomial.induction_on' with
| add p q hp hq => simp only [hp, hq, Polynomial.map_add, RingHom.map_add, eval_add]
| monomial n r => simp only [map_natCast f, eval_monomial, map_monomial, f.map_pow, f.map_mul]
Polynomial.eval_intCast_map
theorem
{R S : Type*} [Ring R] [Ring S] (f : R →+* S) (p : R[X]) (i : ℤ) : (p.map f).eval (i : S) = f (p.eval i)
@[simp]
theorem eval_intCast_map {R S : Type*} [Ring R] [Ring S] (f : R →+* S) (p : R[X]) (i : ℤ) :
(p.map f).eval (i : S) = f (p.eval i) := by
induction p using Polynomial.induction_on' with
| add p q hp hq => simp only [hp, hq, Polynomial.map_add, RingHom.map_add, eval_add]
| monomial n r => simp only [map_intCast, eval_monomial, map_monomial, map_pow, map_mul]
Polynomial.hom_eval₂
theorem
(x : S) : g (p.eval₂ f x) = p.eval₂ (g.comp f) (g x)
Polynomial.eval₂_hom
theorem
(x : R) : p.eval₂ f (f x) = f (p.eval x)
theorem eval₂_hom (x : R) : p.eval₂ f (f x) = f (p.eval x) :=
RingHom.comp_id f ▸ (hom_eval₂ p (RingHom.id R) f x).symm
Polynomial.evalRingHom_zero
theorem
: evalRingHom 0 = constantCoeff
theorem evalRingHom_zero : evalRingHom 0 = constantCoeff :=
DFunLike.ext _ _ fun p => p.coeff_zero_eq_eval_zero.symm
Polynomial.support_map_subset
theorem
[Semiring R] [Semiring S] (f : R →+* S) (p : R[X]) : (map f p).support ⊆ p.support
theorem support_map_subset [Semiring R] [Semiring S] (f : R →+* S) (p : R[X]) :
(map f p).support ⊆ p.support := by
intro x
contrapose!
simp +contextual
Polynomial.support_map_of_injective
theorem
[Semiring R] [Semiring S] (p : R[X]) {f : R →+* S} (hf : Function.Injective f) : (map f p).support = p.support
theorem support_map_of_injective [Semiring R] [Semiring S] (p : R[X]) {f : R →+* S}
(hf : Function.Injective f) : (map f p).support = p.support := by
simp_rw [Finset.ext_iff, mem_support_iff, coeff_map, ← map_zero f, hf.ne_iff,
forall_const]
Polynomial.IsRoot.map
theorem
{f : R →+* S} {x : R} {p : R[X]} (h : IsRoot p x) : IsRoot (p.map f) (f x)
Polynomial.IsRoot.of_map
theorem
{R} [Ring R] {f : R →+* S} {x : R} {p : R[X]} (h : IsRoot (p.map f) (f x)) (hf : Function.Injective f) : IsRoot p x
theorem IsRoot.of_map {R} [Ring R] {f : R →+* S} {x : R} {p : R[X]} (h : IsRoot (p.map f) (f x))
(hf : Function.Injective f) : IsRoot p x := by
rwa [IsRoot, ← (injective_iff_map_eq_zero' f).mp hf, ← eval₂_hom, ← eval_map]
Polynomial.isRoot_map_iff
theorem
{R : Type*} [CommRing R] {f : R →+* S} {x : R} {p : R[X]} (hf : Function.Injective f) :
IsRoot (p.map f) (f x) ↔ IsRoot p x
theorem isRoot_map_iff {R : Type*} [CommRing R] {f : R →+* S} {x : R} {p : R[X]}
(hf : Function.Injective f) : IsRootIsRoot (p.map f) (f x) ↔ IsRoot p x :=
⟨fun h => h.of_map hf, fun h => h.map⟩