MonoidRingCategory(R, M)

mring.spad line 1 [edit on github]

• R : Ring
• M : Monoid

MonoidRingCategory(R, M) defines the algebra of all maps from the monoid M to the commutative ring R with finite support.

* : (%, %) -> %

from Magma

* : (%, R) -> %

from RightModule(R)

* : (R, %) -> %

from LeftModule(R)

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

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 FreeModuleCategory(R, M)

coefficients : % -> List(R)

from FreeModuleCategory(R, M)

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

from Algebra(%)

coerce : M -> %

from CoercibleFrom(M)

coerce : R -> %

from Algebra(R)

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 : % -> OutputForm

from CoercibleTo(OutputForm)

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)

convert : % -> InputForm if M has Finite and R has Finite

from ConvertibleTo(InputForm)

enumerate : () -> List(%) if M has Finite and R has Finite

from Finite

hash : % -> SingleInteger if M has Finite and R has Finite

from Hashable

hashUpdate! : (HashState, %) -> HashState 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 : (Mapping(R, M), %) -> 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 : (Mapping(R, R), %) -> %

from IndexedProductCategory(R, M)

monomial : (R, M) -> %

from IndexedProductCategory(R, M)

monomial? : % -> Boolean

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)

random : () -> % if M has Finite and R has Finite

from Finite

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")

from CancellationAbelianMonoid

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

~= : (%, %) -> Boolean

from BasicType

CharacteristicNonZero

Comparable

ConvertibleTo(InputForm)

CoercibleFrom(R)

Algebra(R)

RightModule(%)

Monoid

Algebra(%)

AbelianMonoid

BiModule(R, R)

NonAssociativeAlgebra(R)

CancellationAbelianMonoid

MagmaWithUnit

NonAssociativeRing

RightModule(R)

CommutativeStar

LeftModule(%)

LeftModule(R)

Finite

SetCategory

CoercibleTo(OutputForm)

RetractableTo(M)

IndexedProductCategory(R, M)

Rng

NonAssociativeAlgebra(%)

CommutativeRing

TwoSidedRecip

Magma

CoercibleFrom(M)

SemiGroup

IndexedDirectProductCategory(R, M)

BiModule(%, %)

unitsKnown

AbelianGroup

AbelianSemiGroup

NonAssociativeSemiRing

AbelianProductCategory(R)

FreeModuleCategory(R, M)

Module(R)

RetractableTo(R)

NonAssociativeRng

Module(%)

Ring

SemiRng

NonAssociativeSemiRng

Hashable

CharacteristicZero

BasicType

SemiRing