JetDifferentialEquation(JB, D)ΒΆ

JetDifferentialEquation provides the basic data structures and procedures for differential equations as needed in the geometric theory. Differential equation means here always a submanifold in the jet bundle. The concrete equations which define this submanifold are called system. In an object of the type JetDifferentialEquation much more than only the system is stored. `D` denotes the class of functions allowed as equations. It is assumed that the `simplify` procedure of `D` returns only independent equations and a system with symbol in row echelon form.

analyseSymbol: SparseEchelonMatrix(JB, D) -> Record(Rank: NonNegativeInteger, NumMultVar: NonNegativeInteger, Betas: List NonNegativeInteger)

`analyseSymbol(symb)` computes the multiplicative variables of the symbol `symb`.

coerce: % -> OutputForm

`coerce(de)` transforms the differential equation `de` to OutputForm.

copy: % -> %

`copy(De)` returns a copy of the equation `De`.

dimension: (%, NonNegativeInteger) -> NonNegativeInteger

`dimension(de, q)` computes the dimension of the differential equation `de` as a submanifold of the `q``-`th order jet bundle. The result is correct only, if `de` is simplified.

display: % -> Void

`display(de)` prints all information stored about the differential equation `de`. This comprises the system ordered by the order of the equations, the Jacobi matrices separately for each order and the index of the independent variable with respect to which the equation was lastly differentiated (1 for not prolonged equations).

extractSymbol: (%, Boolean) -> SparseEchelonMatrix(JB, D)

`extractSymbol(de, solved?)` computes the symbol of the differential equation `de`. If `solved?` is `true`, the row echelon form of the symbol is computed at once.

insert: (List D, %) -> %

`insert(sys, de)` adds the system `sys = 0` to the differential equation `de`.

jacobiMatrix: % -> List SparseEchelonMatrix(JB, D)

`jacobiMatrix(De)` returns a list of Jacobi matrices sorted by the order of the equations.

join: (%, %) -> %

`join(de1, de2)` combines `de1` and `de2` to a single differential equation.

makeSystem: List D -> %

`makeSystem(sys)` creates a differential equation from a system.

order: % -> NonNegativeInteger

`order(de)` yields the order of the differential equation `de`.

printSys: List D -> OutputForm

`printSys(sys)` writes a list of functions as a vector of equations (with right hand side 0) and coerces the result to OutputForm.

project: (%, NonNegativeInteger) -> %

`project(de, q)` projects the differential equation `de` of order higher than `q` into the `q``-`th order jet bundle.

prolong: % -> Record(SDe: %, IC: List D)

`prolong(de)` prolongs the differential equation `de`. Additionally the arising integrability conditions are returned.

prolong: (%, NonNegativeInteger) -> Record(SDe: %, IC: List D)

`prolong(de, q)` is like `prolong(de)`. However, only equations of lower order than `q` are prolonged.

prolongMV: Record(Rank: NonNegativeInteger, NumMultVar: NonNegativeInteger, Betas: List NonNegativeInteger) -> Record(Rank: NonNegativeInteger, NumMultVar: NonNegativeInteger, Betas: List NonNegativeInteger)

`prolongMV(mv)` calculates the number of multiplicative variables for the prolongation of an involutive symbol.

prolongSymbol: SparseEchelonMatrix(JB, D) -> SparseEchelonMatrix(JB, D)

`prolongSymbol(symb)` prolongs directly the symbol `symb`.

retract: % -> List D

`retract(de)` returns the system defining the differential equation `de`.

setSimpMode: NonNegativeInteger -> NonNegativeInteger

`setSimpMode(i)` sets the flag controlling the used simplifications and returns the old value. Current values are: `i = 0` `->` No simplification modulo lower order equations. `i = 1` `->` Simplification modulo lower order equations. Default is 0.

simplify: % -> Record(SDe: %, IC: List D)

`simplify(de)` simplifies the equations of each order separately using the procedure `simplify` from `D`. Found integrability conditions are also returned separately.

tableau: (SparseEchelonMatrix(JB, D), JetDifferential(JB, D)) -> SparseEchelonMatrix(JB, D)

`tableau(symb, chi)` computes the tableau parametrized by a given one-form.

tableau: (SparseEchelonMatrix(JB, D), List JetDifferential(JB, D)) -> SparseEchelonMatrix(JB, D)

`tableau(symb, lchi)` computes the extended tableau parametrized by a given list of one-forms.