# MonoidRingCategory(R, M)ΒΆ

mring.spad line 1 [edit on github]

MonoidRingCategory(`R`

, `M`

) defines the algebra of all maps from the monoid `M`

to the commutative ring `R`

with finite support.

- 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) -> %
`coerce(lt)`

converts a list of terms and coefficients to a member of the domain.- 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 if M has Finite and R has Finite
from Hashable

- 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

- plenaryPower: (%, PositiveInteger) -> % if R has CommutativeRing
from NonAssociativeAlgebra R

- 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 M has Finite and R has Finite or R has Comparable and M has Comparable
from Comparable

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

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

- terms: % -> List Record(k: M, c: R)
`terms(f)`

gives the list of non-zero coefficients combined with their corresponding basis element as records. This is the internal representation.

- 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 M has Finite and R has Finite or R has Comparable and M has Comparable

ConvertibleTo InputForm if M has Finite and R has Finite

Finite if M has Finite and R has Finite

FreeModuleCategory(R, M)

Hashable if M has Finite and R has Finite

IndexedDirectProductCategory(R, M)

IndexedProductCategory(R, M)

Module % if M has CommutativeStar and R has CommutativeRing

Module R if R has CommutativeRing

NonAssociativeAlgebra % if M has CommutativeStar and R has CommutativeRing

NonAssociativeAlgebra R if R has CommutativeRing

TwoSidedRecip if M has CommutativeStar and R has CommutativeRing