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.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from RightModule Fraction Integer

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

from RightModule 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 R has CharacteristicNonZero or % has CharacteristicNonZero and R has PolynomialFactorizationExplicit

from CharacteristicNonZero

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 FreeModuleCategory(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 CoercibleFrom S

coerce: V -> %

from CoercibleFrom V

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: % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, E)

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

from PolynomialCategory(R, E, V)

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

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 GcdDomain

ground?: % -> Boolean

from FiniteAbelianMonoidRing(R, E)

ground: % -> R

from FiniteAbelianMonoidRing(R, E)

hash: % -> SingleInteger if V has Hashable and R has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if V has Hashable and R 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)

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 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: (E -> R, %) -> 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: % -> 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 IndexedProductCategory(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?: % -> Boolean

from IndexedProductCategory(R, E)

monomial: (%, List V, List NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, E, V)

monomial: (%, V, NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, E, V)

monomial: (R, E) -> %

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 R has PatternMatchable Float and V has PatternMatchable Float

from PatternMatchable Float

patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable Integer and V 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 %, 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 IndexedProductCategory(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

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

AbelianProductCategory R

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

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

CoercibleFrom R

CoercibleFrom S

CoercibleFrom V

CoercibleTo OutputForm

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

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

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

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

DifferentialExtension R

DifferentialRing if R has DifferentialRing

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

FreeModuleCategory(R, E)

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

Hashable if V has Hashable and R has Hashable

IndexedDirectProductCategory(R, E)

IndexedProductCategory(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 %

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

NonAssociativeAlgebra % if R has CommutativeRing

NonAssociativeAlgebra Fraction Integer if R has Algebra Fraction Integer

NonAssociativeAlgebra R if R has CommutativeRing

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol

PartialDifferentialRing V

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

PatternMatchable Integer if R has PatternMatchable Integer and V 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 Integer if R has LinearlyExplicitOver Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has CommutativeRing

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients