Javascript required
Skip to content Skip to sidebar Skip to footer

Find a Non-negative Scaling Invariant Solution Having the Form

PDEtools

InvariantSolutions

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

Calling Sequence

Parameters

Description

Examples

Compatibility

Calling Sequence

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

Parameters

PDESYS

-

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

DepVars

-

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

S

-

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

Description

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 n 1 , 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

Examples

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

>

with PDEtools &colon;

>

U diff_table u x &comma; y &comma; z &comma; t &colon;

>

declare U

u x &comma; y &comma; z &comma; t will now be displayed as u

(1)
>

pde 1 U x , x + U y , y + U z , z U t , t = 0

pde 1 u x , x + u y , y + u z , z u t , t = 0

(2)

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 &comma; numberofsolutions = 2 &comma; dependency = 4 &comma; reduceinonego = 3

u = _C1 + _C2 t 2 y 2 z 2 x 2 , u = _C1 t 2 x 2 y 2 z 2 + _C2 t 2 x 2 y 2 z 2

(3)

Compute four solution 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 &comma; numberofsolutions = 4 &comma; dependency = t &comma; x &comma; display

invariants = t 2 x 2 &comma; u

solutions = u = _C2 ln t x t + x + _C1

_________________________________________________

invariants = t x &comma; u

solutions = u = _C3 + _C4 ln t x x 2 _C4 ln t + x x 2

_________________________________________________

invariants = x &comma; t &comma; u

solutions = u = _F1 t + x + _F2 t x

_________________________________________________

invariants = t x &comma; u x

solutions = u = _C5 t + _C6 x t 2 x 2

_________________________________________________

u = _F1 t + x + _F2 t x , u = _C2 ln t x t + x + _C1 , u = _C1 t + _C2 x t 2 x 2 , u = _C1 + _C2 ln t x x 2 _C2 ln t + x x 2

(4)

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 &comma; invariants = x 2 + t 2 &comma; u

u = _C2 ln t x t + x + _C1

(5)

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 &comma; dependencyofinfinitesimals = none

u = _C1 y + _C2 &comma; u = _C1 z + _C2 &comma; u = _C1 t + _C2 &comma; u = _C1 x + _C2

(6)
>

InvariantSolutions pde 1 &comma; typeofsymmetry = polynomial &comma; degreeofinfinitesimals = 0

u = _C1 y + _C2 &comma; u = _C1 z + _C2 &comma; u = _C1 t + _C2 &comma; u = _C1 x + _C2

(7)

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 &comma; degreeofinfinitesimals = 1

u = _C1 t 2 x 2 y 2 z 2 + _C2 t 2 x 2 y 2 z 2 &comma; u = _F1 t 2 x 2 y 2 + z + _F2 t 2 x 2 y 2 + z t 2 x 2 y 2 &comma; u = _F1 t 2 x 2 z 2 + y + _F2 t 2 x 2 z 2 + y t 2 x 2 z 2 &comma; u = _F1 t 2 y 2 z 2 + x + _F2 t 2 y 2 z 2 + x t 2 y 2 z 2 &comma; u = _C1 + _C2 t 2 x 2 z 2 y 2 &comma; u = _C1 + _C2 t 2 y 2 z 2 x 2 &comma; u = _C2 + _C1 t 2 x 2 y 2 z 2 &comma; u = _C2 ln t x t + x y 2 + z 2 + _C1 &comma; u = _C2 ln t y t + y x 2 + z 2 + _C1 &comma; u = _C2 ln t z t + z x 2 + y 2 + _C1

(8)

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 &comma; displayfunctionality = false

S 1 _&xi; x = 0 &comma; _&xi; y = 1 &comma; _&xi; z = 0 &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = 0 &comma; _&xi; y = 0 &comma; _&xi; z = 1 &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = 0 &comma; _&xi; y = 0 &comma; _&xi; z = 0 &comma; _&xi; t = 1 &comma; _&eta; u = 0 , _&xi; x = 1 &comma; _&xi; y = 0 &comma; _&xi; z = 0 &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = 0 &comma; _&xi; y = t &comma; _&xi; z = 0 &comma; _&xi; t = y &comma; _&eta; u = 0 , _&xi; x = 0 &comma; _&xi; y = 0 &comma; _&xi; z = t &comma; _&xi; t = z &comma; _&eta; u = 0 , _&xi; x = t &comma; _&xi; y = 0 &comma; _&xi; z = 0 &comma; _&xi; t = x &comma; _&eta; u = 0 , _&xi; x = x &comma; _&xi; y = y &comma; _&xi; z = z &comma; _&xi; t = t &comma; _&eta; u = 0 , _&xi; x = 0 &comma; _&xi; y = 0 &comma; _&xi; z = 0 &comma; _&xi; t = 0 &comma; _&eta; u = u , _&xi; x = 0 &comma; _&xi; y = z &comma; _&xi; z = y &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = z &comma; _&xi; y = 0 &comma; _&xi; z = x &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = y &comma; _&xi; y = x &comma; _&xi; z = 0 &comma; _&xi; t = 0 &comma; _&eta; u = 0 , _&xi; x = x z &comma; _&xi; y = z y &comma; _&xi; z = z 2 2 + t 2 2 x 2 2 y 2 2 &comma; _&xi; t = z t &comma; _&eta; u = u z , _&xi; x = x y &comma; _&xi; y = y 2 2 + t 2 2 x 2 2 z 2 2 &comma; _&xi; z = z y &comma; _&xi; t = y t &comma; _&eta; u = u y , _&xi; x = x t &comma; _&xi; y = y t &comma; _&xi; z = z t &comma; _&xi; t = t 2 2 + x 2 2 + y 2 2 + z 2 2 &comma; _&eta; u = u t , _&xi; x = x 2 2 t 2 2 + y 2 2 + z 2 2 &comma; _&xi; y = x y &comma; _&xi; z = x z &comma; _&xi; t = x t &comma; _&eta; u = u x

(9)

You can test these results for correctness using the SymmetryTest  command

>

map SymmetryTest &comma; S 1 &comma; pde 1

0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0 &comma; 0

(10)

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 &comma; U

f &rarr; u u f

(11)

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 &comma; U &comma; 0

invs x &comma; z &comma; u &comma; t 2 y 2

(12)
>

InvariantSolutions pde 1 &comma; U &comma; invariants = invs

u = _C1 _C3 &ExponentialE; 2 _c 1 x + 2 _c 2 z + &ExponentialE; 2 _c 1 x _C1 _C4 + _C2 &ExponentialE; 2 _c 2 z _C3 + _C4 _C6 BesselY 0 &comma; _c 1 _c 2 t 2 y 2 + _C5 BesselJ 0 &comma; _c 1 _c 2 t 2 y 2 &ExponentialE; _c 1 x _c 2 z

(13)

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

>

InvariantSolutions pde 1 &comma; U &comma; S 1 6

u = _C1 _C3 &ExponentialE; 2 _c 1 x + 2 _c 2 y + &ExponentialE; 2 _c 1 x _C1 _C4 + _C2 &ExponentialE; 2 _c 2 y _C3 + _C4 _C6 BesselY 0 &comma; _c 1 _c 2 t 2 z 2 + _C5 BesselJ 0 &comma; _c 1 _c 2 t 2 z 2 &ExponentialE; _c 1 x _c 2 y

(14)

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 &comma; t &colon;

>

PDE U x , x U t , t = 0

PDE u x , x u t , t = 0

(15)

Infinitesimals  for this PDE  can be computed and involve arbitrary functions

>

S Infinitesimals PDE

S _&xi; x x &comma; t &comma; u = _F1 t + x + _F2 t x &comma; _&xi; t x &comma; t &comma; u = _F2 t x + _F1 t + x + 1 &comma; _&eta; u x &comma; t &comma; u = _F3 t + x + _F4 t x , _&xi; x x &comma; t &comma; u = _F5 t + x + _F6 t x &comma; _&xi; t x &comma; t &comma; u = _F6 t x + _F5 t + x &comma; _&eta; u x &comma; t &comma; u = u + _F7 t + x + _F8 t x

(16)

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 &comma; U

>

InvariantTransformation S 1 &comma; U

>

SymmetryTransformation S 1 &comma; 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 &comma; specialize_Fn

S _&xi; x x &comma; t &comma; u = 1 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = 0 &comma; _&xi; x x &comma; t &comma; u = 1 &comma; _&xi; t x &comma; t &comma; u = 2 &comma; _&eta; u x &comma; t &comma; u = 0 &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 1 &comma; _&eta; u x &comma; t &comma; u = 1 &comma; _&xi; x x &comma; t &comma; u = 1 &comma; _&xi; t x &comma; t &comma; u = 1 &comma; _&eta; u x &comma; t &comma; u = u &comma; _&xi; x x &comma; t &comma; u = 1 &comma; _&xi; t x &comma; t &comma; u = −1 &comma; _&eta; u x &comma; t &comma; u = u &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 1 &comma; _&eta; u x &comma; t &comma; u = t + x &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 1 &comma; _&eta; u x &comma; t &comma; u = t x &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = u + 1 &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = u + t + x &comma; _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = u + t x &comma; _&xi; x x &comma; t &comma; u = t + x &comma; _&xi; t x &comma; t &comma; u = 1 + t + x &comma; _&eta; u x &comma; t &comma; u = 0 &comma; _&xi; x x &comma; t &comma; u = t x &comma; _&xi; t x &comma; t &comma; u = t + x + 1 &comma; _&eta; u x &comma; t &comma; u = 0 &comma; _&xi; x x &comma; t &comma; u = t + x &comma; _&xi; t x &comma; t &comma; u = t + x &comma; _&eta; u x &comma; t &comma; u = u &comma; _&xi; x x &comma; t &comma; u = t x &comma; _&xi; t x &comma; t &comma; u = t + x &comma; _&eta; u x &comma; t &comma; u = u

(17)

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

>

SymmetryTransformation S 1 &comma; U

_t1 = x + _&epsilon; &comma; _t2 = t &comma; _u1 _t1 &comma; _t2 = u x &comma; t

(18)
>

InvariantTransformation S 11 &comma; U

_t1 = &ExponentialE; 2 t + 2 x 1 + 2 t + 2 x &comma; _t2 = t &comma; _u1 _t1 = u x &comma; t , t = _t2 &comma; x = LambertW _t1 &ExponentialE; 4 _t2 + 1 2 _t2 1 2 &comma; u x &comma; t = _u1 _t1

(19)
>

InvariantSolutions PDE

u x &comma; t = _C1 t + x &comma; u x &comma; t = _C1 t x &comma; u x &comma; t = _C1 x + _C2 + t &comma; u x &comma; t = _C1 2 x + t + _C2 &comma; u x &comma; t = _C1 &ExponentialE; t 2 x 2 &ExponentialE; x &comma; u x &comma; t = _C1 &ExponentialE; t 2 x 2 &ExponentialE; x &comma; u x &comma; t = x 2 2 + 2 t + 2 _C1 x 2 + t 2 2 + _C2 &comma; u x &comma; t = x 2 2 + 2 t + 2 _C2 x 2 + t 2 2 + _C1 &comma; u x &comma; t = _C2 ln &ExponentialE; 2 t + 2 x 1 + 2 t + 2 x + _C1 &comma; u x &comma; t = _C2 ln &ExponentialE; 2 t + 2 x 2 t 2 x 1 + _C1

(20)

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 &comma; t &comma; t &comma; x &comma; x = diff diff diff u x &comma; t &comma; t &comma; t &comma; x

PDE2 u t , x , x = u t , t , x

(21)
>

S2 Infinitesimals PDE2

S2 _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 1 &comma; _&eta; u x &comma; t &comma; u = _F1 t + _F2 x + _F3 t x , _&xi; x x &comma; t &comma; u = 1 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = _F4 t + _F5 x + _F6 t x , _&xi; x x &comma; t &comma; u = x &comma; _&xi; t x &comma; t &comma; u = t &comma; _&eta; u x &comma; t &comma; u = _F7 t + _F8 x + _F9 t x , _&xi; x x &comma; t &comma; u = 0 &comma; _&xi; t x &comma; t &comma; u = 0 &comma; _&eta; u x &comma; t &comma; u = u + _F10 t + _F11 x + _F12 t x

(22)

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 &comma; U

_t1 = x &comma; _t2 = t + _&epsilon; &comma; _u1 _t1 &comma; _t2 = _F2 x _&epsilon; + _F1 t _F3 t x &DifferentialD; t t + _&epsilon; _F1 _a _F3 _a x &DifferentialD; _a + u x &comma; t

(23)
>

SimilarityTransformation S2 2 &comma; U

_&psi; = x &comma; _&phi; 1 = t &comma; _&phi; 2 _&phi; 1 = _F4 t x _F5 x + _F6 t x &DifferentialD; x + u x &comma; t , t = _&phi; 1 &comma; x = _&psi; &comma; u x &comma; t = _&phi; 2 _&phi; 1 + _F4 _&phi; 1 _&psi; + _&psi; _F5 _a + _F6 _&phi; 1 _a &DifferentialD; _a

(24)

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

u x &comma; t = _C2 + _C3 ln t x x _C3 ln t x + t + _C1 , u x &comma; t = _C2 + _C3 ln t x x _C3 ln t x + x + _C1 , u x &comma; t = _C2 + _C3 ln t x x _C3 ln t x + _C1 + ln x , u x &comma; t = _C2 + _C3 ln t x x _C3 ln t x + t x + _C1

(25)
>

InvariantSolutions PDE2 &comma; specialize_Fn = false

u x &comma; t = x _F1 t _a x + _F2 _a + _F3 _a t x x _a &DifferentialD; _a + _C2 + _C3 ln t x x _C3 ln t x + _C1

(26)

Compatibility

The typeofsymmetry  option was updated in Maple 15.

See Also

CharacteristicQ

CharacteristicQInvariants

declare

DeterminingPDE

diff_table

InvariantTransformation

PDEtools

PerformOnAnticommutativeSystem

Physics

PolynomialSolutions

Setup

SimilaritySolutions

SimilarityTransformation

SymmetrySolutions

SymmetryTest

SymmetryTransformation

Download Help Document

Thank you for submitting feedback on this help document. Your feedback will be used to improve Maple's help in the future.

Find a Non-negative Scaling Invariant Solution Having the Form

Source: https://www.maplesoft.com/support/help/maple/view.aspx?path=PDEtools%2FInvariantSolutions