JetBundleFunctionCategory(JB)

JB : JetBundleCategory

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.

* : (%, %) -> %: from Magma

* : (Integer, %) -> %: from AbelianGroup

* : (NonNegativeInteger, %) -> %: from AbelianMonoid

* : (PositiveInteger, %) -> %: from AbelianSemiGroup

+ : (%, %) -> %: from AbelianSemiGroup

- : % -> %: from AbelianGroup

- : (%, %) -> %: from AbelianGroup

0 : () -> %: from AbelianMonoid

1 : () -> %: from MagmaWithUnit

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

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)

P : List(NonNegativeInteger) -> %

P : NonNegativeInteger -> %

P : (PositiveInteger, List(NonNegativeInteger)) -> %

P : (PositiveInteger, NonNegativeInteger) -> %

U : () -> %

U : PositiveInteger -> %

X : () -> %

X : PositiveInteger -> %

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

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

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 : JB -> %: coerce(jv) coerces the jet variable jv into a local section.

coerce : Integer -> %: from NonAssociativeRing

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

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

const? : % -> Boolean: const?(f) checks whether f depends of jet variables.

dSubst : (%, JB, %) -> %: dSubst(f, jv, exp) is like subst(f, jv, exp). But additionally for all derivatives of jv the corresponding substitutions are performed.

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.

exquo : (%, %) -> Union(%, "failed"): from EntireRing

extractSymbol : SparseEchelonMatrix(JB, %) -> SparseEchelonMatrix(JB, %): extractSymbol(jm) extracts the highest order part of the Jacobi matrix.

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.

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.

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

jacobiMatrix : List(%) -> SparseEchelonMatrix(JB, %): jacobiMatrix(sys) constructs the Jacobi matrix of the family sys of functions.

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.

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

numIndVar : () -> PositiveInteger

numerator : % -> %: numerator(f) yields the numerator of f.

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.

plenaryPower : (%, PositiveInteger) -> %: from NonAssociativeAlgebra(%)

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

setNotation : Symbol -> Void

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.

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.