DifferentialAlgebra - Maple Programming Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Differential Equations : Differential Algebra : DifferentialAlgebra/DifferentialRing





constructs a differential polynomial ring with a ranking for the dependent and independent variables


Calling Sequence




Calling Sequence

DifferentialRing (blocks = [...], derivations = [...], arbitrary = [...])

DifferentialRing (R, blocks = [...], derivations = [...], arbitrary = [...])


blocks = [...]


the right-hand-side is a list of dependent variables, possibly including sublists, representing a ranking for them

derivations = [...]


the right-hand-side is a list of independent variables representing a ranking for them

arbitrary = [...]


the right-hand-side is a list of dependent variables, that are supposed to be arbitrary, that is, algebraically independent functions



a differential polynomial ring or a differential ideal; when given, any optional specification of blocks, derivations or arbitrary replaces the one found in R



when R is a differential ring, and additionally is passed, any optional specification of blocks, derivations or arbitrary gets added to the corresponding specification found in R



when the list on the right-hand-side of blocks, derivations or arbitrary contains a single element, this right-hand-side can be the element itself, without enclosing it within a list.



The function call DifferentialRing (derivations = ..., blocks = ..., arbitrary = [...]) constructs and returns a differential polynomial ring, that is a ranking for the dependent and independent variables, possibly specifying arbitrary objects that extend the coefficient field.


The right-hand-side of blocks = [...] is a list of the dependent variables, possibly including sublists of them; only one level of nested sublists is allowed. In the context of a DE system, these dependent variables typically represent the solving variables.


The right-hand-side of derivations = [...] is a list of independent variables specifying the possible dependency of the dependent variables.


The right-hand-side of arbitrary = [...] is a list of algebraically independent arbitrary objects; these can be dependent variables (functions of one or many variables specified in derivations) or other variables (not those specified in derivations). In the context of a DE system, these arbitrary objects typically represent non-solving variables that parameterize the system and its solutions.


Each dependent variable indicated in blocks or arbitrary can be entered as a function's name, say f, or with its dependency explicit, say, as fx,y, and can depend on all or just some of the independent variables specified in derivations, even on none of them, in which case if you enter it as a function use f.


When the DE system to be studied, for example using the RosenfeldGroebner command, will be given in standard Maple function notation, that is with the dependency of functions explicit, then passing the dependent variables to DifferentialRing by giving only their names is naturally simpler. When tackling the DE system, the dependency for each dependent variable will be the one found in the DE system.


Passing the dependent variables to DifferentialRing in function notation is relevant only when some of the dependent variables do not depend on all the independent variables specified in derivations and the DE system to be studied will be given in jet notation, that is with the dependency of functions not made explicit. In this case, when tackling the DE system with RosenfeldGroebner or other DifferentialAlgebra commands, the dependency will be that explicitly specified in blocks = ... and arbitrary = ..., and for each dependent variable in these two lists indicated without dependency, as in f, its dependency will be taken to be the one specified in derivations.


DifferentialRing can also be used to construct a new differential ring from a given one, by changing any of the blocks, derivations or arbitrary parts of it. For this purpose the first argument should be a differential ring, or a differential ideal (for instance returned by RosenfeldGroebner) from which the embedded differential ring is used as a departure point to produce the new differential ring. Note: If additionally is also passed as an argument, any optional specification of blocks, derivations, or arbitrary is added to and not replaced by the corresponding specification found in R.



Together, the lists blocks and derivations provide the ranking of R, that is, an ordering for the derivatives of the dependent variables with respect to the independent variables. In brief, the elements in blocks (dependent variables or sublists of them) are ranked between each other using an elimination raking and those within a sublist are ranked used an orderly ranking.


An elimination ranking is one where derivatives of leftmost dependent variables, or of all the dependent variables in a leftmost sublist within blocks, rank higher than derivatives of variables to their right. An orderly ranking is one where derivatives of higher differential order rank higher than derivatives of lower differential order, and if the order is the same, then derivatives of leftmost variables rank higher. Hence for example if blocks = [u, [v, w]] and derivations = [x, t],

ring := DifferentialAlgebra:-DifferentialRing(blocks = [u, [v, w]], derivations = [x, t]);



the list of second and first order derivatives

[u[t, t], u[x, x], u[t, x], v[t, t], v[x, x], v[t, x], w[t, t], w[x, x], w[t, x], u[t], u[x], v[t], v[x], w[t], w[x]];



rank according to (see SortByRank)

DifferentialAlgebra:-Tools:-SortByRank((2), descending, ring);



When a system of differential polynomials is handled by DifferentialAlgebra commands, rankings are typically used to decide which functions and derivatives are expressed in terms of which other ones. When the system is nonlinear and handled by RosenfeldGroebner, taking into account the ranking will also frequently result in a splitting of the system into cases (differential chains), that then naturally depend on the ordering of variables within the ranking.

Typical useful rankings


When simplifying a DE system with respect to its integrability conditions one obtains a kind of normal form for the system, expressed with the lowest possible differential order, and automatically detects if the system is inconsistent (has no solution). For this purpose use an orderly ranking, for instance indicating blocks = [[u, v, w]].


When solving a coupled ODE system, to perform a chain resolution one needs the system in triangularized form, that is, containing one subsystem that involves only one variable, say w, that subsystem is part of a larger subsystem that involves two variables, say v and w, and in turn that is part of the whole system that involves the three variables u, v and w. To accomplish this triangularized form equivalent to having decoupled the system use an elimination ranking passing blocks = [u, v, w].


When studying a coupled ordinary differential equation (ODE) system, to express the differential equations for one variable, say, u, in terms of the other variables, say v and w, use a mixed ranking passing blocks = [u, [v, w]].


When solving a coupled partial differential equation (PDE) system, it is interesting to compute first the ODEs satisfied by the solutions of the system. For this purpose use a lexicographic ranking prefixing the dependent variables or a sublist of them within blocks by the keyword lex, either orderly as in blocks = [lex[u, v, w]] (the ODEs involving u, v and w may result coupled), or using an elimination ranking, as in blocks = [lex[u], lex[v], lex[w]]


The ranking can be adjusted further, in different ways, using the keywords grlexA, grlexB, degrevlexA, and degrevlexB as explained in the Rankings section of the DifferentialAlgebra Glossary.


This command is part of the DifferentialAlgebra package. It can be called using the form DifferentialRing(...) after executing the command with(DifferentialAlgebra). It can also be directly called using the form DifferentialAlgebra[DifferentialRing](...).


In what follows the command DifferentialRing is illustrated with examples where not only the syntax but also the most common types of rankings are explained, in connection with the mathematical computations most frequently done using the DifferentialAlgebra package. The examples used are the same presented in the page for the RosenfeldGroebner command.




Prior to any computations with the DifferentialAlgebra package, the appropriate differential indeterminates (dependent variables) and derivation variables (independent variables) with the ranking for them must be defined with the command DifferentialRing as shown in the following examples.

Detection of inconsistencies in a differential system: orderly rankings


Consider the 3 following equations.

p1 := diff(u(x, y), x) + v(x, y) - y;



p2 := diff(u(x, y), y) + v(x, y);



p3 := diff(v(x, y), x) - diff(v(x, y), y);



Before any manipulation of these equations, indicate the dependent and independent variables, and an ordering (ranking) for them variables all inside a list within a list, as in u,v

R := DifferentialRing(blocks = [[u, v]], derivations = [x, y]);



Call now the RosenfeldGroebner to simplify the system taking into account all the integrability conditions implied in it

RosenfeldGroebner({p1, p2, p3}, R);


This result indicates that the system bears a contradiction; p1, p2, and p3 have no common solution, the system is inconsistent; see details in the Examples section of RosenfeldGroebner.

Solving ordinary differential systems: elimination ranking


To perform a chain resolution of a system of ordinary differential equations, use an elimination ranking. Consider the differential system defined by the following set S of differential polynomials in the unknown functions xt,yt,zt.

S := [diff(x(t), t) - x(t)*(x(t) + y(t)), diff(y(t), t) + y(t)*(x(t) + y(t)), diff(x(t), t)^2 + diff(y(t), t)^2 + diff(z(t), t)^2 - 1];



Using an elimination ranking where zt>yt>xt, you rewrite the system in such a way that there is one equation in xt alone, an equation determining yt in terms of xt, and finally an equation determining zt in terms of yt and xt. To achieve this elimination use an elimination ranking, that is one where all the dependent variables are enclosed in a list in equal footing, and first the variables that you want to be expressed in terms of the next ones, so as in z,y,x.

R := DifferentialRing(blocks = [z, y, x], derivations = [t]):


To see these dependencies more clearly in the rewritten system use Equations command, which is an alternative to the Equations command.

G := RosenfeldGroebner(S, R);



In the result above we see two cases. The equations of the first case satisfying this elimination ranking mentioned are

Equations(G[1], solved);



The equations of the second case also satisfying the elimination ranking proposed are

Equations(G[2], solved);



Constrained systems: Orderly and mixed rankings


Consider the set of equations describing the motion of a pendulum, that is, a point mass m suspended from a massless rod of length l under the influence of gravity g, in Cartesian coordinates x,y. The Lagrangian formulation leads to two second order differential equations with an algebraic constraint. T is the Lagrangian multiplier.

P := [m*diff(y(t), t, t) + T(t)*y(t) + g, m*diff(x(t), t, t) + T(t)*x(t), x(t)^2 + y(t)^2 - l^2];



Orderly Ranking


To find the lowest order equations vanishing on the zeros of the system modeling the pendulum and in particular all the algebraic constraints (that is, the equations of order 0), use an orderly ranking, with all the dependent variables in a list within a list, as in T,x,y.

R := DifferentialRing(blocks = [[T, x, y]], derivations = [t], arbitrary = [m, l, g]):

G := RosenfeldGroebner(P, R);



Equations(G[1], solved);



Equations(G[2], solved);



The second component in the output of RosenfeldGroebner corresponds to the equilibria of the pendulum. From the first component of the output, it can be seen that the actual motion is described by two first order differential equations with a constraint: the solution depends on only two arbitrary constants.


Mixed Ranking


To obtain the differential system satisfied by x and y alone, eliminate T, so enter a ranking where T is in equal footing to the list of x,y and to its left, as in T,x,y

RM := DifferentialRing(R, blocks = [T, [x, y]]);



GM := RosenfeldGroebner(P, RM);



Equations(GM[1], solved);



Equations(GM[2], solved);



Note here that the motion is given by a second order differential equation in yt. Then the Lagrange multiplier is given explicitly in terms of yt and its first derivative.

Solving partial differential system: lexicographic elimination ranking


To solve overdetermined systems of partial differential equations it is interesting to compute first the ordinary differential equations satisfied by the solutions of the system. For this purpose, a lexicographic ranking must be chosen. Consider the differential system S defining the infinitesimal generators of the symmetry group of the Burgers equations.

Burgers_pde := diff(u(t, x), t) = diff(u(t, x), x, x) - u(t, x)*diff(u(t, x), x);



BurgersSymm := PDEtools:-DeterminingPDE(Burgers_pde, u(t, x), [V1, V2, V3](t, x, u));



Seek the ordinary differential equations with respect to t satisfied by the solutions of this system using lex at the time of raking the variables, as in lexV3,V2,V1

R := DifferentialRing(blocks = [lex[V3, V2, V1]], derivations = [u, x, t]);



G := RosenfeldGroebner(map(lhs - rhs, BurgersSymm), R);



Equations(G[1], solved);



There are three independent ordinary differential equations with respect to t (the last three of the differential characteristic set). All other ordinary (in t) equations vanishing on the solutions of BurgersSymm can be written as linear combination of these three with their derivatives.


You can change any of the pieces of information constituting a differential ring by passing the ring itself as the first argument, followed by any of the keywords blocks = ..., derivations = ..., parameters = ..., and so on, where the right-hand sides specify the new information, or you can also add to the previous information by passing the keyword additionally.

Get(data, R);

* Partial match of 'data' against keyword 'differentialringdata'



R_with_replaced_blocks := DifferentialRing(R, blocks = [F, V1, H]);



Get(data, R_with_replaced_blocks);

* Partial match of 'data' against keyword 'differentialringdata'



R_additionally_blocks_and_arbitrary := DifferentialRing(R, blocks = [F, H], arbitrary = [V1, V2], additionally);



Get(data, R_additionally_blocks_and_arbitrary);

* Partial match of 'data' against keyword 'differentialringdata'



R_with_replaced_arbitrary := DifferentialRing(R, arbitrary = [F, H]);



Get(data, R_with_replaced_arbitrary);

* Partial match of 'data' against keyword 'differentialringdata'



For more details see RosenfeldGroebner

See Also