|
Calling Sequence
|
|
Infinitesimals(PDESYS, DepVars, S, options=value)
|
|
Parameters
|
|
PDESYS
|
-
|
PDE or a set or list of PDEs; it can include ODEs and non-differential equations
|
DepVars
|
-
|
(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 and 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
|
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 and eta[m] components of the infinitesimals
|
|
|
|
|
Options
|
|
•
|
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 is a non-negative integer, so that Infinitesimals will search for infinitesimals all of them of degree . You can also specify the degree of each infinitesimal, say, , , .., , passing, say, degree = {_xi[x] = n, _xi[t] = m, .. , _eta[u] = p}, where , , 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 is a non-negative integer generates a search for infinitesimals depending on any of the permutations of jet variables; this is useful in contexts where you need only infinitesimals depending on just some () variables.
|
–
|
dependency = n..m generates a search for infinitesimals depending on any permutation of variables where , so depending on not less than and no more than variables.
|
–
|
Let's say the jet variables are , , and : 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 .
|
•
|
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 of independent variables plus the number of dependent variables to be correspondingly associated with to and with to infinitesimals. Alternatively, this list can contain 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.
|
|
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 , 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 entering the solution of the determining system use split = false
|
•
|
specialize_Fn = true | false | set(procedure)
|
|
By default the arbitrary functions 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 , where 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.
|
|
This option is used to indicate the root names to be used to represent the infinitesimals instead of the default and .
|
|
|
Description
|
|
•
|
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 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.
|
|
|
Examples
|
|
Consider first a simple case; use diff_table and declare to avoid redundancies in the input and in the display of the output
>
|
U := diff_table(u(x,t)):
|
>
|
PDE := U[x,x] - U[t]=0;
|
To see the last computed output (in this case, ) with all its functionality and structure explicit, not using the enhanced compact mathematical display above, use show
The infinitesimals of (point) symmetry generators for 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 is displayed in jet notation (because of using declare), is and so on. So, another way to compute the infinitesimals is to first compute this determining system and then solve it using pdsolve, as in .
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 and the positions of independent variables in the single function of this problem . The first number indexing the infinitesimal label identifies the dependent variable to which the infinitesimal corresponds (in this example there is only one, ). You can tell that these infinitesimals are related to point symmetry transformations because they where searched as depending on () - not on the partial derivatives of . 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 and of 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 , or
>
|
Infinitesimals(PDE, dependency = {x, t, u});
|
Infinitesimals depending on either of or
>
|
Infinitesimals(PDE, dependency = {[x,t] ,u});
|
Infinitesimals involving the product or sum of only two functions and 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));
|
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;
|
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 and
>
|
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 and . 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 prolonged to order 1 (that is: appliable to functions depending on up to first order partial derivatives of and )
>
|
IG := InfinitesimalGenerator(G[5], DepVars, expanded, prolongation = 1);
|
These are the invariants up to order 1 associated to
>
|
Invariants(G[5], DepVars);
|
Therefore, if you apply to each of these invariants in the sequence above, you are expected to obtain a sequence of zeros
This is the transformation associated to leaving invariant
>
|
NewVars := [f, g](r, s);
|
>
|
SymmetryTransformation(G[5], DepVars, NewVars);
|
In the above is the parameter of the (Lie) group of transformations. These other are the transformation equations and their inverses, associated to , reducing the number of independent variables of
>
|
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 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);
|
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 are
>
|
DE_infinitesimals := Infinitesimals(DE, displayfunc= false);
|
However, the system does not include the integrability condition that can be derived from its equations. You can see that is compatible with DE by changing the ordering for the independent variables (see casesplit)
>
|
casesplit(DE, ivars = [t,x]);
|
To see a version of 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 above
>
|
Infinitesimals(closed_DE, displayfunc= false);
|
Compare for instance the arbitrary functions found in the output above for and with the ones found in . Another way to see how 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 before computing the determining system for its symmetries by using the option closesystem
>
|
Infinitesimals(DE, closesystem, displayfunc= false);
|
>
|
map(SymmetryTest, [(44)], DE);
|
The Infinitesimals command also works with anticommutative variables, natively, without using the approach explained in PerformOnAnticommutativeSystem.
Set first and as suffixes for variables of type/anticommutative (see Setup)
>
|
Setup(anticommutativepre = {theta, Q});
|
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]));
|
>
|
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 and two of the independent variables, and ; 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);
|
>
|
S := [xi[1], xi[2], Xi[1], Xi[2], Eta](x, y, theta[1], theta[2]);
|
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)]);
|
|
|
Compatibility
|
|
•
|
The typeofsymmetry option was updated in Maple 15.
|
|
|
|