UnivariateSkewPolynomialCategory(R)

R : Ring

This is the category of univariate skew polynomials over an Ore coefficient ring. The multiplication is given by x a = \sigma(a) x + \delta a. This category is an evolution of the types MonogenicLinearOperator, OppositeMonogenicLinearOperator, and NonCommutativeOperatorDivision developed by Jean Della Dora and Stephen M. Watt.

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

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

* : (%, Fraction(Integer)) -> % if R has Algebra(Fraction(Integer)): from RightModule(Fraction(Integer))

* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer): from RightModule(Integer)

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

* : (Fraction(Integer), %) -> % if R has Algebra(Fraction(Integer)): from LeftModule(Fraction(Integer))

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

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

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

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

- : % -> %: from AbelianGroup

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

/ : (%, R) -> % if R has Field: from AbelianMonoidRing(R, NonNegativeInteger)

0 : () -> %: from AbelianMonoid

1 : () -> %: from MagmaWithUnit

= : (%, %) -> Boolean: from BasicType

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

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

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

antiCommutator : (%, %) -> %: from NonAssociativeSemiRng

apply : (%, R, R) -> R: apply(p, c, m) returns p(m) where the action is given by x m = c sigma(m) + delta(m).

associates? : (%, %) -> Boolean if R has EntireRing: from EntireRing

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

binomThmExpt : (%, %, NonNegativeInteger) -> % if % has CommutativeRing: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

characteristic : () -> NonNegativeInteger: from NonAssociativeRing

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

coefficient : (%, List(SingletonAsOrderedSet), List(NonNegativeInteger)) -> %: from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

coefficient : (%, SingletonAsOrderedSet, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

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

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

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 -> %: from NonAssociativeRing

coerce : % -> OutputForm: from CoercibleTo(OutputForm)

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

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

constructOrdered : List(Record(k : NonNegativeInteger, c : R)) -> %: from IndexedProductCategory(R, NonNegativeInteger)

content : % -> R if R has GcdDomain: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

degree : (%, List(SingletonAsOrderedSet)) -> List(NonNegativeInteger): from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

degree : % -> NonNegativeInteger: from AbelianMonoidRing(R, NonNegativeInteger)

degree : (%, SingletonAsOrderedSet) -> NonNegativeInteger: from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

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

exquo : (%, R) -> Union(%, "failed") if R has EntireRing: exquo(l, a) returns the exact quotient of l by a, returning "failed" if this is not possible.

fmecg : (%, NonNegativeInteger, R, %) -> %: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

ground : % -> R: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

ground? : % -> Boolean: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

latex : % -> String: from SetCategory

leadingCoefficient : % -> R: from IndexedProductCategory(R, NonNegativeInteger)

leadingMonomial : % -> %: from IndexedProductCategory(R, NonNegativeInteger)

leadingSupport : % -> NonNegativeInteger: from IndexedProductCategory(R, NonNegativeInteger)

leadingTerm : % -> Record(k : NonNegativeInteger, c : R): from IndexedProductCategory(R, NonNegativeInteger)

leftDivide : (%, %) -> Record(quotient : %, remainder : %) if R has Field: leftDivide(a, b) returns the pair [q, r] such that a = b*q + r and the degree of r is less than the degree of b. This process is called ``left division''.

leftExactQuotient : (%, %) -> Union(%, "failed") if R has Field: leftExactQuotient(a, b) computes the value q, if it exists, such that a = b*q.

leftExtendedGcd : (%, %) -> Record(coef1 : %, coef2 : %, generator : %) if R has Field: leftExtendedGcd(a, b) returns [c, d, g] such that g = a * c + b * d = leftGcd(a, b).

leftGcd : (%, %) -> % if R has Field: leftGcd(a, b) computes the value g of highest degree such that a = g*aa b = g*bb for some values aa and bb. The value g is computed using left-division.

leftLcm : (%, %) -> % if R has Field: leftLcm(a, b) computes the value m of lowest degree such that m = aa*a = bb*b for some values aa and bb. The value m is computed using right-division.

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

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

leftQuotient : (%, %) -> % if R has Field: leftQuotient(a, b) computes the pair [q, r] such that a = b*q + r and the degree of r is less than the degree of b. The value q is returned.

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

leftRemainder : (%, %) -> % if R has Field: leftRemainder(a, b) computes the pair [q, r] such that a = b*q + r and the degree of r is less than the degree of b. The value r is returned.

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

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

mainVariable : % -> Union(SingletonAsOrderedSet, "failed"): from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

map : (Mapping(R, R), %) -> %: from IndexedProductCategory(R, NonNegativeInteger)

mapExponents : (Mapping(NonNegativeInteger, NonNegativeInteger), %) -> %: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

minimumDegree : % -> NonNegativeInteger: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

monicLeftDivide : (%, %) -> Record(quotient : %, remainder : %) if R has IntegralDomain: monicLeftDivide(a, b) returns the pair [q, r] such that a = b*q + r and the degree of r is less than the degree of b. b must be monic. This process is called ``left division''.

monicRightDivide : (%, %) -> Record(quotient : %, remainder : %) if R has IntegralDomain: monicRightDivide(a, b) returns the pair [q, r] such that a = q*b + r and the degree of r is less than the degree of b. b must be monic. This process is called ``right division''.

monomial : (%, List(SingletonAsOrderedSet), List(NonNegativeInteger)) -> %: from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

monomial : (%, SingletonAsOrderedSet, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

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

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

monomials : % -> List(%): from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

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

one? : % -> Boolean: from MagmaWithUnit

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

plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra(Fraction(Integer)): from NonAssociativeAlgebra(R)

pomopo! : (%, R, NonNegativeInteger, %) -> %: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

primitiveMonomials : % -> List(%): from MaybeSkewPolynomialCategory(R, NonNegativeInteger, SingletonAsOrderedSet)

primitivePart : % -> % if R has GcdDomain: from FiniteAbelianMonoidRing(R, NonNegativeInteger)

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

reducedSystem : Matrix(%) -> Matrix(R): from LinearlyExplicitOver(R)

reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer): from LinearlyExplicitOver(Integer)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R)): from LinearlyExplicitOver(R)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if R has LinearlyExplicitOver(Integer): from LinearlyExplicitOver(Integer)

reductum : % -> %: from IndexedProductCategory(R, NonNegativeInteger)

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)

rightDivide : (%, %) -> Record(quotient : %, remainder : %) if R has Field: rightDivide(a, b) returns the pair [q, r] such that a = q*b + r and the degree of r is less than the degree of b. This process is called ``right division''.

rightExactQuotient : (%, %) -> Union(%, "failed") if R has Field: rightExactQuotient(a, b) computes the value q, if it exists such that a = q*b.

rightExtendedGcd : (%, %) -> Record(coef1 : %, coef2 : %, generator : %) if R has Field: rightExtendedGcd(a, b) returns [c, d, g] such that g = c * a + d * b = rightGcd(a, b).

rightGcd : (%, %) -> % if R has Field: rightGcd(a, b) computes the value g of highest degree such that a = aa*g b = bb*g for some values aa and bb. The value g is computed using right-division.

rightLcm : (%, %) -> % if R has Field: rightLcm(a, b) computes the value m of lowest degree such that m = a*aa = b*bb for some values aa and bb. The value m is computed using left-division.

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

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

rightQuotient : (%, %) -> % if R has Field: rightQuotient(a, b) computes the pair [q, r] such that a = q*b + r and the degree of r is less than the degree of b. The value q is returned.

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

rightRemainder : (%, %) -> % if R has Field: rightRemainder(a, b) computes the pair [q, r] such that a = q*b + r and the degree of r is less than the degree of b. The value r is returned.

right_ext_ext_GCD : (%, %) -> Record(generator : %, coef1 : %, coef2 : %, coefu : %, coefv : %) if R has Field: right_ext_ext_GCD(a, b) returns g, c, d, u, v such that g = c * a + d * b = rightGcd(a, b), u * a = - v * b = leftLcm(a, b) and matrix matrix([[c, d], [u, v]]) is invertible.