PDEtools - Maple Programming Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Differential Equations : PDEtools : Symmetries : PDEtools/SimilaritySolutions





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


Calling Sequence





Calling Sequence

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




a PDE, or a set of PDEs, or a list of PDEs; it can include ODEs and not 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

HINT = ...


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

reducedsystemsolver = ...


optional - can be pdsolve or SimilaritySolutions, specifies the command to be used to attempt solving the reduced PDESYS

removeredundant = ...


optional - can be true or false, 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



Given a PDE problem (PDESYS), as an equation or a set or list of them, SimilaritySolutions computes the so-called similarity solutions of PDESYS; these are solutions derived from a 1-dimensional symmetry group admitted by PDESYS, by reducing the number of independent variables by one then attempting solving this reduced problem.


Similarity solutions are special cases of group invariant solutions that can be computed by reducing the number of independent variables by many in one go. Thus, if you are only interested in the PDE solutions, there is a difference to have in mind between these two solving approaches: computing similarity solutions requires computing additional symmetries for the reduced problem, after having reduced it, to further reduce the number of independent variables one at a time until obtaining an ODE problem, while that is not required when reducing the given PDE problem to an ODE problem in one go (i.e. reducing all but one of the independent variables in a single computational step) with InvariantSolutions.


Similarity solutions can also be computed interactively, step by step, by first computing the determining PDE system, next solving this system to obtain the infinitesimals, with them you compute an similarity transformation to reduce by one 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 respectively using the commands: DeterminingPDE, Infinitesimals, SimilarityTransformation and dchange.


If DepVars is not given, SimilaritySolutions 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.


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 SimilaritySolutions 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 SimilaritySolutions. 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 = 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 the Library routine UpperBounds. To override this behavior pass degreeofinfinitesimals = n, where n is a non-negative integer, so that Infinitesimals, called by SimilaritySolutions, 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. In other words, depending on not less than n and no more than m variables.


Specifying a set of lists, for instance, if the jet variables are x, t, and u, so that dependencyofinfinitesimals = {[x], [x, t], [t, u]},this option will generate a search for infinitesimals depending on any of the three 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.


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.


reducedsystemsolver = ...


The right-hand-side is either pdsolve or SimilaritySolutions, 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.)


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


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;



You can compute the similarity solutions corresponding to all the point symmetries of pde[1] in one step by entering SimilaritySolutions(pde[1]); or better: check first the infinitesimals corresponding to point symmetries admitted by pde[1], then examine the different solutions and choose the more suitable one

declare((_xi, _eta)(x, y, z, t, u));

_xix&comma;y&comma;z&comma;t&comma;uwill now be displayed as_&xi;

_etax&comma;y&comma;z&comma;t&comma;uwill now be displayed as_&eta;


S[1] := Infinitesimals(pde[1]);



These are the similarity solutions corresponding to the first list of infinitesimals in S[1]

SimilaritySolutions(pde[1], U[], S[1][1]);



You can test these results for correctness using the pdetest command

pdetest((5), pde[1]);



The approach by means of which SimilaritySolutions computes the solutions above consists of computing a similarity transformation that reduces the number of independent variables of the PDE system by one. For example, this is the similarity transformation

ITR, TR := SimilarityTransformation(S[1][1], U[]);



So this is the transformation to be used with dchange - the command for changing variables:

dchange(TR, pde[1], simplify);



Solve now this PDE problem depending now on three variables (one less than pde[1])

pdsolve((8), build);



Evaluate now TR at this solution for _φ4(_φ1, _φ2, _φ3) to obtain the solution of the original pde[1]

select(has, eval(TR, (9)), u);



Verify this result

pdetest((10), pde[1]);



By default, SimilaritySolutions 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);