Infinitesimals - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim





compute the infinitesimals of symmetry groups admitted by a given PDE system


Calling Sequence






Calling Sequence

Infinitesimals(PDESYS, DepVars, S, options=value)




PDE or a set or list of PDEs; it can include ODEs and non-differential equations



(optional - may be required) function or list of functions indicating the dependent variables of the problem

checkconsistency = ...


(optional) can be true or false (default); to check the consistency of PDESYS before proceeding

closesystem = ...


(optional) can be true or false (default); to derive and then include in PDESYS, explicitly, all its integrability conditions, necessary to compute all the infinitesimals of PDESYS

degree = ...


(optional) related to the option typeofsymmetry = polynomial, indicates the upper bound degree of the polynomial infinitesimals with respect to all or each of the dependent variables

dependency = ...


(optional) indicates the dependency of the infinitesimals, as a number (of jet variables), a range of them, a name, or a set of dependencies each of which can be a set or list of variables or numbers

displayfunctionality = ...


(optional) can be true (default) or false; to display the functionality on the left-hand side of the _ξn...=... and _ηm...=... infinitesimal functions

HINT = ...


(optional) list with the functional form of the infinitesimals of a symmetry generator

jetnotation = ...


(optional) can be jetvariables (default), jetvariableswithbrackets, jetnumbers or jetODE; to respectively return or not using the different jet notations available

simplifier = ...


(optional) indicates the simplifier to be used instead of the default simplify/size

specialize_Fn = ...


(optional) can be true, false (default), or a set of procedures; to specialize any arbitrary functions that may appear in the infinitesimals

specialize_Cn = ...


(optional) can be true (default) or false; to split or not the list of infinitesimals into cases by specializing the integration constants _Cn

typeofsymmetry = ...


(optional) can be any of pointlike (default), contact, evolutionary, or general, or any of polynomial or functionfield, or And(<kind>, <functionality>) where kind is any of the first three types mentioned and functionality is any of polynomial or functionfield; indicates the type of symmetry to be computed

xi_eta = ...


(optional) list of two names to be used as roots for the ξn and eta[m] components of the infinitesimals



checkconsistency = true | false


The default value is false; when true, the consistency of PDESYS is checked before proceeding. Note that you could construct the determining system for the symmetries of an inconsistent PDESYS, in which case the solution of the determining system and everything else derived from it would be meaningless.


closesystem = true | false


By default Infinitesimals processes PDESYS as given. If, in PDESYS, all the integrability conditions that can be derived from its equations are explicitly present, then the determining system for the symmetries is assured to have for solution all the symmetries of PDESYS. Otherwise, the determining system for the symmetries may in rare situations also (correctly) include equations that however may restrict the possible values of the symmetry solutions, and hence some of the symmetries be missed. Correspondingly, some infinitesimals may not be present in the output of Infinitesimals. Note also that, for a system to be closed, it is not sufficient to have it in reduced involutive or equivalent form produced by the casesplit and rifsimp commands or the DifferentialAlgebra package. To assure that all the integrability conditions are explicitly present use the option closesystem. See also the Library routine CloseSystem.


degree = nonnegint | set(function = nonnegint)


This option is related to the option typeofsymmetry = polynomial explained below. By default, an upper bound for the degree of the polynomial dependency of the infinitesimals on the jet variables is determined by PDEtools:-Library:-UpperBounds. To override this behavior pass degree = n, where n is a non-negative integer, so that Infinitesimals will search for infinitesimals all of them of degree n. You can also specify the degree of each infinitesimal, say, _&xi;x, _&xi;t, .., _&eta;u, passing, say, degree = {_xi[x] = n, _xi[t] = m, .. , _eta[u] = p}, where n, m, p are non-negative integers.


dependency = name | nonnegint | range(nonnegint) | set(name) | list(name), or a set or list of any of the previous types


This option is used to specify the dependency of the infinitesimals, typically to restrict it so that their computation is easier.


dependency = name, generates a search for infinitesimals depending only on that name variable.


dependency = n where n is a non-negative integer generates a search for infinitesimals depending on any of the permutations of n jet variables; this is useful in contexts where you need only infinitesimals depending on just some (n) variables.


dependency = n..m generates a search for infinitesimals depending on any permutation of k variables where n<k<m, so depending on not less than n and no more than m variables.


Let's say the jet variables are x, t, and u: dependency = {[x], [x, t], [t, u]} generates a search for infinitesimals depending on any of the tree lists of variables specified.


dependency = {x, t, u} generates a search for infinitesimals depending on any but only one of the indicated variables, in this case x,t,u.


displayfunctionality = true | false


By default, the functionality with which the infinitesimals were searched is displayed together with infinitesimal's labels in the left-hand sides of the equations of the lists returned by Infinitesimals, regardless of the actual dependency found for them (as shown in the dependency of the right-hand sides). To suppress the display of this functionality on the left-hand sides pass displayfunctionality = false.


HINT = <functional form of the infinitesimals>


The functional form of the infinitesimals can be specified as a list of algebraic expressions. There must be as many expressions as the number n of independent variables plus the number m of dependent variables to be correspondingly associated with _&xi;1 to _&xi;n and with _&eta;1 to  _&eta;m infinitesimals. Alternatively, this list can contain n+m equations, where the left-hand sides contain any functions of name variables and the right-hand sides contains the actual hint being suggested. In both cases, the algebraic expressions (or those in the right-hand- sides) may or not contain functions to be determined so that the problem has solution. If there are no functions, then either the given HINT exactly solves the determining system for the infinitesimals, and hence is returned as the solution, or it doesn't in which case Infinitesimals will returns no result.


jetnotation = jetvariables | jetvariableswithbrackets | jetODE | jetnumbers


The default value is jetvariables so that the infinitesimals are expressed with the dependent variables and its derivatives in jetvariables jet notation. The value jetODE can be used provided that the input PDESYS consists of a single ODE; the infinitesimals are then expressed using the jetODE notation of DEtools,Lie, the package for ODE symmetries developed before the introduction of symmetry commands in PDEtools.


simplifier = anything


The default value is simplify/size. Use this option to specify the simplifier of your choice. To indicate that no simplification is preferred pass the keyword none on the right-hand side.


specialize_Cn = true | false


By default the returned infinitesimals are split into cases by specializing the integration constants _Cn, all of them but one equal to 0, the remaining one equal to 1. To avoid this splitting and compute a more compact representation of the infinitesimals, parameterized by the _Cn entering the solution of the determining system use split = false


specialize_Fn = true | false | set(procedure)


By default the arbitrary functions Fn... entering the returned infinitesimals are not specialized. When specialize_Fn = true, these functions are specialized taking all of them but one equal to 0, the remaining one equal to 1, and also equal to each of its arguments. So if an arbitrary function has, for example, three arguments, then there will be four specializations. Alternatively you can specify a set of procedures to be applied to the arguments of the arbitrary functions, each one resulting in a different desired specialization.


typeofsymmetry = pointlike | evolutionary | contact | general | polynomial | functionfield | And(symmetry_type, functionality_type)


By default Infinitesimals will search for point symmetries. Alternatively you can request to search for symmetries with polynomial or functionfield type of functionality, or of evolutionary, contact or general symmetry types instead of pointlike, where in this context general means infinitesimals depending on derivatives of each unknown of the system up to order n1, where n is the differential order of the unknown as found in the system, and evolutionary is like general but with the ξ infinitesimals (related to transformations of the independent variables) all equal to zero. The right-hand side can also be of the form And(symmetry_type, functionality_type) where symmetry_type is any of pointlike, evolutionary, contact or general, and functionality_type is one of polynomial or functionfield, the latter related to the FunctionFieldSolutions command. In these cases, You can set the degree of the polynomial or functionfield form using the option degree explained above.


xi_eta = true|false


This option is used to indicate the root names to be used to represent the infinitesimals instead of the default _&xi;n and _&eta;m.



Given a PDE problem (PDESYS), as an equation or a set or list of them, the Infinitesimals command computes the infinitesimals of symmetry generators of transformations leaving invariant PDESYS. Infinitesimals also works with anticommutative variables set using the Physics package.


Within the framework of computing the group-invariant (GI) solutions of PDESYS, the first step is to compute the determining PDE system. Next, you attempt to solve this system to obtain the infinitesimals. These are the two steps Infinitesimals does. With these infinitesimals you compute an invariant transformation to reduce the number of independent variables of PDESYS. Finally, you attempt solving the reduced system to change variables back resulting in GI solutions for PDESYS. You can compute any of these steps directly departing from PDESYS, respectively using the commands: DeterminingPDE and pdsolve, or Infinitesimals, InvariantTransformation and InvariantSolutions.


If DepVars is not given, Infinitesimals will consider all the differentiated unknown functions in PDESYS as unknown of the problems. Specifying DepVars however permits not only restricting the unknowns in different ways but also specifying unknowns of the problems which do not appear differentiated in PDESYS.


The infinitesimals returned by Infinitesimals are expressed in jetnotation  = jetvariables, are split into cases by specializing the integration constants _Cn in the solution of the determining PDE system, and simplified using the simplifier of DeterminingPDE. You can change these and other defaults, also indicate the functional form of the symmetries, by using the optional arguments explained below.


To avoid having to remember the optional keywords, if you type the keyword misspelled, or just a portion of it, a matching against the correct keywords is performed, and when there is only one match, the input is automatically corrected.



Consider first a simple case; use diff_table and declare to avoid redundancies in the input and in the display of the output


ux&comma;twill now be displayed asu


U := diff_table(u(x,t)):

PDE := U[x,x] - U[t]=0;



To see the last computed output (in this case, PDE) with all its functionality and structure explicit, not using the enhanced compact mathematical display above, use show




The infinitesimals of (point) symmetry generators for PDE are




This result is a sequence of lists of infinitesimals components, with equations where the left-hand side is an infinitesimal label including the functionality with which that infinitesimal was searched, and the right-hand sides show the values found for them. To avoid displaying the functionality in these labels, use displayfunctionality = false.

To rewrite these list of infinitesimals returned by Infinitesimals as the corresponding infinitesimal generator differential operators, for example the last one of the result above




use InfinitesimalGenerator, as in

InfinitesimalGenerator((4)[-1], u(x,t));



The infinitesimals returned by Infinitesimals are computed by solving the determining PDE system returned by DeterminingPDE

DetSys := DeterminingPDE(PDE);



Note in the output above that _&eta;ut,u is 2tu_&eta;ux&comma;t&comma;u displayed in jet notation (because of using declare), _&xi;tt,t is 2t2_&xi;tx&comma;t&comma;u and so on. So, another way to compute the infinitesimals is to first compute this determining system DetSys and then solve it using pdsolve, as in pdsolveDetSys.

To see the lists of infinitesimals before specializing into cases the integration constants of the solution of DetSys use the optional argument split = false

Infinitesimals(PDE, specialize_Cn = false);



To see this output in the jetnumbers jet notation use ToJet or call Infinitesimals with the optional argument jetnotation = jetnumbers

Infinitesimals(PDE, specialize_Cn = false, jetnotation = jetnumbers);



This notation is less readable than the default jetvariables but may be easier to manipulate within programs. Note the correspondence between the numbers indexing the infinitesimal label _&xi; and the positions of independent variables in the single function of this problem u. The first number indexing the infinitesimal label _&eta; identifies the dependent variable to which the infinitesimal corresponds (in this example there is only one, u). You can tell that these infinitesimals are related to point symmetry transformations because they where searched as depending on (x,t,u) - not on the partial derivatives of u. To generate these infinitesimal labels, in jetnumbers or jetvariables notation, prolonged or not, see the GenerateInfinitesimalLabels command of the PDEtools programming Library.

You can test for the correctness of the output of Infinitesimals using the SymmetryTest command in this way

SymmetryTest((9), PDE);



Alternatively you can search for restricted forms of the infinitesimals. The following generates a search for infinitesimals of polynomial type with degree 0 (all the infinitesimals are constants):

Infinitesimals(PDE, degree = 0);



Infinitesimals of polynomial type such that the degree of _&xi;1 and of _&eta;1 are respectively at most 1 and 2, also avoid displaying the functionality on the left-hand sides:

Infinitesimals(PDE, degree = {_xi[x] = 1, _eta[u] = 2}, displayfunctionality = false);



Infinitesimals depending on either of x, t or u

Infinitesimals(PDE, dependency = {x, t, u});



Infinitesimals depending on either of x&comma;t or u

Infinitesimals(PDE, dependency = {[x,t] ,u});



Infinitesimals involving the product or sum of only two functions fx and gt in a particular form

Infinitesimals(PDE, HINT = [_xi[x] = f(x)*g(t), _xi[t] = f(x) + g(t), _eta[u] = f(x)*g(t)]);



The option HINT = [f(x)*g(t), f(x) + g(t), f(x)*g(t)] produces essentially the same output.

An example with two independent and two dependent variables

declare((u,v)(x,t), (xi,eta)(x,t,u,v));

ux&comma;twill now be displayed asu

vx&comma;twill now be displayed asv

ξx&comma;t&comma;u&comma;vwill now be displayed asξ

ηx&comma;t&comma;u&comma;vwill now be displayed asη


DepVars := [u,v](x,t);



To input the system saving redundant input use diff_table

U, V := diff_table(u(x,t)), diff_table(v(x,t)):

e1 := U[t] + 1/2*U[x]^2 + 2*V[] - 2*x = 1/2*(-V[x]^2 + 2*V[x,x] * V[])/V[]^2;



e2 := V[t] + diff(V[]*U[x], x)=0;



PDESYS := [e1, e2]:

The infinitesimals

G := Infinitesimals(PDESYS);



map(SymmetryTest, [G], PDESYS);



You can also specialize the search further, indicating both a type of symmetry, for example: evolutionary, and a type of functionality, for example: polynomial. In their general form, evolutionary symmetries are dynamical in that they depend on derivatives of the functions defining the jet space, here u and v

S := Infinitesimals(PDESYS, typeofsymmetry = And(evolutionary, polynomial), displayfunctionality = false);



As expected, in the result above there are dynamical symmetries (the last three), involving the derivatives ut,ux,vt and vx. Dynamical symmetries can also be tested for correctness with SymmetryTest

map(SymmetryTest, [S], PDESYS);



The infinitesimals of a PDE system are the key building blocks with which you can construct invariant solutions, invariant functions, transformations leaving the PDE system invariant or transformations reducing the number of its independent variables, etc.

For example, this is the infinitesimal generator associated to the fourth list of infinitesimals in G prolonged to order 1 (that is: appliable to functions depending on up to first order partial derivatives of u and v)

IG := InfinitesimalGenerator(G[5], DepVars, expanded, prolongation = 1);



These are the invariants up to order 1 associated to G5

Invariants(G[5], DepVars);



Therefore, if you apply IG to each of these invariants in the sequence above, you are expected to obtain a sequence of zeros

map(IG, [(25)]);






This is the transformation associated to G5 leaving PDESYS invariant

NewVars := [f, g](r, s);



SymmetryTransformation(G[5], DepVars, NewVars);



In the above _&epsilon; is the parameter of the (Lie) group of transformations. These other are the transformation equations and their inverses, associated to G5, reducing the number of independent variables of PDESYS

SimilarityTransformation(G[5], DepVars, NewVars);


An example where the infinitesimals depend on arbitrary functions

U := diff_table(u(x,t)):

PDE := U[x,x] - U[t,t]=0;






To specialize the arbitrary functions _Fn... in the output above use the option specialize_Fn (see the Options section)

Infinitesimals(PDE, specialize_Fn);



To specialize these functions taking, for instance, the product or sum of their arguments, use

Infinitesimals(PDE, specialize_Fn = {`*`, `+`});



An example that is not linear in the highest derivative

PDE := U[x,x]^2*t-U[t]*u^2*x = 0;



Infinitesimals(PDE, display = false);

* Partial match of 'display' against keyword 'displayfunctionality'



By default Infinitesimals processes DE systems as given. If all the integrability conditions that can be derived from the system's equations are explicitly present, then the resulting determining system for the symmetry infinitesimals has for solution all the symmetries. This is not true otherwise. Consider for instance:

DE := [U[x] - U[t] = 0, U[t,t] = 0];



The infinitesimals of point symmetries of DE are

DE_infinitesimals := Infinitesimals(DE, displayfunc= false);

* Partial match of 'displayfunc' against keyword 'displayfunctionality'



However, the system DE does not include the integrability condition ux,x=0 that can be derived from its equations. You can see that ux,x=0 is compatible with DE by changing the ordering for the independent variables (see casesplit)

casesplit(DE, ivars = [t,x]);



To see a version of DE that is closed, i.e., that it includes all its integrability conditions explicitly use the Library routine CloseSystem

closed_DE := PDEtools:-Library:-CloseSystem(DE, [u(x, t)]);



When the system is closed, the resulting determining system and hence infinitesimals that solve it include some not present in DE_infinitesimals above

Infinitesimals(closed_DE, displayfunc= false);

* Partial match of 'displayfunc' against keyword 'displayfunctionality'



Compare for instance the arbitrary functions found in the output above for _&xi;x and _&xi;t with the ones found in DE_infinitesimals. Another way to see how DE_infinitesimals are more restricted is to compute the arbitrary functions present in each result

indets([(41)], typefunc(anything, suffixed(_F)));



indets([DE_infinitesimals], typefunc(anything, suffixed(_F)));



Instead of closing the system interactively, you can request directly to Infinitesimals to close the given system DE before computing the determining system for its symmetries by using the option closesystem

Infinitesimals(DE, closesystem, displayfunc= false);

* Partial match of 'displayfunc' against keyword 'displayfunctionality'



map(SymmetryTest, [(44)], DE);



The Infinitesimals command also works with anticommutative variables, natively, without using the approach explained in PerformOnAnticommutativeSystem.




Set first θ and Q as suffixes for variables of type/anticommutative (see Setup)

Setup(anticommutativepre = {theta, Q});

* Partial match of 'anticommutativepre' against keyword 'anticommutativeprefix'




A PDE system example with two unknown anticommutative functions of four variables, two commutative and two anticommutative; to avoid redundant typing in the input that follows and redundant display of information on the screen let's use PDEtools:-diff_table and PDEtools:-declare.

PDEtools:-declare(Q(x, y, theta[1], theta[2]));

Qx&comma;y&comma;θ1&comma;θ2will now be displayed asQ


q := PDEtools:-diff_table(Q(x, y, theta[1], theta[2])):

Now we can enter derivatives directly as the function's name indexed by the differentiation variables and see the display the same way; two PDEs

pde[1] := q[x, y, theta[1]] + q[x, y, theta[2]] - q[y, theta[1], theta[2]] = 0;



pde[2] := q[theta[1]] = 0;



Set for instance the generic form of the infinitesimals for a PDE system like this one formed by pde[1] and pde[2]. For this purpose, we need anticommutative infinitesimals for the dependent variable Q and two of the independent variables, θ1 and θ2; we use here the capital Greek letters Ξ and Η for the anticommutative infinitesimal symmetry generators and the corresponding lowercase Greek letters for commutative ones

Setup(anticommutativepre = {Xi, Rho}, additionally);

* Partial match of 'anticommutativepre' against keyword 'anticommutativeprefix'




S := [xi[1], xi[2], Xi[1], Xi[2], Eta](x, y, theta[1], theta[2]);




Ηx&comma;y&comma;θ1&comma;θ2will now be displayed asΗ

Ξx&comma;y&comma;θ1&comma;θ2will now be displayed asΞ

ξx&comma;y&comma;θ1&comma;θ2will now be displayed asξ


The corresponding InfinitesimalGenerator

InfinitesimalGenerator(S, Q(x,y,theta[1], theta[2]));



To compute the symmetry infinitesimals you can now compute the DeterminingPDE for this system, then call pdsolve to solve it, or directly call Infinitesimals that performs all that and some other convenient algebraic manipulations automatically; the related result comes specialized

Infinitesimals([pde[1], pde[2]], q[], S);



To verify this result you can use SymmetryTest - it also handles anticommutative variables natively.

map(SymmetryTest, [(55)], [pde[1], pde[2]]);



To see these three list of symmetry infinitesimals in a more readable form with a label on the left-hand side, you can use

map[3](zip, `=`, S, [(55)]);





The typeofsymmetry option was updated in Maple 15.

See Also