fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
isNilpotent_pow_X_mul_C_of_isNilpotent (n : ℕ) (hnil : IsNilpotent r) :
IsNilpotent (X ^ n * (C r)) := by
rw [commute_X_pow]
exact isNilpotent_C_mul_pow_X_of_isNilpotent n hnil
@[simp] lemma isNilpotent_monomial_iff {n : ℕ} :
IsNilpotent (monomial (R := R) n r) ↔ IsNilpotent r :=
exists_congr fun k ↦ by simp
@[simp] lemma isNilpotent_C_iff :
IsNilpotent (C r) ↔ IsNilpotent r :=
exists_congr fun k ↦ by simpa only [← C_pow] using C_eq_zero
@[simp] lemma isNilpotent_X_mul_iff :
IsNilpotent (X * P) ↔ IsNilpotent P := by
refine ⟨fun h ↦ ?_, ?_⟩
· rwa [Commute.isNilpotent_mul_left_iff (commute_X P) (by simp)] at h
· rintro ⟨k, hk⟩
exact ⟨k, by simp [(commute_X P).mul_pow, hk]⟩
@[simp] lemma isNilpotent_mul_X_iff :
IsNilpotent (P * X) ↔ IsNilpotent P := by
rw [← commute_X P]
exact isNilpotent_X_mul_iff | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isNilpotent_pow_X_mul_C_of_isNilpotent | null |
protected isNilpotent_iff :
IsNilpotent P ↔ ∀ i, IsNilpotent (coeff P i) := by
refine
⟨P.recOnHorner (by simp) (fun p r hp₀ _ hp hpr i ↦ ?_) (fun p _ hnp hpX i ↦ ?_), fun h ↦ ?_⟩
· rw [← sum_monomial_eq P]
exact isNilpotent_sum (fun i _ ↦ by simpa only [isNilpotent_monomial_iff] using h i)
· have hr : IsNilpotent (C r) := by
obtain ⟨k, hk⟩ := hpr
replace hp : eval 0 p = 0 := by rwa [coeff_zero_eq_aeval_zero] at hp₀
refine isNilpotent_C_iff.mpr ⟨k, ?_⟩
simpa [coeff_zero_eq_aeval_zero, hp] using congr_arg (fun q ↦ coeff q 0) hk
rcases i with - | i
· simpa [hp₀] using hr
simp only [coeff_add, coeff_C_succ, add_zero]
apply hp
simpa using Commute.isNilpotent_sub (Commute.all _ _) hpr hr
· rcases i with - | i
· simp
simpa using hnp (isNilpotent_mul_X_iff.mp hpX) i
@[simp] lemma isNilpotent_reflect_iff {P : R[X]} {N : ℕ} (hN : P.natDegree ≤ N) :
IsNilpotent (reflect N P) ↔ IsNilpotent P := by
simp only [Polynomial.isNilpotent_iff]
refine ⟨fun h i ↦ ?_, fun h i ↦ ?_⟩ <;> rcases le_or_gt i N with hi | hi
· simpa [tsub_tsub_cancel_of_le hi] using h (N - i)
· simp [coeff_eq_zero_of_natDegree_lt <| lt_of_le_of_lt hN hi]
· simpa [hi, revAt_le] using h (N - i)
· simpa [revAt_eq_self_of_lt hi] using h i
@[simp] lemma isNilpotent_reverse_iff :
IsNilpotent P.reverse ↔ IsNilpotent P :=
isNilpotent_reflect_iff (le_refl _) | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isNilpotent_iff | null |
isUnit_of_coeff_isUnit_isNilpotent (hunit : IsUnit (P.coeff 0))
(hnil : ∀ i, i ≠ 0 → IsNilpotent (P.coeff i)) : IsUnit P := by
induction h : P.natDegree using Nat.strong_induction_on generalizing P with | _ k hind
by_cases hdeg : P.natDegree = 0
· rw [eq_C_of_natDegree_eq_zero hdeg]
exact hunit.map C
set P₁ := P.eraseLead with hP₁
suffices IsUnit P₁ by
rw [← eraseLead_add_monomial_natDegree_leadingCoeff P, ← C_mul_X_pow_eq_monomial, ← hP₁]
refine IsNilpotent.isUnit_add_left_of_commute ?_ this (Commute.all _ _)
exact isNilpotent_C_mul_pow_X_of_isNilpotent _ (hnil _ hdeg)
have hdeg₂ := lt_of_le_of_lt P.eraseLead_natDegree_le (Nat.sub_lt
(Nat.pos_of_ne_zero hdeg) zero_lt_one)
refine hind P₁.natDegree ?_ ?_ (fun i hi => ?_) rfl
· simp_rw [P₁, ← h, hdeg₂]
· simp_rw [P₁, eraseLead_coeff_of_ne _ (Ne.symm hdeg), hunit]
· by_cases H : i ≤ P₁.natDegree
· simp_rw [P₁, eraseLead_coeff_of_ne _ (ne_of_lt (lt_of_le_of_lt H hdeg₂)), hnil i hi]
· simp_rw [coeff_eq_zero_of_natDegree_lt (lt_of_not_ge H), IsNilpotent.zero] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isUnit_of_coeff_isUnit_isNilpotent | Let `P` be a polynomial over `R`. If its constant term is a unit and its other coefficients are
nilpotent, then `P` is a unit.
See also `Polynomial.isUnit_iff_coeff_isUnit_isNilpotent`. |
coeff_isUnit_isNilpotent_of_isUnit (hunit : IsUnit P) :
IsUnit (P.coeff 0) ∧ (∀ i, i ≠ 0 → IsNilpotent (P.coeff i)) := by
obtain ⟨Q, hQ⟩ := IsUnit.exists_right_inv hunit
constructor
· refine isUnit_of_mul_eq_one _ (Q.coeff 0) ?_
have h := (mul_coeff_zero P Q).symm
rwa [hQ, coeff_one_zero] at h
· intro n hn
rw [nilpotent_iff_mem_prime]
intro I hI
let f := mapRingHom (Ideal.Quotient.mk I)
have hPQ : degree (f P) = 0 ∧ degree (f Q) = 0 := by
rw [← Nat.WithBot.add_eq_zero_iff, ← degree_mul, ← map_mul, hQ, map_one, degree_one]
have hcoeff : (f P).coeff n = 0 := by
refine coeff_eq_zero_of_degree_lt ?_
rw [hPQ.1]
exact WithBot.coe_pos.2 hn.bot_lt
rw [coe_mapRingHom, coeff_map, ← RingHom.mem_ker, Ideal.mk_ker] at hcoeff
exact hcoeff | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | coeff_isUnit_isNilpotent_of_isUnit | Let `P` be a polynomial over `R`. If `P` is a unit, then all its coefficients are nilpotent,
except its constant term which is a unit.
See also `Polynomial.isUnit_iff_coeff_isUnit_isNilpotent`. |
isUnit_iff_coeff_isUnit_isNilpotent :
IsUnit P ↔ IsUnit (P.coeff 0) ∧ (∀ i, i ≠ 0 → IsNilpotent (P.coeff i)) :=
⟨coeff_isUnit_isNilpotent_of_isUnit, fun H => isUnit_of_coeff_isUnit_isNilpotent H.1 H.2⟩
@[simp] lemma isUnit_C_add_X_mul_iff :
IsUnit (C r + X * P) ↔ IsUnit r ∧ IsNilpotent P := by
have : ∀ i, coeff (C r + X * P) (i + 1) = coeff P i := by simp
simp_rw [isUnit_iff_coeff_isUnit_isNilpotent, Nat.forall_ne_zero_iff, this]
simp only [coeff_add, coeff_C_zero, mul_coeff_zero, coeff_X_zero, zero_mul, add_zero,
← Polynomial.isNilpotent_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isUnit_iff_coeff_isUnit_isNilpotent | Let `P` be a polynomial over `R`. `P` is a unit if and only if all its coefficients are
nilpotent, except its constant term which is a unit.
See also `Polynomial.isUnit_iff'`. |
isUnit_iff' :
IsUnit P ↔ IsUnit (eval 0 P) ∧ IsNilpotent (P /ₘ X) := by
suffices P = C (eval 0 P) + X * (P /ₘ X) by
conv_lhs => rw [this]; simp
conv_lhs => rw [← modByMonic_add_div P monic_X]
simp [modByMonic_X] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isUnit_iff' | null |
not_isUnit_of_natDegree_pos_of_isReduced [IsReduced R] (p : R[X])
(hpl : 0 < p.natDegree) : ¬ IsUnit p := by
simp only [ne_eq, isNilpotent_iff_eq_zero, not_and, not_forall, exists_prop,
Polynomial.isUnit_iff_coeff_isUnit_isNilpotent]
intro _
refine ⟨p.natDegree, hpl.ne', ?_⟩
contrapose! hpl
simp only [coeff_natDegree, leadingCoeff_eq_zero] at hpl
simp [hpl] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | not_isUnit_of_natDegree_pos_of_isReduced | null |
not_isUnit_of_degree_pos_of_isReduced [IsReduced R] (p : R[X])
(hpl : 0 < p.degree) : ¬ IsUnit p :=
not_isUnit_of_natDegree_pos_of_isReduced _ (natDegree_pos_iff_degree_pos.mpr hpl) | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | not_isUnit_of_degree_pos_of_isReduced | null |
isNilpotent_aeval_sub_of_isNilpotent_sub (h : IsNilpotent (a - b)) :
IsNilpotent (aeval a P - aeval b P) := by
simp only [← eval_map_algebraMap]
have ⟨c, hc⟩ := evalSubFactor (map (algebraMap R S) P) a b
exact hc ▸ (Commute.all _ _).isNilpotent_mul_left h
variable {P} | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isNilpotent_aeval_sub_of_isNilpotent_sub | null |
isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub
(hb : IsUnit (aeval b P)) (hab : IsNilpotent (a - b)) :
IsUnit (aeval a P) := by
rw [← add_sub_cancel (aeval b P) (aeval a P)]
refine IsNilpotent.isUnit_add_left_of_commute ?_ hb (Commute.all _ _)
exact isNilpotent_aeval_sub_of_isNilpotent_sub P hab | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.AlgebraMap",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Identities",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Nilpotent.Basic",
"Mathlib.RingTheory.Nilpotent.Lemmas"
] | Mathlib/RingTheory/Polynomial/Nilpotent.lean | isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub | null |
opRingEquiv (R : Type*) [Semiring R] : R[X]ᵐᵒᵖ ≃+* Rᵐᵒᵖ[X] :=
((toFinsuppIso R).op.trans AddMonoidAlgebra.opRingEquiv).trans (toFinsuppIso _).symm
/-! Lemmas to get started, using `opRingEquiv R` on the various expressions of
`Finsupp.single`: `monomial`, `C a`, `X`, `C a * X ^ n`. -/
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv | Ring isomorphism between `R[X]ᵐᵒᵖ` and `Rᵐᵒᵖ[X]` sending each coefficient of a polynomial
to the corresponding element of the opposite ring. |
opRingEquiv_op_monomial (n : ℕ) (r : R) :
opRingEquiv R (op (monomial n r : R[X])) = monomial n (op r) := by
simp only [opRingEquiv, RingEquiv.coe_trans, Function.comp_apply,
AddMonoidAlgebra.opRingEquiv_apply, RingEquiv.op_apply_apply, toFinsuppIso_apply, unop_op,
toFinsupp_monomial, Finsupp.mapRange_single, toFinsuppIso_symm_apply, ofFinsupp_single]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_op_monomial | null |
opRingEquiv_op_C (a : R) : opRingEquiv R (op (C a)) = C (op a) :=
opRingEquiv_op_monomial 0 a
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_op_C | null |
opRingEquiv_op_X : opRingEquiv R (op (X : R[X])) = X :=
opRingEquiv_op_monomial 1 1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_op_X | null |
opRingEquiv_op_C_mul_X_pow (r : R) (n : ℕ) :
opRingEquiv R (op (C r * X ^ n : R[X])) = C (op r) * X ^ n := by
simp only [X_pow_mul, op_mul, op_pow, map_mul, map_pow, opRingEquiv_op_X, opRingEquiv_op_C]
/-! Lemmas to get started, using `(opRingEquiv R).symm` on the various expressions of
`Finsupp.single`: `monomial`, `C a`, `X`, `C a * X ^ n`. -/
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_op_C_mul_X_pow | null |
opRingEquiv_symm_monomial (n : ℕ) (r : Rᵐᵒᵖ) :
(opRingEquiv R).symm (monomial n r) = op (monomial n (unop r)) :=
(opRingEquiv R).injective (by simp)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_symm_monomial | null |
opRingEquiv_symm_C (a : Rᵐᵒᵖ) : (opRingEquiv R).symm (C a) = op (C (unop a)) :=
opRingEquiv_symm_monomial 0 a
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_symm_C | null |
opRingEquiv_symm_X : (opRingEquiv R).symm (X : Rᵐᵒᵖ[X]) = op X :=
opRingEquiv_symm_monomial 1 1 | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_symm_X | null |
opRingEquiv_symm_C_mul_X_pow (r : Rᵐᵒᵖ) (n : ℕ) :
(opRingEquiv R).symm (C r * X ^ n : Rᵐᵒᵖ[X]) = op (C (unop r) * X ^ n) := by
rw [C_mul_X_pow_eq_monomial, opRingEquiv_symm_monomial, C_mul_X_pow_eq_monomial]
/-! Lemmas about more global properties of polynomials and opposites. -/
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | opRingEquiv_symm_C_mul_X_pow | null |
coeff_opRingEquiv (p : R[X]ᵐᵒᵖ) (n : ℕ) :
(opRingEquiv R p).coeff n = op ((unop p).coeff n) := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | coeff_opRingEquiv | null |
support_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).support = (unop p).support :=
Finsupp.support_mapRange_of_injective (map_zero _) _ op_injective
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | support_opRingEquiv | null |
natDegree_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).natDegree = (unop p).natDegree := by
by_cases p0 : p = 0
· simp only [p0, map_zero, natDegree_zero, unop_zero]
· simp only [p0, natDegree_eq_support_max', Ne, EmbeddingLike.map_eq_zero_iff, not_false_iff,
support_opRingEquiv, unop_eq_zero_iff]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | natDegree_opRingEquiv | null |
leadingCoeff_opRingEquiv (p : R[X]ᵐᵒᵖ) :
(opRingEquiv R p).leadingCoeff = op (unop p).leadingCoeff := by
rw [leadingCoeff, coeff_opRingEquiv, natDegree_opRingEquiv, leadingCoeff] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | leadingCoeff_opRingEquiv | null |
isLeftCancelMulZero_iff :
IsLeftCancelMulZero R[X] ↔ IsLeftCancelMulZero R ∧ IsCancelAdd R where
mp h := .intro (C_injective.isLeftCancelMulZero _ C_0 fun _ _ ↦ C_mul) <|
have : IsLeftCancelAdd R := .mk fun a b c eq ↦ by
nontriviality R
let trinomial (r : R) : R[X] := a • X ^ 2 + r • X + C a
have ht r : (X + C 1) * trinomial r = a • X ^ 3 + (a + r) • X ^ 2 + (a + r) • X + C a := by
simp only [trinomial, mul_add, add_mul, ← C_mul', C_1, one_mul, ← mul_assoc, X_mul_C, C_add]
noncomm_ring
simpa [trinomial] using congr_arg (coeff · 1) <|
h.1 (a₁ := trinomial b) (a₂ := trinomial c) (X_add_C_ne_zero 1) <| by simp_rw [ht, eq]
AddCommMagma.IsLeftCancelAdd.toIsCancelAdd R
mpr := fun ⟨_, _⟩ ↦ inferInstance | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | isLeftCancelMulZero_iff | null |
isRightCancelMulZero_iff :
IsRightCancelMulZero R[X] ↔ IsRightCancelMulZero R ∧ IsCancelAdd R := by
rw [← MulOpposite.isLeftCancelMulZero_iff, (opRingEquiv R).isLeftCancelMulZero_iff,
isLeftCancelMulZero_iff, MulOpposite.isLeftCancelMulZero_iff, MulOpposite.isCancelAdd_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | isRightCancelMulZero_iff | null |
protected isCancelMulZero_iff :
IsCancelMulZero R[X] ↔ IsCancelMulZero R ∧ IsCancelAdd R := by
simp_rw [isCancelMulZero_iff, isLeftCancelMulZero_iff, isRightCancelMulZero_iff]
rw [and_and_and_comm, and_self] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | isCancelMulZero_iff | null |
isDomain_iff : IsDomain R[X] ↔ IsDomain R ∧ IsCancelAdd R := by
simp_rw [isDomain_iff_cancelMulZero_and_nontrivial, nontrivial_iff,
Polynomial.isCancelMulZero_iff, and_right_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.Degree.Support",
"Mathlib.Tactic.NoncommRing"
] | Mathlib/RingTheory/Polynomial/Opposites.lean | isDomain_iff | null |
noncomputable ascPochhammer : ℕ → S[X]
| 0 => 1
| n + 1 => X * (ascPochhammer n).comp (X + 1)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer | `ascPochhammer S n` is the polynomial `X * (X + 1) * ... * (X + n - 1)`,
with coefficients in the semiring `S`. |
ascPochhammer_zero : ascPochhammer S 0 = 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_zero | null |
ascPochhammer_one : ascPochhammer S 1 = X := by simp [ascPochhammer] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_one | null |
ascPochhammer_succ_left (n : ℕ) :
ascPochhammer S (n + 1) = X * (ascPochhammer S n).comp (X + 1) := by
rw [ascPochhammer] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_succ_left | null |
monic_ascPochhammer (n : ℕ) [Nontrivial S] [NoZeroDivisors S] :
Monic <| ascPochhammer S n := by
induction n with
| zero => simp
| succ n hn =>
have : leadingCoeff (X + 1 : S[X]) = 1 := leadingCoeff_X_add_C 1
rw [ascPochhammer_succ_left, Monic.def, leadingCoeff_mul,
leadingCoeff_comp (ne_zero_of_eq_one <| natDegree_X_add_C 1 : natDegree (X + 1) ≠ 0), hn,
monic_X, one_mul, one_mul, this, one_pow] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | monic_ascPochhammer | null |
@[simp]
ascPochhammer_map (f : S →+* T) (n : ℕ) :
(ascPochhammer S n).map f = ascPochhammer T n := by
induction n with
| zero => simp
| succ n ih => simp [ih, ascPochhammer_succ_left, map_comp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_map | null |
ascPochhammer_eval₂ (f : S →+* T) (n : ℕ) (t : T) :
(ascPochhammer T n).eval t = (ascPochhammer S n).eval₂ f t := by
rw [← ascPochhammer_map f]
exact eval_map f t | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval₂ | null |
ascPochhammer_eval_comp {R : Type*} [CommSemiring R] (n : ℕ) (p : R[X]) [Algebra R S]
(x : S) : ((ascPochhammer S n).comp (p.map (algebraMap R S))).eval x =
(ascPochhammer S n).eval (p.eval₂ (algebraMap R S) x) := by
rw [ascPochhammer_eval₂ (algebraMap R S), ← eval₂_comp', ← ascPochhammer_map (algebraMap R S),
← map_comp, eval_map] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_comp | null |
@[simp, norm_cast]
ascPochhammer_eval_cast (n k : ℕ) :
(((ascPochhammer ℕ n).eval k : ℕ) : S) = ((ascPochhammer S n).eval k : S) := by
rw [← ascPochhammer_map (algebraMap ℕ S), eval_map, ← eq_natCast (algebraMap ℕ S),
eval₂_at_natCast,Nat.cast_id] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_cast | null |
ascPochhammer_eval_zero {n : ℕ} : (ascPochhammer S n).eval 0 = if n = 0 then 1 else 0 := by
cases n
· simp
· simp [X_mul, ascPochhammer_succ_left] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_zero | null |
ascPochhammer_zero_eval_zero : (ascPochhammer S 0).eval 0 = 1 := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_zero_eval_zero | null |
ascPochhammer_ne_zero_eval_zero {n : ℕ} (h : n ≠ 0) : (ascPochhammer S n).eval 0 = 0 := by
simp [ascPochhammer_eval_zero, h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_ne_zero_eval_zero | null |
ascPochhammer_succ_right (n : ℕ) :
ascPochhammer S (n + 1) = ascPochhammer S n * (X + (n : S[X])) := by
suffices h : ascPochhammer ℕ (n + 1) = ascPochhammer ℕ n * (X + (n : ℕ[X])) by
apply_fun Polynomial.map (algebraMap ℕ S) at h
simpa only [ascPochhammer_map, Polynomial.map_mul, Polynomial.map_add, map_X,
Polynomial.map_natCast] using h
induction n with
| zero => simp
| succ n ih =>
conv_lhs =>
rw [ascPochhammer_succ_left, ih, mul_comp, ← mul_assoc, ← ascPochhammer_succ_left, add_comp,
X_comp, natCast_comp, add_assoc, add_comm (1 : ℕ[X]), ← Nat.cast_succ] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_succ_right | null |
ascPochhammer_succ_eval {S : Type*} [Semiring S] (n : ℕ) (k : S) :
(ascPochhammer S (n + 1)).eval k = (ascPochhammer S n).eval k * (k + n) := by
rw [ascPochhammer_succ_right, mul_add, eval_add, eval_mul_X, ← Nat.cast_comm, ← C_eq_natCast,
eval_C_mul, Nat.cast_comm, ← mul_add] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_succ_eval | null |
ascPochhammer_succ_comp_X_add_one (n : ℕ) :
(ascPochhammer S (n + 1)).comp (X + 1) =
ascPochhammer S (n + 1) + (n + 1) • (ascPochhammer S n).comp (X + 1) := by
suffices (ascPochhammer ℕ (n + 1)).comp (X + 1) =
ascPochhammer ℕ (n + 1) + (n + 1) * (ascPochhammer ℕ n).comp (X + 1)
by simpa [map_comp] using congr_arg (Polynomial.map (Nat.castRingHom S)) this
nth_rw 2 [ascPochhammer_succ_left]
rw [← add_mul, ascPochhammer_succ_right ℕ n, mul_comp, mul_comm, add_comp, X_comp, natCast_comp,
add_comm, ← add_assoc]
ring | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_succ_comp_X_add_one | null |
ascPochhammer_mul (n m : ℕ) :
ascPochhammer S n * (ascPochhammer S m).comp (X + (n : S[X])) = ascPochhammer S (n + m) := by
induction m with
| zero => simp
| succ m ih =>
rw [ascPochhammer_succ_right, Polynomial.mul_X_add_natCast_comp, ← mul_assoc, ih,
← add_assoc, ascPochhammer_succ_right, Nat.cast_add, add_assoc] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_mul | null |
ascPochhammer_nat_eq_ascFactorial (n : ℕ) :
∀ k, (ascPochhammer ℕ k).eval n = n.ascFactorial k
| 0 => by rw [ascPochhammer_zero, eval_one, Nat.ascFactorial_zero]
| t + 1 => by
rw [ascPochhammer_succ_right, eval_mul, ascPochhammer_nat_eq_ascFactorial n t, eval_add, eval_X,
eval_natCast, Nat.cast_id, Nat.ascFactorial_succ, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_nat_eq_ascFactorial | null |
ascPochhammer_nat_eq_natCast_ascFactorial (S : Type*) [Semiring S] (n k : ℕ) :
(ascPochhammer S k).eval (n : S) = n.ascFactorial k := by
norm_cast
rw [ascPochhammer_nat_eq_ascFactorial] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_nat_eq_natCast_ascFactorial | null |
ascPochhammer_nat_eq_descFactorial (a b : ℕ) :
(ascPochhammer ℕ b).eval a = (a + b - 1).descFactorial b := by
rw [ascPochhammer_nat_eq_ascFactorial, Nat.add_descFactorial_eq_ascFactorial'] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_nat_eq_descFactorial | null |
ascPochhammer_nat_eq_natCast_descFactorial (S : Type*) [Semiring S] (a b : ℕ) :
(ascPochhammer S b).eval (a : S) = (a + b - 1).descFactorial b := by
norm_cast
rw [ascPochhammer_nat_eq_descFactorial]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_nat_eq_natCast_descFactorial | null |
ascPochhammer_natDegree (n : ℕ) [NoZeroDivisors S] [Nontrivial S] :
(ascPochhammer S n).natDegree = n := by
induction n with
| zero => simp
| succ n hn =>
have : natDegree (X + (n : S[X])) = 1 := natDegree_X_add_C (n : S)
rw [ascPochhammer_succ_right,
natDegree_mul _ (ne_zero_of_natDegree_gt <| this.symm ▸ Nat.zero_lt_one), hn, this]
cases n
· simp
· refine ne_zero_of_natDegree_gt <| hn.symm ▸ Nat.add_one_pos _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_natDegree | null |
ascPochhammer_pos (n : ℕ) (s : S) (h : 0 < s) : 0 < (ascPochhammer S n).eval s := by
induction n with
| zero =>
simp only [ascPochhammer_zero, eval_one]
exact zero_lt_one
| succ n ih =>
rw [ascPochhammer_succ_right, mul_add, eval_add, ← Nat.cast_comm, eval_natCast_mul, eval_mul_X,
Nat.cast_comm, ← mul_add]
exact mul_pos ih (lt_of_lt_of_le h (le_add_of_nonneg_right (Nat.cast_nonneg n))) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_pos | null |
@[simp]
ascPochhammer_eval_one (S : Type*) [Semiring S] (n : ℕ) :
(ascPochhammer S n).eval (1 : S) = (n ! : S) := by
rw_mod_cast [ascPochhammer_nat_eq_ascFactorial, Nat.one_ascFactorial] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_one | null |
factorial_mul_ascPochhammer (S : Type*) [Semiring S] (r n : ℕ) :
(r ! : S) * (ascPochhammer S n).eval (r + 1 : S) = (r + n)! := by
rw_mod_cast [ascPochhammer_nat_eq_ascFactorial, Nat.factorial_mul_ascFactorial] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | factorial_mul_ascPochhammer | null |
ascPochhammer_nat_eval_succ (r : ℕ) :
∀ n : ℕ, n * (ascPochhammer ℕ r).eval (n + 1) = (n + r) * (ascPochhammer ℕ r).eval n
| 0 => by
by_cases h : r = 0
· simp only [h, zero_mul, zero_add]
· simp only [ascPochhammer_eval_zero, zero_mul, if_neg h, mul_zero]
| k + 1 => by simp only [ascPochhammer_nat_eq_ascFactorial, Nat.succ_ascFactorial, add_right_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_nat_eval_succ | null |
ascPochhammer_eval_succ (r n : ℕ) :
(n : S) * (ascPochhammer S r).eval (n + 1 : S) =
(n + r) * (ascPochhammer S r).eval (n : S) :=
mod_cast congr_arg Nat.cast (ascPochhammer_nat_eval_succ r n) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_succ | null |
noncomputable descPochhammer : ℕ → R[X]
| 0 => 1
| n + 1 => X * (descPochhammer n).comp (X - 1)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer | `descPochhammer R n` is the polynomial `X * (X - 1) * ... * (X - n + 1)`,
with coefficients in the ring `R`. |
descPochhammer_zero : descPochhammer R 0 = 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_zero | null |
descPochhammer_one : descPochhammer R 1 = X := by simp [descPochhammer] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_one | null |
descPochhammer_succ_left (n : ℕ) :
descPochhammer R (n + 1) = X * (descPochhammer R n).comp (X - 1) := by
rw [descPochhammer] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_succ_left | null |
monic_descPochhammer (n : ℕ) [Nontrivial R] [NoZeroDivisors R] :
Monic <| descPochhammer R n := by
induction n with
| zero => simp
| succ n hn =>
have h : leadingCoeff (X - 1 : R[X]) = 1 := leadingCoeff_X_sub_C 1
have : natDegree (X - (1 : R[X])) ≠ 0 := ne_zero_of_eq_one <| natDegree_X_sub_C (1 : R)
rw [descPochhammer_succ_left, Monic.def, leadingCoeff_mul, leadingCoeff_comp this, hn, monic_X,
one_mul, one_mul, h, one_pow] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | monic_descPochhammer | null |
@[simp]
descPochhammer_map (f : R →+* T) (n : ℕ) :
(descPochhammer R n).map f = descPochhammer T n := by
induction n with
| zero => simp
| succ n ih => simp [ih, descPochhammer_succ_left, map_comp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_map | null |
@[simp, norm_cast]
descPochhammer_eval_cast (n : ℕ) (k : ℤ) :
(((descPochhammer ℤ n).eval k : ℤ) : R) = ((descPochhammer R n).eval k : R) := by
rw [← descPochhammer_map (algebraMap ℤ R), eval_map, ← eq_intCast (algebraMap ℤ R)]
simp only [algebraMap_int_eq, eq_intCast, eval₂_at_intCast, Int.cast_id] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_cast | null |
descPochhammer_eval_zero {n : ℕ} :
(descPochhammer R n).eval 0 = if n = 0 then 1 else 0 := by
cases n
· simp
· simp [X_mul, descPochhammer_succ_left] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_zero | null |
descPochhammer_zero_eval_zero : (descPochhammer R 0).eval 0 = 1 := by simp
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_zero_eval_zero | null |
descPochhammer_ne_zero_eval_zero {n : ℕ} (h : n ≠ 0) : (descPochhammer R n).eval 0 = 0 := by
simp [descPochhammer_eval_zero, h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_ne_zero_eval_zero | null |
descPochhammer_succ_right (n : ℕ) :
descPochhammer R (n + 1) = descPochhammer R n * (X - (n : R[X])) := by
suffices h : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - (n : ℤ[X])) by
apply_fun Polynomial.map (algebraMap ℤ R) at h
simpa [descPochhammer_map, Polynomial.map_mul, Polynomial.map_add, map_X,
Polynomial.map_intCast] using h
induction n with
| zero => simp [descPochhammer]
| succ n ih =>
conv_lhs =>
rw [descPochhammer_succ_left, ih, mul_comp, ← mul_assoc, ← descPochhammer_succ_left, sub_comp,
X_comp, natCast_comp]
rw [Nat.cast_add, Nat.cast_one, sub_add_eq_sub_sub_swap]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_succ_right | null |
descPochhammer_natDegree (n : ℕ) [NoZeroDivisors R] [Nontrivial R] :
(descPochhammer R n).natDegree = n := by
induction n with
| zero => simp
| succ n hn =>
have : natDegree (X - (n : R[X])) = 1 := natDegree_X_sub_C (n : R)
rw [descPochhammer_succ_right,
natDegree_mul _ (ne_zero_of_natDegree_gt <| this.symm ▸ Nat.zero_lt_one), hn, this]
cases n
· simp
· refine ne_zero_of_natDegree_gt <| hn.symm ▸ Nat.add_one_pos _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_natDegree | null |
descPochhammer_succ_eval {S : Type*} [Ring S] (n : ℕ) (k : S) :
(descPochhammer S (n + 1)).eval k = (descPochhammer S n).eval k * (k - n) := by
rw [descPochhammer_succ_right, mul_sub, eval_sub, eval_mul_X, ← Nat.cast_comm, ← C_eq_natCast,
eval_C_mul, Nat.cast_comm, ← mul_sub] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_succ_eval | null |
descPochhammer_succ_comp_X_sub_one (n : ℕ) :
(descPochhammer R (n + 1)).comp (X - 1) =
descPochhammer R (n + 1) - (n + (1 : R[X])) • (descPochhammer R n).comp (X - 1) := by
suffices (descPochhammer ℤ (n + 1)).comp (X - 1) =
descPochhammer ℤ (n + 1) - (n + 1) * (descPochhammer ℤ n).comp (X - 1)
by simpa [map_comp] using congr_arg (Polynomial.map (Int.castRingHom R)) this
nth_rw 2 [descPochhammer_succ_left]
rw [← sub_mul, descPochhammer_succ_right ℤ n, mul_comp, mul_comm, sub_comp, X_comp, natCast_comp]
ring | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_succ_comp_X_sub_one | null |
descPochhammer_eq_ascPochhammer (n : ℕ) :
descPochhammer ℤ n = (ascPochhammer ℤ n).comp ((X : ℤ[X]) - n + 1) := by
induction n with
| zero => rw [descPochhammer_zero, ascPochhammer_zero, one_comp]
| succ n ih =>
rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_right,
ascPochhammer_succ_left, ih, X_mul, mul_X_comp, comp_assoc, add_comp, X_comp, one_comp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eq_ascPochhammer | null |
descPochhammer_eval_eq_ascPochhammer (r : R) (n : ℕ) :
(descPochhammer R n).eval r = (ascPochhammer R n).eval (r - n + 1) := by
induction n with
| zero => rw [descPochhammer_zero, eval_one, ascPochhammer_zero, eval_one]
| succ n ih =>
rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_eval, ih,
ascPochhammer_succ_left, X_mul, eval_mul_X, show (X + 1 : R[X]) =
(X + 1 : ℕ[X]).map (algebraMap ℕ R) by simp only [Polynomial.map_add, map_X,
Polynomial.map_one], ascPochhammer_eval_comp, eval₂_add, eval₂_X, eval₂_one] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_eq_ascPochhammer | null |
descPochhammer_mul (n m : ℕ) :
descPochhammer R n * (descPochhammer R m).comp (X - (n : R[X])) = descPochhammer R (n + m) := by
induction m with
| zero => simp
| succ m ih =>
rw [descPochhammer_succ_right, Polynomial.mul_X_sub_intCast_comp, ← mul_assoc, ih,
← add_assoc, descPochhammer_succ_right, Nat.cast_add, sub_add_eq_sub_sub] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_mul | null |
ascPochhammer_eval_neg_eq_descPochhammer (r : R) : ∀ (k : ℕ),
(ascPochhammer R k).eval (-r) = (-1)^k * (descPochhammer R k).eval r
| 0 => by
rw [ascPochhammer_zero, descPochhammer_zero]
simp only [eval_one, pow_zero, mul_one]
| (k+1) => by
rw [ascPochhammer_succ_right, mul_add, eval_add, eval_mul_X, ← Nat.cast_comm, eval_natCast_mul,
Nat.cast_comm, ← mul_add, ascPochhammer_eval_neg_eq_descPochhammer r k, mul_assoc,
descPochhammer_succ_right, mul_sub, eval_sub, eval_mul_X, ← Nat.cast_comm, eval_natCast_mul,
pow_add, pow_one, mul_assoc ((-1)^k) (-1), mul_sub, neg_one_mul, neg_mul_eq_mul_neg,
Nat.cast_comm, sub_eq_add_neg, neg_one_mul, neg_neg, ← mul_add] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_neg_eq_descPochhammer | null |
descPochhammer_eval_eq_descFactorial (n k : ℕ) :
(descPochhammer R k).eval (n : R) = n.descFactorial k := by
induction k with
| zero => rw [descPochhammer_zero, eval_one, Nat.descFactorial_zero, Nat.cast_one]
| succ k ih =>
rw [descPochhammer_succ_right, Nat.descFactorial_succ, mul_sub, eval_sub, eval_mul_X,
← Nat.cast_comm k, eval_natCast_mul, ← Nat.cast_comm n, ← sub_mul, ih]
by_cases h : n < k
· rw [Nat.descFactorial_eq_zero_iff_lt.mpr h, Nat.cast_zero, mul_zero, mul_zero, Nat.cast_zero]
· rw [Nat.cast_mul, Nat.cast_sub <| not_lt.mp h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_eq_descFactorial | null |
descPochhammer_int_eq_ascFactorial (a b : ℕ) :
(descPochhammer ℤ b).eval (a + b : ℤ) = (a + 1).ascFactorial b := by
rw [← Nat.cast_add, descPochhammer_eval_eq_descFactorial ℤ (a + b) b,
Nat.add_descFactorial_eq_ascFactorial]
variable {R} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_int_eq_ascFactorial | null |
ascPochhammer_eval_neg_coe_nat_of_lt {n k : ℕ} (h : k < n) :
(ascPochhammer R n).eval (-(k : R)) = 0 := by
induction n with
| zero => contradiction
| succ n ih =>
rw [ascPochhammer_succ_eval]
rcases lt_trichotomy k n with hkn | rfl | hkn
· simp [ih hkn]
· simp
· cutsat | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_neg_coe_nat_of_lt | The Pochhammer polynomial of degree `n` has roots at `0`, `-1`, ..., `-(n - 1)`. |
@[simp]
ascPochhammer_eval_eq_zero_iff [IsDomain R]
(n : ℕ) (r : R) : (ascPochhammer R n).eval r = 0 ↔ ∃ k < n, k = -r := by
refine ⟨fun zero' ↦ ?_, fun hrn ↦ ?_⟩
· induction n with
| zero => simp only [ascPochhammer_zero, Polynomial.eval_one, one_ne_zero] at zero'
| succ n ih =>
rw [ascPochhammer_succ_eval, mul_eq_zero] at zero'
cases zero' with
| inl h =>
obtain ⟨rn, hrn, rrn⟩ := ih h
exact ⟨rn, by cutsat, rrn⟩
| inr h =>
exact ⟨n, lt_add_one n, eq_neg_of_add_eq_zero_right h⟩
· obtain ⟨rn, hrn, rnn⟩ := hrn
convert ascPochhammer_eval_neg_coe_nat_of_lt hrn
simp [rnn] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | ascPochhammer_eval_eq_zero_iff | Over an integral domain, the Pochhammer polynomial of degree `n` has roots *only* at
`0`, `-1`, ..., `-(n - 1)`. |
descPochhammer_eval_coe_nat_of_lt {k n : ℕ} (h : k < n) :
(descPochhammer R n).eval (k : R) = 0 := by
rw [descPochhammer_eval_eq_ascPochhammer, sub_add_eq_add_sub,
← Nat.cast_add_one, ← neg_sub, ← Nat.cast_sub h]
exact ascPochhammer_eval_neg_coe_nat_of_lt (Nat.sub_lt_of_pos_le k.succ_pos h) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_coe_nat_of_lt | `descPochhammer R n` is `0` for `0, 1, …, n-1`. |
descPochhammer_eval_eq_prod_range {R : Type*} [CommRing R] (n : ℕ) (r : R) :
(descPochhammer R n).eval r = ∏ j ∈ Finset.range n, (r - j) := by
induction n with
| zero => simp
| succ n ih => simp [descPochhammer_succ_right, ih, ← Finset.prod_range_succ] | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_eval_eq_prod_range | null |
descPochhammer_pos {n : ℕ} {s : S} (h : n - 1 < s) :
0 < (descPochhammer S n).eval s := by
rw [← sub_pos, ← sub_add] at h
rw [descPochhammer_eval_eq_ascPochhammer]
exact ascPochhammer_pos n (s - n + 1) h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_pos | `descPochhammer S n` is positive on `(n-1, ∞)`. |
descPochhammer_nonneg {n : ℕ} {s : S} (h : n - 1 ≤ s) :
0 ≤ (descPochhammer S n).eval s := by
rcases eq_or_lt_of_le h with heq | h
· rw [← heq, descPochhammer_eval_eq_ascPochhammer,
sub_sub_cancel_left, neg_add_cancel, ascPochhammer_eval_zero]
positivity
· exact (descPochhammer_pos h).le | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | descPochhammer_nonneg | `descPochhammer S n` is nonnegative on `[n-1, ∞)`. |
pow_le_descPochhammer_eval {n : ℕ} {s : S} (h : n - 1 ≤ s) :
(s - n + 1)^n ≤ (descPochhammer S n).eval s := by
induction n with
| zero => simp
| succ n ih =>
rw [Nat.cast_add_one, add_sub_cancel_right, ← sub_nonneg] at h
have hsub1 : n - 1 ≤ s := (sub_le_self (n : S) zero_le_one).trans (le_of_sub_nonneg h)
rw [pow_succ, descPochhammer_succ_eval, Nat.cast_add_one, sub_add, add_sub_cancel_right]
apply mul_le_mul _ le_rfl h (descPochhammer_nonneg hsub1)
exact (ih hsub1).trans' <| pow_le_pow_left₀ h (le_add_of_nonneg_right zero_le_one) n | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | pow_le_descPochhammer_eval | `descPochhammer S n` is at least `(s-n+1)^n` on `[n-1, ∞)`. |
monotoneOn_descPochhammer_eval (n : ℕ) :
MonotoneOn (descPochhammer S n).eval (Set.Ici (n - 1 : S)) := by
induction n with
| zero => simp [monotoneOn_const]
| succ n ih =>
intro a ha b hb hab
rw [Set.mem_Ici, Nat.cast_add_one, add_sub_cancel_right] at ha hb
have ha_sub1 : n - 1 ≤ a := (sub_le_self (n : S) zero_le_one).trans ha
have hb_sub1 : n - 1 ≤ b := (sub_le_self (n : S) zero_le_one).trans hb
simp_rw [descPochhammer_succ_eval]
exact mul_le_mul (ih ha_sub1 hb_sub1 hab) (sub_le_sub_right hab (n : S))
(sub_nonneg_of_le ha) (descPochhammer_nonneg hb_sub1) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Basic",
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.Polynomial.Degree.Lemmas",
"Mathlib.Algebra.Polynomial.Eval.Algebra",
"Mathlib.Tactic.Abel"
] | Mathlib/RingTheory/Polynomial/Pochhammer.lean | monotoneOn_descPochhammer_eval | `descPochhammer S n` is monotone on `[n-1, ∞)`. |
noncomputable quotientSpanXSubCAlgEquiv (x : R) :
(R[X] ⧸ Ideal.span ({X - C x} : Set R[X])) ≃ₐ[R] R :=
let e := RingHom.quotientKerEquivOfRightInverse (fun x => by
exact eval_C : Function.RightInverse (fun a : R => (C a : R[X])) (@aeval R R _ _ _ x))
(Ideal.quotientEquivAlgOfEq R (ker_evalRingHom x).symm).trans
{ e with commutes' := fun r => e.apply_symm_apply r }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientSpanXSubCAlgEquiv | For a commutative ring $R$, evaluating a polynomial at an element $x \in R$ induces an
isomorphism of $R$-algebras $R[X] / \langle X - x \rangle \cong R$. |
quotientSpanXSubCAlgEquiv_mk (x : R) (p : R[X]) :
quotientSpanXSubCAlgEquiv x (Ideal.Quotient.mk _ p) = p.eval x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientSpanXSubCAlgEquiv_mk | null |
quotientSpanXSubCAlgEquiv_symm_apply (x : R) (y : R) :
(quotientSpanXSubCAlgEquiv x).symm y = algebraMap R _ y :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientSpanXSubCAlgEquiv_symm_apply | null |
noncomputable quotientSpanCXSubCAlgEquiv (x y : R) :
(R[X] ⧸ (Ideal.span {C x, X - C y} : Ideal R[X])) ≃ₐ[R] R ⧸ (Ideal.span {x} : Ideal R) :=
(Ideal.quotientEquivAlgOfEq R <| by rw [Ideal.span_insert, sup_comm]).trans <|
(DoubleQuot.quotQuotEquivQuotSupₐ R _ _).symm.trans <|
(Ideal.quotientEquivAlg _ _ (quotientSpanXSubCAlgEquiv y) rfl).trans <|
Ideal.quotientEquivAlgOfEq R <| by
simp only [Ideal.map_span, Set.image_singleton]; congr 2; exact eval_C | def | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientSpanCXSubCAlgEquiv | For a commutative ring $R$, evaluating a polynomial at an element $y \in R$ induces an
isomorphism of $R$-algebras $R[X] / \langle x, X - y \rangle \cong R / \langle x \rangle$. |
noncomputable quotientSpanCXSubCXSubCAlgEquiv {x : R} {y : R[X]} :
@AlgEquiv R (R[X][X] ⧸ (Ideal.span {C (X - C x), X - C y} : Ideal <| R[X][X])) R _ _ _
(Ideal.Quotient.algebra R) _ :=
((quotientSpanCXSubCAlgEquiv (X - C x) y).restrictScalars R).trans <| quotientSpanXSubCAlgEquiv x | def | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientSpanCXSubCXSubCAlgEquiv | For a commutative ring $R$, evaluating a polynomial at elements $y(X) \in R[X]$ and $x \in R$
induces an isomorphism of $R$-algebras $R[X, Y] / \langle X - x, Y - y(X) \rangle \cong R$. |
modByMonic_eq_zero_iff_quotient_eq_zero (p q : R[X]) (hq : q.Monic) :
p %ₘ q = 0 ↔ (p : R[X] ⧸ Ideal.span {q}) = 0 := by
rw [modByMonic_eq_zero_iff_dvd hq, Ideal.Quotient.eq_zero_iff_dvd] | lemma | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | modByMonic_eq_zero_iff_quotient_eq_zero | null |
quotient_map_C_eq_zero {I : Ideal R} :
∀ a ∈ I, ((Quotient.mk (map (C : R →+* R[X]) I : Ideal R[X])).comp C) a = 0 := by
intro a ha
rw [RingHom.comp_apply, Quotient.eq_zero_iff_mem]
exact mem_map_of_mem _ ha | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotient_map_C_eq_zero | null |
eval₂_C_mk_eq_zero {I : Ideal R} :
∀ f ∈ (map (C : R →+* R[X]) I : Ideal R[X]), eval₂RingHom (C.comp (Quotient.mk I)) X f = 0 := by
intro a ha
rw [← sum_monomial_eq a]
dsimp
rw [eval₂_sum]
refine Finset.sum_eq_zero fun n _ => ?_
dsimp
rw [eval₂_monomial (C.comp (Quotient.mk I)) X]
refine mul_eq_zero_of_left (Polynomial.ext fun m => ?_) (X ^ n)
rw [RingHom.comp_apply, coeff_C]
by_cases h : m = 0
· simpa [h] using Quotient.eq_zero_iff_mem.2 ((mem_map_C_iff.1 ha) n)
· simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | eval₂_C_mk_eq_zero | null |
polynomialQuotientEquivQuotientPolynomial (I : Ideal R) :
(R ⧸ I)[X] ≃+* R[X] ⧸ (map C I : Ideal R[X]) where
toFun :=
eval₂RingHom
(Quotient.lift I ((Quotient.mk (map C I : Ideal R[X])).comp C) quotient_map_C_eq_zero)
(Quotient.mk (map C I : Ideal R[X]) X)
invFun :=
Quotient.lift (map C I : Ideal R[X]) (eval₂RingHom (C.comp (Quotient.mk I)) X)
eval₂_C_mk_eq_zero
map_mul' f g := by simp only [coe_eval₂RingHom, eval₂_mul]
map_add' f g := by simp only [eval₂_add, coe_eval₂RingHom]
left_inv := by
intro f
refine Polynomial.induction_on' f ?_ ?_
· intro p q hp hq
simp only [coe_eval₂RingHom] at hp hq
simp only [coe_eval₂RingHom, hp, hq, RingHom.map_add]
· rintro n ⟨x⟩
simp only [← smul_X_eq_monomial, C_mul', Quotient.lift_mk, Submodule.Quotient.quot_mk_eq_mk,
Quotient.mk_eq_mk, eval₂_X_pow, eval₂_smul, coe_eval₂RingHom, RingHom.map_pow, eval₂_C,
RingHom.coe_comp, RingHom.map_mul, eval₂_X, Function.comp_apply]
right_inv := by
rintro ⟨f⟩
refine Polynomial.induction_on' f ?_ ?_
· intro p q hp hq
simp only [Submodule.Quotient.quot_mk_eq_mk, Quotient.mk_eq_mk, map_add, Quotient.lift_mk,
coe_eval₂RingHom] at hp hq ⊢
rw [hp, hq]
· intro n a
simp only [← smul_X_eq_monomial, ← C_mul' a (X ^ n), Quotient.lift_mk,
Submodule.Quotient.quot_mk_eq_mk, Quotient.mk_eq_mk,
coe_eval₂RingHom, RingHom.map_pow, eval₂_C, RingHom.coe_comp, RingHom.map_mul, eval₂_X,
Function.comp_apply]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | polynomialQuotientEquivQuotientPolynomial | If `I` is an ideal of `R`, then the ring polynomials over the quotient ring `I.quotient` is
isomorphic to the quotient of `R[X]` by the ideal `map C I`,
where `map C I` contains exactly the polynomials whose coefficients all lie in `I`. |
polynomialQuotientEquivQuotientPolynomial_symm_mk (I : Ideal R) (f : R[X]) :
I.polynomialQuotientEquivQuotientPolynomial.symm (Quotient.mk _ f) = f.map (Quotient.mk I) := by
rw [polynomialQuotientEquivQuotientPolynomial, RingEquiv.symm_mk, RingEquiv.coe_mk,
Equiv.coe_fn_mk, Quotient.lift_mk, coe_eval₂RingHom, eval₂_eq_eval_map, ← Polynomial.map_map,
← eval₂_eq_eval_map, Polynomial.eval₂_C_X]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | polynomialQuotientEquivQuotientPolynomial_symm_mk | null |
polynomialQuotientEquivQuotientPolynomial_map_mk (I : Ideal R) (f : R[X]) :
I.polynomialQuotientEquivQuotientPolynomial (f.map <| Quotient.mk I) =
Quotient.mk (map C I : Ideal R[X]) f := by
apply (polynomialQuotientEquivQuotientPolynomial I).symm.injective
rw [RingEquiv.symm_apply_apply, polynomialQuotientEquivQuotientPolynomial_symm_mk] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | polynomialQuotientEquivQuotientPolynomial_map_mk | null |
isDomain_map_C_quotient {P : Ideal R} (_ : IsPrime P) :
IsDomain (R[X] ⧸ (map (C : R →+* R[X]) P : Ideal R[X])) :=
MulEquiv.isDomain (Polynomial (R ⧸ P)) (polynomialQuotientEquivQuotientPolynomial P).symm | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | isDomain_map_C_quotient | If `P` is a prime ideal of `R`, then `R[x]/(P)` is an integral domain. |
eq_zero_of_polynomial_mem_map_range (I : Ideal R[X]) (x : ((Quotient.mk I).comp C).range)
(hx : C x ∈ I.map (Polynomial.mapRingHom ((Quotient.mk I).comp C).rangeRestrict)) : x = 0 := by
let i := ((Quotient.mk I).comp C).rangeRestrict
have hi' : RingHom.ker (Polynomial.mapRingHom i) ≤ I := by
refine fun f hf => polynomial_mem_ideal_of_coeff_mem_ideal I f fun n => ?_
rw [mem_comap, ← Quotient.eq_zero_iff_mem, ← RingHom.comp_apply]
rw [RingHom.mem_ker, coe_mapRingHom] at hf
replace hf := congr_arg (fun f : Polynomial _ => f.coeff n) hf
simp only [coeff_map, coeff_zero] at hf
rwa [Subtype.ext_iff, RingHom.coe_rangeRestrict] at hf
obtain ⟨x, hx'⟩ := x
obtain ⟨y, rfl⟩ := RingHom.mem_range.1 hx'
refine Subtype.eq ?_
simp only [RingHom.comp_apply, Quotient.eq_zero_iff_mem, ZeroMemClass.coe_zero]
suffices C (i y) ∈ I.map (Polynomial.mapRingHom i) by
obtain ⟨f, hf⟩ := mem_image_of_mem_map_of_surjective (Polynomial.mapRingHom i)
(Polynomial.map_surjective _ (RingHom.rangeRestrict_surjective ((Quotient.mk I).comp C))) this
refine sub_add_cancel (C y) f ▸ I.add_mem (hi' ?_ : C y - f ∈ I) hf.1
rw [RingHom.mem_ker, RingHom.map_sub, hf.2, sub_eq_zero, coe_mapRingHom, map_C]
exact hx | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | eq_zero_of_polynomial_mem_map_range | Given any ring `R` and an ideal `I` of `R[X]`, we get a map `R → R[x] → R[x]/I`.
If we let `R` be the image of `R` in `R[x]/I` then we also have a map `R[x] → R'[x]`.
In particular we can map `I` across this map, to get `I'` and a new map `R' → R'[x] → R'[x]/I`.
This theorem shows `I'` will not contain any non-zero constant polynomials. |
IsField.of_isPrincipalIdealRing_polynomial [IsDomain R] [IsPrincipalIdealRing R[X]] :
IsField R := by
apply (quotientSpanXSubCAlgEquiv 0).symm.toMulEquiv.isField
rw [← Quotient.maximal_ideal_iff_isField_quotient]
exact PrincipalIdealRing.isMaximal_of_irreducible (irreducible_X_sub_C 0) | lemma | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | IsField.of_isPrincipalIdealRing_polynomial | Given a domain `R`, if `R[X]` is a principal ideal ring, then `R` is a field. |
quotient_map_C_eq_zero {I : Ideal R} {i : R} (hi : i ∈ I) :
(Ideal.Quotient.mk (Ideal.map (C : R →+* MvPolynomial σ R) I :
Ideal (MvPolynomial σ R))).comp C i = 0 := by
simp only [Function.comp_apply, RingHom.coe_comp, Ideal.Quotient.eq_zero_iff_mem]
exact Ideal.mem_map_of_mem _ hi | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotient_map_C_eq_zero | null |
eval₂_C_mk_eq_zero {I : Ideal R} {a : MvPolynomial σ R}
(ha : a ∈ (Ideal.map (C : R →+* MvPolynomial σ R) I : Ideal (MvPolynomial σ R))) :
eval₂Hom (C.comp (Ideal.Quotient.mk I)) X a = 0 := by
rw [as_sum a]
rw [coe_eval₂Hom, eval₂_sum]
refine Finset.sum_eq_zero fun n _ => ?_
simp only [eval₂_monomial, Function.comp_apply, RingHom.coe_comp]
refine mul_eq_zero_of_left ?_ _
suffices coeff n a ∈ I by
rw [← @Ideal.mk_ker R _ I, RingHom.mem_ker] at this
simp only [this, C_0]
exact mem_map_C_iff.1 ha n | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | eval₂_C_mk_eq_zero | null |
quotientEquivQuotientMvPolynomial_rightInverse (I : Ideal R) :
Function.RightInverse
(eval₂ (Ideal.Quotient.lift I
((Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R))).comp C)
fun _ hi => quotient_map_C_eq_zero hi)
fun i => Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R)) (X i))
(Ideal.Quotient.lift (Ideal.map C I : Ideal (MvPolynomial σ R))
(eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) fun _ ha => eval₂_C_mk_eq_zero ha) := by
intro f
apply induction_on f
· intro r
obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective r
rw [eval₂_C, Ideal.Quotient.lift_mk, RingHom.comp_apply, Ideal.Quotient.lift_mk, eval₂Hom_C,
RingHom.comp_apply]
· intro p q hp hq
simp only [RingHom.map_add, MvPolynomial.eval₂_add]
at hp hq ⊢
rw [hp, hq]
· intro p i hp
simp only at hp
simp only [hp, coe_eval₂Hom, Ideal.Quotient.lift_mk, eval₂_mul, RingHom.map_mul, eval₂_X] | lemma | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientEquivQuotientMvPolynomial_rightInverse | Split off from `quotientEquivQuotientMvPolynomial` for speed. |
quotientEquivQuotientMvPolynomial_leftInverse (I : Ideal R) :
Function.LeftInverse
(eval₂ (Ideal.Quotient.lift I
((Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R))).comp C)
fun _ hi => quotient_map_C_eq_zero hi)
fun i => Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R)) (X i))
(Ideal.Quotient.lift (Ideal.map C I : Ideal (MvPolynomial σ R))
(eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) fun _ ha => eval₂_C_mk_eq_zero ha) := by
intro f
obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective f
apply induction_on f
· intro r
rw [Ideal.Quotient.lift_mk, eval₂Hom_C, RingHom.comp_apply, eval₂_C, Ideal.Quotient.lift_mk,
RingHom.comp_apply]
· intro p q hp hq
rw [Ideal.Quotient.lift_mk] at hp hq ⊢
simp only [eval₂_add, RingHom.map_add, coe_eval₂Hom] at hp hq ⊢
rw [hp, hq]
· intro p i hp
simp only [coe_eval₂Hom, Ideal.Quotient.lift_mk,
eval₂_mul, RingHom.map_mul, eval₂_X] at hp ⊢
simp only [hp] | lemma | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientEquivQuotientMvPolynomial_leftInverse | Split off from `quotientEquivQuotientMvPolynomial` for speed. |
noncomputable quotientEquivQuotientMvPolynomial (I : Ideal R) :
MvPolynomial σ (R ⧸ I) ≃ₐ[R] MvPolynomial σ R ⧸ (Ideal.map C I : Ideal (MvPolynomial σ R)) :=
let e : MvPolynomial σ (R ⧸ I) →ₐ[R]
MvPolynomial σ R ⧸ (Ideal.map C I : Ideal (MvPolynomial σ R)) :=
{ eval₂Hom
(Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R))).comp C)
fun _ hi => quotient_map_C_eq_zero hi)
fun i => Ideal.Quotient.mk (Ideal.map C I : Ideal (MvPolynomial σ R)) (X i) with
commutes' := fun r => eval₂Hom_C _ _ (Ideal.Quotient.mk I r) }
{ e with
invFun := Ideal.Quotient.lift (Ideal.map C I : Ideal (MvPolynomial σ R))
(eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) fun _ ha => eval₂_C_mk_eq_zero ha
left_inv := quotientEquivQuotientMvPolynomial_rightInverse I
right_inv := quotientEquivQuotientMvPolynomial_leftInverse I } | def | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.Algebra.Polynomial.Div",
"Mathlib.Algebra.Polynomial.Eval.SMul",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Polynomial.Basic",
"Mathlib.RingTheory.Polynomial.Ideal",
"Mathlib.RingTheory.PrincipalId... | Mathlib/RingTheory/Polynomial/Quotient.lean | quotientEquivQuotientMvPolynomial | If `I` is an ideal of `R`, then the ring `MvPolynomial σ I.quotient` is isomorphic as an
`R`-algebra to the quotient of `MvPolynomial σ R` by the ideal generated by `I`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.