# DifferentialPolynomialCategory(R, S, V, E)ΒΆ

- R: Ring
- S: OrderedSet
- V: DifferentialVariableCategory S
- E: OrderedAbelianMonoidSup

DifferentialPolynomialCategory is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition, it implements defaults for the basic functions. The functions order and weight are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are leader, initial, separant, differentialVariables, and isobaric?. Furthermore, if the ground ring is a differential ring, then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by eval. A convenient way of referencing derivatives is provided by the functions makeVariable. To construct a domain using this constructor, one needs to provide a ground ring `R`

, an ordered set `S`

of differential indeterminates, a ranking `V`

on the set of derivatives of the differential indeterminates, and a set `E`

of exponents in bijection with the set of differential monomials in the given differential indeterminates.

- 0: %
- from AbelianMonoid
- 1: %
- from MagmaWithUnit
- *: (%, %) -> %
- from Magma
- *: (%, Fraction Integer) -> % if R has Algebra Fraction Integer
- from RightModule Fraction Integer
- *: (%, R) -> %
- from RightModule R
- *: (Fraction Integer, %) -> % if R has Algebra Fraction Integer
- from LeftModule Fraction Integer
- *: (Integer, %) -> %
- from AbelianGroup
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- *: (R, %) -> %
- from LeftModule R
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- /: (%, R) -> % if R has Field
- from AbelianMonoidRing(R, E)
- =: (%, %) -> Boolean
- from BasicType
- ^: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> %
- from Magma
- ~=: (%, %) -> Boolean
- from BasicType
- annihilate?: (%, %) -> Boolean
- from Rng
- antiCommutator: (%, %) -> %
- from NonAssociativeSemiRng
- associates?: (%, %) -> Boolean if R has EntireRing
- from EntireRing
- associator: (%, %, %) -> %
- from NonAssociativeRng
- binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing
- from FiniteAbelianMonoidRing(R, E)
- characteristic: () -> NonNegativeInteger
- from NonAssociativeRing
- charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
- from PolynomialFactorizationExplicit
- coefficient: (%, E) -> R
- from AbelianMonoidRing(R, E)
- coefficient: (%, List V, List NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- coefficient: (%, V, NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- coefficients: % -> List R
- from FiniteAbelianMonoidRing(R, E)
- coerce: % -> % if R has CommutativeRing
- from Algebra %
- coerce: % -> OutputForm
- from CoercibleTo OutputForm
- coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer
- from Algebra Fraction Integer
- coerce: Integer -> %
- from NonAssociativeRing
- coerce: R -> %
- from Algebra R
- coerce: S -> %
- from RetractableTo S
- coerce: V -> %
- from RetractableTo V
- commutator: (%, %) -> %
- from NonAssociativeRng
- conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- content: % -> R if R has GcdDomain
- from FiniteAbelianMonoidRing(R, E)
- content: (%, V) -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- convert: % -> InputForm if R has ConvertibleTo InputForm and V has ConvertibleTo InputForm
- from ConvertibleTo InputForm
- convert: % -> Pattern Float if R has ConvertibleTo Pattern Float and V has ConvertibleTo Pattern Float
- from ConvertibleTo Pattern Float
- convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer and V has ConvertibleTo Pattern Integer
- from ConvertibleTo Pattern Integer
- D: % -> % if R has DifferentialRing
- from DifferentialRing
- D: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, List V) -> %
- from PartialDifferentialRing V
- D: (%, List V, List NonNegativeInteger) -> %
- from PartialDifferentialRing V
- D: (%, NonNegativeInteger) -> % if R has DifferentialRing
- from DifferentialRing
- D: (%, R -> R) -> %
- from DifferentialExtension R
- D: (%, R -> R, NonNegativeInteger) -> %
- from DifferentialExtension R
- D: (%, Symbol) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, V) -> %
- from PartialDifferentialRing V
- D: (%, V, NonNegativeInteger) -> %
- from PartialDifferentialRing V
- degree: % -> E
- from AbelianMonoidRing(R, E)
- degree: (%, List V) -> List NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)

- degree: (%, S) -> NonNegativeInteger
`degree(p, s)`

returns the maximum degree of the differential polynomial`p`

viewed as a differential polynomial in the differential indeterminate`s`

alone.- degree: (%, V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)

- differentialVariables: % -> List S
`differentialVariables(p)`

returns a list of differential indeterminates occurring in a differential polynomial`p`

.- differentiate: % -> % if R has DifferentialRing
- from DifferentialRing
- differentiate: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, List V) -> %
- from PartialDifferentialRing V
- differentiate: (%, List V, List NonNegativeInteger) -> %
- from PartialDifferentialRing V
- differentiate: (%, NonNegativeInteger) -> % if R has DifferentialRing
- from DifferentialRing
- differentiate: (%, R -> R) -> %
- from DifferentialExtension R
- differentiate: (%, R -> R, NonNegativeInteger) -> %
- from DifferentialExtension R
- differentiate: (%, Symbol) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, V) -> %
- from PartialDifferentialRing V
- differentiate: (%, V, NonNegativeInteger) -> %
- from PartialDifferentialRing V
- discriminant: (%, V) -> % if R has CommutativeRing
- from PolynomialCategory(R, E, V)
- eval: (%, %, %) -> %
- from InnerEvalable(%, %)
- eval: (%, Equation %) -> %
- from Evalable %
- eval: (%, List %, List %) -> %
- from InnerEvalable(%, %)
- eval: (%, List Equation %) -> %
- from Evalable %
- eval: (%, List S, List %) -> % if R has DifferentialRing
- from InnerEvalable(S, %)
- eval: (%, List S, List R) -> % if R has DifferentialRing
- from InnerEvalable(S, R)
- eval: (%, List V, List %) -> %
- from InnerEvalable(V, %)
- eval: (%, List V, List R) -> %
- from InnerEvalable(V, R)
- eval: (%, S, %) -> % if R has DifferentialRing
- from InnerEvalable(S, %)
- eval: (%, S, R) -> % if R has DifferentialRing
- from InnerEvalable(S, R)
- eval: (%, V, %) -> %
- from InnerEvalable(V, %)
- eval: (%, V, R) -> %
- from InnerEvalable(V, R)
- exquo: (%, %) -> Union(%, failed) if R has EntireRing
- from EntireRing
- exquo: (%, R) -> Union(%, failed) if R has EntireRing
- from FiniteAbelianMonoidRing(R, E)
- factor: % -> Factored % if R has PolynomialFactorizationExplicit
- from UniqueFactorizationDomain
- factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- fmecg: (%, E, R, %) -> %
- from FiniteAbelianMonoidRing(R, E)
- gcd: (%, %) -> % if R has GcdDomain
- from GcdDomain
- gcd: List % -> % if R has GcdDomain
- from GcdDomain
- gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has GcdDomain
- from PolynomialFactorizationExplicit
- ground: % -> R
- from FiniteAbelianMonoidRing(R, E)
- ground?: % -> Boolean
- from FiniteAbelianMonoidRing(R, E)
- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory

- initial: % -> %
`initial(p)`

returns the leading coefficient when the differential polynomial`p`

is written as a univariate polynomial in its leader.- isExpt: % -> Union(Record(var: V, exponent: NonNegativeInteger), failed)
- from PolynomialCategory(R, E, V)

- isobaric?: % -> Boolean
`isobaric?(p)`

returns`true`

if every differential monomial appearing in the differential polynomial`p`

has same weight, and returns`false`

otherwise.- isPlus: % -> Union(List %, failed)
- from PolynomialCategory(R, E, V)
- isTimes: % -> Union(List %, failed)
- from PolynomialCategory(R, E, V)
- latex: % -> String
- from SetCategory
- lcm: (%, %) -> % if R has GcdDomain
- from GcdDomain
- lcm: List % -> % if R has GcdDomain
- from GcdDomain
- lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has GcdDomain
- from LeftOreRing

- leader: % -> V
`leader(p)`

returns the derivative of the highest rank appearing in the differential polynomial`p`

Note: an error occurs if`p`

is in the ground ring.- leadingCoefficient: % -> R
- from AbelianMonoidRing(R, E)
- leadingMonomial: % -> %
- from AbelianMonoidRing(R, E)
- leftPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> %
- from Magma
- leftRecip: % -> Union(%, failed)
- from MagmaWithUnit
- mainVariable: % -> Union(V, failed)
- from MaybeSkewPolynomialCategory(R, E, V)

- makeVariable: % -> NonNegativeInteger -> % if R has DifferentialRing
`makeVariable(p)`

views`p`

as an element of a differential ring, in such a way that the`n`

-th derivative of`p`

may be simply referenced as`z`

.`n`

where`z`

`:=`

makeVariable(`p`

). Note: In the interpreter,`z`

is given as an internal map, which may be ignored.

- makeVariable: S -> NonNegativeInteger -> %
`makeVariable(s)`

views`s`

as a differential indeterminate, in such a way that the`n`

-th derivative of`s`

may be simply referenced as`z`

.`n`

where`z`

`:=`

makeVariable(`s`

). Note: In the interpreter,`z`

is given as an internal map, which may be ignored.- map: (R -> R, %) -> %
- from AbelianMonoidRing(R, E)
- mapExponents: (E -> E, %) -> %
- from FiniteAbelianMonoidRing(R, E)
- minimumDegree: % -> E
- from FiniteAbelianMonoidRing(R, E)
- minimumDegree: (%, List V) -> List NonNegativeInteger
- from PolynomialCategory(R, E, V)
- minimumDegree: (%, V) -> NonNegativeInteger
- from PolynomialCategory(R, E, V)
- monicDivide: (%, %, V) -> Record(quotient: %, remainder: %)
- from PolynomialCategory(R, E, V)
- monomial: (%, List V, List NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- monomial: (%, V, NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- monomial: (R, E) -> %
- from AbelianMonoidRing(R, E)
- monomial?: % -> Boolean
- from AbelianMonoidRing(R, E)
- monomials: % -> List %
- from MaybeSkewPolynomialCategory(R, E, V)
- multivariate: (SparseUnivariatePolynomial %, V) -> %
- from PolynomialCategory(R, E, V)
- multivariate: (SparseUnivariatePolynomial R, V) -> %
- from PolynomialCategory(R, E, V)
- numberOfMonomials: % -> NonNegativeInteger
- from FiniteAbelianMonoidRing(R, E)
- one?: % -> Boolean
- from MagmaWithUnit
- opposite?: (%, %) -> Boolean
- from AbelianMonoid

- order: % -> NonNegativeInteger
`order(p)`

returns the order of the differential polynomial`p`

, which is the maximum number of differentiations of a differential indeterminate, among all those appearing in`p`

.

- order: (%, S) -> NonNegativeInteger
`order(p, s)`

returns the order of the differential polynomial`p`

in differential indeterminate`s`

.- patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if V has PatternMatchable Float and R has PatternMatchable Float
- from PatternMatchable Float
- patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if V has PatternMatchable Integer and R has PatternMatchable Integer
- from PatternMatchable Integer
- pomopo!: (%, R, E, %) -> %
- from FiniteAbelianMonoidRing(R, E)
- prime?: % -> Boolean if R has PolynomialFactorizationExplicit
- from UniqueFactorizationDomain
- primitiveMonomials: % -> List %
- from MaybeSkewPolynomialCategory(R, E, V)
- primitivePart: % -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- primitivePart: (%, V) -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- recip: % -> Union(%, failed)
- from MagmaWithUnit
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
- from LinearlyExplicitOver R
- reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix R
- from LinearlyExplicitOver R
- reductum: % -> %
- from AbelianMonoidRing(R, E)
- resultant: (%, %, V) -> % if R has CommutativeRing
- from PolynomialCategory(R, E, V)
- retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
- from RetractableTo Fraction Integer
- retract: % -> Integer if R has RetractableTo Integer
- from RetractableTo Integer
- retract: % -> R
- from RetractableTo R
- retract: % -> S
- from RetractableTo S
- retract: % -> V
- from RetractableTo V
- 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
- retractIfCan: % -> Union(R, failed)
- from RetractableTo R
- retractIfCan: % -> Union(S, failed)
- from RetractableTo S
- retractIfCan: % -> Union(V, failed)
- from RetractableTo V
- rightPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- rightPower: (%, PositiveInteger) -> %
- from Magma
- rightRecip: % -> Union(%, failed)
- from MagmaWithUnit
- sample: %
- from AbelianMonoid

- separant: % -> %
`separant(p)`

returns the partial derivative of the differential polynomial`p`

with respect to its leader.- smaller?: (%, %) -> Boolean if R has Comparable
- from Comparable
- solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- squareFree: % -> Factored % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- squareFreePart: % -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid
- totalDegree: % -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- totalDegree: (%, List V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- totalDegreeSorted: (%, List V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- 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
- univariate: % -> SparseUnivariatePolynomial R
- from PolynomialCategory(R, E, V)
- univariate: (%, V) -> SparseUnivariatePolynomial %
- from PolynomialCategory(R, E, V)
- variables: % -> List V
- from MaybeSkewPolynomialCategory(R, E, V)

- weight: % -> NonNegativeInteger
`weight(p)`

returns the maximum weight of all differential monomials appearing in the differential polynomial`p`

.

- weight: (%, S) -> NonNegativeInteger
`weight(p, s)`

returns the maximum weight of all differential monomials appearing in the differential polynomial`p`

when`p`

is viewed as a differential polynomial in the differential indeterminate`s`

alone.

- weights: % -> List NonNegativeInteger
`weights(p)`

returns a list of weights of differential monomials appearing in differential polynomial`p`

.

- weights: (%, S) -> List NonNegativeInteger
`weights(p, s)`

returns a list of weights of differential monomials appearing in the differential polynomial`p`

when`p`

is viewed as a differential polynomial in the differential indeterminate`s`

alone.- zero?: % -> Boolean
- from AbelianMonoid

AbelianMonoidRing(R, E)

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Algebra Fraction Integer

BiModule(R, R)

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm and V has ConvertibleTo InputForm

ConvertibleTo Pattern Float if R has ConvertibleTo Pattern Float and V has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if R has ConvertibleTo Pattern Integer and V has ConvertibleTo Pattern Integer

DifferentialRing if R has DifferentialRing

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

InnerEvalable(%, %)

InnerEvalable(S, %) if R has DifferentialRing

InnerEvalable(S, R) if R has DifferentialRing

InnerEvalable(V, %)

InnerEvalable(V, R)

IntegralDomain if R has IntegralDomain

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

noZeroDivisors if R has EntireRing

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol

PatternMatchable Float if V has PatternMatchable Float and R has PatternMatchable Float

PatternMatchable Integer if V has PatternMatchable Integer and R has PatternMatchable Integer

PolynomialCategory(R, E, V)

PolynomialFactorizationExplicit if R has PolynomialFactorizationExplicit

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RightModule Fraction Integer if R has Algebra Fraction Integer

TwoSidedRecip if R has CommutativeRing

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit