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 ⌀ |
|---|---|---|---|---|---|---|
degree_zero : m.degree (0 : MvPolynomial σ R) = 0 := by
simp [degree] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_zero | null |
ne_zero_of_degree_ne_zero {f : MvPolynomial σ R} (h : m.degree f ≠ 0) : f ≠ 0 := by
rintro rfl
exact h m.degree_zero
@[simp, nontriviality] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | ne_zero_of_degree_ne_zero | null |
degree_subsingleton [Subsingleton R] {f : MvPolynomial σ R} :
m.degree f = 0 := by
rw [Subsingleton.eq_zero f, degree_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_subsingleton | null |
leadingCoeff_zero : m.leadingCoeff (0 : MvPolynomial σ R) = 0 := by
simp [degree, leadingCoeff] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_zero | null |
Monic.ne_zero [Nontrivial R] {f : MvPolynomial σ R} (hf : m.Monic f) :
f ≠ 0 := by
rintro rfl
simp [Monic, leadingCoeff_zero] at hf | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | Monic.ne_zero | null |
degree_monomial_le {d : σ →₀ ℕ} (c : R) :
m.degree (monomial d c) ≼[m] d := by
simp only [degree, AddEquiv.apply_symm_apply]
apply le_trans (Finset.sup_mono support_monomial_subset)
simp only [Finset.sup_singleton, le_refl] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_monomial_le | null |
degree_monomial {d : σ →₀ ℕ} (c : R) [Decidable (c = 0)] :
m.degree (monomial d c) = if c = 0 then 0 else d := by
simp only [degree, support_monomial]
split_ifs with hc <;> simp | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_monomial | null |
degree_X_le_single {s : σ} : m.degree (X s : MvPolynomial σ R) ≼[m] Finsupp.single s 1 :=
degree_monomial_le 1 | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_X_le_single | null |
degree_X [Nontrivial R] {s : σ} :
m.degree (X s : MvPolynomial σ R) = Finsupp.single s 1 := by
classical
change m.degree (monomial (Finsupp.single s 1) (1 : R)) = _
rw [degree_monomial, if_neg one_ne_zero]
@[simp] theorem degree_one : m.degree (1 : MvPolynomial σ R) = 0 := by
nontriviality R
classical rw [MvPolynomial.one_def, degree_monomial]
simp
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_X | null |
leadingCoeff_monomial {d : σ →₀ ℕ} (c : R) :
m.leadingCoeff (monomial d c) = c := by
classical
simp only [leadingCoeff, degree_monomial]
split_ifs with hc <;> simp [hc]
@[simp] theorem monic_monomial_one {d : σ →₀ ℕ} :
m.Monic (monomial d (1 : R)) :=
m.leadingCoeff_monomial 1 | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_monomial | null |
monic_monomial {d : σ →₀ ℕ} {c : R} :
m.Monic (monomial d c) ↔ c = 1 := by
rw [Monic, m.leadingCoeff_monomial] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | monic_monomial | null |
leadingCoeff_X {s : σ} :
m.leadingCoeff (X s : MvPolynomial σ R) = 1 :=
m.leadingCoeff_monomial 1
@[simp] theorem monic_X {s : σ} :
m.Monic (X s : MvPolynomial σ R) :=
monic_monomial_one | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_X | null |
leadingCoeff_one : m.leadingCoeff (1 : MvPolynomial σ R) = 1 :=
m.leadingCoeff_monomial 1 | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_one | null |
monic_one : m.Monic (C 1 : MvPolynomial σ R) :=
monic_monomial_one | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | monic_one | null |
degree_le_iff {f : MvPolynomial σ R} {d : σ →₀ ℕ} :
m.degree f ≼[m] d ↔ ∀ c ∈ f.support, c ≼[m] d := by
unfold degree
simp only [AddEquiv.apply_symm_apply, Finset.sup_le_iff, mem_support_iff, ne_eq] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_le_iff | null |
degree_lt_iff {f : MvPolynomial σ R} {d : σ →₀ ℕ} (hd : 0 ≺[m] d) :
m.degree f ≺[m] d ↔ ∀ c ∈ f.support, c ≺[m] d := by
simp only [map_zero] at hd
unfold degree
simp only [AddEquiv.apply_symm_apply]
exact Finset.sup_lt_iff hd | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_lt_iff | null |
le_degree {f : MvPolynomial σ R} {d : σ →₀ ℕ} (hd : d ∈ f.support) :
d ≼[m] m.degree f := by
unfold degree
simp only [AddEquiv.apply_symm_apply, Finset.le_sup hd] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | le_degree | null |
coeff_eq_zero_of_lt {f : MvPolynomial σ R} {d : σ →₀ ℕ} (hd : m.degree f ≺[m] d) :
f.coeff d = 0 := by
rw [← not_le] at hd
by_contra hf
apply hd (m.le_degree (mem_support_iff.mpr hf)) | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_eq_zero_of_lt | null |
leadingCoeff_ne_zero_iff {f : MvPolynomial σ R} :
m.leadingCoeff f ≠ 0 ↔ f ≠ 0 := by
constructor
· rw [not_imp_not]
intro hf
rw [hf, leadingCoeff_zero]
· intro hf
rw [← support_nonempty] at hf
rw [leadingCoeff, ← mem_support_iff, degree]
suffices f.support.sup m.toSyn ∈ m.toSyn '' f.support by
obtain ⟨d, hd, hd'⟩ := this
rw [← hd', AddEquiv.symm_apply_apply]
exact hd
exact Finset.sup_mem_of_nonempty hf
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_ne_zero_iff | null |
leadingCoeff_eq_zero_iff {f : MvPolynomial σ R} :
leadingCoeff m f = 0 ↔ f = 0 := by
simp only [← not_iff_not, leadingCoeff_ne_zero_iff] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_eq_zero_iff | null |
coeff_degree_ne_zero_iff {f : MvPolynomial σ R} :
f.coeff (m.degree f) ≠ 0 ↔ f ≠ 0 :=
m.leadingCoeff_ne_zero_iff | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_degree_ne_zero_iff | null |
degree_mem_support_iff (f : MvPolynomial σ R) : m.degree f ∈ f.support ↔ f ≠ 0 :=
mem_support_iff.trans coeff_degree_ne_zero_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mem_support_iff | null |
coeff_degree_eq_zero_iff {f : MvPolynomial σ R} :
f.coeff (m.degree f) = 0 ↔ f = 0 :=
m.leadingCoeff_eq_zero_iff | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_degree_eq_zero_iff | null |
degree_mem_support {p : MvPolynomial σ R} (hp : p ≠ 0) :
m.degree p ∈ p.support := by
rwa [MvPolynomial.mem_support_iff, coeff_degree_ne_zero_iff] | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mem_support | null |
degree_eq_zero_iff_totalDegree_eq_zero {f : MvPolynomial σ R} :
m.degree f = 0 ↔ f.totalDegree = 0 := by
rw [← m.toSyn.injective.eq_iff]
rw [map_zero, ← m.bot_eq_zero, eq_bot_iff, m.bot_eq_zero, ← m.toSyn.map_zero]
rw [degree_le_iff]
rw [totalDegree_eq_zero_iff]
apply forall_congr'
intro d
apply imp_congr (rfl.to_iff)
rw [map_zero, ← m.bot_eq_zero, ← eq_bot_iff, m.bot_eq_zero]
simp only [EmbeddingLike.map_eq_zero_iff]
exact Finsupp.ext_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_eq_zero_iff_totalDegree_eq_zero | null |
degree_C (r : R) :
m.degree (C r) = 0 := by
rw [degree_eq_zero_iff_totalDegree_eq_zero, totalDegree_C] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_C | null |
eq_C_of_degree_eq_zero {f : MvPolynomial σ R} (hf : m.degree f = 0) :
f = C (m.leadingCoeff f) := by
ext d
simp only [leadingCoeff, hf]
classical
by_cases hd : d = 0
· simp [hd]
· rw [coeff_C, if_neg (Ne.symm hd)]
apply coeff_eq_zero_of_lt (m := m)
rw [hf, map_zero, lt_iff_le_and_ne, ne_eq, eq_comm, EmbeddingLike.map_eq_zero_iff]
exact ⟨bot_le, hd⟩ | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | eq_C_of_degree_eq_zero | null |
degree_eq_zero_iff {f : MvPolynomial σ R} :
m.degree f = 0 ↔ f = C (m.leadingCoeff f) :=
⟨MonomialOrder.eq_C_of_degree_eq_zero, fun h => by rw [h, MonomialOrder.degree_C]⟩ | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_eq_zero_iff | null |
degree_add_le {f g : MvPolynomial σ R} :
m.toSyn (m.degree (f + g)) ≤ m.toSyn (m.degree f) ⊔ m.toSyn (m.degree g) := by
conv_rhs => rw [← m.toSyn.apply_symm_apply (_ ⊔ _)]
rw [degree_le_iff]
simp only [AddEquiv.apply_symm_apply, le_sup_iff]
intro b hb
by_cases hf : b ∈ f.support
· left
exact m.le_degree hf
· right
apply m.le_degree
simp only [notMem_support_iff] at hf
simpa only [mem_support_iff, coeff_add, hf, zero_add] using hb | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_add_le | null |
degree_sum_le {α : Type*} {s : Finset α} {f : α → MvPolynomial σ R} :
(m.toSyn <| m.degree <| ∑ x ∈ s, f x) ≤ s.sup fun x ↦ (m.toSyn <| m.degree <| f x) := by
induction s using Finset.cons_induction_on with
| empty => simp
| cons a s haA h =>
rw [Finset.sum_cons, Finset.sup_cons]
exact le_trans m.degree_add_le (max_le_max le_rfl h) | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_sum_le | null |
degree_add_of_lt {f g : MvPolynomial σ R} (h : m.degree g ≺[m] m.degree f) :
m.degree (f + g) = m.degree f := by
apply m.toSyn.injective
apply le_antisymm
· apply le_trans degree_add_le
simp only [sup_le_iff, le_refl, true_and, le_of_lt h]
· apply le_degree
rw [mem_support_iff, coeff_add, m.coeff_eq_zero_of_lt h, add_zero,
← leadingCoeff, leadingCoeff_ne_zero_iff]
intro hf
rw [← not_le, hf] at h
apply h
simp only [degree_zero, map_zero]
apply bot_le | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_add_of_lt | null |
degree_add_eq_right_of_lt {f g : MvPolynomial σ R} (h : m.degree f ≺[m] m.degree g) :
m.degree (f + g) = m.degree g := by
rw [add_comm]
exact degree_add_of_lt h | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_add_eq_right_of_lt | null |
leadingCoeff_add_of_lt {f g : MvPolynomial σ R} (h : m.degree g ≺[m] m.degree f) :
m.leadingCoeff (f + g) = m.leadingCoeff f := by
simp only [leadingCoeff, m.degree_add_of_lt h, coeff_add, coeff_eq_zero_of_lt h, add_zero] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_add_of_lt | null |
Monic.add_of_lt {f g : MvPolynomial σ R} (hf : m.Monic f) (h : m.degree g ≺[m] m.degree f) :
m.Monic (f + g) := by
simp only [Monic, leadingCoeff_add_of_lt h, hf.leadingCoeff_eq_one] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | Monic.add_of_lt | null |
degree_add_of_ne {f g : MvPolynomial σ R}
(h : m.degree f ≠ m.degree g) :
m.toSyn (m.degree (f + g)) = m.toSyn (m.degree f) ⊔ m.toSyn (m.degree g) := by
by_cases h' : m.degree g ≺[m] m.degree f
· simp [degree_add_of_lt h', le_of_lt h']
· rw [not_lt, le_iff_eq_or_lt, Classical.or_iff_not_imp_left, EmbeddingLike.apply_eq_iff_eq] at h'
rw [add_comm, degree_add_of_lt (h' h), right_eq_sup]
simp only [le_of_lt (h' h)] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_add_of_ne | null |
degree_mul_le {f g : MvPolynomial σ R} :
m.degree (f * g) ≼[m] m.degree f + m.degree g := by
classical
rw [degree_le_iff]
intro c
rw [← not_lt, mem_support_iff, not_imp_not]
intro hc
rw [coeff_mul]
apply Finset.sum_eq_zero
rintro ⟨d, e⟩ hde
simp only [Finset.mem_antidiagonal] at hde
dsimp only
by_cases hd : m.degree f ≺[m] d
· rw [m.coeff_eq_zero_of_lt hd, zero_mul]
· suffices m.degree g ≺[m] e by
rw [m.coeff_eq_zero_of_lt this, mul_zero]
simp only [not_lt] at hd
apply lt_of_add_lt_add_left (a := m.toSyn d)
simp only [← map_add, hde]
apply lt_of_le_of_lt _ hc
simp only [map_add]
exact add_le_add_right hd _ | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mul_le | null |
coeff_mul_of_add_of_degree_le {f g : MvPolynomial σ R} {a b : σ →₀ ℕ}
(ha : m.degree f ≼[m] a) (hb : m.degree g ≼[m] b) :
(f * g).coeff (a + b) = f.coeff a * g.coeff b := by
classical
rw [coeff_mul, Finset.sum_eq_single (a,b)]
· rintro ⟨c, d⟩ hcd h
simp only [Finset.mem_antidiagonal] at hcd
by_cases hf : m.degree f ≺[m] c
· rw [m.coeff_eq_zero_of_lt hf, zero_mul]
· suffices m.degree g ≺[m] d by
rw [coeff_eq_zero_of_lt this, mul_zero]
rw [not_lt] at hf
rw [← not_le]
intro hf'
apply h
suffices c = a by
simpa [Prod.mk.injEq, this] using hcd
apply m.toSyn.injective
apply le_antisymm (le_trans hf ha)
apply le_of_add_le_add_right (a := m.toSyn b)
rw [← map_add, ← hcd, map_add]
simp only [add_le_add_iff_left]
exact le_trans hf' hb
· simp | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_mul_of_add_of_degree_le | Multiplicativity of leading coefficients |
coeff_mul_of_degree_add {f g : MvPolynomial σ R} :
(f * g).coeff (m.degree f + m.degree g) = m.leadingCoeff f * m.leadingCoeff g :=
coeff_mul_of_add_of_degree_le (le_of_eq rfl) (le_of_eq rfl) | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_mul_of_degree_add | Multiplicativity of leading coefficients |
degree_mul_of_mul_leadingCoeff_ne_zero {f g : MvPolynomial σ R}
(hfg : m.leadingCoeff f * m.leadingCoeff g ≠ 0) :
m.degree (f * g) = m.degree f + m.degree g := by
apply m.toSyn.injective
apply le_antisymm degree_mul_le
apply le_degree
rw [mem_support_iff, coeff_mul_of_degree_add]
exact hfg | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mul_of_mul_leadingCoeff_ne_zero | Monomial degree of product |
leadingCoeff_mul_of_mul_leadingCoeff_ne_zero {f g : MvPolynomial σ R}
(hfg : m.leadingCoeff f * m.leadingCoeff g ≠ 0) :
m.leadingCoeff (f * g) = m.leadingCoeff f * m.leadingCoeff g := by
rw [leadingCoeff, ← coeff_mul_of_degree_add, degree_mul_of_mul_leadingCoeff_ne_zero hfg] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_mul_of_mul_leadingCoeff_ne_zero | Multiplicativity of leading coefficients |
degree_mul_of_isRegular_left {f g : MvPolynomial σ R}
(hf : IsRegular (m.leadingCoeff f)) (hg : g ≠ 0) :
m.degree (f * g) = m.degree f + m.degree g := by
apply degree_mul_of_mul_leadingCoeff_ne_zero
simp only [ne_eq, hf, IsRegular.left, IsLeftRegular.mul_left_eq_zero_iff,
leadingCoeff_eq_zero_iff]
exact hg | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mul_of_isRegular_left | Monomial degree of product |
leadingCoeff_mul_of_isRegular_left {f g : MvPolynomial σ R}
(hf : IsRegular (m.leadingCoeff f)) (hg : g ≠ 0) :
m.leadingCoeff (f * g) = m.leadingCoeff f * m.leadingCoeff g := by
simp only [leadingCoeff, degree_mul_of_isRegular_left hf hg, coeff_mul_of_degree_add] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_mul_of_isRegular_left | Multiplicativity of leading coefficients |
degree_mul_of_isRegular_right {f g : MvPolynomial σ R}
(hf : f ≠ 0) (hg : IsRegular (m.leadingCoeff g)) :
m.degree (f * g) = m.degree f + m.degree g := by
rw [mul_comm, m.degree_mul_of_isRegular_left hg hf, add_comm] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mul_of_isRegular_right | Monomial degree of product |
leadingCoeff_mul_of_isRegular_right {f g : MvPolynomial σ R}
(hf : f ≠ 0) (hg : IsRegular (m.leadingCoeff g)) :
m.leadingCoeff (f * g) = m.leadingCoeff f * m.leadingCoeff g := by
simp only [leadingCoeff, degree_mul_of_isRegular_right hf hg, coeff_mul_of_degree_add] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_mul_of_isRegular_right | Multiplicativity of leading coefficients |
Monic.mul {f g : MvPolynomial σ R} (hf : m.Monic f) (hg : m.Monic g) :
m.Monic (f * g) := by
nontriviality R
suffices m.leadingCoeff f * m.leadingCoeff g = 1 by
rw [Monic, MonomialOrder.leadingCoeff,
degree_mul_of_mul_leadingCoeff_ne_zero, coeff_mul_of_degree_add, this]
rw [this]
exact one_ne_zero
rw [hf.leadingCoeff_eq_one, hg.leadingCoeff_eq_one, one_mul] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | Monic.mul | null |
degree_mul [IsCancelMulZero R] {f g : MvPolynomial σ R} (hf : f ≠ 0) (hg : g ≠ 0) :
m.degree (f * g) = m.degree f + m.degree g :=
degree_mul_of_isRegular_left (isRegular_of_ne_zero (leadingCoeff_ne_zero_iff.mpr hf)) hg | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_mul | Monomial degree of product |
leadingCoeff_mul [IsCancelMulZero R] {f g : MvPolynomial σ R} (hf : f ≠ 0) (hg : g ≠ 0) :
m.leadingCoeff (f * g) = m.leadingCoeff f * m.leadingCoeff g := by
rw [leadingCoeff, degree_mul hf hg, ← coeff_mul_of_degree_add] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_mul | Multiplicativity of leading coefficients |
degree_pow_le {f : MvPolynomial σ R} (n : ℕ) :
m.degree (f ^ n) ≼[m] n • (m.degree f) := by
induction n with
| zero => simp [m.degree_one]
| succ n hrec =>
simp only [pow_add, pow_one, add_smul, one_smul]
apply le_trans m.degree_mul_le
simp only [map_add, add_le_add_iff_right]
exact hrec | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_pow_le | Monomial degree of powers |
coeff_pow_nsmul_degree (f : MvPolynomial σ R) (n : ℕ) :
(f ^ n).coeff (n • m.degree f) = m.leadingCoeff f ^ n := by
induction n with
| zero => simp
| succ n hrec =>
simp only [add_smul, one_smul, pow_add, pow_one]
rw [m.coeff_mul_of_add_of_degree_le (m.degree_pow_le _) le_rfl, hrec, leadingCoeff] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_pow_nsmul_degree | null |
degree_pow_of_pow_leadingCoeff_ne_zero {f : MvPolynomial σ R} {n : ℕ}
(hf : m.leadingCoeff f ^ n ≠ 0) :
m.degree (f ^ n) = n • m.degree f := by
apply m.toSyn.injective
apply le_antisymm (m.degree_pow_le n)
apply le_degree
rw [mem_support_iff, coeff_pow_nsmul_degree]
exact hf | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_pow_of_pow_leadingCoeff_ne_zero | Monomial degree of powers |
leadingCoeff_pow_of_pow_leadingCoeff_ne_zero {f : MvPolynomial σ R} {n : ℕ}
(hf : m.leadingCoeff f ^ n ≠ 0) :
m.leadingCoeff (f ^ n) = m.leadingCoeff f ^ n := by
rw [leadingCoeff, degree_pow_of_pow_leadingCoeff_ne_zero hf, coeff_pow_nsmul_degree] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_pow_of_pow_leadingCoeff_ne_zero | Leading coefficient of powers |
protected Monic.pow {f : MvPolynomial σ R} {n : ℕ} (hf : m.Monic f) :
m.Monic (f ^ n) := by
nontriviality R
rw [Monic, leadingCoeff_pow_of_pow_leadingCoeff_ne_zero, hf.leadingCoeff_eq_one, one_pow]
rw [hf.leadingCoeff_eq_one, one_pow]
exact one_ne_zero | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | Monic.pow | null |
degree_pow [IsReduced R] (f : MvPolynomial σ R) (n : ℕ) :
m.degree (f ^ n) = n • m.degree f := by
by_cases hf : f = 0
· rw [hf, degree_zero, smul_zero]
by_cases hn : n = 0
· rw [hn, pow_zero, degree_one]
· rw [zero_pow hn, degree_zero]
nontriviality R
apply degree_pow_of_pow_leadingCoeff_ne_zero
apply IsReduced.pow_ne_zero
rw [leadingCoeff_ne_zero_iff]
exact hf | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_pow | Monomial degree of powers (in a reduced ring) |
leadingCoeff_pow [IsReduced R] (f : MvPolynomial σ R) (n : ℕ) :
m.leadingCoeff (f ^ n) = m.leadingCoeff f ^ n := by
rw [leadingCoeff, degree_pow, coeff_pow_nsmul_degree] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_pow | Leading coefficient of powers (in a reduced ring) |
degree_smul_le {r : R} {f : MvPolynomial σ R} :
m.degree (r • f) ≼[m] m.degree f := by
rw [smul_eq_C_mul]
apply le_of_le_of_eq degree_mul_le
simp | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_smul_le | null |
degree_smul {r : R} (hr : IsRegular r) {f : MvPolynomial σ R} :
m.degree (r • f) = m.degree f := by
by_cases hf : f = 0
· simp [hf]
apply m.toSyn.injective
apply le_antisymm degree_smul_le
apply le_degree
simp only [mem_support_iff, smul_eq_C_mul]
rw [← zero_add (degree m f), ← degree_C r, coeff_mul_of_degree_add]
simp [leadingCoeff, hr.left.mul_left_eq_zero_iff, hf] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_smul | null |
degree_prod_le {ι : Type*} {P : ι → MvPolynomial σ R} {s : Finset ι} :
m.degree (∏ i ∈ s, P i) ≼[m] ∑ i ∈ s, m.degree (P i) := by
classical
induction s using Finset.induction_on with
| empty =>
simp only [Finset.prod_empty, Finset.sum_empty]
rw [← C_1, m.degree_C, map_zero]
| insert a s has hrec =>
rw [Finset.prod_insert has, Finset.sum_insert has]
apply le_trans degree_mul_le
simp only [map_add, add_le_add_iff_left, hrec] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_prod_le | null |
coeff_prod_sum_degree {ι : Type*} (P : ι → MvPolynomial σ R) (s : Finset ι) :
coeff (∑ i ∈ s, m.degree (P i)) (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingCoeff (P i) := by
classical
induction s using Finset.induction_on with
| empty => simp
| insert a s has hrec =>
simp only [Finset.prod_insert has, Finset.sum_insert has]
rw [coeff_mul_of_add_of_degree_le (le_of_eq rfl) degree_prod_le]
exact congr_arg₂ _ rfl hrec | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | coeff_prod_sum_degree | null |
degree_prod_of_regular {ι : Type*}
{P : ι → MvPolynomial σ R} {s : Finset ι} (H : ∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) :
m.degree (∏ i ∈ s, P i) = ∑ i ∈ s, m.degree (P i) := by
cases subsingleton_or_nontrivial R with
| inl _ => simp [Subsingleton.elim _ (0 : MvPolynomial σ R)]
| inr _ =>
apply m.toSyn.injective
refine le_antisymm degree_prod_le (m.le_degree ?_)
rw [mem_support_iff, m.coeff_prod_sum_degree]
exact (IsRegular.prod H).ne_zero | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_prod_of_regular | null |
degree_prod [IsCancelMulZero R] {ι : Type*} {P : ι → MvPolynomial σ R} {s : Finset ι}
(H : ∀ i ∈ s, P i ≠ 0) :
m.degree (∏ i ∈ s, P i) = ∑ i ∈ s, m.degree (P i) := by
apply degree_prod_of_regular
intro i hi
apply isRegular_of_ne_zero
rw [leadingCoeff_ne_zero_iff]
exact H i hi | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_prod | null |
leadingCoeff_prod_of_regular {ι : Type*}
{P : ι → MvPolynomial σ R} {s : Finset ι} (H : ∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) :
m.leadingCoeff (∏ i ∈ s, P i) = ∏ i ∈ s, m.leadingCoeff (P i) := by
simp only [leadingCoeff, degree_prod_of_regular H, coeff_prod_sum_degree] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_prod_of_regular | null |
protected Monic.prod {ι : Type*} {P : ι → MvPolynomial σ R} {s : Finset ι}
(H : ∀ i ∈ s, m.Monic (P i)) :
m.Monic (∏ i ∈ s, P i) := by
rw [Monic, leadingCoeff_prod_of_regular]
· exact Finset.prod_eq_one H
· intro i hi
rw [(H i hi).leadingCoeff_eq_one]
exact isRegular_one | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | Monic.prod | A product of monic polynomials is monic |
@[simp]
degree_neg {f : MvPolynomial σ R} :
m.degree (-f) = m.degree f := by
unfold degree
rw [support_neg]
@[simp] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_neg | null |
leadingCoeff_neg {f : MvPolynomial σ R} :
m.leadingCoeff (-f) = - m.leadingCoeff f := by
simp only [leadingCoeff, degree_neg, coeff_neg] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_neg | null |
degree_sub_le {f g : MvPolynomial σ R} :
m.toSyn (m.degree (f - g)) ≤ m.toSyn (m.degree f) ⊔ m.toSyn (m.degree g) := by
rw [sub_eq_add_neg]
apply le_of_le_of_eq m.degree_add_le
rw [degree_neg] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_sub_le | null |
degree_sub_of_lt {f g : MvPolynomial σ R} (h : m.degree g ≺[m] m.degree f) :
m.degree (f - g) = m.degree f := by
rw [sub_eq_add_neg]
apply degree_add_of_lt
simp only [degree_neg, h] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_sub_of_lt | null |
leadingCoeff_sub_of_lt {f g : MvPolynomial σ R} (h : m.degree g ≺[m] m.degree f) :
m.leadingCoeff (f - g) = m.leadingCoeff f := by
rw [sub_eq_add_neg]
apply leadingCoeff_add_of_lt
simp only [degree_neg, h] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | leadingCoeff_sub_of_lt | null |
isUnit_leadingCoeff {f : MvPolynomial σ R} :
IsUnit (m.leadingCoeff f) ↔ f ≠ 0 := by
simp only [isUnit_iff_ne_zero, ne_eq, leadingCoeff_eq_zero_iff] | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | isUnit_leadingCoeff | null |
degree_X_add_C [Nontrivial R]
{ι : Type*} (m : MonomialOrder ι) (i : ι) (r : R) :
m.degree (X i + C r) = single i 1 := by
rw [degree_add_of_lt, degree_X]
simp only [degree_C, map_zero, degree_X]
rw [← bot_eq_zero, bot_lt_iff_ne_bot, bot_eq_zero, ← map_zero m.toSyn]
simp | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_X_add_C | null |
degree_X_sub_C [Nontrivial R]
{ι : Type*} (m : MonomialOrder ι) (i : ι) (r : R) :
m.degree (X i - C r) = single i 1 := by
rw [sub_eq_add_neg, ← map_neg, degree_X_add_C] | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | degree_X_sub_C | null |
monic_X_add_C {ι : Type*} (m : MonomialOrder ι) (i : ι) (r : R) :
m.Monic (X i + C r) := by
nontriviality R
apply monic_X.add_of_lt
simp [degree_C, degree_X, ← not_le, ← eq_zero_iff] | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | monic_X_add_C | null |
monic_X_sub_C {ι : Type*} (m : MonomialOrder ι) (i : ι) (r : R) :
m.Monic (X i - C r) := by
rw [sub_eq_add_neg, ← map_neg]
apply monic_X_add_C | lemma | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/MvPolynomial/MonomialOrder.lean | monic_X_sub_C | null |
aeval_map_algebraMap (x : σ → B) (p : MvPolynomial σ R) :
aeval x (map (algebraMap R A) p) = aeval x p := by
rw [aeval_def, aeval_def, eval₂_map, IsScalarTower.algebraMap_eq R A B] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPolynomial/Tower.lean | aeval_map_algebraMap | null |
aeval_algebraMap_apply (x : σ → A) (p : MvPolynomial σ R) :
aeval (algebraMap A B ∘ x) p = algebraMap A B (MvPolynomial.aeval x p) := by
rw [aeval_def, aeval_def, ← coe_eval₂Hom, ← coe_eval₂Hom, map_eval₂Hom, ←
IsScalarTower.algebraMap_eq, Function.comp_def] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPolynomial/Tower.lean | aeval_algebraMap_apply | null |
aeval_algebraMap_eq_zero_iff [NoZeroSMulDivisors A B] [Nontrivial B] (x : σ → A)
(p : MvPolynomial σ R) : aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0 := by
rw [aeval_algebraMap_apply, Algebra.algebraMap_eq_smul_one, smul_eq_zero,
iff_false_intro (one_ne_zero' B), or_false] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPolynomial/Tower.lean | aeval_algebraMap_eq_zero_iff | null |
aeval_algebraMap_eq_zero_iff_of_injective {x : σ → A} {p : MvPolynomial σ R}
(h : Function.Injective (algebraMap A B)) :
aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0 := by
rw [aeval_algebraMap_apply, ← (algebraMap A B).map_zero, h.eq_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPolynomial/Tower.lean | aeval_algebraMap_eq_zero_iff_of_injective | null |
@[simp]
mvPolynomial_aeval_coe (S : Subalgebra R A) (x : σ → S) (p : MvPolynomial σ R) :
aeval (fun i => (x i : A)) p = aeval x p := by convert aeval_algebraMap_apply A x p | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Tower",
"Mathlib.Algebra.MvPolynomial.Eval"
] | Mathlib/RingTheory/MvPolynomial/Tower.lean | mvPolynomial_aeval_coe | null |
weightedTotalDegree' (w : σ → M) (p : MvPolynomial σ R) : WithBot M :=
p.support.sup fun s => weight w s | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree' | The weighted total degree of a multivariate polynomial, taking values in `WithBot M`. |
weightedTotalDegree'_eq_bot_iff (w : σ → M) (p : MvPolynomial σ R) :
weightedTotalDegree' w p = ⊥ ↔ p = 0 := by
simp only [weightedTotalDegree', Finset.sup_eq_bot_iff, mem_support_iff, WithBot.coe_ne_bot,
MvPolynomial.eq_zero_iff]
exact forall_congr' fun _ => Classical.not_not | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree'_eq_bot_iff | The `weightedTotalDegree'` of a polynomial `p` is `⊥` if and only if `p = 0`. |
weightedTotalDegree'_zero (w : σ → M) :
weightedTotalDegree' w (0 : MvPolynomial σ R) = ⊥ := by
simp only [weightedTotalDegree', support_zero, Finset.sup_empty] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree'_zero | The `weightedTotalDegree'` of the zero polynomial is `⊥`. |
weightedTotalDegree (w : σ → M) (p : MvPolynomial σ R) : M :=
p.support.sup fun s => weight w s | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree | When `M` has a `⊥` element, we can define the weighted total degree of a multivariate
polynomial as a function taking values in `M`. |
weightedTotalDegree_coe (w : σ → M) (p : MvPolynomial σ R) (hp : p ≠ 0) :
weightedTotalDegree' w p = ↑(weightedTotalDegree w p) := by
rw [Ne, ← weightedTotalDegree'_eq_bot_iff w p, ← Ne, WithBot.ne_bot_iff_exists] at hp
obtain ⟨m, hm⟩ := hp
apply le_antisymm
· simp only [weightedTotalDegree, weightedTotalDegree', Finset.sup_le_iff, WithBot.coe_le_coe]
intro b
exact Finset.le_sup
· simp only [weightedTotalDegree]
have hm' : weightedTotalDegree' w p ≤ m := le_of_eq hm.symm
rw [← hm]
simpa [weightedTotalDegree'] using hm' | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree_coe | This lemma relates `weightedTotalDegree` and `weightedTotalDegree'`. |
weightedTotalDegree_zero (w : σ → M) :
weightedTotalDegree w (0 : MvPolynomial σ R) = ⊥ := by
simp only [weightedTotalDegree, support_zero, Finset.sup_empty] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedTotalDegree_zero | The `weightedTotalDegree` of the zero polynomial is `⊥`. |
le_weightedTotalDegree (w : σ → M) {φ : MvPolynomial σ R} {d : σ →₀ ℕ}
(hd : d ∈ φ.support) : weight w d ≤ φ.weightedTotalDegree w :=
le_sup hd | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | le_weightedTotalDegree | null |
IsWeightedHomogeneous (w : σ → M) (φ : MvPolynomial σ R) (m : M) : Prop :=
∀ ⦃d⦄, coeff d φ ≠ 0 → weight w d = m
variable (R) | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | IsWeightedHomogeneous | A multivariate polynomial `φ` is weighted homogeneous of weighted degree `m` if all monomials
occurring in `φ` have weighted degree `m`. |
weightedHomogeneousSubmodule (w : σ → M) (m : M) : Submodule R (MvPolynomial σ R) where
carrier := { x | x.IsWeightedHomogeneous w m }
smul_mem' r a ha c hc := by
rw [coeff_smul] at hc
exact ha (right_ne_zero_of_mul hc)
zero_mem' _ hd := False.elim (hd <| coeff_zero _)
add_mem' {a} {b} ha hb c hc := by
rw [coeff_add] at hc
obtain h | h : coeff c a ≠ 0 ∨ coeff c b ≠ 0 := by
contrapose! hc
simp only [hc, add_zero]
· exact ha h
· exact hb h
@[simp] | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedHomogeneousSubmodule | The submodule of homogeneous `MvPolynomial`s of degree `n`. |
mem_weightedHomogeneousSubmodule (w : σ → M) (m : M) (p : MvPolynomial σ R) :
p ∈ weightedHomogeneousSubmodule R w m ↔ p.IsWeightedHomogeneous w m :=
Iff.rfl | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | mem_weightedHomogeneousSubmodule | null |
weightedHomogeneousSubmodule_eq_finsupp_supported (w : σ → M) (m : M) :
weightedHomogeneousSubmodule R w m = Finsupp.supported R R { d | weight w d = m } := by
ext x
rw [mem_supported, Set.subset_def]
simp only [Finsupp.mem_support_iff, mem_coe]
rfl
variable {R} | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedHomogeneousSubmodule_eq_finsupp_supported | The submodule `weightedHomogeneousSubmodule R w m` of homogeneous `MvPolynomial`s of
degree `n` is equal to the `R`-submodule of all `p : (σ →₀ ℕ) →₀ R` such that
`p.support ⊆ {d | weight w d = m}`. While equal, the former has a
convenient definitional reduction. |
weightedHomogeneousSubmodule_mul (w : σ → M) (m n : M) :
weightedHomogeneousSubmodule R w m * weightedHomogeneousSubmodule R w n ≤
weightedHomogeneousSubmodule R w (m + n) := by
classical
rw [Submodule.mul_le]
intro φ hφ ψ hψ c hc
rw [coeff_mul] at hc
obtain ⟨⟨d, e⟩, hde, H⟩ := Finset.exists_ne_zero_of_sum_ne_zero hc
have aux : coeff d φ ≠ 0 ∧ coeff e ψ ≠ 0 := by
contrapose! H
by_cases h : coeff d φ = 0 <;>
simp_all only [Ne, not_false_iff, zero_mul, mul_zero]
rw [← mem_antidiagonal.mp hde, ← hφ aux.1, ← hψ aux.2, map_add] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | weightedHomogeneousSubmodule_mul | The submodule generated by products `Pm * Pn` of weighted homogeneous polynomials of degrees `m`
and `n` is contained in the submodule of weighted homogeneous polynomials of degree `m + n`. |
isWeightedHomogeneous_monomial (w : σ → M) (d : σ →₀ ℕ) (r : R) {m : M}
(hm : weight w d = m) : IsWeightedHomogeneous w (monomial d r) m := by
classical
intro c hc
rw [coeff_monomial] at hc
split_ifs at hc with h
· subst c
exact hm
· contradiction | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_monomial | Monomials are weighted homogeneous. |
isWeightedHomogeneous_of_total_degree_zero [SemilatticeSup M] [OrderBot M] (w : σ → M)
{p : MvPolynomial σ R} (hp : weightedTotalDegree w p = (⊥ : M)) :
IsWeightedHomogeneous w p (⊥ : M) := by
intro d hd
have h := weightedTotalDegree_coe w p (MvPolynomial.ne_zero_iff.mpr ⟨d, hd⟩)
simp only [weightedTotalDegree', hp] at h
rw [eq_bot_iff, ← WithBot.coe_le_coe, ← h]
apply Finset.le_sup (mem_support_iff.mpr hd) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_of_total_degree_zero | A polynomial of weightedTotalDegree `⊥` is weighted_homogeneous of degree `⊥`. |
isWeightedHomogeneous_C (w : σ → M) (r : R) :
IsWeightedHomogeneous w (C r : MvPolynomial σ R) 0 :=
isWeightedHomogeneous_monomial _ _ _ (map_zero _)
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_C | Constant polynomials are weighted homogeneous of degree 0. |
isWeightedHomogeneous_zero (w : σ → M) (m : M) :
IsWeightedHomogeneous w (0 : MvPolynomial σ R) m :=
(weightedHomogeneousSubmodule R w m).zero_mem | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_zero | 0 is weighted homogeneous of any degree. |
isWeightedHomogeneous_one (w : σ → M) : IsWeightedHomogeneous w (1 : MvPolynomial σ R) 0 :=
isWeightedHomogeneous_C _ _ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_one | 1 is weighted homogeneous of degree 0. |
isWeightedHomogeneous_X (w : σ → M) (i : σ) :
IsWeightedHomogeneous w (X i : MvPolynomial σ R) (w i) := by
apply isWeightedHomogeneous_monomial
simp only [weight, LinearMap.toAddMonoidHom_coe, linearCombination_single, one_nsmul] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | isWeightedHomogeneous_X | An indeterminate `i : σ` is weighted homogeneous of degree `w i`. |
coeff_eq_zero {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (d : σ →₀ ℕ)
(hd : weight w d ≠ n) : coeff d φ = 0 := by
have aux := mt (@hφ d) hd
rwa [Classical.not_not] at aux | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | coeff_eq_zero | The weighted degree of a weighted homogeneous polynomial controls its support. |
inj_right {w : σ → M} (hφ : φ ≠ 0) (hm : IsWeightedHomogeneous w φ m)
(hn : IsWeightedHomogeneous w φ n) : m = n := by
obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
rw [← hm hd, ← hn hd] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | inj_right | The weighted degree of a nonzero weighted homogeneous polynomial is well-defined. |
add {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (hψ : IsWeightedHomogeneous w ψ n) :
IsWeightedHomogeneous w (φ + ψ) n :=
(weightedHomogeneousSubmodule R w n).add_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | add | The sum of two weighted homogeneous polynomials of degree `n` is weighted homogeneous of
weighted degree `n`. |
sum {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : M) {w : σ → M}
(h : ∀ i ∈ s, IsWeightedHomogeneous w (φ i) n) : IsWeightedHomogeneous w (∑ i ∈ s, φ i) n :=
(weightedHomogeneousSubmodule R w n).sum_mem h | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | sum | The sum of weighted homogeneous polynomials of degree `n` is weighted homogeneous of
weighted degree `n`. |
mul {w : σ → M} (hφ : IsWeightedHomogeneous w φ m) (hψ : IsWeightedHomogeneous w ψ n) :
IsWeightedHomogeneous w (φ * ψ) (m + n) :=
weightedHomogeneousSubmodule_mul w m n <| Submodule.mul_mem_mul hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Finprod",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.Basic",
"Mathlib.Algebra.Order.Monoid.Canonical.Defs",
"Mathlib.Data.Finsupp.Weight",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | mul | The product of weighted homogeneous polynomials of weighted degrees `m` and `n` is weighted
homogeneous of weighted degree `m + n`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.