DifferentialPolynomialCategory(R, S, V, E)

dpolcat.spad line 175 [edit on github]

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.

* : (%, %) -> %: 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, E)

0 : () -> %: from AbelianMonoid

1 : () -> %: from MagmaWithUnit

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

D : % -> % if R has DifferentialRing: from DifferentialRing

D : (%, V) -> %: from PartialDifferentialRing(V)

D : (%, V, NonNegativeInteger) -> %: from PartialDifferentialRing(V)

D : (%, List(V)) -> %: from PartialDifferentialRing(V)

D : (%, List(V), List(NonNegativeInteger)) -> %: from PartialDifferentialRing(V)

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 : (%, Mapping(R, R)) -> %: from DifferentialExtension(R)

D : (%, Mapping(R, R), NonNegativeInteger) -> %: from DifferentialExtension(R)

D : (%, NonNegativeInteger) -> % if R has DifferentialRing: from DifferentialRing

D : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol): from PartialDifferentialRing(Symbol)

D : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol): from PartialDifferentialRing(Symbol)

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

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

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 : (%, V, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)

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

coefficient : (%, E) -> R: from AbelianMonoidRing(R, E)

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

coerce : % -> % if R has CommutativeRing: from Algebra(%)

coerce : R -> %: from Algebra(R)

coerce : S -> %: from CoercibleFrom(S)

coerce : V -> %: from CoercibleFrom(V)

coerce : Fraction(Integer) -> % if R has Algebra(Fraction(Integer)) or R has RetractableTo(Fraction(Integer)): from Algebra(Fraction(Integer))

coerce : Integer -> %: from NonAssociativeRing

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

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

conditionP : Matrix(%) -> Union(Vector(%), "failed") if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit: from PolynomialFactorizationExplicit

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

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

content : (%, V) -> % if R has GcdDomain: from PolynomialCategory(R, E, V)

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

convert : % -> InputForm if V has ConvertibleTo(InputForm) and R has ConvertibleTo(InputForm): from ConvertibleTo(InputForm)

convert : % -> Pattern(Float) if V has ConvertibleTo(Pattern(Float)) and R has ConvertibleTo(Pattern(Float)): from ConvertibleTo(Pattern(Float))

convert : % -> Pattern(Integer) if V has ConvertibleTo(Pattern(Integer)) and R has ConvertibleTo(Pattern(Integer)): from ConvertibleTo(Pattern(Integer))

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 : (%, V) -> %: from PartialDifferentialRing(V)

differentiate : (%, V, NonNegativeInteger) -> %: from PartialDifferentialRing(V)

differentiate : (%, List(V)) -> %: from PartialDifferentialRing(V)

differentiate : (%, List(V), List(NonNegativeInteger)) -> %: from PartialDifferentialRing(V)

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 : (%, Mapping(R, R)) -> %: from DifferentialExtension(R)

differentiate : (%, Mapping(R, R), NonNegativeInteger) -> %: from DifferentialExtension(R)

differentiate : (%, NonNegativeInteger) -> % if R has DifferentialRing: from DifferentialRing

differentiate : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol): from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol): from PartialDifferentialRing(Symbol)

discriminant : (%, V) -> % if R has CommutativeRing: from PolynomialCategory(R, E, V)

eval : (%, %, %) -> %: from InnerEvalable(%, %)

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)

eval : (%, Equation(%)) -> %: from Evalable(%)

eval : (%, List(%), List(%)) -> %: from InnerEvalable(%, %)

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 : (%, List(Equation(%))) -> %: from Evalable(%)

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 if R has Hashable and V has Hashable: from Hashable

hashUpdate! : (HashState, %) -> HashState if R has Hashable and V has Hashable: from Hashable

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)

isPlus : % -> Union(List(%), "failed"): from PolynomialCategory(R, E, V)

isTimes : % -> Union(List(%), "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.

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 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) -> %: from MagmaWithUnit

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

leftRecip : % -> Union(%, "failed"): 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)

mainVariable : % -> Union(V, "failed"): from MaybeSkewPolynomialCategory(R, E, V)

makeVariable : % -> Mapping(%, 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 -> Mapping(%, 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 : (Mapping(R, R), %) -> %: from IndexedProductCategory(R, E)

mapExponents : (Mapping(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 : (%, V, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)

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

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

monomial? : % -> Boolean: from IndexedProductCategory(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 IndexedDirectProductCategory(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)

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

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(%) -> 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, E)

resultant : (%, %, V) -> % if R has CommutativeRing: from PolynomialCategory(R, E, V)

retract : % -> R: from RetractableTo(R)

retract : % -> S: from RetractableTo(S)

retract : % -> V: from RetractableTo(V)

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(S, "failed"): from RetractableTo(S)

retractIfCan : % -> Union(V, "failed"): 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)

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

support : % -> List(E): from FreeModuleCategory(R, E)

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 : (%, V) -> SparseUnivariatePolynomial(%): from PolynomialCategory(R, E, V)

univariate : % -> SparseUnivariatePolynomial(R): 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.