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

Online Help

All Products    Maple    MapleSim





computes the group invariant (symmetry) solutions for a given PDE system


Calling Sequence





Calling Sequence

InvariantSolutions(PDESYS, DepVars, S, 'options'='value')




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



optional - may be required; a function or a list of them indicating the dependent variables of the problem



optional - a list with the functional form of the infinitesimals of a symmetry generator, or a list of lists of them

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 before computing the determining system for its symmetries

degreeofinfinitesimals = ...


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 invariant solutions, 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

dependencyofinfinitesimals = ...


optional - same as dependency but for the infinitesimals with which the invariant solutions are constructed

discardinfinitesimalswithintegrals = ...


optional - can be true or false (default), to discard infinitesimals that contain uncomputed integrals

display = ...


optional - can be true or false (default), to display or not the solutions on the screen as they are computed

HINT = ...


optional - a list with the functional form of the infinitesimals of a symmetry generator

invariants = ...


optional - a list of lists, where each inner list contains invariants to be used to compute group invariant solutions

numberofsolutions = ...


optional - can be a non-negative integer or the keyword all, to specify the maximum number of invariant solutions desired; default is 10

onlythetransformation = ...


optional - can be true or false, to return or not just the different transformations used to reduce the number of independent variables of PDESYS

reducedsystemsolver = ...


optional - can be pdsolve or InvariantSolutions, specifies the command to be used to solve the system resulting from reducing the number of independent variables of PDESYS

reduceinonego = ...


optional - a positive integer up to infinity, specifies how many independent variables are reduced in one go; default is as much as possible

removeredundant = ...


optional - can be true or false (default), to remove or not, redundant solutions which happen to be particular cases of more general solutions being returned together

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

usestandardinvariants = ...


optional - can be true or false (default), to use the standard Invariants instead of the CharacteristicQInvariants for the purpose of computing the invariant solutions



Given a PDE problem (PDESYS), as an equation or a set or list of them, the InvariantSolutions command computes the so-called group invariant solutions of PDESYS; these are solutions derived from n-dimensional symmetry groups admitted by PDESYS by reducing the number of independent variables by n in one go. From a practical point of view, this is an important difference with regards to the so-called similarity solutions (also implemented in PDEtools - see SimilaritySolutions) where the number of independent variables are reduced one at a time and to arrive at a solution requires computing further symmetries for the reduced equation at each step. A "similarity solutions" approach can also be performed using InvariantSolutions using the optional argument reduceinonego = 1. InvariantSolutions also works with anticommutative variables set using the Physics package using the approach explained in PerformOnAnticommutativeSystem.


The group-invariant solutions for PDESYS returned in one step by InvariantSolutions, can also be computed step by step, by first computing the determining PDE system, next solving this system to obtain the infinitesimals. With the infinitesimals, you compute an invariant transformation to reduce the number of independent variables of PDESYS. Finally you solve the reduced system to change variables back, resulting in the solutions for PDESYS. You can compute any of these steps directly departing from PDESYS, respectively using the commands: DeterminingPDE, Infinitesimals, InvariantTransformation, dchange and InvariantSolutions.


If DepVars is not given, InvariantSolutions will consider all the differentiated unknown functions in PDESYS as unknowns 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.


It is possible to indicate the functional form of the symmetries, as shown in the examples, otherwise InvariantSolutions will compute only the solutions that can be derived from the point symmetries admitted by PDESYS.


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.

Optional arguments


A number of optional arguments can change the default computational behavior of InvariantSolutions in ways that, depending on the example or your needs, may be preferred.


checkconsistency = true | false


The default value is false; when true, the consistency of PDESYS is checked before proceeding. Note that one 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 InvariantSolutions 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 invariant solutions may not be present in the output of InvariantSolutions. 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.


degreeofinfinitesimals = nonnegint | set(function = nonnegint)


This option is related to the option typeofsymmetry being polynomial or functionfield explained below. By default, an upper bound for the degree of the polynomial dependency of the infinitesimals on the jet variables is determined by the Library routine UpperBounds. To override this behavior pass degreeofinfinitesimals = n, where n is a non-negative integer, so that Infinitesimals, called by InvariantSolutions, will search for infinitesimals all of them of degree n. You can also specify the degree of each infinitesimal, say, _&xi;1, _&xi;2, _&eta;1, passing, say, degreeofinfinitesimals = {_xi[1] = n, _xi[2] = m, _eta[1] = 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


The right-hand-side is a positive integer, or a set or list of independent variables of the PDE problem represented by PDESYS, respectively indicating either the minimum number of independent variables on which the solutions are expected to depend, or the actual independent variables expected in this dependency. This option is relevant in connection with the fact that some of the group invariant solutions do not depend on all the independent variables of the problem.  If this option is not indicated, the solutions returned are computed regardless of their dependency, using as many symmetries as possible in one go.


dependencyofinfinitesimals = 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.


When dependencyofinfinitesimals = name, all the infinitesimals are assumed to depend only on that name variable.


dependencyofinfinitesimals = 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 we need only infinitesimals depending on just some (n) variables.


Specifying an integer range dependencyofinfinitesimals = 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.


Specifying a set of lists, say the jet variables are x, t, and u, so for instance as in dependencyofinfinitesimals = {[x], [x, t], [t, u]} will generate a search for infinitesimals depending on any of the tree lists of variables specified.


Specifying a set or list of names generates a search for infinitesimals depending on any but only one of the indicated variables.


discardinfinitesimalswithintegrals = true | false


The right-hand-side is either true or false, to discard or not infinitesimals that contain uncomputed integrals before attempting the computation invariants with them and the related group invariant solutions. The default value of this option is false. Passing discardinfinitesimalswithintegrals = true however can remove from the computational process invariants that due to the presence of integrals slow down the solving process significantly even when not help to find any more solutions.


display = true | false


The right-hand-side is either true or false, to display or not the solutions on the screen as they are computed - that is before the final form of the output, typically involving many group invariant solutions, is ready to be returned. The default value of this option is 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 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. 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 used as given to construct solutions, or it doesn't in which case they are discarded.


invariants = [[algebraic, ...], [algebraic, ...], ...]


The right-hand-side is a list of lists, where each inner list contains invariants represented by algebraic expressions, to be used to compute the group invariant solutions. When this option is used, InvariantSolutions will not attempt to compute any infinitesimals for PDESYS and will instead use the given lists of invariants directly.


Note there is a connection between the number of invariants (e.g., in one of these lists) and the number of independent variables that can be removed from the problem in one go. For a PDESYS problem involving n independent and m dependent variables, a point symmetry of PDESYS has n + m - 1 differential invariants of order zero. Recalling: invariants of order j involve at most derivatives of order j of the dependent variables. For each additional point symmetry enlarging the symmetry group, this number o differential invariants of order zero, now simultaneously invariant under the whole group, gets reduced by one. So, when n + m - k invariants of order zero are passed, InvariantSolutions will attempt first a reduction of k variables in one go, then k - 1 and so on until either achieving the numberofsolutions or exhausting the use of the invariants received for the purpose of computing solutions.


numberofsolutions = nonnegint


The right-hand-side is a positive integer indicating how many solutions InvariantSolutions will attempt to compute before interrupting the process and returning the solutions found. This option is relevant in connection that, depending on the Infinitesimals and related Invariants found, the computation of all the related solutions may take more time than desired in a situation where only some solutions are required.  The default behavior is to compute the 10 group invariant solutions obtained by reducing the number of independent variables as much as possible in one go (that is using many symmetries at the same time).


onlythetransformation = ...


The right-hand-side is either true or false, to return or not just the different transformations used to reduce the number of independent variables of PDESYS. This option is used by the InvariantTransformation command to compute these transformations. By combining this option with the other options you can search in an optimized way for only the transformations you are interested in. This option is also of use when the transformation to reduce - say by k - the number of independent variables in one go exist, but the system fails in solving the resulting reduced problem. In these cases it may be that by working with the transformation and the reduced PDEs system you may arrive to the solution to the original PDESYS after some interactive steps.


reducedsystemsolver = ...


The right-hand-side is either pdsolve or InvariantSolutions, specifies the command to be used to attempt solving the reduced PDESYS. The default command used is a combination of pdsolve, dsolve and solve and whenever the solution obtained involves ODESolStruc or DESol, this solution is discarded as unsuitable for representing PDE solutions. (Note: this may change in the future.)


reduceinonego = ...


The right-hand-side is a positive integer, say k; infinity is allowed meaning as much as possible. This number k specifies how many independent variables are to be reduced in one go. The default value is infinity. When this option is passed, only solutions obtained by reducing k variables in one go are returned. Note also that this option interacts with the numberofsolutions = ... option in that InvariantSolutions will not compute more solutions than the value of numberofsolutions.


removeredundant = ...


The right-hand-side is either true or false, to remove or not redundant solutions that frequently appear in the set of group invariant solutions; they may be redundant in that they may be particular cases of more general solutions being returned together.


simplifier = ...


The right-hand-side indicates the simplifier to be used instead of the default which is simplify/size. This option is of use not just to simplify the solutions. You can specify any procedure to be used as simplifier; in this way you can have the solutions computed InvariantSolutions post-processed entirely in the way you need before being returned (e.g. discard some, do something else with other ones, etc.).


specialize_Cn = ...


The right-hand-side is either true or false, to split or not the list of infinitesimals into cases by specializing the integration constants _Cn (see related discussion in Infinitesimals) before computing invariants in the framework of the process to derive group-invariant solutions from these infinitesimals. The default of this option is true. This option is irrelevant when invariants are passed using the invariants = ... option described above.


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 specializing, taking all of them but one equal to 0, the remaining one equal to 1 and to each of its arguments. So if an arbitrary function has - say - 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 InvariantSolutions will search for point symmetries to construct the corresponding invariant solutions. Alternatively you can request it 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 degreeofinfinitesimals explained above.


usestandardinvariants = true | false


By default, InvariantSolutions will search for solutions by computing invariants from the characteristicQ function of the symmetries. The same computation can be carried out using the standard Invariants, normally resulting in a more complicated computation, though sometimes preferred for investigation or pedagogical reasons. For that purpose pass usestandardinvariants = true


InvariantSolutions is programmed to automatically return invariant solutions (up to 10) reducing as many independent variables as possible in one go. So invoking it as in InvariantSolutions(PDE) would suffice for that purpose. Most of the time, however, we are interested in either the most general invariant solutions, or those that can be computed faster, or that depend only on certain variables and so on. The following examples aim at illustrating the different ways of computing all these solutions.

Consider the wave equation in four dimensions; to avoid redundant typing on input and on the display use diff_table and declare


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


ux&comma;y&comma;z&comma;twill now be displayed asu


pde[1] := U[x,x] + U[y,y] + U[z,z] - U[t,t] = 0;



Compute just two solutions, both depending on the four variables {x, y, z, t}, reducing the number of independent variables only by three in one go (so that the problem becomes an ODE)

{InvariantSolutions(pde[1], numberofsolutions = 2, dependency = 4, reduceinonego = 3)};


Compute four solutions depending at least on {x, t} (note these may depend on arbitrary functions _Fn where n is an integer); display each of them as soon as it is computed (before computing the other ones)

InvariantSolutions(pde[1], numberofsolutions = 4, dependency = {x,t}, display);














This display option is also useful in that you can select the invariants =[....] with the mouse, copy, and paste it as extra argument to InvariantSolutions, in order to compute only the solutions it can derive from those invariants. In this sense the invariants you see on the screen associated to each solution are a sort of fingerprint of the solution. For example

InvariantSolutions(pde[1], invariants = [-x^2+t^2, u]);



If the purpose is to compute some solutions rapidly, regardless of their generality, you can use use the options typeofsymmetry = polynomial or in addition specify that the degreeofinfinitesimals = 0 so that only constant infinitesimals are searched to construct invariant solutions; the same can be obtained specifying that the dependencyofinfinitesimals = 0 (they depend on 0 variables) or that they depend on no variables, for example

[InvariantSolutions(pde[1], dependencyofinfinitesimals = none)];



[InvariantSolutions(pde[1], typeofsymmetry = polynomial, degreeofinfinitesimals = 0)];



This results in solutions computed fast and at the same time a bit more general than in the above; we can omit typeofsymmetry = polynomial because it is already implicit when entering degreeofinfinitesimals = ...

{InvariantSolutions(pde[1], degreeofinfinitesimals = 1)};


From where are the group invariant solutions being derived? They are derived from pde[1]'s symmetries, represented by its infinitesimals, that is, a list with the coefficients of the infinitesimal generator of symmetry transformations leaving invariant (in form) pde[1]. These infinitesimals can be computed via

S[1] := Infinitesimals(pde[1], displayfunctionality = false);



You can test these results for correctness using the SymmetryTest command

map(SymmetryTest, [S[1]], pde[1]);



Sometimes, instead of these infinitesimals it is preferable to see the corresponding infinitesimal generator; here is how you get it for example for the infinitesimals of the fourth list of infinitesimals above

InfinitesimalGenerator(S[1][9], U[]);



How are these infinitesimals used? With the infinitesimals you can compute invariants under the whole symmetry group (one or more symmetries); with them, transformations reducing the number of independent variables can systematically be computed (provided the computer has enough memory and time for that purpose - this is frequently the case).

For example, these are the invariants of order zero associated to the fifth list of infinitesimals in S[1], and this is how you can pass them to InvariantSolutions to be used at the time of constructing the solution

invs := [Invariants(S[1][5], U[], 0)];



InvariantSolutions(pde[1], U[], invariants = invs);


The symmetry used when computing the invariant solutions can also be specified

InvariantSolutions(pde[1], U[], S[1][6]);


By default, InvariantSolutions will specialize arbitrary functions _Fn... found in the infinitesimals before attempting a reduction of the number of independent variables. This is so because infinitesimals with arbitrary functions are difficult to use, the invariants necessary may result, in practice, impossible to compute. On the other hand, when those invariants can be computed, the corresponding invariant solution is more general without specializing these arbitrary functions. To handle the latter case use the specialize_Fn = false, or with any procedure of your choice on the right-hand-side. Here are two examples illustrating the two situations.

Consider the wave equation in two dimensions:

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

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



Infinitesimals for this PDE can be computed and involve arbitrary functions

S := Infinitesimals(PDE);



It is not possible to compute a SimilarityTransformation or for the case any symmetry related transformation with them, because of the arbitrary functions, all these commands return NULL:

SimilarityTransformation(S[1], U[]);

InvariantTransformation(S[1], U[]);

SymmetryTransformation(S[1], U[]);

In order to be able to use the infinitesimals S, these arbitrary functions are automatically specialized by all the symmetry commands (but for Infinitesimals), as you could see by interactively using specialize_Fn = true in the call to Infinitesimals

S := [Infinitesimals(PDE, specialize_Fn)];



In this way, all these commands can deal with PDE properly

SymmetryTransformation(S[1], U[]);



InvariantTransformation(S[11], U[]);






As an example where this approach leads to less general solutions consider this other PDE2, also admitting infinitesimals that depend on arbitrary functions

PDE2 := diff(diff(diff(u(x,t),t),x),x) = -diff(diff(diff(u(x,t),t),t),x);



S2 := Infinitesimals(PDE2);



For these other infinitesimals, despite the arbitrary functions it is possible to compute all kinds of symmetry transformations, although the results involve uncomputed integrals

SymmetryTransformation(S2[1], U[]);

_t1=x&comma;_t2=t+_&epsilon;&comma;_u1_t1&comma;_t2=f__2x_&epsilon;` `t+_&epsilon;f__1_af__3_ax&DifferentialD;_a+f__1tf__3tx&DifferentialD;t+ux&comma;t


SimilarityTransformation(S2[2], U[]);

_&psi;=x&comma;_&phi;1=t&comma;_&phi;2_&phi;1=f__4txf__5x+f__6tx&DifferentialD;x+ux&comma;t,t=_&phi;1&comma;x=_&psi;&comma;ux&comma;t=_&phi;2_&phi;1+f__4_&phi;1_&psi;+` `_&psi;f__5_a+f__6_&phi;1_a&DifferentialD;_a


Consequently, the default solution returned by InvariantSolutions is less general than the one you obtain enforcing the use of the infinitesimals with specialize_Fn = false




InvariantSolutions(PDE2, specialize_Fn = false);

ux&comma;t=` `xf__1t_ax+f__2_a+f__3_atxx_a&DifferentialD;_a+c__2+c__3lntxxc__3lntx+c__1




The typeofsymmetry option was updated in Maple 15.

See Also