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

dpolcat.spad line 175

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

AbelianGroup

AbelianMonoid

AbelianMonoidRing(R, E)

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

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

BiModule(R, R)

CancellationAbelianMonoid

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleTo OutputForm

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

DifferentialExtension R

DifferentialRing if R has DifferentialRing

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

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 %

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftModule R

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol

PartialDifferentialRing V

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

RetractableTo R

RetractableTo S

RetractableTo V

RightModule %

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients