File: Mathlib/Algebra/MonoidAlgebra/Grading.lean

full_name: AddMonoidAlgebra.gradeBy
code: /-- The submodule corresponding to each grade given by the degree function `f`. -/
abbrev gradeBy (f : M → ι) (i : ι) : Submodule R R[M] 
goal: Submodule R (AddMonoidAlgebra R M)

full_name: AddMonoidAlgebra.grade
code: /-- The submodule corresponding to each grade. -/
abbrev grade (m : M) : Submodule R R[M] 
goal: Submodule R (AddMonoidAlgebra R M)

full_name: AddMonoidAlgebra.gradeBy_id
code: theorem gradeBy_id : gradeBy R (id : M → M) = grade R 
goal: AddMonoidAlgebra.gradeBy R id = AddMonoidAlgebra.grade R

full_name: AddMonoidAlgebra.mem_gradeBy_iff
code: theorem mem_gradeBy_iff (f : M → ι) (i : ι) (a : R[M]) :
    a ∈ gradeBy R f i ↔ (a.support : Set M) ⊆ f ⁻¹' {i} 
goal: a ∈ AddMonoidAlgebra.gradeBy R f i ↔ ↑a.support ⊆ f ⁻¹' {i}

full_name: AddMonoidAlgebra.mem_grade_iff
code: theorem mem_grade_iff (m : M) (a : R[M]) : a ∈ grade R m ↔ a.support ⊆ {m} 
goal: a ∈ AddMonoidAlgebra.grade R m ↔ a.support ⊆ {m}

full_name: AddMonoidAlgebra.mem_grade_iff'
code: theorem mem_grade_iff' (m : M) (a : R[M]) :
    a ∈ grade R m ↔ a ∈ (LinearMap.range (Finsupp.lsingle m : R →ₗ[R] M →₀ R) :
      Submodule R R[M]) 
goal: a ∈ AddMonoidAlgebra.grade R m ↔ a ∈ LinearMap.range (Finsupp.lsingle m)

full_name: AddMonoidAlgebra.grade_eq_lsingle_range
code: theorem grade_eq_lsingle_range (m : M) :
    grade R m = LinearMap.range (Finsupp.lsingle m : R →ₗ[R] M →₀ R) 
goal: AddMonoidAlgebra.grade R m = LinearMap.range (Finsupp.lsingle m)

full_name: AddMonoidAlgebra.single_mem_gradeBy
code: theorem single_mem_gradeBy {R} [CommSemiring R] (f : M → ι) (m : M) (r : R) :
    Finsupp.single m r ∈ gradeBy R f (f m) 
goal: Finsupp.single m r ∈ AddMonoidAlgebra.gradeBy R f (f m)

full_name: AddMonoidAlgebra.single_mem_grade
code: theorem single_mem_grade {R} [CommSemiring R] (i : M) (r : R) : Finsupp.single i r ∈ grade R i 
goal: Finsupp.single i r ∈ AddMonoidAlgebra.grade R i

full_name: AddMonoidAlgebra.gradeBy.gradedMonoid
code: instance gradeBy.gradedMonoid [AddMonoid M] [AddMonoid ι] [CommSemiring R] (f : M →+ ι) :
    SetLike.GradedMonoid (gradeBy R f : ι → Submodule R R[M]) 
goal: SetLike.GradedMonoid (AddMonoidAlgebra.gradeBy R ⇑f)

full_name: AddMonoidAlgebra.grade.gradedMonoid
code: instance grade.gradedMonoid [AddMonoid M] [CommSemiring R] :
    SetLike.GradedMonoid (grade R : M → Submodule R R[M]) 
goal: SetLike.GradedMonoid (AddMonoidAlgebra.grade R)

full_name: AddMonoidAlgebra.decomposeAux
code: /-- Auxiliary definition; the canonical grade decomposition, used to provide
`DirectSum.decompose`. -/
def decomposeAux : R[M] →ₐ[R] ⨁ i : ι, gradeBy R f i 
goal: AddMonoidAlgebra R M →ₐ[R] DirectSum ι fun i => ↥(AddMonoidAlgebra.gradeBy R (⇑f) i)

full_name: AddMonoidAlgebra.decomposeAux_single
code: theorem decomposeAux_single (m : M) (r : R) :
    decomposeAux f (Finsupp.single m r) =
      DirectSum.of (fun i : ι => gradeBy R f i) (f m)
        ⟨Finsupp.single m r, single_mem_gradeBy _ _ _⟩ 
goal: (AddMonoidAlgebra.decomposeAux f) (Finsupp.single m r) =
  (DirectSum.of (fun i => ↥(AddMonoidAlgebra.gradeBy R (⇑f) i)) (f m)) ⟨Finsupp.single m r, ⋯⟩

full_name: AddMonoidAlgebra.decomposeAux_coe
code: theorem decomposeAux_coe {i : ι} (x : gradeBy R f i) :
    decomposeAux f ↑x = DirectSum.of (fun i => gradeBy R f i) i x 
goal: (AddMonoidAlgebra.decomposeAux f) ↑x = (DirectSum.of (fun i => ↥(AddMonoidAlgebra.gradeBy R (⇑f) i)) i) x

full_name: AddMonoidAlgebra.gradeBy.gradedAlgebra
code: instance gradeBy.gradedAlgebra : GradedAlgebra (gradeBy R f) 
goal: GradedAlgebra (AddMonoidAlgebra.gradeBy R ⇑f)

full_name: AddMonoidAlgebra.gradeBy.decomposition
code: instance gradeBy.decomposition : DirectSum.Decomposition (gradeBy R f) 
goal: DirectSum.Decomposition (AddMonoidAlgebra.gradeBy R ⇑f)

full_name: AddMonoidAlgebra.decomposeAux_eq_decompose
code: @[simp]
theorem decomposeAux_eq_decompose :
    ⇑(decomposeAux f : R[M] →ₐ[R] ⨁ i : ι, gradeBy R f i) =
      DirectSum.decompose (gradeBy R f) 
goal: ⇑(AddMonoidAlgebra.decomposeAux f) = ⇑(DirectSum.decompose (AddMonoidAlgebra.gradeBy R ⇑f))

full_name: AddMonoidAlgebra.GradesBy.decompose_single
code: theorem GradesBy.decompose_single (m : M) (r : R) :
    DirectSum.decompose (gradeBy R f) (Finsupp.single m r : R[M]) =
      DirectSum.of (fun i : ι => gradeBy R f i) (f m)
        ⟨Finsupp.single m r, single_mem_gradeBy _ _ _⟩ 
goal: (DirectSum.decompose (AddMonoidAlgebra.gradeBy R ⇑f)) (Finsupp.single m r) =
  (DirectSum.of (fun i => ↥(AddMonoidAlgebra.gradeBy R (⇑f) i)) (f m)) ⟨Finsupp.single m r, ⋯⟩

full_name: AddMonoidAlgebra.grade.gradedAlgebra
code: instance grade.gradedAlgebra : GradedAlgebra (grade R : ι → Submodule _ _) 
goal: GradedAlgebra (AddMonoidAlgebra.grade R)

full_name: AddMonoidAlgebra.grade.decomposition
code: instance grade.decomposition : DirectSum.Decomposition (grade R : ι → Submodule _ _) 
goal: DirectSum.Decomposition (AddMonoidAlgebra.grade R)

full_name: AddMonoidAlgebra.grade.decompose_single
code: theorem grade.decompose_single (i : ι) (r : R) :
    DirectSum.decompose (grade R : ι → Submodule _ _) (Finsupp.single i r : AddMonoidAlgebra _ _) =
      DirectSum.of (fun i : ι => grade R i) i ⟨Finsupp.single i r, single_mem_grade _ _⟩ 
goal: (DirectSum.decompose (AddMonoidAlgebra.grade R)) (Finsupp.single i r) =
  (DirectSum.of (fun i => ↥(AddMonoidAlgebra.grade R i)) i) ⟨Finsupp.single i r, ⋯⟩

full_name: AddMonoidAlgebra.gradeBy.isInternal
code: /-- `AddMonoidAlgebra.gradeBy` describe an internally graded algebra. -/
theorem gradeBy.isInternal : DirectSum.IsInternal (gradeBy R f) 
goal: DirectSum.IsInternal (AddMonoidAlgebra.gradeBy R ⇑f)

full_name: AddMonoidAlgebra.grade.isInternal
code: /-- `AddMonoidAlgebra.grade` describe an internally graded algebra. -/
theorem grade.isInternal : DirectSum.IsInternal (grade R : ι → Submodule R _) 
goal: DirectSum.IsInternal (AddMonoidAlgebra.grade R)