File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

full_name: MvPolynomial.weightedTotalDegree'
code: /-- The weighted total degree of a multivariate polynomial, taking values in `WithBot M`. -/
def weightedTotalDegree' (w : σ → M) (p : MvPolynomial σ R) : WithBot M 
goal: WithBot M

full_name: MvPolynomial.weightedTotalDegree'_eq_bot_iff
code: /-- The `weightedTotalDegree'` of a polynomial `p` is `⊥` if and only if `p = 0`. -/
theorem weightedTotalDegree'_eq_bot_iff (w : σ → M) (p : MvPolynomial σ R) :
    weightedTotalDegree' w p = ⊥ ↔ p = 0 
goal: MvPolynomial.weightedTotalDegree' w p = ⊥ ↔ p = 0

full_name: MvPolynomial.weightedTotalDegree'_zero
code: /-- The `weightedTotalDegree'` of the zero polynomial is `⊥`. -/
theorem weightedTotalDegree'_zero (w : σ → M) :
    weightedTotalDegree' w (0 : MvPolynomial σ R) = ⊥ 
goal: MvPolynomial.weightedTotalDegree' w 0 = ⊥

full_name: MvPolynomial.weightedTotalDegree
code: /-- When `M` has a `⊥` element, we can define the weighted total degree of a multivariate
  polynomial as a function taking values in `M`. -/
def weightedTotalDegree (w : σ → M) (p : MvPolynomial σ R) : M 
goal: M

full_name: MvPolynomial.weightedTotalDegree_coe
code: /-- This lemma relates `weightedTotalDegree` and `weightedTotalDegree'`. -/
theorem weightedTotalDegree_coe (w : σ → M) (p : MvPolynomial σ R) (hp : p ≠ 0) :
    weightedTotalDegree' w p = ↑(weightedTotalDegree w p) 
goal: MvPolynomial.weightedTotalDegree' w p = ↑(MvPolynomial.weightedTotalDegree w p)

full_name: MvPolynomial.weightedTotalDegree_zero
code: /-- The `weightedTotalDegree` of the zero polynomial is `⊥`. -/
theorem weightedTotalDegree_zero (w : σ → M) :
    weightedTotalDegree w (0 : MvPolynomial σ R) = ⊥ 
goal: MvPolynomial.weightedTotalDegree w 0 = ⊥

full_name: MvPolynomial.le_weightedTotalDegree
code: theorem le_weightedTotalDegree (w : σ → M) {φ : MvPolynomial σ R} {d : σ →₀ ℕ}
    (hd : d ∈ φ.support) : weight w d ≤ φ.weightedTotalDegree w 
goal: (Finsupp.weight w) d ≤ MvPolynomial.weightedTotalDegree w φ

full_name: MvPolynomial.IsWeightedHomogeneous
code: /-- A multivariate polynomial `φ` is weighted homogeneous of weighted degree `m` if all monomials
  occurring in `φ` have weighted degree `m`. -/
def IsWeightedHomogeneous (w : σ → M) (φ : MvPolynomial σ R) (m : M) : Prop 
goal: Prop

full_name: MvPolynomial.weightedHomogeneousSubmodule
code: /-- The submodule of homogeneous `MvPolynomial`s of degree `n`. -/
def weightedHomogeneousSubmodule (w : σ → M) (m : M) : Submodule R (MvPolynomial σ R) 
goal: Submodule R (MvPolynomial σ R)

full_name: MvPolynomial.mem_weightedHomogeneousSubmodule
code: @[simp]
theorem mem_weightedHomogeneousSubmodule (w : σ → M) (m : M) (p : MvPolynomial σ R) :
    p ∈ weightedHomogeneousSubmodule R w m ↔ p.IsWeightedHomogeneous w m 
goal: p ∈ MvPolynomial.weightedHomogeneousSubmodule R w m ↔ MvPolynomial.IsWeightedHomogeneous w p m

full_name: MvPolynomial.weightedHomogeneousSubmodule_eq_finsupp_supported
code: /-- 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. -/
theorem weightedHomogeneousSubmodule_eq_finsupp_supported (w : σ → M) (m : M) :
    weightedHomogeneousSubmodule R w m = Finsupp.supported R R { d | weight w d = m } 
goal: MvPolynomial.weightedHomogeneousSubmodule R w m = Finsupp.supported R R {d | (Finsupp.weight w) d = m}

full_name: MvPolynomial.weightedHomogeneousSubmodule_mul
code: /-- 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`. -/
theorem weightedHomogeneousSubmodule_mul (w : σ → M) (m n : M) :
    weightedHomogeneousSubmodule R w m * weightedHomogeneousSubmodule R w n ≤
      weightedHomogeneousSubmodule R w (m + n) 
goal: MvPolynomial.weightedHomogeneousSubmodule R w m * MvPolynomial.weightedHomogeneousSubmodule R w n ≤
  MvPolynomial.weightedHomogeneousSubmodule R w (m + n)

full_name: MvPolynomial.isWeightedHomogeneous_monomial
code: /-- Monomials are weighted homogeneous. -/
theorem isWeightedHomogeneous_monomial (w : σ → M) (d : σ →₀ ℕ) (r : R) {m : M}
    (hm : weight w d = m) : IsWeightedHomogeneous w (monomial d r) m 
goal: MvPolynomial.IsWeightedHomogeneous w ((MvPolynomial.monomial d) r) m

full_name: MvPolynomial.isWeightedHomogeneous_of_total_degree_zero
code: /-- A polynomial of weightedTotalDegree `⊥` is weighted_homogeneous of degree `⊥`. -/
theorem isWeightedHomogeneous_of_total_degree_zero [SemilatticeSup M] [OrderBot M] (w : σ → M)
    {p : MvPolynomial σ R} (hp : weightedTotalDegree w p = (⊥ : M)) :
    IsWeightedHomogeneous w p (⊥ : M) 
goal: MvPolynomial.IsWeightedHomogeneous w p ⊥

full_name: MvPolynomial.isWeightedHomogeneous_C
code: /-- Constant polynomials are weighted homogeneous of degree 0. -/
theorem isWeightedHomogeneous_C (w : σ → M) (r : R) :
    IsWeightedHomogeneous w (C r : MvPolynomial σ R) 0 
goal: MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.C r) 0

full_name: MvPolynomial.isWeightedHomogeneous_zero
code: /-- 0 is weighted homogeneous of any degree. -/
theorem isWeightedHomogeneous_zero (w : σ → M) (m : M) :
    IsWeightedHomogeneous w (0 : MvPolynomial σ R) m 
goal: MvPolynomial.IsWeightedHomogeneous w 0 m

full_name: MvPolynomial.isWeightedHomogeneous_one
code: /-- 1 is weighted homogeneous of degree 0. -/
theorem isWeightedHomogeneous_one (w : σ → M) : IsWeightedHomogeneous w (1 : MvPolynomial σ R) 0 
goal: MvPolynomial.IsWeightedHomogeneous w 1 0

full_name: MvPolynomial.isWeightedHomogeneous_X
code: /-- An indeterminate `i : σ` is weighted homogeneous of degree `w i`. -/
theorem isWeightedHomogeneous_X (w : σ → M) (i : σ) :
    IsWeightedHomogeneous w (X i : MvPolynomial σ R) (w i) 
goal: MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i)

full_name: MvPolynomial.IsWeightedHomogeneous.coeff_eq_zero
code: /-- The weighted degree of a weighted homogeneous polynomial controls its support. -/
theorem coeff_eq_zero {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (d : σ →₀ ℕ)
    (hd : weight w d ≠ n) : coeff d φ = 0 
goal: MvPolynomial.coeff d φ = 0

full_name: MvPolynomial.IsWeightedHomogeneous.inj_right
code: /-- The weighted degree of a nonzero weighted homogeneous polynomial is well-defined. -/
theorem inj_right {w : σ → M} (hφ : φ ≠ 0) (hm : IsWeightedHomogeneous w φ m)
    (hn : IsWeightedHomogeneous w φ n) : m = n 
goal: m = n

full_name: MvPolynomial.IsWeightedHomogeneous.add
code: /-- The sum of two weighted homogeneous polynomials of degree `n` is weighted homogeneous of
  weighted degree `n`. -/
theorem add {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (hψ : IsWeightedHomogeneous w ψ n) :
    IsWeightedHomogeneous w (φ + ψ) n 
goal: MvPolynomial.IsWeightedHomogeneous w (φ + ψ) n

full_name: MvPolynomial.IsWeightedHomogeneous.sum
code: /-- The sum of weighted homogeneous polynomials of degree `n` is weighted homogeneous of
  weighted degree `n`. -/
theorem sum {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : M) {w : σ → M}
    (h : ∀ i ∈ s, IsWeightedHomogeneous w (φ i) n) : IsWeightedHomogeneous w (∑ i ∈ s, φ i) n 
goal: MvPolynomial.IsWeightedHomogeneous w (∑ i ∈ s, φ i) n

full_name: MvPolynomial.IsWeightedHomogeneous.mul
code: /-- The product of weighted homogeneous polynomials of weighted degrees `m` and `n` is weighted
  homogeneous of weighted degree `m + n`. -/
theorem mul {w : σ → M} (hφ : IsWeightedHomogeneous w φ m) (hψ : IsWeightedHomogeneous w ψ n) :
    IsWeightedHomogeneous w (φ * ψ) (m + n) 
goal: MvPolynomial.IsWeightedHomogeneous w (φ * ψ) (m + n)

full_name: MvPolynomial.IsWeightedHomogeneous.prod
code: /-- A product of weighted homogeneous polynomials is weighted homogeneous, with weighted degree
  equal to the sum of the weighted degrees. -/
theorem prod {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : ι → M) {w : σ → M} :
    (∀ i ∈ s, IsWeightedHomogeneous w (φ i) (n i)) →
      IsWeightedHomogeneous w (∏ i ∈ s, φ i) (∑ i ∈ s, n i) 
goal: (∀ i ∈ s, MvPolynomial.IsWeightedHomogeneous w (φ i) (n i)) →
  MvPolynomial.IsWeightedHomogeneous w (∏ i ∈ s, φ i) (∑ i ∈ s, n i)

full_name: MvPolynomial.IsWeightedHomogeneous.weighted_total_degree
code: /-- A non zero weighted homogeneous polynomial of weighted degree `n` has weighted total degree
  `n`. -/
theorem weighted_total_degree [SemilatticeSup M] {w : σ → M} (hφ : IsWeightedHomogeneous w φ n)
    (h : φ ≠ 0) : weightedTotalDegree' w φ = n 
goal: MvPolynomial.weightedTotalDegree' w φ = ↑n

full_name: MvPolynomial.WeightedHomogeneousSubmodule.gradedMonoid
code: /-- The weighted homogeneous submodules form a graded monoid. -/
lemma WeightedHomogeneousSubmodule.gradedMonoid {w : σ → M} :
    SetLike.GradedMonoid (weightedHomogeneousSubmodule R w) 
goal: SetLike.GradedMonoid (MvPolynomial.weightedHomogeneousSubmodule R w)

full_name: MvPolynomial.weightedHomogeneousComponent
code: /-- `weightedHomogeneousComponent w n φ` is the part of `φ` that is weighted homogeneous of
  weighted degree `n`, with respect to the weights `w`.
  See `sum_weightedHomogeneousComponent` for the statement that `φ` is equal to the sum
  of all its weighted homogeneous components. -/
def weightedHomogeneousComponent (w : σ → M) (n : M) : MvPolynomial σ R →ₗ[R] MvPolynomial σ R 
goal: MvPolynomial σ R →ₗ[R] MvPolynomial σ R

full_name: MvPolynomial.coeff_weightedHomogeneousComponent
code: theorem coeff_weightedHomogeneousComponent [DecidableEq M] (d : σ →₀ ℕ) :
    coeff d (weightedHomogeneousComponent w n φ) =
      if weight w d = n then coeff d φ else 0 
goal: MvPolynomial.coeff d ((MvPolynomial.weightedHomogeneousComponent w n) φ) =
  if (Finsupp.weight w) d = n then MvPolynomial.coeff d φ else 0

full_name: MvPolynomial.weightedHomogeneousComponent_apply
code: theorem weightedHomogeneousComponent_apply [DecidableEq M] :
    weightedHomogeneousComponent w n φ =
      ∑ d ∈ φ.support.filter fun d => weight w d = n, monomial d (coeff d φ) 
goal: (MvPolynomial.weightedHomogeneousComponent w n) φ =
  ∑ d ∈ Finset.filter (fun d => (Finsupp.weight w) d = n) φ.support, (MvPolynomial.monomial d) (MvPolynomial.coeff d φ)

full_name: MvPolynomial.weightedHomogeneousComponent_isWeightedHomogeneous
code: /-- The `n` weighted homogeneous component of a polynomial is weighted homogeneous of
weighted degree `n`. -/
theorem weightedHomogeneousComponent_isWeightedHomogeneous :
    (weightedHomogeneousComponent w n φ).IsWeightedHomogeneous w n 
goal: MvPolynomial.IsWeightedHomogeneous w ((MvPolynomial.weightedHomogeneousComponent w n) φ) n

full_name: MvPolynomial.weightedHomogeneousComponent_mem
code: theorem weightedHomogeneousComponent_mem (w : σ → M) (φ : MvPolynomial σ R) (m : M) :
    weightedHomogeneousComponent w m φ ∈ weightedHomogeneousSubmodule R w m 
goal: (MvPolynomial.weightedHomogeneousComponent w m) φ ∈ MvPolynomial.weightedHomogeneousSubmodule R w m

full_name: MvPolynomial.weightedHomogeneousComponent_C_mul
code: @[simp]
theorem weightedHomogeneousComponent_C_mul (n : M) (r : R) :
    weightedHomogeneousComponent w n (C r * φ) = C r * weightedHomogeneousComponent w n φ 
goal: (MvPolynomial.weightedHomogeneousComponent w n) (MvPolynomial.C r * φ) =
  MvPolynomial.C r * (MvPolynomial.weightedHomogeneousComponent w n) φ

full_name: MvPolynomial.weightedHomogeneousComponent_eq_zero'
code: theorem weightedHomogeneousComponent_eq_zero'
    (h : ∀ d : σ →₀ ℕ, d ∈ φ.support → weight w d ≠ n) :
    weightedHomogeneousComponent w n φ = 0 
goal: (MvPolynomial.weightedHomogeneousComponent w n) φ = 0

full_name: MvPolynomial.weightedHomogeneousComponent_eq_zero
code: theorem weightedHomogeneousComponent_eq_zero [SemilatticeSup M] [OrderBot M]
    (h : weightedTotalDegree w φ < n) : weightedHomogeneousComponent w n φ = 0 
goal: (MvPolynomial.weightedHomogeneousComponent w n) φ = 0

full_name: MvPolynomial.weightedHomogeneousComponent_finsupp
code: theorem weightedHomogeneousComponent_finsupp :
    (Function.support fun m => weightedHomogeneousComponent w m φ).Finite 
goal: (Function.support fun m => (MvPolynomial.weightedHomogeneousComponent w m) φ).Finite

full_name: MvPolynomial.sum_weightedHomogeneousComponent
code: /-- Every polynomial is the sum of its weighted homogeneous components. -/
theorem sum_weightedHomogeneousComponent :
    (finsum fun m => weightedHomogeneousComponent w m φ) = φ 
goal: ∑ᶠ (m : M), (MvPolynomial.weightedHomogeneousComponent w m) φ = φ

full_name: MvPolynomial.finsum_weightedHomogeneousComponent
code: theorem finsum_weightedHomogeneousComponent :
    (finsum fun m => weightedHomogeneousComponent w m φ) = φ 
goal: ∑ᶠ (m : M), (MvPolynomial.weightedHomogeneousComponent w m) φ = φ

full_name: MvPolynomial.IsWeightedHomogeneous.weightedHomogeneousComponent_same
code: theorem IsWeightedHomogeneous.weightedHomogeneousComponent_same {m : M} {p : MvPolynomial σ R}
    (hp : IsWeightedHomogeneous w p m) :
    weightedHomogeneousComponent w m p = p 
goal: (MvPolynomial.weightedHomogeneousComponent w m) p = p

full_name: MvPolynomial.IsWeightedHomogeneous.weightedHomogeneousComponent_ne
code: theorem IsWeightedHomogeneous.weightedHomogeneousComponent_ne {m : M} (n : M)
    {p : MvPolynomial σ R} (hp : IsWeightedHomogeneous w p m) :
    n ≠ m → weightedHomogeneousComponent w n p = 0 
goal: n ≠ m → (MvPolynomial.weightedHomogeneousComponent w n) p = 0

full_name: MvPolynomial.weightedHomogeneousComponent_of_mem
code: /-- The weighted homogeneous components of a weighted homogeneous polynomial. -/
theorem weightedHomogeneousComponent_of_mem [DecidableEq M] {m n : M}
    {p : MvPolynomial σ R} (h : p ∈ weightedHomogeneousSubmodule R w n) :
    weightedHomogeneousComponent w m p = if m = n then p else 0 
goal: (MvPolynomial.weightedHomogeneousComponent w m) p = if m = n then p else 0

full_name: MvPolynomial.weightedHomogeneousComponent_of_isWeightedHomogeneous_same
code: theorem weightedHomogeneousComponent_of_isWeightedHomogeneous_same
    {m : M} {p : MvPolynomial σ R} (hp : IsWeightedHomogeneous w p m) :
    weightedHomogeneousComponent w m p = p 
goal: (MvPolynomial.weightedHomogeneousComponent w m) p = p

full_name: MvPolynomial.weightedHomogeneousComponent_of_isWeightedHomogeneous_ne
code: theorem weightedHomogeneousComponent_of_isWeightedHomogeneous_ne
    {m n : M} {p : MvPolynomial σ R} (hp : IsWeightedHomogeneous w p m) (hn : n ≠ m) :
    weightedHomogeneousComponent w n p = 0 
goal: (MvPolynomial.weightedHomogeneousComponent w n) p = 0

full_name: MvPolynomial.DirectSum.coeLinearMap_eq_dfinsupp_sum
code: theorem DirectSum.coeLinearMap_eq_dfinsupp_sum [DecidableEq σ] [DecidableEq R] [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) :
    (coeLinearMap fun i : M => weightedHomogeneousSubmodule R w i) x =
      DFinsupp.sum x (fun _ x => ↑x) 
goal: (DirectSum.coeLinearMap fun i => MvPolynomial.weightedHomogeneousSubmodule R w i) x = DFinsupp.sum x fun x x_1 => ↑x_1

full_name: MvPolynomial.DirectSum.coeAddMonoidHom_eq_support_sum
code: theorem DirectSum.coeAddMonoidHom_eq_support_sum [DecidableEq σ] [DecidableEq R] [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) :
    (DirectSum.coeAddMonoidHom fun i : M => weightedHomogeneousSubmodule R w i) x =
      DFinsupp.sum x (fun _ x => ↑x) 
goal: (DirectSum.coeAddMonoidHom fun i => MvPolynomial.weightedHomogeneousSubmodule R w i) x =
  DFinsupp.sum x fun x x_1 => ↑x_1

full_name: MvPolynomial.DirectSum.coeLinearMap_eq_finsum
code: theorem DirectSum.coeLinearMap_eq_finsum [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) :
    (DirectSum.coeLinearMap fun i : M => weightedHomogeneousSubmodule R w i) x =
      finsum fun m => x m 
goal: (DirectSum.coeLinearMap fun i => MvPolynomial.weightedHomogeneousSubmodule R w i) x = ∑ᶠ (m : M), ↑(x m)

full_name: MvPolynomial.weightedHomogeneousComponent_directSum
code: theorem weightedHomogeneousComponent_directSum [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) (m : M) :
    (weightedHomogeneousComponent w m)
      ((DirectSum.coeLinearMap fun i : M => weightedHomogeneousSubmodule R w i) x) = x m 
goal: (MvPolynomial.weightedHomogeneousComponent w m)
    ((DirectSum.coeLinearMap fun i => MvPolynomial.weightedHomogeneousSubmodule R w i) x) =
  ↑(x m)

full_name: MvPolynomial.weightedHomogeneousComponent_zero
code: /-- If `M` is a `CanonicallyOrderedAddCommMonoid`, then the `weightedHomogeneousComponent`
  of weighted degree `0` of a polynomial is its constant coefficient. -/
@[simp]
theorem weightedHomogeneousComponent_zero [NoZeroSMulDivisors ℕ M] (hw : ∀ i : σ, w i ≠ 0) :
    weightedHomogeneousComponent w 0 φ = C (coeff 0 φ) 
goal: (MvPolynomial.weightedHomogeneousComponent w 0) φ = MvPolynomial.C (MvPolynomial.coeff 0 φ)

full_name: MvPolynomial.NonTorsionWeight
code: /-- A weight function is nontorsion if its values are not torsion. -/
def NonTorsionWeight (w : σ → M) 
goal: Prop

full_name: MvPolynomial.nonTorsionWeight_of
code: theorem nonTorsionWeight_of [NoZeroSMulDivisors ℕ M] (hw : ∀ i : σ, w i ≠ 0) :
    NonTorsionWeight w 
goal: MvPolynomial.NonTorsionWeight w

full_name: MvPolynomial.weightedDegree_eq_zero_iff
code: /-- If `w` is a nontorsion weight function, then the finitely supported function `m : σ →₀ ℕ`
  has weighted degree zero if and only if `∀ x : σ, m x = 0`. -/
theorem weightedDegree_eq_zero_iff (hw : NonTorsionWeight w) {m : σ →₀ ℕ} :
    weight w m = 0 ↔ ∀ x : σ, m x = 0 
goal: (Finsupp.weight w) m = 0 ↔ ∀ (x : σ), m x = 0

full_name: MvPolynomial.isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero
code: /-- A multivatiate polynomial is weighted homogeneous of weighted degree zero if and only if
  its weighted total degree is equal to zero. -/
theorem isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero {p : MvPolynomial σ R} :
    IsWeightedHomogeneous w p 0 ↔ p.weightedTotalDegree w = 0 
goal: MvPolynomial.IsWeightedHomogeneous w p 0 ↔ MvPolynomial.weightedTotalDegree w p = 0

full_name: MvPolynomial.weightedTotalDegree_eq_zero_iff
code: /-- If `w` is a nontorsion weight function, then a multivariate polynomial has weighted total
  degree zero if and only if for every `m ∈ p.support` and `x : σ`, `m x = 0`. -/
theorem weightedTotalDegree_eq_zero_iff (hw : NonTorsionWeight w) (p : MvPolynomial σ R) :
    p.weightedTotalDegree w = 0 ↔ ∀ (m : σ →₀ ℕ) (_ : m ∈ p.support) (x : σ), m x = 0 
goal: MvPolynomial.weightedTotalDegree w p = 0 ↔ ∀ m ∈ p.support, ∀ (x : σ), m x = 0

full_name: MvPolynomial.weightedHomogeneousComponent_eq_zero_of_not_mem
code: theorem weightedHomogeneousComponent_eq_zero_of_not_mem [DecidableEq M]
    (φ : MvPolynomial σ R) (i : M) (hi : i ∉ Finset.image (weight w) φ.support) :
    weightedHomogeneousComponent w i φ = 0 
goal: (MvPolynomial.weightedHomogeneousComponent w i) φ = 0

full_name: MvPolynomial.decompose'
code: /-- The `decompose'` argument of `weightedDecomposition`.  -/
def decompose' [DecidableEq M] 
goal: DirectSum M fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i)

full_name: MvPolynomial.decompose'_apply
code: theorem decompose'_apply [DecidableEq M] (φ : MvPolynomial σ R) (m : M) :
    (decompose' R w φ m : MvPolynomial σ R) = weightedHomogeneousComponent w m φ 
goal: ↑((MvPolynomial.decompose' R w φ) m) = (MvPolynomial.weightedHomogeneousComponent w m) φ

full_name: MvPolynomial.weightedDecomposition
code: /-- Given a weight `w`, the decomposition of `MvPolynomial σ R` into weighted homogeneous
submodules -/
def weightedDecomposition [DecidableEq M] :
    DirectSum.Decomposition (weightedHomogeneousSubmodule R w) 
goal: DirectSum.Decomposition (MvPolynomial.weightedHomogeneousSubmodule R w)

full_name: MvPolynomial.weightedGradedAlgebra
code: /-- Given a weight, `MvPolynomial` as a graded algebra -/
def weightedGradedAlgebra [DecidableEq M] :
    GradedAlgebra (weightedHomogeneousSubmodule R w) 
goal: GradedAlgebra (MvPolynomial.weightedHomogeneousSubmodule R w)

full_name: MvPolynomial.weightedDecomposition.decompose'_eq
code: theorem weightedDecomposition.decompose'_eq [DecidableEq M] :
    (weightedDecomposition R w).decompose' = fun φ : MvPolynomial σ R =>
      DirectSum.mk (fun i : M => ↥(weightedHomogeneousSubmodule R w i))
        (Finset.image (weight w) φ.support) fun m =>
          ⟨weightedHomogeneousComponent w m φ, weightedHomogeneousComponent_mem w φ m⟩ 
goal: DirectSum.Decomposition.decompose' = fun φ =>
  (DirectSum.mk (fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i))
      (Finset.image (⇑(Finsupp.weight w)) φ.support))
    fun m => ⟨(MvPolynomial.weightedHomogeneousComponent w ↑m) φ, ⋯⟩

full_name: MvPolynomial.weightedDecomposition.decompose'_apply
code: theorem weightedDecomposition.decompose'_apply [DecidableEq M]
    (φ : MvPolynomial σ R) (m : M) :
    ((weightedDecomposition R w).decompose' φ m : MvPolynomial σ R) =
      weightedHomogeneousComponent w m φ 
goal: ↑((DirectSum.Decomposition.decompose' φ) m) = (MvPolynomial.weightedHomogeneousComponent w m) φ