# JetBundleFunctionCategory JBΒΆ

JetBundleFunctionCategory defines the category of functions (local sections) over a jet bundle. The formal derivative is defined already here. It uses the Jacobi matrix of the functions. The columns of the matrices are enumerated by jet variables. Thus they are represented as a Record of the matrix and a list of the jet variables. Several simplification routines are implemented already here.

- 0: %
- from AbelianMonoid
- 1: %
- from MagmaWithUnit
- *: (%, %) -> %
- from Magma
- *: (Integer, %) -> %
- from AbelianGroup
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- =: (%, %) -> Boolean
- from BasicType
- ^: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> %
- from Magma
- ~=: (%, %) -> Boolean
- from BasicType
- annihilate?: (%, %) -> Boolean
- from Rng
- antiCommutator: (%, %) -> %
- from NonAssociativeSemiRng
- associates?: (%, %) -> Boolean
- from EntireRing
- associator: (%, %, %) -> %
- from NonAssociativeRng

- autoReduce: List % -> List %
`autoReduce(sys)`

tries to simplify a system by solving each equation for its leading term and substituting it into the other equations.- characteristic: () -> NonNegativeInteger
- from NonAssociativeRing

- class: % -> NonNegativeInteger
`class(f)`

is defined as the highest class of the jet variables effectively occurring in`f`

.- coerce: % -> %
- from Algebra %
- coerce: % -> OutputForm
- from CoercibleTo OutputForm
- coerce: Integer -> %
- from NonAssociativeRing

- coerce: JB -> %
`coerce(jv)`

coerces the jet variable`jv`

into a local section.- commutator: (%, %) -> %
- from NonAssociativeRng

- const?: % -> Boolean
`const?(f)`

checks whether`f`

depends of jet variables.- D: (%, List Symbol) -> %
- from PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol
- D: (%, Symbol) -> %
- from PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> %
- from PartialDifferentialRing Symbol

- denominator: % -> %
`denominator(f)`

yields the denominator of`f`

.

- differentiate: (%, JB) -> %
`differentiate(f, jv)`

differentiates the function`f`

`wrt`

the jet variable`jv`

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

- dimension: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
`dimension(sys, jm, q)`

computes the dimension of the manifold described by the system`sys`

with Jacobi matrix`jm`

in the jet bundle of order`q`

.

- dSubst: (%, JB, %) -> %
`dSubst(f, jv, exp)`

is like`subst(f, jv, exp)`

. But additionally for all derivatives of`jv`

the corresponding substitutions are performed.- exquo: (%, %) -> Union(%, failed)
- from EntireRing

- extractSymbol: SparseEchelonMatrix(JB, %) -> SparseEchelonMatrix(JB, %)
`extractSymbol(jm)`

extracts the highest order part of the Jacobi matrix.

- formalDiff2: (%, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DPhi: %, JVars: List JB)
`formalDiff2(f, i, jm)`

formally differentiates the function`f`

with the Jacobi matrix`jm`

`wrt`

the`i`

`-`

th independent variable.`JVars`

is a list of the jet variables effectively in the result`DPhi`

(might be too large).

- formalDiff2: (List %, PositiveInteger, SparseEchelonMatrix(JB, %)) -> Record(DSys: List %, JVars: List List JB)
`formalDiff2(sys, i, jm)`

is like the other ``formalDiff2`` but for systems.

- formalDiff: (%, List NonNegativeInteger) -> %
`formalDiff(f, mu)`

formally differentiates`f`

as indicated by the multi-index`mu`

.

- formalDiff: (%, PositiveInteger) -> %
`formalDiff(f, i)`

formally (totally) differentiates`f`

`wrt`

the`i`

`-`

th independent variable.

- formalDiff: (List %, PositiveInteger) -> List %
`formalDiff(sys, i)`

formally differentiates a family`sys`

of functions`wrt`

the`i`

`-`

th independent variable.

- freeOf?: (%, JB) -> Boolean
`freeOf?(fun, jv)`

checks whether`fun`

contains the jet variable`jv`

.- gcd: (%, %) -> %
- from GcdDomain
- gcd: List % -> %
- from GcdDomain
- gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
- from GcdDomain

getNotation: () -> Symbol

- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory

- jacobiMatrix: (List %, List List JB) -> SparseEchelonMatrix(JB, %)
`jacobiMatrix(sys, jvars)`

constructs the Jacobi matrix of the family`sys`

of functions.`jvars`

contains for each function the effectively occurring jet variables. The columns of the matrix are ordered.

- jacobiMatrix: List % -> SparseEchelonMatrix(JB, %)
`jacobiMatrix(sys)`

constructs the Jacobi matrix of the family`sys`

of functions.

- jetVariables: % -> List JB
`jetVariables(f)`

yields all jet variables effectively occurring in`f`

in an ordered list.- latex: % -> String
- from SetCategory
- lcm: (%, %) -> %
- from GcdDomain
- lcm: List % -> %
- from GcdDomain
- lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)
- from LeftOreRing

- leadingDer: % -> JB
`leadingDer(fun)`

yields the leading derivative of`fun`

. If`fun`

contains no derivatives`1`

is returned.- leftPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> %
- from Magma
- leftRecip: % -> Union(%, failed)
- from MagmaWithUnit

numDepVar: () -> PositiveInteger

- numerator: % -> %
`numerator(f)`

yields the numerator of`f`

.

numIndVar: () -> PositiveInteger

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

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

gives highest order of the jet variables effectively occurring in`f`

.

- orderDim: (List %, SparseEchelonMatrix(JB, %), NonNegativeInteger) -> NonNegativeInteger
`orderDim(sys, jm, q)`

computes the dimension of the manifold described by the system`sys`

with Jacobi matrix`jm`

in the jet bundle of order`q`

over the jet bundle of order`q-1`

.

P: (PositiveInteger, List NonNegativeInteger) -> %

P: (PositiveInteger, NonNegativeInteger) -> %

P: List NonNegativeInteger -> %

P: NonNegativeInteger -> %

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

- reduceMod: (List %, List %) -> List %
`reduceMod(sys1, sys2)`

reduces the system`sys1`

modulo the system`sys2`

.- retract: % -> JB
- from RetractableTo JB
- retractIfCan: % -> Union(JB, failed)
- from RetractableTo JB
- rightPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- rightPower: (%, PositiveInteger) -> %
- from Magma
- rightRecip: % -> Union(%, failed)
- from MagmaWithUnit
- sample: %
- from AbelianMonoid

- simplify: (List %, SparseEchelonMatrix(JB, %)) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
`simplify(sys, jm)`

simplifies a system with given Jacobi matrix. The Jacobi matrix of the simplified system is returned, too.`Depend`

contains for each equation of the simplified system the numbers of the equations of the original system out of which it is build, if it is possible to obtain this information. If one can generate equations of lower order by purely algebraic operations, then`simplify`

should do this.

- simpMod: (List %, List %) -> List %
`simpMod(sys1, sys2)`

simplifies the system`sys1`

modulo the system`sys2`

.

- simpMod: (List %, SparseEchelonMatrix(JB, %), List %) -> Record(Sys: List %, JM: SparseEchelonMatrix(JB, %), Depend: Union(failed, List List NonNegativeInteger))
`simpMod(sys1, sys2)`

simplifies the system`sys1`

modulo the system`sys2`

. Returns the same information as`simplify`

.

- simpOne: % -> %
`simpOne(f)`

removes unnecessary coefficients and exponents, denominators etc.

- solveFor: (%, JB) -> Union(%, failed)
`solveFor(fun, jv)`

tries to solve`fun`

for the jet variable`jv`

.

- sortLD: List % -> List %
`sortLD(sys)`

sorts the functions in`sys`

according to their leading derivatives.

- subst: (%, JB, %) -> %
`subst(f, jv, exp)`

substitutes`exp`

for the jet variable`jv`

in the function`f`

.- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid

- symbol: List % -> SparseEchelonMatrix(JB, %)
`symbol(sys)`

computes directly the symbol of the family`sys`

of functions.

U: () -> %

U: PositiveInteger -> %

- unit?: % -> Boolean
- from EntireRing
- unitCanonical: % -> %
- from EntireRing
- unitNormal: % -> Record(unit: %, canonical: %, associate: %)
- from EntireRing

X: () -> %

X: PositiveInteger -> %

- zero?: % -> Boolean
- from AbelianMonoid

Algebra %

BiModule(%, %)

Module %