# MonoidRing(R, M)ΒΆ

mring.spad line 33 [edit on github]

MonoidRing(`R`

, `M`

), implements the algebra of all maps from the monoid `M`

to the commutative ring `R`

with finite support. Multiplication of two maps `f`

and `g`

is defined to map an element `c`

of `M`

to the (convolution) sum over *f(a)g(b)* such that *ab = c*. Thus `M`

can be identified with a canonical basis and the maps can also be considered as formal linear combinations of the elements in `M`

. Scalar multiples of a basis element are called monomials. A prominent example is the class of polynomials where the monoid is a direct product of the natural numbers with pointwise addition. When `M`

is FreeMonoid Symbol, one gets polynomials in infinitely many non-commuting variables. Another application area is representation theory of finite groups `G`

, where modules over MonoidRing(`R`

, `G`

) are studied.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

- *: (%, %) -> %
from LeftModule %

- *: (%, R) -> %
from RightModule R

- *: (Integer, %) -> %
from AbelianGroup

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- associator: (%, %, %) -> %
from NonAssociativeRng

- characteristic: () -> NonNegativeInteger
from NonAssociativeRing

- charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero

- coefficient: (%, M) -> R
from FreeModuleCategory(R, M)

- coefficients: % -> List R
from FreeModuleCategory(R, M)

- coerce: % -> % if M has CommutativeStar and R has CommutativeRing
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Integer -> %
from NonAssociativeRing

- coerce: List Record(k: M, c: R) -> %
from MonoidRingCategory(R, M)

- coerce: M -> %
from CoercibleFrom M

- coerce: R -> %
from Algebra R

- commutator: (%, %) -> %
from NonAssociativeRng

- construct: List Record(k: M, c: R) -> %
from IndexedProductCategory(R, M)

- constructOrdered: List Record(k: M, c: R) -> % if M has Comparable
from IndexedProductCategory(R, M)

- hash: % -> SingleInteger
from SetCategory

- hashUpdate!: (HashState, %) -> HashState
from SetCategory

- index: PositiveInteger -> % if M has Finite and R has Finite
from Finite

- latex: % -> String
from SetCategory

- leadingCoefficient: % -> R if M has Comparable
from IndexedProductCategory(R, M)

- leadingMonomial: % -> % if M has Comparable
from IndexedProductCategory(R, M)

- leadingSupport: % -> M if M has Comparable
from IndexedProductCategory(R, M)

- leadingTerm: % -> Record(k: M, c: R) if M has Comparable
from IndexedProductCategory(R, M)

- leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed)
from MagmaWithUnit

- linearExtend: (M -> R, %) -> R if R has CommutativeRing
from FreeModuleCategory(R, M)

- listOfTerms: % -> List Record(k: M, c: R)
from IndexedDirectProductCategory(R, M)

- lookup: % -> PositiveInteger if M has Finite and R has Finite
from Finite

- map: (R -> R, %) -> %
from IndexedProductCategory(R, M)

- monomial?: % -> Boolean
from IndexedProductCategory(R, M)

- monomial: (R, M) -> %
from IndexedProductCategory(R, M)

- monomials: % -> List %
from FreeModuleCategory(R, M)

- numberOfMonomials: % -> NonNegativeInteger
from IndexedDirectProductCategory(R, M)

- one?: % -> Boolean
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- recip: % -> Union(%, failed)
from MagmaWithUnit

- reductum: % -> % if M has Comparable
from IndexedProductCategory(R, M)

- retract: % -> M
from RetractableTo M

- retract: % -> R
from RetractableTo R

- retractIfCan: % -> Union(M, failed)
from RetractableTo M

- retractIfCan: % -> Union(R, failed)
from RetractableTo R

- rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed)
from MagmaWithUnit

- sample: %
from AbelianMonoid

- size: () -> NonNegativeInteger if M has Finite and R has Finite
from Finite

- smaller?: (%, %) -> Boolean if R has Comparable and M has Comparable or M has Finite and R has Finite
from Comparable

- subtractIfCan: (%, %) -> Union(%, failed)

- support: % -> List M
from FreeModuleCategory(R, M)

- terms: % -> List Record(k: M, c: R)
from MonoidRingCategory(R, M)

- zero?: % -> Boolean
from AbelianMonoid

Algebra % if M has CommutativeStar and R has CommutativeRing

Algebra R if R has CommutativeRing

BiModule(%, %)

BiModule(R, R)

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CommutativeRing if M has CommutativeStar and R has CommutativeRing

CommutativeStar if M has CommutativeStar and R has CommutativeRing

Comparable if R has Comparable and M has Comparable or M has Finite and R has Finite

ConvertibleTo InputForm if M has Finite and R has Finite

Finite if M has Finite and R has Finite

FreeModuleCategory(R, M)

IndexedDirectProductCategory(R, M)

IndexedProductCategory(R, M)

Module % if M has CommutativeStar and R has CommutativeRing

Module R if R has CommutativeRing

MonoidRingCategory(R, M)

TwoSidedRecip if M has CommutativeStar and R has CommutativeRing