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 ⌀ |
|---|---|---|---|---|---|---|
mem_restrictDegree_iff_sup [DecidableEq σ] (p : MvPolynomial σ R) (n : ℕ) :
p ∈ restrictDegree σ R n ↔ ∀ i, p.degrees.count i ≤ n := by
simp only [mem_restrictDegree, degrees_def, Multiset.count_finset_sup, Finsupp.count_toMultiset,
Finset.sup_le_iff]
exact ⟨fun h n s hs => h s hs n, fun h s hs n => h n s hs⟩
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | mem_restrictDegree_iff_sup | null |
restrictTotalDegree_le_restrictDegree (m : ℕ) :
restrictTotalDegree σ R m ≤ restrictDegree σ R m :=
fun p hp ↦ (mem_restrictDegree _ _ _).mpr fun s hs i ↦ (degreeOf_le_iff.mp
(degreeOf_le_totalDegree p i) s hs).trans ((mem_restrictTotalDegree _ _ _).mp hp) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | restrictTotalDegree_le_restrictDegree | null |
basisMonomials : Basis (σ →₀ ℕ) R (MvPolynomial σ R) :=
Finsupp.basisSingleOne
@[simp] | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | basisMonomials | The monomials form a basis on `MvPolynomial σ R`. |
coe_basisMonomials :
(basisMonomials σ R : (σ →₀ ℕ) → MvPolynomial σ R) = fun s => monomial s 1 :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | coe_basisMonomials | null |
linearIndependent_X : LinearIndependent R (X : σ → MvPolynomial σ R) :=
(basisMonomials σ R).linearIndependent.comp (fun s : σ => Finsupp.single s 1)
(Finsupp.single_left_injective one_ne_zero) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | linearIndependent_X | null |
private finite_setOf_bounded (α) [Finite α] (n : ℕ) : Finite {f : α →₀ ℕ | ∀ a, f a ≤ n} :=
((Set.Finite.pi' fun _ ↦ Set.finite_le_nat _).preimage DFunLike.coe_injective.injOn).to_subtype | lemma | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | finite_setOf_bounded | null |
protected IsWeightedHomogeneous.pderiv [AddCancelCommMonoid M] {w : σ → M} {n n' : M} {i : σ}
(h : φ.IsWeightedHomogeneous w n) (h' : n' + w i = n) :
(pderiv i φ).IsWeightedHomogeneous w n' := by
rw [← mem_weightedHomogeneousSubmodule, weightedHomogeneousSubmodule_eq_finsupp_supported,
Finsupp.supported_eq_span_single] at h
refine Submodule.span_induction ?_ ?_ (fun p q _ _ hp hq ↦ ?_) (fun r p _ h ↦ ?_) h
· rintro _ ⟨m, hm, rfl⟩
simp_rw [single_eq_monomial, pderiv_monomial, one_mul]
by_cases hi : m i = 0
· rw [hi, Nat.cast_zero, monomial_zero]; apply isWeightedHomogeneous_zero
convert isWeightedHomogeneous_monomial ..
rw [← add_right_cancel_iff (a := w i), h', ← hm, weight_sub_single_add hi]
· rw [map_zero]; apply isWeightedHomogeneous_zero
· rw [map_add]; exact hp.add hq
· rw [(pderiv i).map_smul]; exact (weightedHomogeneousSubmodule ..).smul_mem _ h | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.RingTheory.MvPolynomial.Homogeneous"
] | Mathlib/RingTheory/MvPolynomial/EulerIdentity.lean | IsWeightedHomogeneous.pderiv | null |
protected IsHomogeneous.pderiv {n : ℕ} {i : σ} (h : φ.IsHomogeneous n) :
(pderiv i φ).IsHomogeneous (n - 1) := by
obtain _ | n := n
· rw [← totalDegree_zero_iff_isHomogeneous, totalDegree_eq_zero_iff_eq_C] at h
rw [h, pderiv_C]; apply isHomogeneous_zero
· exact IsWeightedHomogeneous.pderiv h rfl
variable [Fintype σ] {n : ℕ}
open Finset in | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.RingTheory.MvPolynomial.Homogeneous"
] | Mathlib/RingTheory/MvPolynomial/EulerIdentity.lean | IsHomogeneous.pderiv | null |
IsWeightedHomogeneous.sum_weight_X_mul_pderiv {w : σ → ℕ}
(h : φ.IsWeightedHomogeneous w n) : ∑ i : σ, w i • (X i * pderiv i φ) = n • φ := by
rw [← mem_weightedHomogeneousSubmodule, weightedHomogeneousSubmodule_eq_finsupp_supported,
supported_eq_span_single] at h
refine Submodule.span_induction ?_ ?_ (fun p q _ _ hp hq ↦ ?_) (fun r p _ h ↦ ?_) h
· rintro _ ⟨m, hm, rfl⟩
simp_rw [single_eq_monomial, X_mul_pderiv_monomial, smul_smul, ← sum_smul, mul_comm (w _)]
congr
rwa [Set.mem_setOf, weight_apply, sum_fintype] at hm
intro; apply zero_smul
· simp
· simp_rw [map_add, left_distrib, smul_add, sum_add_distrib, hp, hq]
· simp_rw [(pderiv _).map_smul, nsmul_eq_mul, mul_smul_comm, ← Finset.smul_sum, ← nsmul_eq_mul, h] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.RingTheory.MvPolynomial.Homogeneous"
] | Mathlib/RingTheory/MvPolynomial/EulerIdentity.lean | IsWeightedHomogeneous.sum_weight_X_mul_pderiv | Euler's identity for weighted homogeneous polynomials. |
IsHomogeneous.sum_X_mul_pderiv (h : φ.IsHomogeneous n) :
∑ i : σ, X i * pderiv i φ = n • φ := by
simp_rw [← h.sum_weight_X_mul_pderiv, Pi.one_apply, one_smul] | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.PDeriv",
"Mathlib.RingTheory.MvPolynomial.Homogeneous"
] | Mathlib/RingTheory/MvPolynomial/EulerIdentity.lean | IsHomogeneous.sum_X_mul_pderiv | Euler's identity for homogeneous polynomials. |
genericPolyMap (monoms : ι → Finset (κ →₀ ℕ)) :
ι → FreeCommRing ((Σ i : ι, monoms i) ⊕ κ) :=
fun i => (monoms i).attach.sum
(fun m => FreeCommRing.of (Sum.inl ⟨i, m⟩) *
Finsupp.prod m.1 (fun j n => FreeCommRing.of (Sum.inr j)^ n)) | def | RingTheory | [
"Mathlib.RingTheory.FreeCommRing"
] | Mathlib/RingTheory/MvPolynomial/FreeCommRing.lean | genericPolyMap | Given a finite set of monomials `monoms : ι → Finset (κ →₀ ℕ)`, the
`genericPolyMap monoms` is an indexed collection of elements of the `FreeCommRing`,
that can be evaluated to any collection `p : ι → MvPolynomial κ R` of
polynomials such that `∀ i, (p i).support ⊆ monoms i`. |
noncomputable mvPolynomialSupportLEEquiv
[DecidableEq κ] [CommRing R] [DecidableEq R]
(monoms : ι → Finset (κ →₀ ℕ)) :
{ p : ι → MvPolynomial κ R // ∀ i, (p i).support ⊆ monoms i } ≃
((Σ i, monoms i) → R) :=
{ toFun := fun p i => (p.1 i.1).coeff i.2,
invFun := fun p => ⟨fun i =>
{ toFun := fun m => if hm : m ∈ monoms i then p ⟨i, ⟨m, hm⟩⟩ else 0
support := {m ∈ monoms i | ∃ hm : m ∈ monoms i, p ⟨i, ⟨m, hm⟩⟩ ≠ 0},
mem_support_toFun := by simp },
fun i => Finset.filter_subset _ _⟩,
left_inv := fun p => by
ext i m
simp only [coeff, ne_eq, exists_prop, dite_eq_ite, Finsupp.coe_mk, ite_eq_left_iff]
intro hm
have : m ∉ (p.1 i).support := fun h => hm (p.2 i h)
simpa [coeff, eq_comm, MvPolynomial.mem_support_iff] using this
right_inv := fun p => by ext; simp [coeff] }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.FreeCommRing"
] | Mathlib/RingTheory/MvPolynomial/FreeCommRing.lean | mvPolynomialSupportLEEquiv | Collections of `MvPolynomial`s, `p : ι → MvPolynomial κ R` such
that `∀ i, (p i).support ⊆ monoms i` can be identified with functions
`(Σ i, monoms i) → R` by using the coefficient function |
MvPolynomialSupportLEEquiv_symm_apply_coeff [DecidableEq κ] [CommRing R] [DecidableEq R]
(p : ι → MvPolynomial κ R) : (mvPolynomialSupportLEEquiv (fun i => (p i).support)).symm
(fun i => (p i.1).coeff i.2.1) = ⟨p, fun _ => Finset.Subset.refl _⟩ :=
(mvPolynomialSupportLEEquiv (R := R) (fun i : ι => (p i).support)).symm_apply_apply
⟨p, fun _ => Finset.Subset.refl _⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.FreeCommRing"
] | Mathlib/RingTheory/MvPolynomial/FreeCommRing.lean | MvPolynomialSupportLEEquiv_symm_apply_coeff | null |
lift_genericPolyMap [DecidableEq κ] [CommRing R]
[DecidableEq R] (monoms : ι → Finset (κ →₀ ℕ))
(f : (i : ι) × { x // x ∈ monoms i } ⊕ κ → R) (i : ι) :
FreeCommRing.lift f (genericPolyMap monoms i) =
MvPolynomial.eval (f ∘ Sum.inr)
(((mvPolynomialSupportLEEquiv monoms).symm
(f ∘ Sum.inl)).1 i) := by
simp only [genericPolyMap, map_sum, map_mul, lift_of, support,
mvPolynomialSupportLEEquiv, coeff, Finset.sum_filter, MvPolynomial.eval_eq,
ne_eq, Function.comp, Equiv.coe_fn_symm_mk, Finsupp.coe_mk]
conv_rhs => rw [← Finset.sum_attach]
refine Finset.sum_congr rfl ?_
intro m _
simp only [Finsupp.prod, map_prod, map_pow, lift_of, Subtype.coe_eta, Finset.coe_mem,
exists_prop, true_and, dite_eq_ite, ite_true, ite_not]
split_ifs with h0 <;> simp_all | theorem | RingTheory | [
"Mathlib.RingTheory.FreeCommRing"
] | Mathlib/RingTheory/MvPolynomial/FreeCommRing.lean | lift_genericPolyMap | null |
noncomputable subLTerm (f : MvPolynomial σ R) : MvPolynomial σ R :=
f - monomial (m.degree f) (m.leadingCoeff f) | def | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | subLTerm | Delete the leading term in a multivariate polynomial (for some monomial order) |
degree_sub_LTerm_le (f : MvPolynomial σ R) :
m.degree (m.subLTerm f) ≼[m] m.degree f := by
apply le_trans degree_sub_le
simp only [sup_le_iff, le_refl, true_and]
apply degree_monomial_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.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | degree_sub_LTerm_le | null |
degree_sub_LTerm_lt {f : MvPolynomial σ R} (hf : m.degree f ≠ 0) :
m.degree (m.subLTerm f) ≺[m] m.degree f := by
rw [lt_iff_le_and_ne]
refine ⟨degree_sub_LTerm_le f, ?_⟩
classical
intro hf'
simp only [EmbeddingLike.apply_eq_iff_eq] at hf'
have : m.subLTerm f ≠ 0 := by
intro h
simp only [h, degree_zero] at hf'
exact hf hf'.symm
rw [← coeff_degree_ne_zero_iff (m := m), hf'] at this
apply this
simp [subLTerm, coeff_monomial, leadingCoeff]
variable (m) in | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | degree_sub_LTerm_lt | null |
noncomputable
reduce {b : MvPolynomial σ R} (hb : IsUnit (m.leadingCoeff b)) (f : MvPolynomial σ R) :
MvPolynomial σ R :=
f - monomial (m.degree f - m.degree b) (hb.unit⁻¹ * m.leadingCoeff f) * b | def | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | reduce | Reduce a polynomial modulo a polynomial with unit leading term (for some monomial order) |
degree_reduce_lt {f b : MvPolynomial σ R} (hb : IsUnit (m.leadingCoeff b))
(hbf : m.degree b ≤ m.degree f) (hf : m.degree f ≠ 0) :
m.degree (m.reduce hb f) ≺[m] m.degree f := by
have H : m.degree f =
m.degree ((monomial (m.degree f - m.degree b)) (hb.unit⁻¹ * m.leadingCoeff f)) +
m.degree b := by
classical
rw [degree_monomial, if_neg]
· ext d
rw [tsub_add_cancel_of_le hbf]
· simp only [Units.mul_right_eq_zero, leadingCoeff_eq_zero_iff]
intro hf0
apply hf
simp [hf0]
have H' : coeff (m.degree f) (m.reduce hb f) = 0 := by
simp only [reduce, coeff_sub, sub_eq_zero]
nth_rewrite 2 [H]
rw [coeff_mul_of_degree_add (m := m), leadingCoeff_monomial, mul_comm, ← mul_assoc,
IsUnit.mul_val_inv, one_mul, ← leadingCoeff]
rw [lt_iff_le_and_ne]
constructor
· classical
apply le_trans degree_sub_le
simp only [sup_le_iff, le_refl, true_and]
apply le_of_le_of_eq degree_mul_le
rw [m.toSyn.injective.eq_iff]
exact H.symm
· intro K
simp only [EmbeddingLike.apply_eq_iff_eq] at K
nth_rewrite 1 [← K] at H'
rw [← leadingCoeff, leadingCoeff_eq_zero_iff] at H'
rw [H', degree_zero] at K
exact hf K.symm | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | degree_reduce_lt | null |
div {ι : Type*} {b : ι → MvPolynomial σ R}
(hb : ∀ i, IsUnit (m.leadingCoeff (b i))) (f : MvPolynomial σ R) :
∃ (g : ι →₀ (MvPolynomial σ R)) (r : MvPolynomial σ R),
f = Finsupp.linearCombination _ b g + r ∧
(∀ i, m.degree (b i * (g i)) ≼[m] m.degree f) ∧
(∀ c ∈ r.support, ∀ i, ¬ (m.degree (b i) ≤ c)) := by
by_cases hb' : ∃ i, m.degree (b i) = 0
· obtain ⟨i, hb0⟩ := hb'
use Finsupp.single i ((hb i).unit⁻¹ • f), 0
constructor
· simp only [Finsupp.linearCombination_single, smul_eq_mul, add_zero]
simp only [smul_mul_assoc, ← smul_eq_iff_eq_inv_smul, Units.smul_isUnit]
nth_rewrite 2 [eq_C_of_degree_eq_zero hb0]
rw [mul_comm, smul_eq_C_mul]
constructor
· intro j
by_cases hj : j = i
· apply le_trans degree_mul_le
simp only [hj, hb0, Finsupp.single_eq_same, zero_add]
apply le_of_eq
simp only [EmbeddingLike.apply_eq_iff_eq]
apply degree_smul (Units.isRegular _)
· simp only [Finsupp.single_eq_of_ne hj, mul_zero, degree_zero, map_zero]
apply bot_le
· simp
push_neg at hb'
by_cases hf0 : f = 0
· refine ⟨0, 0, by simp [hf0], ?_, by simp⟩
intro b
simp only [Finsupp.coe_zero, Pi.zero_apply, mul_zero, degree_zero, map_zero]
exact bot_le
by_cases hf : ∃ i, m.degree (b i) ≤ m.degree f
· obtain ⟨i, hf⟩ := hf
have deg_reduce : m.degree (m.reduce (hb i) f) ≺[m] m.degree f := by
apply degree_reduce_lt (hb i) hf
intro hf0'
apply hb' i
simpa [hf0'] using hf
obtain ⟨g', r', H'⟩ := div hb (m.reduce (hb i) f)
use g' +
Finsupp.single i (monomial (m.degree f - m.degree (b i)) ((hb i).unit⁻¹ * m.leadingCoeff f))
use r'
constructor
· rw [map_add, add_assoc, add_comm _ r', ← add_assoc, ← H'.1]
simp [reduce]
constructor
· rintro j
simp only [Finsupp.coe_add, Pi.add_apply]
rw [mul_add]
apply le_trans degree_add_le
simp only [sup_le_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.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | div | Division by a family of multivariate polynomials
whose leading coefficients are invertible with respect to a monomial order |
div_set {B : Set (MvPolynomial σ R)}
(hB : ∀ b ∈ B, IsUnit (m.leadingCoeff b)) (f : MvPolynomial σ R) :
∃ (g : B →₀ (MvPolynomial σ R)) (r : MvPolynomial σ R),
f = Finsupp.linearCombination _ (fun (b : B) ↦ (b : MvPolynomial σ R)) g + r ∧
(∀ (b : B), m.degree ((b : MvPolynomial σ R) * (g b)) ≼[m] m.degree f) ∧
(∀ c ∈ r.support, ∀ b ∈ B, ¬ (m.degree b ≤ c)) := by
obtain ⟨g, r, H⟩ := m.div (b := fun (p : B) ↦ p) (fun b ↦ hB b b.prop) f
exact ⟨g, r, H.1, H.2.1, fun c hc b hb ↦ H.2.2 c hc ⟨b, 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.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | div_set | Division by a *set* of multivariate polynomials
whose leading coefficients are invertible with respect to a monomial order |
div_single {b : MvPolynomial σ R}
(hb : IsUnit (m.leadingCoeff b)) (f : MvPolynomial σ R) :
∃ (g : MvPolynomial σ R) (r : MvPolynomial σ R),
f = g * b + r ∧
(m.degree (b * g) ≼[m] m.degree f) ∧
(∀ c ∈ r.support, ¬ (m.degree b ≤ c)) := by
obtain ⟨g, r, hgr, h1, h2⟩ := div_set (B := {b}) (m := m) (by simp [hb]) f
specialize h1 ⟨b, by simp⟩
set q := g ⟨b, by simp⟩
simp only [Set.mem_singleton_iff, forall_eq] at h2
simp only at h1
refine ⟨q, r, ?_, h1, h2⟩
rw [hgr]
simp only [Finsupp.linearCombination, Finsupp.coe_lsum, LinearMap.coe_smulRight, LinearMap.id_coe,
id_eq, smul_eq_mul, add_left_inj]
rw [Finsupp.sum_eq_single ⟨b, by simp⟩ _ (by simp)]
simp +contextual | theorem | RingTheory | [
"Mathlib.Data.Finsupp.Lex",
"Mathlib.Data.Finsupp.MonomialOrder",
"Mathlib.Data.Finsupp.WellFounded",
"Mathlib.Data.List.TFAE",
"Mathlib.RingTheory.MvPolynomial.Homogeneous",
"Mathlib.RingTheory.MvPolynomial.MonomialOrder"
] | Mathlib/RingTheory/MvPolynomial/Groebner.lean | div_single | Division by a multivariate polynomial
whose leading coefficient is invertible with respect to a monomial order |
IsHomogeneous [CommSemiring R] (φ : MvPolynomial σ R) (n : ℕ) :=
IsWeightedHomogeneous 1 φ n
variable [CommSemiring R] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | IsHomogeneous | A multivariate polynomial `φ` is homogeneous of degree `n`
if all monomials occurring in `φ` have degree `n`. |
weightedTotalDegree_one (φ : MvPolynomial σ R) :
weightedTotalDegree (1 : σ → ℕ) φ = φ.totalDegree := by
simp only [totalDegree, weightedTotalDegree, weight, LinearMap.toAddMonoidHom_coe,
linearCombination, Pi.one_apply, Finsupp.coe_lsum, LinearMap.coe_smulRight, LinearMap.id_coe,
id, Algebra.id.smul_eq_mul, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | weightedTotalDegree_one | null |
weightedTotalDegree_rename_of_injective {σ τ : Type*} {e : σ → τ}
{w : τ → ℕ} {P : MvPolynomial σ R} (he : Function.Injective e) :
weightedTotalDegree w (rename e P) = weightedTotalDegree (w ∘ e) P := by
classical
unfold weightedTotalDegree
rw [support_rename_of_injective he, Finset.sup_image]
congr; ext; unfold weight; simp
variable (σ R) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | weightedTotalDegree_rename_of_injective | null |
homogeneousSubmodule (n : ℕ) : Submodule R (MvPolynomial σ R) where
carrier := { x | x.IsHomogeneous n }
smul_mem' r a ha c hc := by
rw [coeff_smul] at hc
apply ha
intro h
apply hc
rw [h]
exact smul_zero r
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.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousSubmodule | The submodule of homogeneous `MvPolynomial`s of degree `n`. |
weightedHomogeneousSubmodule_one (n : ℕ) :
weightedHomogeneousSubmodule R 1 n = homogeneousSubmodule σ R n := rfl
variable {σ R}
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | weightedHomogeneousSubmodule_one | null |
mem_homogeneousSubmodule (n : ℕ) (p : MvPolynomial σ R) :
p ∈ homogeneousSubmodule σ R n ↔ p.IsHomogeneous n := Iff.rfl
variable (σ R) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | mem_homogeneousSubmodule | null |
homogeneousSubmodule_eq_finsupp_supported (n : ℕ) :
homogeneousSubmodule σ R n = Finsupp.supported _ R { d | d.degree = n } := by
simp_rw [degree_eq_weight_one]
exact weightedHomogeneousSubmodule_eq_finsupp_supported R 1 n
variable {σ R} | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousSubmodule_eq_finsupp_supported | While equal, the former has a convenient definitional reduction. |
homogeneousSubmodule_mul (m n : ℕ) :
homogeneousSubmodule σ R m * homogeneousSubmodule σ R n ≤ homogeneousSubmodule σ R (m + n) :=
weightedHomogeneousSubmodule_mul 1 m n | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousSubmodule_mul | null |
isHomogeneous_monomial {d : σ →₀ ℕ} (r : R) {n : ℕ} (hn : d.degree = n) :
IsHomogeneous (monomial d r) n := by
rw [degree_eq_weight_one] at hn
exact isWeightedHomogeneous_monomial 1 d r hn
variable (σ) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | isHomogeneous_monomial | null |
totalDegree_eq_zero_iff (p : MvPolynomial σ R) :
p.totalDegree = 0 ↔ ∀ (m : σ →₀ ℕ) (_ : m ∈ p.support) (x : σ), m x = 0 := by
rw [← weightedTotalDegree_one, weightedTotalDegree_eq_zero_iff _ p]
exact nonTorsionWeight_of (Function.const σ one_ne_zero) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | totalDegree_eq_zero_iff | null |
totalDegree_zero_iff_isHomogeneous {p : MvPolynomial σ R} :
p.totalDegree = 0 ↔ IsHomogeneous p 0 := by
rw [← weightedTotalDegree_one,
← isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero, IsHomogeneous]
alias ⟨isHomogeneous_of_totalDegree_zero, _⟩ := totalDegree_zero_iff_isHomogeneous | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | totalDegree_zero_iff_isHomogeneous | null |
isHomogeneous_C (r : R) : IsHomogeneous (C r : MvPolynomial σ R) 0 := by
apply isHomogeneous_monomial
simp only [Finsupp.degree, Finsupp.zero_apply, Finset.sum_const_zero]
variable (R) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | isHomogeneous_C | null |
isHomogeneous_zero (n : ℕ) : IsHomogeneous (0 : MvPolynomial σ R) n :=
(homogeneousSubmodule σ R n).zero_mem | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | isHomogeneous_zero | null |
isHomogeneous_one : IsHomogeneous (1 : MvPolynomial σ R) 0 :=
isHomogeneous_C _ _
variable {σ} | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | isHomogeneous_one | null |
isHomogeneous_X (i : σ) : IsHomogeneous (X i : MvPolynomial σ R) 1 := by
apply isHomogeneous_monomial
rw [Finsupp.degree, Finsupp.support_single_ne_zero _ one_ne_zero, Finset.sum_singleton]
exact Finsupp.single_eq_same | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | isHomogeneous_X | null |
coeff_eq_zero (hφ : IsHomogeneous φ n) {d : σ →₀ ℕ} (hd : d.degree ≠ n) :
coeff d φ = 0 := by
rw [degree_eq_weight_one] at hd
exact IsWeightedHomogeneous.coeff_eq_zero hφ d hd | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | coeff_eq_zero | null |
inj_right (hm : IsHomogeneous φ m) (hn : IsHomogeneous φ n) (hφ : φ ≠ 0) : m = n := by
obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
rw [← hm hd, ← hn hd] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | inj_right | null |
add (hφ : IsHomogeneous φ n) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ + ψ) n :=
(homogeneousSubmodule σ R n).add_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | add | null |
sum {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : ℕ)
(h : ∀ i ∈ s, IsHomogeneous (φ i) n) : IsHomogeneous (∑ i ∈ s, φ i) n :=
(homogeneousSubmodule σ R n).sum_mem h | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | sum | null |
mul (hφ : IsHomogeneous φ m) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ * ψ) (m + n) :=
homogeneousSubmodule_mul m n <| Submodule.mul_mem_mul hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | mul | null |
prod {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : ι → ℕ)
(h : ∀ i ∈ s, IsHomogeneous (φ i) (n i)) : IsHomogeneous (∏ i ∈ s, φ i) (∑ i ∈ s, n i) := by
classical
revert h
refine Finset.induction_on s ?_ ?_
· intro
simp only [isHomogeneous_one, Finset.sum_empty, Finset.prod_empty]
· intro i s his IH h
simp only [his, Finset.prod_insert, Finset.sum_insert, not_false_iff]
apply (h i (by grind)).mul (IH _)
grind | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | prod | null |
C_mul (hφ : φ.IsHomogeneous m) (r : R) :
(C r * φ).IsHomogeneous m := by
simpa only [zero_add] using (isHomogeneous_C _ _).mul hφ | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | C_mul | null |
_root_.MvPolynomial.isHomogeneous_C_mul_X (r : R) (i : σ) :
(C r * X i).IsHomogeneous 1 :=
(isHomogeneous_X _ _).C_mul _ | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | _root_.MvPolynomial.isHomogeneous_C_mul_X | null |
pow (hφ : φ.IsHomogeneous m) (n : ℕ) : (φ ^ n).IsHomogeneous (m * n) := by
rw [show φ ^ n = ∏ _i ∈ Finset.range n, φ by simp]
rw [show m * n = ∑ _i ∈ Finset.range n, m by simp [mul_comm]]
apply IsHomogeneous.prod _ _ _ (fun _ _ ↦ hφ) | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | pow | null |
_root_.MvPolynomial.isHomogeneous_X_pow (i : σ) (n : ℕ) :
(X (R := R) i ^ n).IsHomogeneous n := by
simpa only [one_mul] using (isHomogeneous_X _ _).pow n | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | _root_.MvPolynomial.isHomogeneous_X_pow | null |
_root_.MvPolynomial.isHomogeneous_C_mul_X_pow (r : R) (i : σ) (n : ℕ) :
(C r * X i ^ n).IsHomogeneous n :=
(isHomogeneous_X_pow _ _).C_mul _ | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | _root_.MvPolynomial.isHomogeneous_C_mul_X_pow | null |
eval₂ (hφ : φ.IsHomogeneous m) (f : R →+* MvPolynomial τ S) (g : σ → MvPolynomial τ S)
(hf : ∀ r, (f r).IsHomogeneous 0) (hg : ∀ i, (g i).IsHomogeneous n) :
(eval₂ f g φ).IsHomogeneous (n * m) := by
apply IsHomogeneous.sum
intro i hi
rw [← zero_add (n * m)]
apply IsHomogeneous.mul (hf _) _
convert IsHomogeneous.prod _ _ (fun k ↦ n * i k) _
· rw [Finsupp.mem_support_iff] at hi
rw [← Finset.mul_sum, ← hφ hi, weight_apply]
simp_rw [smul_eq_mul, Finsupp.sum, Pi.one_apply, mul_one]
· rintro k -
apply (hg k).pow | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | eval₂ | null |
map (hφ : φ.IsHomogeneous n) (f : R →+* S) : (map f φ).IsHomogeneous n := by
simpa only [one_mul] using hφ.eval₂ _ _ (fun r ↦ isHomogeneous_C _ (f r)) (isHomogeneous_X _) | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | map | null |
aeval [Algebra R S] (hφ : φ.IsHomogeneous m)
(g : σ → MvPolynomial τ S) (hg : ∀ i, (g i).IsHomogeneous n) :
(aeval g φ).IsHomogeneous (n * m) :=
hφ.eval₂ _ _ (fun _ ↦ isHomogeneous_C _ _) hg | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | aeval | null |
neg (hφ : IsHomogeneous φ n) : IsHomogeneous (-φ) n :=
(homogeneousSubmodule σ R n).neg_mem hφ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | neg | null |
sub (hφ : IsHomogeneous φ n) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ - ψ) n :=
(homogeneousSubmodule σ R n).sub_mem hφ hψ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | sub | null |
totalDegree_le (hφ : IsHomogeneous φ n) : φ.totalDegree ≤ n := by
apply Finset.sup_le
intro d hd
rw [mem_support_iff] at hd
simp_rw [Finsupp.sum, ← hφ hd, weight_apply, Pi.one_apply, smul_eq_mul, mul_one, Finsupp.sum,
le_rfl] | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | totalDegree_le | The homogeneous degree bounds the total degree.
See also `MvPolynomial.IsHomogeneous.totalDegree` when `φ` is non-zero. |
totalDegree (hφ : IsHomogeneous φ n) (h : φ ≠ 0) : totalDegree φ = n := by
apply le_antisymm hφ.totalDegree_le
obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero h
simp only [← hφ hd, MvPolynomial.totalDegree, Finsupp.sum]
replace hd := Finsupp.mem_support_iff.mpr hd
simp only [weight_apply, Pi.one_apply, smul_eq_mul, mul_one]
exact Finset.le_sup (f := fun s ↦ ∑ x ∈ s.support, s x) hd | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | totalDegree | null |
rename_isHomogeneous {f : σ → τ} (h : φ.IsHomogeneous n) :
(rename f φ).IsHomogeneous n := by
rw [← φ.support_sum_monomial_coeff, map_sum]; simp_rw [rename_monomial]
apply IsHomogeneous.sum _ _ _ fun d hd ↦ isHomogeneous_monomial _ _
intro d hd
apply (Finsupp.sum_mapDomain_index_addMonoidHom fun _ ↦ .id ℕ).trans
convert h (mem_support_iff.mp hd)
simp only [weight_apply, AddMonoidHom.id_apply, Pi.one_apply, smul_eq_mul, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | rename_isHomogeneous | null |
rename_isHomogeneous_iff {f : σ → τ} (hf : f.Injective) :
(rename f φ).IsHomogeneous n ↔ φ.IsHomogeneous n := by
refine ⟨fun h d hd ↦ ?_, rename_isHomogeneous⟩
convert ← @h (d.mapDomain f) _
· simp only [weight_apply, Pi.one_apply, smul_eq_mul, mul_one]
exact Finsupp.sum_mapDomain_index_inj (h := fun _ ↦ id) hf
· rwa [coeff_rename_mapDomain f hf] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | rename_isHomogeneous_iff | null |
finSuccEquiv_coeff_isHomogeneous {N : ℕ} {φ : MvPolynomial (Fin (N + 1)) R} {n : ℕ}
(hφ : φ.IsHomogeneous n) (i j : ℕ) (h : i + j = n) :
((finSuccEquiv _ _ φ).coeff i).IsHomogeneous j := by
intro d hd
rw [finSuccEquiv_coeff_coeff] at hd
have h' : (weight 1) (Finsupp.cons i d) = i + j := by
simpa [Finset.sum_subset_zero_on_sdiff (g := d.cons i)
(d.cons_support (y := i)) (by simp) (fun _ _ ↦ rfl), ← h] using hφ hd
simp only [weight_apply, Pi.one_apply, smul_eq_mul, mul_one, Finsupp.sum_cons,
add_right_inj] at h' ⊢
exact h' | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | finSuccEquiv_coeff_isHomogeneous | null |
coeff_isHomogeneous_of_optionEquivLeft_symm
[hσ : Finite σ] {p : Polynomial (MvPolynomial σ R)}
(hp : ((optionEquivLeft R σ).symm p).IsHomogeneous n) (i j : ℕ) (h : i + j = n) :
(p.coeff i).IsHomogeneous j := by
obtain ⟨k, ⟨e⟩⟩ := Finite.exists_equiv_fin σ
let e' := e.optionCongr.trans (_root_.finSuccEquiv _).symm
let F := renameEquiv R e
let F' := renameEquiv R e'
let φ := F' ((optionEquivLeft R σ).symm p)
have hφ : φ.IsHomogeneous n := hp.rename_isHomogeneous
suffices IsHomogeneous (F (p.coeff i)) j by
rwa [← (IsHomogeneous.rename_isHomogeneous_iff e.injective)]
convert hφ.finSuccEquiv_coeff_isHomogeneous i j h using 1
dsimp only [φ, F', F, renameEquiv_apply]
rw [finSuccEquiv_rename_finSuccEquiv, AlgEquiv.apply_symm_apply]
simp
open Polynomial in | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | coeff_isHomogeneous_of_optionEquivLeft_symm | null |
private
exists_eval_ne_zero_of_coeff_finSuccEquiv_ne_zero_aux
{N : ℕ} {F : MvPolynomial (Fin (Nat.succ N)) R} {n : ℕ} (hF : IsHomogeneous F n)
(hFn : ((finSuccEquiv R N) F).coeff n ≠ 0) :
∃ r, eval r F ≠ 0 := by
have hF₀ : F ≠ 0 := by contrapose! hFn; simp [hFn]
have hdeg : natDegree (finSuccEquiv R N F) < n + 1 := by
linarith [natDegree_finSuccEquiv F, degreeOf_le_totalDegree F 0, hF.totalDegree hF₀]
use Fin.cons 1 0
have aux : ∀ i ∈ Finset.range n, constantCoeff ((finSuccEquiv R N F).coeff i) = 0 := by
intro i hi
rw [Finset.mem_range] at hi
apply (hF.finSuccEquiv_coeff_isHomogeneous i (n-i) (by cutsat)).coeff_eq_zero
simp only [Finsupp.degree_zero]
rw [← Nat.sub_ne_zero_iff_lt] at hi
exact hi.symm
simp_rw [eval_eq_eval_mv_eval', eval_one_map, Polynomial.eval_eq_sum_range' hdeg,
eval_zero, one_pow, mul_one, map_sum, Finset.sum_range_succ, Finset.sum_eq_zero aux, zero_add]
contrapose! hFn
ext d
rw [coeff_zero]
obtain rfl | hd := eq_or_ne d 0
· apply hFn
· contrapose! hd
ext i
rw [Finsupp.coe_zero, Pi.zero_apply]
by_cases hi : i ∈ d.support
· have := hF.finSuccEquiv_coeff_isHomogeneous n 0 (add_zero _) hd
simp only [weight_apply, Pi.one_apply, smul_eq_mul, mul_one, Finsupp.sum] at this
rw [Finset.sum_eq_zero_iff_of_nonneg (fun _ _ ↦ zero_le')] at this
exact this i hi
· simpa using hi | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | exists_eval_ne_zero_of_coeff_finSuccEquiv_ne_zero_aux | null |
private
exists_eval_ne_zero_of_totalDegree_le_card_aux {N : ℕ} {F : MvPolynomial (Fin N) R} {n : ℕ}
(hF : F.IsHomogeneous n) (hF₀ : F ≠ 0) (hnR : n ≤ #R) :
∃ r, eval r F ≠ 0 := by
induction N generalizing n with
| zero =>
use 0
contrapose! hF₀
ext d
simpa only [Subsingleton.elim d 0, eval_zero, coeff_zero] using hF₀
| succ N IH =>
have hdeg : natDegree (finSuccEquiv R N F) < n + 1 := by
linarith [natDegree_finSuccEquiv F, degreeOf_le_totalDegree F 0, hF.totalDegree hF₀]
obtain ⟨i, hi⟩ : ∃ i : ℕ, (finSuccEquiv R N F).coeff i ≠ 0 := by
contrapose! hF₀
exact (finSuccEquiv _ _).injective <| Polynomial.ext <| by simpa using hF₀
have hin : i ≤ n := by
contrapose! hi
exact coeff_eq_zero_of_natDegree_lt <| (Nat.le_of_lt_succ hdeg).trans_lt hi
obtain hFn | hFn := ne_or_eq ((finSuccEquiv R N F).coeff n) 0
· exact hF.exists_eval_ne_zero_of_coeff_finSuccEquiv_ne_zero_aux hFn
have hin : i < n := hin.lt_or_eq.elim id <| by aesop
obtain ⟨j, hj⟩ : ∃ j, i + (j + 1) = n := (Nat.exists_eq_add_of_lt hin).imp <| by cutsat
obtain ⟨r, hr⟩ : ∃ r, (eval r) (Polynomial.coeff ((finSuccEquiv R N) F) i) ≠ 0 :=
IH (hF.finSuccEquiv_coeff_isHomogeneous _ _ hj) hi (.trans (by norm_cast; cutsat) hnR)
set φ : R[X] := Polynomial.map (eval r) (finSuccEquiv _ _ F) with hφ
have hφ₀ : φ ≠ 0 := fun hφ₀ ↦ hr <| by
rw [← coeff_eval_eq_eval_coeff, ← hφ, hφ₀, Polynomial.coeff_zero]
have hφR : φ.natDegree < #R := by
refine lt_of_lt_of_le ?_ hnR
norm_cast
refine lt_of_le_of_lt natDegree_map_le ?_
suffices (finSuccEquiv _ _ F).natDegree ≠ n by cutsat
rintro rfl
refine leadingCoeff_ne_zero.mpr ?_ hFn
simpa using (finSuccEquiv R N).injective.ne hF₀
obtain ⟨r₀, hr₀⟩ : ∃ r₀, Polynomial.eval r₀ φ ≠ 0 :=
φ.exists_eval_ne_zero_of_natDegree_lt_card hφ₀ hφR
use Fin.cons r₀ r
rwa [eval_eq_eval_mv_eval'] | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | exists_eval_ne_zero_of_totalDegree_le_card_aux | null |
eq_zero_of_forall_eval_eq_zero_of_le_card
(hF : F.IsHomogeneous n) (h : ∀ r : σ → R, eval r F = 0) (hnR : n ≤ #R) :
F = 0 := by
contrapose! h
obtain ⟨k, f, hf, F, rfl⟩ := exists_fin_rename F
have hF₀ : F ≠ 0 := by rintro rfl; simp at h
have hF : F.IsHomogeneous n := by rwa [rename_isHomogeneous_iff hf] at hF
obtain ⟨r, hr⟩ := exists_eval_ne_zero_of_totalDegree_le_card_aux hF hF₀ hnR
obtain ⟨r, rfl⟩ := (Function.factorsThrough_iff _).mp <| (hf.factorsThrough r)
use r
rwa [eval_rename] | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | eq_zero_of_forall_eval_eq_zero_of_le_card | See `MvPolynomial.IsHomogeneous.eq_zero_of_forall_eval_eq_zero`
for a version that assumes `Infinite R`. |
funext_of_le_card (hF : F.IsHomogeneous n) (hG : G.IsHomogeneous n)
(h : ∀ r : σ → R, eval r F = eval r G) (hnR : n ≤ #R) :
F = G := by
rw [← sub_eq_zero]
apply eq_zero_of_forall_eval_eq_zero_of_le_card (hF.sub hG) _ hnR
simpa [sub_eq_zero] using h | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | funext_of_le_card | See `MvPolynomial.IsHomogeneous.funext`
for a version that assumes `Infinite R`. |
eq_zero_of_forall_eval_eq_zero [Infinite R] {F : MvPolynomial σ R} {n : ℕ}
(hF : F.IsHomogeneous n) (h : ∀ r : σ → R, eval r F = 0) : F = 0 := by
apply eq_zero_of_forall_eval_eq_zero_of_le_card hF h
exact (Cardinal.nat_lt_aleph0 _).le.trans <| Cardinal.infinite_iff.mp ‹Infinite R› | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | eq_zero_of_forall_eval_eq_zero | See `MvPolynomial.IsHomogeneous.eq_zero_of_forall_eval_eq_zero_of_le_card`
for a version that assumes `n ≤ #R`. |
funext [Infinite R] {F G : MvPolynomial σ R} {n : ℕ}
(hF : F.IsHomogeneous n) (hG : G.IsHomogeneous n)
(h : ∀ r : σ → R, eval r F = eval r G) : F = G := by
apply funext_of_le_card hF hG h
exact (Cardinal.nat_lt_aleph0 _).le.trans <| Cardinal.infinite_iff.mp ‹Infinite R› | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | funext | See `MvPolynomial.IsHomogeneous.funext_of_le_card`
for a version that assumes `n ≤ #R`. |
HomogeneousSubmodule.gcommSemiring : SetLike.GradedMonoid (homogeneousSubmodule σ R) where
one_mem := isHomogeneous_one σ R
mul_mem _ _ _ _ := IsHomogeneous.mul | instance | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | HomogeneousSubmodule.gcommSemiring | The homogeneous submodules form a graded ring. This instance is used by `DirectSum.commSemiring`
and `DirectSum.algebra`. |
homogeneousComponent [CommSemiring R] (n : ℕ) : MvPolynomial σ R →ₗ[R] MvPolynomial σ R :=
weightedHomogeneousComponent 1 n | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent | `homogeneousComponent n φ` is the part of `φ` that is homogeneous of degree `n`.
See `sum_homogeneousComponent` for the statement that `φ` is equal to the sum
of all its homogeneous components. |
homogeneousComponent_mem :
homogeneousComponent n φ ∈ homogeneousSubmodule σ R n :=
weightedHomogeneousComponent_mem _ φ n | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_mem | null |
coeff_homogeneousComponent (d : σ →₀ ℕ) :
coeff d (homogeneousComponent n φ) = if d.degree = n then coeff d φ else 0 := by
rw [degree_eq_weight_one]
convert coeff_weightedHomogeneousComponent n φ d | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | coeff_homogeneousComponent | null |
homogeneousComponent_apply :
homogeneousComponent n φ = ∑ d ∈ φ.support with d.degree = n, monomial d (coeff d φ) := by
simp_rw [degree_eq_weight_one]
convert weightedHomogeneousComponent_apply n φ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_apply | null |
homogeneousComponent_isHomogeneous : (homogeneousComponent n φ).IsHomogeneous n :=
weightedHomogeneousComponent_isWeightedHomogeneous n φ
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_isHomogeneous | null |
homogeneousComponent_zero : homogeneousComponent 0 φ = C (coeff 0 φ) :=
weightedHomogeneousComponent_zero φ (fun _ => Nat.succ_ne_zero Nat.zero)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_zero | null |
homogeneousComponent_C_mul (n : ℕ) (r : R) :
homogeneousComponent n (C r * φ) = C r * homogeneousComponent n φ :=
weightedHomogeneousComponent_C_mul φ n r | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_C_mul | null |
homogeneousComponent_eq_zero'
(h : ∀ d : σ →₀ ℕ, d ∈ φ.support → d.degree ≠ n) :
homogeneousComponent n φ = 0 := by
simp_rw [degree_eq_weight_one] at h
exact weightedHomogeneousComponent_eq_zero' n φ h | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_eq_zero' | null |
homogeneousComponent_eq_zero (h : φ.totalDegree < n) : homogeneousComponent n φ = 0 := by
apply homogeneousComponent_eq_zero'
rw [totalDegree, Finset.sup_lt_iff (lt_of_le_of_lt (Nat.zero_le _) h)] at h
intro d hd; exact ne_of_lt (h d hd) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_eq_zero | null |
sum_homogeneousComponent :
(∑ i ∈ range (φ.totalDegree + 1), homogeneousComponent i φ) = φ := by
ext1 d
suffices φ.totalDegree < d.support.sum d → 0 = coeff d φ by
simpa [coeff_sum, coeff_homogeneousComponent]
exact fun h => (coeff_eq_zero_of_totalDegree_lt h).symm | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | sum_homogeneousComponent | null |
homogeneousComponent_of_mem {m n : ℕ} {p : MvPolynomial σ R}
(h : p ∈ homogeneousSubmodule σ R n) :
homogeneousComponent m p = if m = n then p else 0 :=
weightedHomogeneousComponent_of_mem h | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | homogeneousComponent_of_mem | null |
HomogeneousSubmodule.gradedMonoid :
SetLike.GradedMonoid (homogeneousSubmodule σ R) :=
WeightedHomogeneousSubmodule.gradedMonoid | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | HomogeneousSubmodule.gradedMonoid | The homogeneous submodules form a graded ring.
This instance is used by `DirectSum.commSemiring` and `DirectSum.algebra`. |
decomposition :
DirectSum.Decomposition (homogeneousSubmodule σ R) :=
weightedDecomposition R (1 : σ → ℕ) | abbrev | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | decomposition | The decomposition of `MvPolynomial σ R` into homogeneous submodules. |
gradedAlgebra : GradedAlgebra (homogeneousSubmodule σ R) :=
weightedGradedAlgebra R (1 : σ → ℕ) | abbrev | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | gradedAlgebra | `MvPolynomial σ R` as a graded algebra, graded by the degree.
We do not make this a global instance because one may want to consider a different
graded algebra structure on `MvPolynomial σ R`, induced by another weight function.
To make it a local instance, you may use
`attribute [local instance] MvPolynomial.gradedAlgebra`. |
decomposition.decompose'_apply (φ : MvPolynomial σ R) (i : ℕ) :
(decomposition.decompose' φ i : MvPolynomial σ R) = homogeneousComponent i φ :=
weightedDecomposition.decompose'_apply R _ φ i | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | decomposition.decompose'_apply | null |
decomposition.decompose'_eq :
decomposition.decompose' = fun φ : MvPolynomial σ R =>
DirectSum.mk (fun i : ℕ => ↥(homogeneousSubmodule σ R i)) (φ.support.image Finsupp.degree)
fun m => ⟨homogeneousComponent m φ, homogeneousComponent_mem m φ⟩ := by
rw [degree_eq_weight_one]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.GradedMonoid",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.MvPolynomial.Equiv",
"Mathlib.Algebra.MvPolynomial.Variables",
"Mathlib.Algebra.Polynomial.Roots",
"Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous",
"Mathlib.SetTheory.C... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | decomposition.decompose'_eq | null |
mem_ideal_span_monomial_image {x : MvPolynomial σ R} {s : Set (σ →₀ ℕ)} :
x ∈ Ideal.span ((fun s => monomial s (1 : R)) '' s) ↔ ∀ xi ∈ x.support, ∃ si ∈ s, si ≤ xi := by
refine AddMonoidAlgebra.mem_ideal_span_of'_image.trans ?_
simp_rw [le_iff_exists_add, add_comm]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.MonoidAlgebra.Ideal",
"Mathlib.Algebra.MvPolynomial.Division"
] | Mathlib/RingTheory/MvPolynomial/Ideal.lean | mem_ideal_span_monomial_image | `x` is in a monomial ideal generated by `s` iff every element of its support dominates one of
the generators. Note that `si ≤ xi` is analogous to saying that the monomial corresponding to `si`
divides the monomial corresponding to `xi`. |
mem_ideal_span_monomial_image_iff_dvd {x : MvPolynomial σ R} {s : Set (σ →₀ ℕ)} :
x ∈ Ideal.span ((fun s => monomial s (1 : R)) '' s) ↔
∀ xi ∈ x.support, ∃ si ∈ s, monomial si 1 ∣ monomial xi (x.coeff xi) := by
refine mem_ideal_span_monomial_image.trans (forall₂_congr fun xi hxi => ?_)
simp_rw [monomial_dvd_monomial, one_dvd, and_true, mem_support_iff.mp hxi, false_or] | theorem | RingTheory | [
"Mathlib.Algebra.MonoidAlgebra.Ideal",
"Mathlib.Algebra.MvPolynomial.Division"
] | Mathlib/RingTheory/MvPolynomial/Ideal.lean | mem_ideal_span_monomial_image_iff_dvd | null |
mem_ideal_span_X_image {x : MvPolynomial σ R} {s : Set σ} :
x ∈ Ideal.span (MvPolynomial.X '' s : Set (MvPolynomial σ R)) ↔
∀ m ∈ x.support, ∃ i ∈ s, (m : σ →₀ ℕ) i ≠ 0 := by
have := @mem_ideal_span_monomial_image σ R _ x ((fun i => Finsupp.single i 1) '' s)
rw [Set.image_image] at this
refine this.trans ?_
simp [Nat.one_le_iff_ne_zero] | theorem | RingTheory | [
"Mathlib.Algebra.MonoidAlgebra.Ideal",
"Mathlib.Algebra.MvPolynomial.Division"
] | Mathlib/RingTheory/MvPolynomial/Ideal.lean | mem_ideal_span_X_image | `x` is in a monomial ideal generated by variables `X` iff every element of its support
has a component in `s`. |
isLocalization : IsLocalization (M.map <| C (σ := σ)) (MvPolynomial σ S) :=
isLocalizedModule_iff_isLocalization.mp <| (isLocalizedModule_iff_isBaseChange M S _).mpr <|
.of_equiv (algebraTensorAlgEquiv _ _).toLinearEquiv fun _ ↦ by simp | instance | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | isLocalization | If `S` is the localization of `R` at a submonoid `M`, then `MvPolynomial σ S`
is the localization of `MvPolynomial σ R` at `M.map MvPolynomial.C`.
See also `Polynomial.isLocalization` for the univariate case. |
isLocalization_C_mk' (a : R) (m : M) :
C (IsLocalization.mk' S a m) = IsLocalization.mk' (MvPolynomial σ S) (C (σ := σ) a)
⟨C m, Submonoid.mem_map_of_mem C m.property⟩ := by
simp_rw [IsLocalization.eq_mk'_iff_mul_eq, algebraMap_def, map_C, ← map_mul,
IsLocalization.mk'_spec] | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | isLocalization_C_mk' | null |
private noncomputable
auxHom : (MvPolynomial Unit R) ⧸ (Ideal.span { C r * X () - 1 }) →ₐ[R] S :=
Ideal.Quotient.liftₐ (Ideal.span { C r * X () - 1}) (aeval (fun _ ↦ invSelf r)) <| by
intro p hp
refine Submodule.span_induction ?_ ?_ ?_ ?_ hp
· rintro p ⟨q, rfl⟩
simp
· simp
· intro p q _ _ hp hq
simp [hp, hq]
· intro a x _ hx
simp [hx]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | auxHom | The canonical algebra map from `MvPolynomial Unit R` quotiented by
`C r * X () - 1` to the localization of `R` away from `r`. |
private auxHom_mk (p : MvPolynomial Unit R) :
auxHom S r p = aeval (S₁ := S) (fun _ ↦ invSelf r) p :=
rfl
private noncomputable | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | auxHom_mk | null |
auxInv : S →+* (MvPolynomial Unit R) ⧸ Ideal.span { C r * X () - 1 } :=
letI g : R →+* MvPolynomial Unit R ⧸ (Ideal.span { C r * X () - 1 }) :=
(Ideal.Quotient.mk _).comp C
IsLocalization.Away.lift (S := S) (g := g) r <| by
simp only [RingHom.coe_comp, Function.comp_apply, g]
rw [isUnit_iff_exists_inv]
use (Ideal.Quotient.mk _ <| X ())
rw [← map_mul, ← map_one (Ideal.Quotient.mk _), Ideal.Quotient.mk_eq_mk_iff_sub_mem]
exact Ideal.mem_span_singleton_self (C r * X () - 1) | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | auxInv | null |
private auxHom_auxInv : (auxHom S r).toRingHom.comp (auxInv S r) = RingHom.id S := by
apply IsLocalization.ringHom_ext (Submonoid.powers r)
ext x
simp [auxInv] | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | auxHom_auxInv | null |
private auxInv_auxHom : (auxInv S r).comp (auxHom (S := S) r).toRingHom = RingHom.id _ := by
rw [← RingHom.cancel_right (Ideal.Quotient.mk_surjective)]
ext x
· simp [auxInv]
· simp only [auxInv, AlgHom.toRingHom_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
Function.comp_apply, auxHom_mk, aeval_X, RingHomCompTriple.comp_eq, invSelf, Away.lift,
lift_mk'_spec]
simp only [map_one]
rw [← map_one (Ideal.Quotient.mk _), ← map_mul, Ideal.Quotient.mk_eq_mk_iff_sub_mem,
← Ideal.neg_mem_iff, neg_sub]
exact Ideal.mem_span_singleton_self (C r * X x - 1) | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | auxInv_auxHom | null |
noncomputable mvPolynomialQuotientEquiv :
((MvPolynomial Unit R) ⧸ Ideal.span { C r * X () - 1 }) ≃ₐ[R] S where
toFun := auxHom S r
invFun := auxInv S r
left_inv x := by
simpa using congrFun (congrArg DFunLike.coe <| auxInv_auxHom S r) x
right_inv s := by
simpa using congrFun (congrArg DFunLike.coe <| auxHom_auxInv S r) s
map_mul' := by simp
map_add' := by simp
commutes' := by simp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | mvPolynomialQuotientEquiv | The canonical algebra isomorphism from `MvPolynomial Unit R` quotiented by
`C r * X () - 1` to the localization of `R` away from `r`. |
mvPolynomialQuotientEquiv_apply (p : MvPolynomial Unit R) :
mvPolynomialQuotientEquiv S r (Ideal.Quotient.mk _ p) = aeval (S₁ := S) (fun _ ↦ invSelf r) p :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.TensorProduct.MvPolynomial"
] | Mathlib/RingTheory/MvPolynomial/Localization.lean | mvPolynomialQuotientEquiv_apply | null |
degree (f : MvPolynomial σ R) : σ →₀ ℕ :=
m.toSyn.symm (f.support.sup m.toSyn)
variable (m) in | def | 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 | the degree of a multivariate polynomial with respect to a monomial ordering |
leadingCoeff (f : MvPolynomial σ R) : R :=
f.coeff (m.degree f)
variable (m) in | def | 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 | the leading coefficient of a multivariate polynomial with respect to a monomial ordering |
Monic (f : MvPolynomial σ R) : Prop :=
m.leadingCoeff f = 1
@[nontriviality] theorem Monic.of_subsingleton [Subsingleton R] {f : MvPolynomial σ R} :
m.Monic f :=
Subsingleton.eq_one (m.leadingCoeff f) | def | 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 | A multivariate polynomial is `Monic` with respect to a monomial order
if its leading coefficient (for that monomial order) is 1. |
Monic.decidable [DecidableEq R] (f : MvPolynomial σ R) :
Decidable (m.Monic f) := by
unfold Monic; infer_instance
@[simp] | instance | 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.decidable | null |
Monic.leadingCoeff_eq_one {f : MvPolynomial σ R} (hf : m.Monic f) : m.leadingCoeff f = 1 :=
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.leadingCoeff_eq_one | null |
Monic.coeff_degree {f : MvPolynomial σ R} (hf : m.Monic f) : f.coeff (m.degree f) = 1 :=
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 | Monic.coeff_degree | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.