PDEtools
DeterminingPDE
computes the determining PDE system satisfied by the infinitesimals of the symmetry groups, or the integrating factors or the conserved currents, admitted by a given PDE system
Calling Sequence
Parameters
Options
Description
Examples
Compatibility
DeterminingPDE(PDESYS, DepVars, S, options=value)
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
S
(optional) list with the functional form of the infinitesimals of a symmetry generator
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 of PDESYS symmetries
conservedcurrents = ...
(optional) indicates the computation of the determining system for the conserved currents or their algebraic form
dependency = ...
(optional) name or a set of names; to indicate (extend or restrict) the dependency of the infinitesimals, integrating factors and conserved currents
integrabilityconditions = ...
(optional) can be true (default) or false; to reduce, or not reduce, the determining PDE output system taking into account its integrability conditions
integratingfactors = ...
(optional) indicates the computation of the determining system for the integrating factors or their algebraic form
jetnotation = ...
(optional) can be jetvariables (default), jetvariableswithbrackets, jetnumbers or jetODE; to respectively return or not using the different jet notations available
moduloPDESYS = ...
(optional) can be true (default) or false; to reduce or not the determining PDE output system taking into account the given PDESYS
simplifier = ...
(optional) indicates the simplifier to be used instead of the default simplify/size
split = ...
(optional) can be true (default) or false; to split or not the returned determining PDE system by taking the coefficients of power of independent objects not entering the dependency of the infinitesimals
typeofsymmetry = ...
(optional) can be pointlike (default), contact, evolutionary or general; indicates the type of symmetry for which a determining PDE system is to be returned
xi_eta = ...
(optional) list of two names to be used as roots for the ξn and ηm components of the infinitesimals
checkconsistency = true | false
The default value is false; when true, the consistency of PDESYS is checked before proceeding. Note that one could construct the determining system for the symmetries of an inconsistent PDESYS, in which case the solution of the determining system would be meaningless.
closesystem = true | false
By default DeterminingPDE processes PDESYS as given. If, in PDESYS, all the integrability conditions that can be derived from its equations are explicitly present, then the resulting determining system for the symmetries is assured to have for solution all the symmetries of PDESYS. Otherwise, the returned determining system 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. 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 related example in the Examples section. See also the Library routine CloseSystem. This option is ignored when computing integrating factors or conserved currents
conservedcurrents
Use this option, giving just the keyword conservedcurrents, to request the determining system satisfied by the conserved currents. Each component of the conserved current will be represented by a different function depending on all the jet space variables including derivatives up to the maximum differential order found in PDESYS minus one. This option can also be used as an equation, in which case the right-hand side can be a single function, and the components of the conserved currents will be taken to be different functions all of them having the same functionality as the one indicated in the right-hand side. Alternatively you can specify the right-hand side as a list directly indicating the functionality of each of the components of the conserved currents.
dependency = x | {x, t, ...}
Indicates the dependency of the infinitesimals, integrating factors or conserved currents. Default value is all the jet space variables associated to point transformations. To change this default use this option with a name variable or a set or list of name variables in the right-hand side.
integrabilityconditions = true | false
Default value is true, and so the output system is simplified with respect to its integrability conditions before being returned. This default frequently simplifies the determining PDE system significantly, but in same cases the mathematical computations to achieve the result are lengthy. To skip that simplification and have DeterminingPDE returning faster pass this option with false in the right-hand side.
integratingfactors
Use this option, giving just the keyword integratingfactors, to request the determining system satisfied by the integrating factors. Each component of the conserved current will be represented by a different function depending on all the jet space variables including derivatives up to the maximum differential order found in PDESYS minus one. This option can also be used as an equation, in which case the right-hand side can be a single function, and the components of the integrating factors will be taken to be different functions all of them having the same functionality as the one indicated in the right-hand side. Alternatively you can specify the right-hand side as a list directly indicating the functionality of each of the components of the integrating factors.
jetnotation = jetvariables | jetvariableswithbrackets | jetODE | jetnumbers
The default value is jetvariables so that the output has all the dependent variables and its derivatives expressed in jet notation. The value jetODE can be used provided that the input is a single ODE; the output is then expressed using the jetODE notation of DEtools,Lie, the package for ODE symmetries developed before the introduction of symmetry commands in PDEtools.
moduloPDESYS = true | false
By default the output system is computed modulo the given PDESYS; when this option is passed with false in the right-hand side, this computational step is skipped.
simplifier = anything
The default value is simplify/size. Use this option to specify the simplifier of your choice. To indicate that no simplification is preferred pass the keyword none in the right-hand side.
split = true | false
By default the output system is split, that is, conformed by the coefficients of different powers of independent objects (e.g.: when computing point symmetries, the system's equations are the coefficients of different powers of the derivatives of the unknowns). That frequently makes the output to be an overdetermined system. When this option is passed with false in the right-hand side, the output system consists of a single partial differential equation.
typeofsymmetry = pointlike | contact | evolutionary | general
By default DeterminingPDE returns a system whose solutions are the point symmetries of the given PDESYS. You can also request the determining system for symmetries of evolutionary, contact or general types, 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. By differential order of the unknown as found in the system it is meant: take the maximum differential order of an unknown within each equation of the PDE system, then take the minimum of those numbers, so that it is possible to return a determining system moduloPDESYS.
xi_eta = true | false
This option is used to indicate the root names to be used to represent the infinitesimals instead of the default _ξn and _ηm.
Given a PDE problem (PDESYS), as an equation, or a set or list of them, the DeterminingPDE command computes the determining PDE system for the symmetries, integrating factors or conserved currents of PDESYS. The output is thus a system of partial differential equations whose solution gives, respectively, the infinitesimals of the symmetry generators leaving invariant PDESYS, the integrating factors or the conserved currents of PDESYS. DeterminingPDE also works with anticommutative variables set using the Physics package.
By default, DeterminingPDE computes the system satisfied by the symmetry infinitesimals of PDESYS and processes PDESYS as given. To request the determining system for the integrating factors or the conserved currents pass the keywords integratingfactors or conservedcurrents. Note that in the case of symmetries, if PDESYS is not closed in the sense of including explicitly all its integrability conditions, the resulting determining system may not include for solutions all the symmetries of PDESYS. To close the system in order to compute all the symmetries use the option closesystem - see details in the Optional arguments section below - see also the related PDEtools Library routine CloseSystem.
Within the framework of computing the so-called group-invariant (GI) solutions of PDESYS, the first step is to compute the determining PDE system, next you attempt solving this system to obtain the infinitesimals, with them 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, Infinitesimals, InvariantTransformation and InvariantSolutions.
If DepVars is not given, DeterminingPDE will consider all the differentiated unknown functions in PDESYS as unknowns of the problem. 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 argument S is optionally used to indicate the functional form of the symmetries - see the examples - if not given, DeterminingPDE will return a determining system whose solution are the infinitesimals of the point symmetries of PDESYS. To override that behavior when not passing S, use the option typeofsymmetry = ... where the right-hand side can be any of pointlike (default), contact, evolutionary or general (see definitions in the Options section).
Among the most commonly used options explained in the Options section, the PDE system returned by DeterminingPDE is automatically reduced taking into account its integrability conditions, a frequently desired but in some cases expensive mathematical computation, unless explicitly requested otherwise by passing the optional argument integrabilityconditions = false, in which case DeterminingPDE will return faster. Also, the output is by default in jetnotation = jetvariables, modulo the given PDESYS, split with respect to powers of independent objects not entering the dependency of the infinitesimals, and simplified in size. That is frequently the most compact and useful form of the determining system. You can override any of these defaults by passing any of the optional arguments integrabilityconditions = false, jetnotation = ..., moduloPDESYS = false, simplifier = none (or the one you prefer).
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.
with(PDEtools, DeterminingPDE, declare, diff_table, casesplit, InfinitesimalGenerator, Infinitesimals, SymmetryTest):
Consider first a simple case; use diff_table and declare to avoid redundancies in the input (you can enter things using jetvariableswithbrackets jet notation) and in the display of the output (expressed using jetvariables jet notation)
declare(u(x,t));
u⁡x,t⁢will now be displayed as⁢u
U := diff_table(u(x,t)):
PDE1 := U[x,x] - U[t] = 0;
PDE1≔ux,x−ut=0
The determining PDE system whose solutions are the infinitesimals
DetSys := DeterminingPDE(PDE1);
DetSys≔_ξtt,t,t=0,_ηut,u=−_ξtt,t4,_ηuu,u=0,_ηux,x=_ηut,_ξtu=0,_ξtx=0,_ξxt=−2⁢_ηuu,x,_ξxu=0,_ξxx=_ξtt2
The system returned has the leading derivatives isolated on the left-hand sides, and the jet notation used by default is jetvariables, so u is represented by u, ∂u∂x by ux, and so on. The derivatives of the _ξ and _η infinitesimals are displayed indexed, in jetvariableswithbrackets notation, because of the use of declare.
Note the labels for the infinitesimals: they are of the form ξxn and ηum, where xn and um are respectively the names of independent and dependent variables; these are the infinitesimals associated to symmetry transformations of the corresponding (independent or dependent) variable.
You can also specify that you want a different jet notation, for instance jetnumbers (a less mathematical notation, sometimes preferred for programming purposes), in which case the labels identifying each infinitesimal will also appear in jetnumbers notation, as in ξn and ηm
DeterminingPDE(PDE1, jetnotation = jetnumbers);
_ξ2t,t,t=0,_η1t,u=−_ξ2t,t4,_η1x,x=_η1t,_η1u,u=0,_ξ1t=−2⁢_η1x,u,_ξ1x=_ξ2t2,_ξ1u=0,_ξ2x=0,_ξ2u=0
The system returned by DeterminingPDE is automatically simplified with respect to its integrability conditions. This simplification is normally desirable, but in some cases it can be expensive in time or depending on the problem even a bottleneck in the computation of symmetries. To skip this simplification use the option integrabilityconditions = false, in which case the leading derivatives are not isolated; compare for instance DetSys with this other equivalent determining system
DeterminingPDE(PDE1, integrabilityconditions = false);
_ηux,x−_ηut,−2⁢_ξtu,x−2⁢_ξxu,−2⁢_ξxu,x+_ηuu,u,2⁢_ηuu,x−_ξxx,x+_ξxt,−_ξtx,x−2⁢_ξxx+_ξtt,_ξtu,u,_ξxu,u,_ξtu,_ξtx
The fastest (and less simplified) way to compute the determining PDE for the symmetries includes skipping the automatic splitting into coefficients of independent objects, in which case the output consists of a set with a single determining PDE, not a system
DeterminingPDE(PDE1, integrabilityconditions = false, split = false);
−_ξxu,u⁢ux3−_ξtu,u⁢ux2⁢ut−2⁢_ξxu,x⁢ux2−2⁢_ξtu,x⁢ux⁢ut+_ηuu,u⁢ux2−2⁢_ξxu⁢ux⁢ut−2⁢_ξtu⁢ux⁢ux,t+2⁢ux⁢_ηuu,x−_ξxx,x⁢ux−_ξtx,x⁢ut−2⁢_ξxx⁢ut−2⁢_ξtx⁢ux,t+_ηux,x+_ξxt⁢ux+_ξtt⁢ut−_ηut
Note in the output above the presence of ux and ut representing derivatives of u written in jetnotation. To see the last computed output with all its functionality and structure explicit, not using the enhanced compact mathematical display due to declare, use show
show;
−∂2∂u2_ξx⁡x,t,u⁢ux3−∂2∂u2_ξt⁡x,t,u⁢ux2⁢ut−2⁢∂2∂u∂x_ξx⁡x,t,u⁢ux2−2⁢∂2∂u∂x_ξt⁡x,t,u⁢ux⁢ut+∂2∂u2_ηu⁡x,t,u⁢ux2−2⁢∂∂u_ξx⁡x,t,u⁢ux⁢ut−2⁢∂∂u_ξt⁡x,t,u⁢ux⁢ux,t+2⁢ux⁢∂2∂u∂x_ηu⁡x,t,u−∂2∂x2_ξx⁡x,t,u⁢ux−∂2∂x2_ξt⁡x,t,u⁢ut−2⁢∂∂x_ξx⁡x,t,u⁢ut−2⁢∂∂x_ξt⁡x,t,u⁢ux,t+∂2∂x2_ηu⁡x,t,u+∂∂t_ξx⁡x,t,u⁢ux+∂∂t_ξt⁡x,t,u⁢ut−∂∂t_ηu⁡x,t,u
Note in the above that although the infinitesimals and its derivatives are not displayed in jet notation anymore, the unknown u and its derivatives ux, ut are still in jet notation - they enter the expression actually as names, not functions, but representing the functions. As usual, to convert into function notation use FromJet.
The infinitesimals are obtained solving this determining system - we take the most simplified version of it, DetSys, computed lines above
pdsolve(DetSys);
_ηu⁡x,t,u=−x2−2⁢t⁢c__18+c__4⁢x+c__5⁢u+c__8⁢ⅇ_c1⁢t⁢c__6⁢ⅇ_c1⁢x+c__8⁢ⅇ_c1⁢t⁢c__7ⅇ_c1⁢x,_ξt⁡x,t,u=12⁢c__1⁢t2+c__2⁢t+c__3,_ξx⁡x,t,u=x⁢c__1−4⁢c__4⁢t2+c__2⁢x2+c__9
You can compute these infinitesimals directly from PDE1 as well. By default, whenever, it is possible Infinitesimals will present the symmetry groups with all its independent members explicitly, that is, with the integration constants specialized, as in
Infinitesimals(PDE1);
_ξx⁡x,t,u=0,_ξt⁡x,t,u=1,_ηu⁡x,t,u=0,_ξx⁡x,t,u=1,_ξt⁡x,t,u=0,_ηu⁡x,t,u=0,_ξx⁡x,t,u=0,_ξt⁡x,t,u=0,_ηu⁡x,t,u=u,_ξx⁡x,t,u=x2,_ξt⁡x,t,u=t,_ηu⁡x,t,u=0,_ξx⁡x,t,u=−2⁢t,_ξt⁡x,t,u=0,_ηu⁡x,t,u=x⁢u,_ξx⁡x,t,u=0,_ξt⁡x,t,u=0,_ηu⁡x,t,u=ⅇ_c1⁢x⁢ⅇ_c1⁢t,_ξx⁡x,t,u=0,_ξt⁡x,t,u=0,_ηu⁡x,t,u=ⅇ_c1⁢tⅇ_c1⁢x,_ξx⁡x,t,u=t⁢x2,_ξt⁡x,t,u=t22,_ηu⁡x,t,u=−x2+2⁢t⁢u8
The determining PDE system for the integrating factors of PDE1
DeterminingPDE(PDE1, integratingfactors);
_μ1x,x=−_μ1t,_μ1u=0,_μ1ut=0,_μ1ux=0
The determining PDE system for the conserved currents of PDE1 that depend only on x and t
DeterminingPDE(PDE1, conservedcurrents, dependency = [x, t]);
_Jxx+_Jtt
To compute the actual integrating factors or conserved currents - so not just their determining equations- see IntegratingFactors and ConservedCurrents.
The Laplace equation in spherical coordinates with a source term ut,t symmetries
declare(u(r, phi, theta, t), (_xi, _eta)((r, phi, theta, t, u)));
u⁡r,φ,θ,t⁢will now be displayed as⁢u
_ξ⁡r,φ,θ,t,u⁢will now be displayed as⁢_ξ
_η⁡r,φ,θ,t,u⁢will now be displayed as⁢_η
U := diff_table(u(r,phi,theta,t)):
PDE2 := 1/r^2*(2*r*U[r]+r^2*U[r,r]) + 1/r^2/sin(theta)*(cos(theta)*U[theta] + sin(theta)*U[theta,theta]) + 1/r^2/sin(theta)^2*U[phi,phi] = U[t,t];
PDE2≔r2⁢ur,r+2⁢r⁢urr2+cos⁡θ⁢uθ+sin⁡θ⁢uθ,θr2⁢sin⁡θ+uφ,φr2⁢sin⁡θ2=ut,t
The infinitesimals are computed either by Infinitesimals by calling DeterminingPDE to obtain the determining system then solving it calling pdsolve, finally splitting the result according to the integration constants found in pdsolve's solution
Infinitesimals(PDE2);
An ODE example (see more commands for handling ODE symmetry problems also in DEtools,Lie) and a dynamical symmetry represented by infinitesimals depending on the first derivative y'
declare(y(x), prime = x);
y⁡x⁢will now be displayed as⁢y
derivatives with respect to⁢x⁢of functions of one variable will now be displayed with '
ODE2 := diff(y(x),x,x) = Phi(y(x));
ODE2≔y''=Φ⁡y
DS := [_xi = f(x,y,_y1), _eta = 0];
DS≔_ξ=f⁡x,y,_y1,_η=0
The corresponding determining system directly in jetODE notation, that is the notation used in DEtools,Lie, the package for symmetries and integrating factors for ODEs developed before the symmetry commands of PDEtools
DeterminingPDE(ODE2, y(x), DS, 'jetnotation' = 'jetODE');
fx,x=−f_y1,_y1⁢_y1⁢Φ⁡y2−2⁢f_y1,y⁢_y12⁢Φ⁡y−Φy⁢_y12⁢f_y1−fy,y⁢_y13−2⁢f_y1⁢Φ⁡y2−2⁢f_y1,x⁢_y1⁢Φ⁡y−3⁢fy⁢_y1⁢Φ⁡y−2⁢fx,y⁢_y12−2⁢fx⁢Φ⁡y_y1
An ODE in disguise, appearing as a PDE, and the corresponding determining PDE system for a very particular form S2 of its infinitesimals, depending on two arbitrary functions f__1 and f__2
ODE2 := diff(z(x,y),x) = y/x*z(x,y);
ODE2≔zx=y⁢z⁡x,yx
S2 := [0, _F1(y,z*x^(-y)), x^y*z*x^(-y)*_F1(y,z*x^(-y))*ln(x)+x^y*_F2(y,z*x^(-y))];
S2≔0,f__1⁡y,z⁢x−y,xy⁢z⁢x−y⁢f__1⁡y,z⁢x−y⁢ln⁡x+xy⁢f__2⁡y,z⁢x−y
DeterminingPDE(ODE2, S2);
0
The output above is zero because S2 is already a symmetry of ODE2, thus canceling completely the determining system. To test symmetries given as lists of infinitesimals use the SymmetryTest command
SymmetryTest(S2, ODE2);
The determining system for symmetries in evolutionary form for an ODE, directly in jetODE notation
ODE3 := diff(y(x), x,x) = x*y(x)*diff(y(x), x);
ODE3≔y''=x⁢y⁢y'
DeterminingPDE(ODE3, typeofsymmetry = evolutionary, notation = jetODE);
_ηyx,x=−_ηy_y1,_y1⁢x2⁢y2⁢_y12−2⁢_ηy_y1,y⁢_y12⁢x⁢y−_ηy_y1⁢_y12⁢x−2⁢x⁢y⁢_y1⁢_ηy_y1,x+_ηy⁡x,y,_y1⁢x⁢_y1−_ηyy,y⁢_y12−y⁢_ηy_y1⁢_y1+_ηyx⁢x⁢y−2⁢_y1⁢_ηyx,y
By default DeterminingPDE 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 always true otherwise. Consider for instance:
declare(u(x,y));
u⁡x,y⁢will now be displayed as⁢u
U := diff_table(u(x,y)):
DE := [U[x] - U[y] = 0, U[y,y] = 0];
DE≔ux−uy=0,uy,y=0
The determining system for the point symmetries of DE and its corresponding solution are
detsys := DeterminingPDE(DE);
detsys≔_ηuu,u,u=0,_ηuu,u,y=0,_ηuy,y=0,_ξyu,u=0,_ξyu,y=_ηuu,u2,_ξyy,y=2⁢_ηuu,y,_ηux=_ηuy,_ξxu=0,_ξxy=0,_ξyx=_ξyy−_ξxx
pdsolve(detsys);
_ηu⁡x,y,u=c__3⁢u22+x+y⁢c__1+c__4⁢u+x+y⁢c__2+c__5,_ξx⁡x,y,u=f__1⁡x,_ξy⁡x,y,u=−f__1⁡x+c__1⁢x2+4⁢c__1⁢y+c__3⁢u+2⁢c__7⁢x2+c__1⁢y2+c__3⁢u+2⁢c__7⁢y2+c__6⁢u+c__8
The system DE, however, does not include the integrability condition ux,x=0 that can be derived from its equations. To compute a version of DE that is closed, i.e., that it includes all its integrability conditions explicitly you can use the Library routine CloseSystem or directly pass the closesystem option to DeterminingPDE
closed_DE := PDEtools:-Library:-CloseSystem(DE, [u(x, y)]);
closed_DE≔ux−uy,ux,x,ux,y,uy,y
DeterminingPDE(closed_DE);
_ηuu,u,u=0,_ηuu,u,y=0,_ηuy,y=0,_ξyu,u=−_ξxu,u,_ξyu,y=−_ξxu,y+_ηuu,u2,_ξyy,y=2⁢_ηuu,y−_ξxy,y,_ηux=_ηuy,_ξyx=_ξxy+_ξyy−_ξxx
DeterminingPDE(DE, closesystem);
The resulting determining system for the closed version of DE admits solutions more general than (6.28)
pdsolve((31));
_ηu⁡x,y,u=c__3⁢u22+x+y⁢c__1+c__4⁢u+x+y⁢c__2+c__5,_ξx⁡x,y,u=_ξx⁡x,y,u,_ξy⁡x,y,u=x+y2⁢c__1−_ξx⁡x,y,u+x+y⁢c__3+2⁢c__6⁢u2+x+y⁢c__7+c__8
Comparing, in (6.32) _ξx⁡x,y,u is entirely arbitrary while in the infinitesimals (6.28) it is not. The closesystem option is also available when calling Infinitesimals, InvariantSolutions and SimilaritySolutions - all of them will forward the option to DeterminingPDE. For example: the same most general form of the infinitesimals (6.32) can be computed directly via
Infinitesimals(DE, closesystem, dis = false);
* Partial match of 'dis' against keyword 'displayfunctionality'
_ξx=f__1⁡x,y,u,_ξy=−f__1⁡x,y,u,_ηu=1,_ξx=f__2⁡x,y,u,_ξy=−f__2⁡x,y,u+1,_ηu=0,_ξx=f__3⁡x,y,u,_ξy=−f__3⁡x,y,u,_ηu=u,_ξx=f__4⁡x,y,u,_ξy=−f__4⁡x,y,u+x+y,_ηu=0,_ξx=f__5⁡x,y,u,_ξy=−f__5⁡x,y,u+u,_ηu=0,_ξx=f__6⁡x,y,u,_ξy=−f__6⁡x,y,u,_ηu=x+y,_ξx=f__7⁡x,y,u,_ξy=−f__7⁡x,y,u+x+y⁢u2,_ηu=u22,_ξx=f__8⁡x,y,u,_ξy=−f__8⁡x,y,u+x2+2⁢x⁢y+y2,_ηu=x+y⁢u
The DeterminingPDE command also works with anticommutative variables, natively, without using the approach explained in PerformOnAnticommutativeSystem.
with(Physics);
`*`,`.`,Annihilation,AntiCommutator,Antisymmetrize,Assume,Bra,Bracket,Check,Christoffel,Coefficients,Commutator,CompactDisplay,Coordinates,Creation,D_,Dagger,Decompose,Define,Dγ,DiracConjugate,Einstein,EnergyMomentum,Expand,ExteriorDerivative,Factor,FeynmanDiagrams,FeynmanIntegral,Fundiff,Geodesics,GrassmannParity,Gtaylor,Intc,Inverse,Ket,KillingVectors,KroneckerDelta,LagrangeEquations,LeviCivita,Library,LieBracket,LieDerivative,Normal,NumericalRelativity,Parameters,PerformOnAnticommutativeSystem,Projector,Psigma,Redefine,Ricci,Riemann,Setup,Simplify,SortProducts,SpaceTimeVector,StandardModel,Substitute,SubstituteTensor,SubstituteTensorIndices,SumOverRepeatedIndices,Symmetrize,TensorArray,Tetrads,ThreePlusOne,ToContravariant,ToCovariant,ToFieldComponents,ToSuperfields,Trace,TransformCoordinates,Vectors,Weyl,`^`,dAlembertian,d_,diff,g_,gamma_
Set first θ and Q as suffixes for variables of type/anticommutative (see Setup)
Setup(anticommutativepre = {theta, Q});
* Partial match of 'anticommutativepre' against keyword 'anticommutativeprefix'
_______________________________________________________
anticommutativeprefix=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⁡x,y,θ1,θ2⁢will now be displayed as⁢Q
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;
pde1≔Qx,y,θ1+Qx,y,θ2−Qy,θ1,θ2=0
pde[2] := q[theta[1]] = 0;
pde2≔Qθ1=0
Set for instance the generic form of the infinitesimals for a PDE system like this one formed by pde[1] and pde[2]. For this purpose, we need anticommutative infinitesimals for the dependent variable Q and two of the independent variables, θ1 and θ2; we use here the capital Greek letters Ξ and Η for the anticommutative infinitesimal symmetry generators and the corresponding lowercase Greek letters for commutative ones
Setup(anticommutativepre = {Xi, Rho}, additionally);
anticommutativeprefix=Q,Ρ,Ξ,θ
S := [xi[1], xi[2], Xi[1], Xi[2], Eta](x, y, theta[1], theta[2]);
S≔ξ1⁡x,y,θ1,θ2,ξ2⁡x,y,θ1,θ2,Ξ1⁡x,y,θ1,θ2,Ξ2⁡x,y,θ1,θ2,Η⁡x,y,θ1,θ2
PDEtools:-declare(S);
Η⁡x,y,θ1,θ2⁢will now be displayed as⁢Η
Ξ⁡x,y,θ1,θ2⁢will now be displayed as⁢Ξ
ξ⁡x,y,θ1,θ2⁢will now be displayed as⁢ξ
The corresponding InfinitesimalGenerator
InfinitesimalGenerator(S, Q(x,y,theta[1], theta[2]));
f↦ξ1⁡x,y,θ1,θ2⁢ⅆfⅆx+ξ2⁡x,y,θ1,θ2⁢ⅆfⅆy+Ξ1⁡x,y,θ1,θ2⁢ⅆfⅆθ1+Ξ2⁡x,y,θ1,θ2⁢ⅆfⅆθ2+Η⁡x,y,θ1,θ2⁢ⅆfⅆQ
The DeterminingPDE for this system
DeterminingPDE([pde[1], pde[2]], S);
−Ηθ1=0,−Ηx,y,θ2=0,−ξ2θ1=0,−ξ2θ2=0,−ξ1θ1,θ2⁢θ1−ξ1θ2=0,−ξ1θ1+ξ1θ1,θ2⁢θ2=0,−θ1⁢ξ1y,θ1−θ2⁢ξ1y,θ2+ξ1y=0,−θ1⁢ξ2x,θ1−θ2⁢ξ2x,θ2+ξ2x=0,−θ1⁢ξ1x,x,θ1−θ2⁢ξ1x,x,θ2+ξ1x,x=0,Ξ1x−Ξ1x,θ2⁢θ2−Ξ1x,θ1⁢θ1=0,Ξ2x−Ξ2x,θ2⁢θ2−Ξ2x,θ1⁢θ1=0,Ηθ1,θ2=0,Ξ1θ1,θ2=0,Ξ2θ1,θ2=0,ξ1θ1,θ2=0,ξ2θ1,θ2=0,Ξ2x,θ2=0,Ξ2y,θ2=0,Ξ1θ1=−θ1⁢ξ1x,θ1−θ2⁢ξ1x,θ2+ξ1x,Ξ1θ2=θ1⁢ξ1x,θ1+θ2⁢ξ1x,θ2−ξ1x+Ξ2θ2,Ξ2θ1=0
To compute now the exact form of the symmetry infinitesimals you can either solve this PDE system for the commutative and anticommutative functions using pdsolve, or directly pass the system to Infinitesimals that will perform all the steps automatically.
pdsolve((43));
Η=f__1⁡x,y+f__25⁡x+f__24⁡y⁢_λ2⁢θ2,Ξ1=f__21⁡y⁢_λ3+c__2⁢θ1+−c__2+c__1⁢θ2,Ξ2=f__22⁡y⁢_λ5+c__1⁢θ2,ξ1=c__2⁢x+c__3,ξ2=f__23⁡y
The dependency, jetnotation and typeofsymmetry options were updated in Maple 15.
See Also
declare
diff_table
Infinitesimals
Physics
Setup
SymmetryTest
Download Help Document