# MonoidRing(R, M)ΒΆ

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 Magma
- *: (%, R) -> % if R has CommutativeRing or M has Comparable
- from RightModule R
- *: (Integer, %) -> %
- from AbelianGroup
- *: (M, R) -> % if M has Comparable
- from FreeModuleCategory(R, M)
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- *: (R, %) -> % if R has CommutativeRing or M has Comparable
- from LeftModule R
- *: (R, M) -> % if M has Comparable
- from FreeModuleCategory(R, M)
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- <: (%, %) -> Boolean if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from PartialOrder
- <=: (%, %) -> Boolean if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from PartialOrder
- =: (%, %) -> Boolean
- from BasicType
- >: (%, %) -> Boolean if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from PartialOrder
- >=: (%, %) -> Boolean if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from PartialOrder
- ^: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> %
- from Magma
- ~=: (%, %) -> Boolean
- from BasicType
- annihilate?: (%, %) -> Boolean
- from Rng
- antiCommutator: (%, %) -> %
- from NonAssociativeSemiRng
- associator: (%, %, %) -> %
- from NonAssociativeRng
- characteristic: () -> NonNegativeInteger
- from NonAssociativeRing
- charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero
- from CharacteristicNonZero
- coefficient: (%, M) -> R
- from MonoidRingCategory(R, M)
- coefficients: % -> List R
- from MonoidRingCategory(R, M)
- coerce: % -> OutputForm
- from CoercibleTo OutputForm
- coerce: Integer -> %
- from NonAssociativeRing
- coerce: List Record(k: M, c: R) -> %
- from MonoidRingCategory(R, M)
- coerce: M -> %
- from RetractableTo M
- coerce: R -> %
- from RetractableTo R
- commutator: (%, %) -> %
- from NonAssociativeRng
- construct: List Record(k: M, c: R) -> % if M has Comparable
- from IndexedDirectProductCategory(R, M)
- constructOrdered: List Record(k: M, c: R) -> % if M has Comparable
- from IndexedDirectProductCategory(R, M)
- convert: % -> InputForm if R has Finite and M has Finite
- from ConvertibleTo InputForm
- enumerate: () -> List % if R has Finite and M has Finite
- from Finite
- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory
- index: PositiveInteger -> % if R has Finite and M has Finite
- from Finite
- latex: % -> String
- from SetCategory
- leadingCoefficient: % -> R if M has Comparable
- from IndexedDirectProductCategory(R, M)
- leadingMonomial: % -> % if M has Comparable
- from IndexedDirectProductCategory(R, M)
- leadingSupport: % -> M if M has Comparable
- from IndexedDirectProductCategory(R, M)
- leadingTerm: % -> Record(k: M, c: R) if M has Comparable
- from IndexedDirectProductCategory(R, M)
- leftPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> %
- from Magma
- leftRecip: % -> Union(%, failed)
- from MagmaWithUnit
- linearExtend: (M -> R, %) -> R if R has CommutativeRing and M has Comparable
- from FreeModuleCategory(R, M)
- listOfTerms: % -> List Record(k: M, c: R) if M has Comparable
- from IndexedDirectProductCategory(R, M)
- lookup: % -> PositiveInteger if R has Finite and M has Finite
- from Finite
- map: (R -> R, %) -> %
- from MonoidRingCategory(R, M)
- max: (%, %) -> % if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from OrderedSet
- min: (%, %) -> % if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from OrderedSet
- monomial: (R, M) -> %
- from MonoidRingCategory(R, M)
- monomial?: % -> Boolean
- from MonoidRingCategory(R, M)
- monomials: % -> List %
- from MonoidRingCategory(R, M)
- numberOfMonomials: % -> NonNegativeInteger
- from MonoidRingCategory(R, M)
- one?: % -> Boolean
- from MagmaWithUnit
- opposite?: (%, %) -> Boolean
- from AbelianMonoid
- random: () -> % if R has Finite and M has Finite
- from Finite
- recip: % -> Union(%, failed)
- from MagmaWithUnit
- reductum: % -> % if M has Comparable
- from IndexedDirectProductCategory(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 R has Finite and M has Finite
- from Finite
- smaller?: (%, %) -> Boolean if R has Finite and M has Finite or R has Comparable and M has Comparable
- from Comparable
- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid
- sup: (%, %) -> % if M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup
- from OrderedAbelianMonoidSup
- support: % -> List M if M has Comparable
- from FreeModuleCategory(R, M)
- terms: % -> List Record(k: M, c: R)
- from MonoidRingCategory(R, M)
- zero?: % -> Boolean
- from AbelianMonoid

AbelianProductCategory R if M has Comparable

Algebra R if R has CommutativeRing

BiModule(%, %)

BiModule(R, R) if R has CommutativeRing or M has Comparable

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CommutativeRing if R has CommutativeRing and M has CommutativeStar

CommutativeStar if R has CommutativeRing and M has CommutativeStar

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

ConvertibleTo InputForm if R has Finite and M has Finite

Finite if R has Finite and M has Finite

FreeModuleCategory(R, M) if M has Comparable

IndexedDirectProductCategory(R, M) if M has Comparable

LeftModule R if R has CommutativeRing or M has Comparable

Module R if R has CommutativeRing

MonoidRingCategory(R, M)

OrderedAbelianMonoid if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

OrderedAbelianMonoidSup if M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

OrderedAbelianSemiGroup if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

OrderedCancellationAbelianMonoid if M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

OrderedSet if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

PartialOrder if R has OrderedAbelianMonoid and M has OrderedSet and M has Comparable or M has Comparable and M has OrderedSet and R has OrderedAbelianMonoidSup

RightModule R if R has CommutativeRing or M has Comparable