FiniteAbelianMonoidRing(R, E)

polycat.spad line 54 [edit on github]

This category is similar to AbelianMonoidRing, except that the sum is assumed to be finite. It is a useful model for polynomials, but is somewhat more general.

* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (%, Fraction(Integer)) -> % if R has Algebra(Fraction(Integer))
from RightModule(Fraction(Integer))
* : (R, %) -> %
from LeftModule(R)
* : (Fraction(Integer), %) -> % if R has Algebra(Fraction(Integer))
from LeftModule(Fraction(Integer))
* : (Integer, %) -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
- : (%, %) -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
/ : (%, R) -> % if R has Field
from AbelianMonoidRing(R, E)
0 : () -> %
from AbelianMonoid
1 : () -> % if R has SemiRing
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
^ : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
annihilate? : (%, %) -> Boolean if R has Ring
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
associates? : (%, %) -> Boolean if R has EntireRing
from EntireRing
associator : (%, %, %) -> % if R has Ring
from NonAssociativeRng
binomThmExpt : (%, %, NonNegativeInteger) -> % if % has CommutativeRing

binomThmExpt(p, q, n) returns (p+q)^n by means of the binomial theorem trick.

characteristic : () -> NonNegativeInteger if R has Ring
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if R has CharacteristicNonZero
from CharacteristicNonZero
coefficient : (%, E) -> R
from AbelianMonoidRing(R, E)
coefficients : % -> List(R)
from FreeModuleCategory(R, E)
coerce : % -> % if R has IntegralDomain and % has VariablesCommuteWithCoefficients or R has CommutativeRing and % has VariablesCommuteWithCoefficients
from Algebra(%)
coerce : R -> %
from Algebra(R)
coerce : Fraction(Integer) -> % if R has RetractableTo(Fraction(Integer)) or R has Algebra(Fraction(Integer))
from Algebra(Fraction(Integer))
coerce : Integer -> % if R has Ring or R has RetractableTo(Integer)
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> % if R has Ring
from NonAssociativeRng
construct : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
constructOrdered : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
content : % -> R if R has GcdDomain

content(p) gives the gcd of the coefficients of polynomial p.

degree : % -> E
from AbelianMonoidRing(R, E)
exquo : (%, %) -> Union(%, "failed") if R has EntireRing
from EntireRing
exquo : (%, R) -> Union(%, "failed") if R has EntireRing

exquo(p,r) returns the exact quotient of polynomial p by r, or "failed" if none exists.

fmecg : (%, E, R, %) -> % if R has Ring

fmecg(p1, e, r, p2) returns p1 - monomial(r, e) * p2.

ground : % -> R

ground(p) retracts polynomial p to the coefficient ring.

ground? : % -> Boolean

ground?(p) tests if polynomial p is a member of the coefficient ring.

latex : % -> String
from SetCategory
leadingCoefficient : % -> R
from IndexedProductCategory(R, E)
leadingMonomial : % -> %
from IndexedProductCategory(R, E)
leadingSupport : % -> E
from IndexedProductCategory(R, E)
leadingTerm : % -> Record(k : E, c : R)
from IndexedProductCategory(R, E)
leftPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
linearExtend : (Mapping(R, E), %) -> R if R has CommutativeRing
from FreeModuleCategory(R, E)
listOfTerms : % -> List(Record(k : E, c : R))
from IndexedDirectProductCategory(R, E)
map : (Mapping(R, R), %) -> %
from IndexedProductCategory(R, E)
mapExponents : (Mapping(E, E), %) -> %

mapExponents(fn, u) maps function fn onto the exponents of the non-zero monomials of polynomial u.

minimumDegree : % -> E

minimumDegree(p) gives the least exponent of a non-zero term of polynomial p. Error: if applied to 0.

monomial : (R, E) -> %
from IndexedProductCategory(R, E)
monomial? : % -> Boolean
from IndexedProductCategory(R, E)
monomials : % -> List(%)
from FreeModuleCategory(R, E)
numberOfMonomials : % -> NonNegativeInteger
from IndexedDirectProductCategory(R, E)
one? : % -> Boolean if R has SemiRing
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing and % has VariablesCommuteWithCoefficients or R has Algebra(Fraction(Integer)) or R has IntegralDomain and % has VariablesCommuteWithCoefficients
from NonAssociativeAlgebra(%)
pomopo! : (%, R, E, %) -> %

pomopo!(p1, r, e, p2) returns p1 + monomial(r, e) * p2 and may use p1 as workspace. The constant r is assumed to be nonzero.

primitivePart : % -> % if R has GcdDomain

primitivePart(p) returns the unit normalized form of polynomial p divided by the content of p.

recip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
reductum : % -> %
from IndexedProductCategory(R, E)
retract : % -> R
from RetractableTo(R)
retract : % -> Fraction(Integer) if R has RetractableTo(Fraction(Integer))
from RetractableTo(Fraction(Integer))
retract : % -> Integer if R has RetractableTo(Integer)
from RetractableTo(Integer)
retractIfCan : % -> Union(R, "failed")
from RetractableTo(R)
retractIfCan : % -> Union(Fraction(Integer), "failed") if R has RetractableTo(Fraction(Integer))
from RetractableTo(Fraction(Integer))
retractIfCan : % -> Union(Integer, "failed") if R has RetractableTo(Integer)
from RetractableTo(Integer)
rightPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
sample : () -> %
from AbelianMonoid
smaller? : (%, %) -> Boolean if R has Comparable
from Comparable
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
support : % -> List(E)
from FreeModuleCategory(R, E)
unit? : % -> Boolean if R has EntireRing
from EntireRing
unitCanonical : % -> % if R has EntireRing
from EntireRing
unitNormal : % -> Record(unit : %, canonical : %, associate : %) if R has EntireRing
from EntireRing
zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

CharacteristicNonZero

Comparable

Module(Fraction(Integer))

noZeroDivisors

LeftModule(Fraction(Integer))

CoercibleFrom(R)

RightModule(%)

Monoid

Algebra(R)

AbelianMonoid

Algebra(%)

BiModule(R, R)

NonAssociativeAlgebra(Fraction(Integer))

CancellationAbelianMonoid

MagmaWithUnit

RetractableTo(Fraction(Integer))

AbelianGroup

RightModule(Fraction(Integer))

CoercibleFrom(Fraction(Integer))

RetractableTo(Integer)

CommutativeStar

AbelianMonoidRing(R, E)

LeftModule(%)

LeftModule(R)

IndexedProductCategory(R, E)

Module(%)

Algebra(Fraction(Integer))

SetCategory

IndexedDirectProductCategory(R, E)

NonAssociativeAlgebra(R)

Rng

FreeModuleCategory(R, E)

CommutativeRing

IntegralDomain

TwoSidedRecip

Magma

NonAssociativeRing

SemiGroup

BiModule(%, %)

CoercibleFrom(Integer)

CoercibleTo(OutputForm)

AbelianSemiGroup

NonAssociativeSemiRing

NonAssociativeAlgebra(%)

AbelianProductCategory(R)

Module(R)

RightModule(R)

BiModule(Fraction(Integer), Fraction(Integer))

RetractableTo(R)

NonAssociativeRng

unitsKnown

Ring

SemiRng

EntireRing

NonAssociativeSemiRng

CharacteristicZero

BasicType

SemiRing

FullyRetractableTo(R)