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

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : System : Information : Updates : Maple 15 : Differential Equations

Updates to Differential Equation (DE) Solvers in Maple 15



Ordinary Differential Equations (ODEs)

Partial Differential Equations (PDEs)



The theme for exact, symbolic Ordinary Differential Equation solving in Maple 15 is the development of new solving methods for 1st and 2nd order nonlinear ODEs. The results obtained significantly extend the solving capabilities, keeping Maple's ODE solver as the state of the art in computing exact solutions with computer algebra software.


For 1st order ODEs, dsolve can additionally solve two new 1-parameter Abel ODE classes.


For 2nd order ODEs, dsolve can additionally solve eleven new nonlinear ODE families not admitting point symmetries nor integrating factors depending only on just two of x,y,y', so whose solutions are beyond the scope of the previously known solving methods.


Recalling, each new solvable class of equations includes infinitely many different equations that can be transformed into each other through the transformations of the dependent and independent variables that define the class.


For Partial Differential Equations, the theme is the development of more core and new solving algorithms for nonlinear PDEs, and a thorough review of the symmetry commands of PDEtools extending their functionality to handle dynamical symmetries when applicable, and simplifying their use across the board. The Maple mathematical tools for working with Partial Differential Equations are at this point unique, the most complete, and for symmetry analysis the most sophisticated and versatile ones available.


Three new commands were added to PDEtools, one of them involving a new approach to compute solutions to PDE systems involving mathematical functions and for which the standard algorithms are not applicable.


The whole set of symmetry commands of PDEtools now automatically use textbook mathematical jet notation, handle list of infinitesimals or corresponding symmetry generator operators in equal footing, understand different jet notations, and return results in the notation of the input you pass to them, optionally returning in any other jet notation indicated.


Various previously existing commands have had their functionality extended to cover more kinds of problems.


The internal PDEtools Library, presented in Maple 13 with 45 specialized routines for programming purposes, augmented in Maple 14 with 4 new programming routines, is also augmented in Maple 15 with 9 new commands.

Ordinary Differential Equations (ODEs)


By using new algorithms, the dsolve command can additionally solve two 1st order and eleven 2nd order nonlinear ODE families, all of them parametrized by arbitrary functions of the independent and dependent variables and out of reach of the previously existing solving methods.

New solvable 1-parameter 1st order ODE families of Abel type


For 1st order ODEs, the simplest problem beyond reach of complete solving algorithms is known as Abel equations. These are equations of the form



where yyx is the unknown and the fifix and gjgjx are arbitrary functions of x. The biggest subclass of Abel equations known to be solvable was discovered by our research team and is the AIR 4-parameter class. New in Maple 15, two additional 1-parameter classes of Abel equations, beyond the AIR class, are now also solvable.



PDEtools[declare](y(x), prime=x);

yxwill now be displayed asy

derivatives with respect toxof functions of one variable will now be displayed with '


This equation, depending on one parameter α, is now solved in terms of Bessel functions

ode[1] := diff(y(x),x) = (y(x)-x-alpha)/((2*x+2*alpha)*y(x)+2*x);



sol[1] := dsolve(ode[1]);



odetest(sol[1], ode[1]);



The related class of Abel equations that is now entirely solvable consists of the set of equations that can be obtained from (2.1.2) by changing variables



where Fx and the four Pix,Qjx are arbitrary rational functions of x; this is the most general transformation that preserves the form of Abel equations and thus generates Abel ODE classes.


Another Abel equation, also depending on one parameter, is now, surprisingly, solvable entirely in terms of powers, which will be integer whenever α is integer

ode[2] := diff(y(x),x) = -1/2*(y(x)-2)*(((x-1)*alpha+x)*y(x)-2*alpha)/x/((-alpha+x)*y(x)+(x-1)*alpha-x);



sol[2] := dsolve(ode[2]);



As in the case of equation (2.1.2), the entire set of equations obtained by changing variables in (2.1.5) using the transformation that generates Abel ODE classes are now also solvable.

New solvable 2nd order nonlinear ODE families


By using new algorithms developed by our research team, the dsolve command can additionally solve 11 nonlinear 2nd order ODE families that have no point symmetries and admit no integrating factors depending only on two of x,y,y'. Each of these families of equations is parametrized by arbitrary functions of the independent and dependent variables, and the equations are solved by dsolve in Maple 15 for any values of these parametrizing functions. For 3 of these 11 families of equations, a general solution is computable directly, skipping the reduction of order step. For the other 8 families of equations, the original 2nd order ODE is systematically reduced to one of 1st order and dsolve will return a general solution when the 1st order equation is solvable with the existing algorithms. In what follows, an illustration of some of these newly solvable families of equations is presented.




An ODE family parametrized by an arbitrary function Gy

ode[3] := diff(diff(y(x),x),x) = (G(y(x)))/(-x + G(y(x)))/D(G)(y(x))/x + (x + G(y(x)) + x^2)/(x-G(y(x)))/x*diff(y(x),x) + ((-x + G(y(x)))*`@@`(D,2)(G)(y(x))-2*(1/2 + x)*D(G)(y(x))^2)/(x-G(y(x)))/D(G)(y(x))*diff(y(x),x)^2 + D(G)(y(x))^2*x/(x-G(y(x)))*diff(y(x),x)^3;



This ODE has no point symmetries, the determining PDE for them only admits both infinitesimals equal to zero:




A solution for any of the members of this ODE family ode3, that is regardless of the form of the mapping G, can now be computed

sol[3] := dsolve(ode[3]);



Verify this result

odetest(sol[3], ode[3]);



Analogously, this other new ODE family can also be solved for arbitrary values of the parameter α and the function parameter Gy

ode[4] := diff(y(x), x, x) = (alpha*exp(1/x)*x + x^2*diff(G(x),x) + alpha*(ln(y(x)) + 2))/(exp(1/x)*x + ln(y(x)))/alpha/y(x)*diff(y(x),x)^2 + ((2*x^3*diff(G(x),x) + alpha*(-1 + x))*exp(1/x) + 2*x^2*diff(G(x),x)*ln(y(x)))/x/(exp(1/x)*x + ln(y(x)))/alpha*diff(y(x),x) + (x^2*exp(2/x) + 2*x*exp(1/x)*ln(y(x)) + ln(y(x))^2)*diff(G(x),x)/(exp(1/x)*x + ln(y(x)))/alpha*y(x);



sol[4] := dsolve(ode[4], y(x));



The following example shows a different kind of situation, where the nonlinear ODE problem is now reducible with new algorithms; the ODE family also does not admit point symmetries, and is parametrized by two functions Gy,Hx,y, that is, it can be reduced in order for any value or form of these functions

ode[5] := diff(diff(y(x),x),x) = 1/H(x,y(x))/D[2](H)(x,y(x))*D[1](H)(x,y(x))^2-1/x/D[2](H)(x,y(x))*D[1](H)(x,y(x))-D[1,1](H)(x,y(x))/D[2](H)(x,y(x)) + (-2*D[1,2](H)(x,y(x))/D[2](H)(x,y(x))-1/x + 2*D[1](H)(x,y(x))/H(x,y(x)) + 1/H(x,y(x))/D[2](H)(x,y(x))*D[1](H)(x,y(x))^2*x*D(G)(y(x)))*diff(y(x),x) + (1/H(x,y(x))*D[2](H)(x,y(x))-D[2,2](H)(x,y(x))/D[2](H)(x,y(x)) + 2*x*D[1](H)(x,y(x))/H(x,y(x))*D(G)(y(x)))*diff(y(x),x)^2 + 1/H(x,y(x))*x*D[2](H)(x,y(x))*D(G)(y(x))*diff(y(x),x)^3;






As usual, for different sets of particular values of Gy and Hx,y the 1st order ODE shown in the result above is solvable. For example, consider the following 2nd order ODE that results from specializing G and H

ode[5.1] := eval(ode[5], {G = (y -> 1/y), H = ((x,y) -> (1+x*y))});



The corresponding reduced ODE is of Abel type with nonconstant invariants and solvable

sol[5.1] := dsolve(ode[5.1]);

sol5.1c__2x+2c__1ⅇc__1arctanhyx+2xy22xc__1` `yx+22xc__1y_fⅇ2c__1arctanh2c__1_f_f214c__12ⅆ_f=0


Verify this result

odetest(sol[5.1], ode[5.1]);



Another kind of 2nd order nonlinear problem, reducible to first order with the new algorithms is the following ODE family depending on two arbitrary functions Fy,Gy

ode[6] := diff(y(x), x,x) = 1/2*((-2*ln(x)-3)*D(G)(y(x))-2*F(y(x)))/x/(F(y(x)) + D(G)(y(x))*ln(x))*diff(y(x),x) + (-D(F)(y(x))-`@@`(D,2)(G)(y(x))*ln(x))/(F(y(x)) + D(G)(y(x))*ln(x))*diff(y(x),x)^2 + 1/2*x*(F(y(x)) + D(G)(y(x))*ln(x))*D(G)(y(x))*diff(y(x),x)^3;



Consider for instance the simpler case where G=yy,F=y1y, so that our equation becomes

ode[6.1] := eval(ode[6], {G = (y -> y),F = (y -> 1/y)});



sol[6.1] := dsolve(ode[6.1]);



In the same line, consider this other nonlinear ODE family, not admitting point symmetries and depending on four arbitrary functions Fy,Gy,Hx,Jx for which the new routines in Maple 15 can systematically obtain a reduction of order

ode[7] := diff(y(x), x,x) = diff(y(x),x)*J(x)*(1 + H(x)*diff(y(x),x))^2/H(x)*D(F)(y(x)) + (-diff(J(x),x)-diff(y(x),x)*diff(J(x),x)*H(x)-diff(y(x),x)*J(x)*diff(H(x),x))/J(x)/H(x) + diff(y(x),x)*(1 + H(x)*diff(y(x),x))/H(x)*`@@`(D,2)(G)(y(x))/D(G)(y(x))-diff(y(x),x)*(1 + H(x)*diff(y(x),x))/H(x)*`@@`(D,2)(F)(y(x))/D(F)(y(x));



Without specializing the values of the four functions parametrizing the ODE family, only a reduction of order to the most general form of a 1st order equation is possible

sol[7] := dsolve(ode[7], y(x));



Verify this result

odetest(sol[7], ode[7]);



As in the other cases, in the typical situation where these functions Fy,Gy,Hx,Jx appear specialized in some way, the 1st order equation obtained systematically by reducing the order will not be the most general one and so frequently automatically solved when the 2nd order equation is passed to dsolve.

Partial Differential Equations (PDEs)


A relevant number of improvements and additions were made to the PDEtools package, setting a new benchmark for the state-of-the-art in symbolic computation and partial differential equation solving and symmetry analysis.

New commands: FunctionFieldSolutions, SymmetryCommutator and SymmetryGauge


Three new commands were added to PDEtools.


FunctionFieldSolutions is a new command that involves an innovative approach to computing exact solutions to DE systems involving mathematical functions, possibly inequations, ODEs and also non-differential equations. In these cases, due to the presence of nonpolynomial objects, the original Maple approach by decoupling the system using differential polynomial extensions, although powerful, sometimes fails in solving the problem. The new approach in FunctionFieldSolutions skips entirely that step and instead searches for solutions that can be written as a power series (with some upper bound degree n) in the mathematical functions and its derivatives (up to some upper bound differential order m), having for coefficients multivariable polynomials (with some upper bound degree r). In turn these polynomials have undetermined coefficients that get adjusted, resulting in the solution. To compute the key values of n,m,r to construct these function field solutions, the new command maps the problem into one that can be tackled with the existing PDEtools:-Library:-UpperBounds (see PDEtools[Library]).


SymmetryCommutator is a new command to compute the commutator between two symmetries, given either as lists of infinitesimals or as infinitesimal generator procedures. This command is useful when studying the properties of a group of symmetries or when deriving the group constants or relations to make the group complete.


SymmetryGauge is a new command to gauge PDE symmetries. It is well known that an ODE symmetry can be rewritten in different ways (see Xgauge). It is not so well known, but the same happens with PDE symmetries. The ability to rewrite a symmetry is relevant for a number of purposes. First, that permits identifying that two apparently different symmetries are actually the same by rewriting them in evolutionary form (gauge ξ=0). Second, symmetries that appear as dynamical ones can frequently be rewritten as pointlike, transforming the usability of the symmetry from perhaps very difficult into straightforward. Finally, depending on the form of the symmetry, by rewriting them it is frequently possible to simplify its form considerably so that invariants or canonical coordinates become computable and so the symmetry can be used to reduce the number of independent variables of PDE systems.





For FunctionFieldSolutions, consider the following nonlinear coupled system in Fx,y,Gx,y that involves the exponential function exp

declare((F, G)(x, y));

Fx,ywill now be displayed asF

Gx,ywill now be displayed asG


sys[1] := {-F(x,y)*diff(F(x,y),y)+diff(F(x,y),x) = -F(x,y)*(exp(x)-1/y)+exp(x)*y+1/x, -F(x,y)*diff(G(x,y),y)+diff(G(x,y),x) = -F(x,y)*(exp(x)+1/y)+exp(x)*y+1/x};



Typically, systems of this type do not admit polynomial solutions

PolynomialSolutions(sys[1]);   # returns NULL


On the other hand, these systems frequently admit function field solutions:

sol[1] := FunctionFieldSolutions(sys[1]);



Verify this solution

pdetest(sol[1], sys[1]);



The following nonlinear system is also not solvable by pdsolve

sys[2] := {-F(x,y)*diff(F(x,y),y)+diff(F(x,y),x) = -F(x,y)*(exp(x)-1/y*exp(x/y))+exp(x)*y+exp(x/y)/x, -F(x,y)*diff(G(x,y),y)+diff(G(x,y),x) = -F(x,y)*(exp(x)+cos(x*y)/y)+exp(x)*y+cos(x*y)/x};



Its solution via FunctionFieldSolutions takes time to be computed; in cases like this, the use of optional arguments to restrict the degrees in which the solution would depend on mathematical functions, can diminish the computational time

sol[2] := FunctionFieldSolutions(sys[2], mathfunctiondegree = 1);



pdetest(sol[2], sys[2]);





For SymmetryCommutator, consider two list of infinitesimals corresponding to a symmetry transformation where there are two independent (x,t) and one dependent variable, ux,t

S[1], S[2] := [_xi[x] = x, _xi[t] = 1, _eta[u] = t], [_xi[x] = 1, _xi[t] = 1/t, _eta[u] = x^2];



For illustration purposes compute also the corresponding infinitesimal generators as differential operators

G[1] := InfinitesimalGenerator(S[1], u(x,t), expanded);



G[2] := InfinitesimalGenerator(S[2], u(x,t), expanded);



The symmetry commutator is S1,S2=S1@S2S2@S1; when the first symmetry (S1) is a differential operator procedure, the output is also a differential operator

SymmetryCommutator(G[1], G[2], u(x,t));



The output can be requested as a list or a procedure and the input can also be of mixed types, here we pass G1 and S2

SymmetryCommutator(G[1], S[2], u(x,t), output = list);



The prolongation order of the commutator is by default the one of the given infinitesimals, and the same happens with the output's jetnotation, but both can be requested to be different using the optional arguments prolongation = n, and notation = <any jet notation>

SymmetryCommutator(G[1], G[2], u(x,t), prolongation = 2);



SymmetryCommutator(G[1], G[2], u(x,t), prolongation = 2, notation = jetnumbers);





For SymmetryGauge, consider the list of infinitesimals corresponding to a symmetry transformation where there are two independent and one dependent variables, ux&comma;t

S := [_xi[x] = 1, _xi[t] = t, _eta[u] = u];



For illustration purposes let's construct also the general form of a 2nd order PDE admitting this symmetry; for that we use the InvariantEquation command

PDE := InvariantEquation(S, u(x,t), order = 2, name = Lambda);

* Partial match of 'name' against keyword 'arbitraryfunctionname'



This general form can be particularized in different ways, for instance

pde := isolate(op(-1, PDE) = subsop(-1 = NULL, PDE), diff(u(x,t), x,x));



Now: the general form of the symmetry S admitted by pde is not S but

S1 := SymmetryGauge(S, u(x,t));



Verify that S1 is a symmetry of pde

SymmetryTest(S1, pde);



Note the presence of arbitrary functions in S1; there are as many as the number of independent variables. The input of SymmetryGauge can also be the infinitesimal generator procedure corresponding to S, in which case the output of SymmetryGauge will also be a procedure; the option expanded of SymmetryGauge is the same one of InfinitesimalGenerator

G := InfinitesimalGenerator(S, u(x,t), jetnotation = jetvariables);



SymmetryGauge(G, u(x,t), expanded);



The prolongation order of the symmetry returned is by default the one of the given symmetry, but can also be requested to be different using the optional argument prolongation = n, where n is a positive integer. To rewrite the symmetry in evolutionary form use the _xi = 0 optional argument

S0_xi := SymmetryGauge(S, u(x,t), xi = 0);



Verify that S0_xi is a symmetry of pde

SymmetryTest(S0_xi, pde);



Compare with the gauge where _eta = 0

S0_eta := SymmetryGauge(S, u(x,t), eta = 0);



SymmetryTest(S0_eta, pde);



You can also indicate the value of each of the infinitesimals appearing in the output, see SymmetryGauge

New functionality in PDEtools commands


The following commands were significantly enhanced in their functionality: ConservedCurrents, D_Dx, DeterminingPDE, Eta_k, InfinitesimalGenerator, Infinitesimals, IntegratingFactors, InvariantEquation and Solve.


Apart from that, in Maple 15, the entire set of symmetry commands of PDEtools:


automatically use textbook mathematical jet notation on input and output;


handle list of infinitesimals or the corresponding symmetry generator operators in equal footing;


understand different jet notations as representing the same mathematical objects;


return list of infinitesimals with infinitesimal labels in mathematical notation, unless your input contains infinitesimals without labels;


return results in the jet notation of the input you pass to them;


optionally return in any jet notation you request.




Consider a problem with one dependent variable ux&comma;t and the infinitesimal generator of a symmetry transformation

G := f -> x*diff(f, x) + diff(f, t) + u*diff(f, u);



To compute, for instance, the transformation that maps this operator into its canonical form, that is the canonical coordinates associated to this symmetry, you no longer need to construct the list of infinitesimals corresponding to G; you can now pass G itself

CanonicalCoordinates(G, u(x,t), v(r,s));



Solving now for the new variables vr&comma;s, to achieve the canonical form of G you change variables in the symmetry, and now you can pass to ChangeSymmetry the operator G itself; also new: the output is automatically an operator because the input is so, or you can optionally request this output to be a list of infinitesimals

solve((50), {x,t, u(x,t)});



ChangeSymmetry((51), G);



ChangeSymmetry((51), G, out = list);

* Partial match of 'out' against keyword 'output'



Note the (new) presence of infinitesimal labels in this output. The motivation behind all these changes is to have a computational experience with symmetry analysis using true mathematical notation, as close as possible as the one you use when computing with paper and pencil.


Apart from the ability to compute conserved currents and integrating factors of general types, ConservedCurrents and IntegratingFactors can now specifically compute conserved currents and integrating factors of polynomial or functionfield types.



declare(u(x, t));

ux&comma;twill now be displayed asu


pde := diff(u(x, t), t, x)+diff(u(x, t), x, x, x)+(diff(u(x, t), x))*u(x, t) = 0;



A conserved current of order 1 (so involving up to 1st order derivatives), depending on arbitrary functions

ConservedCurrents(pde, order = 1);



A conserved current of order 2 (so involving up to 2nd order derivatives), of polynomial type

ConservedCurrents(pde, type = polynomial, split = false);

* Partial match of 'type' against keyword 'typeofconservedcurrent'


ConservedCurrentTest((57), pde);



An integrating factor of order 1 (so involving up to 1st order derivatives), depending on one arbitrary function

IntegratingFactors(pde, order = 1);



An integrating factor of order 2 of polynomial type

IntegratingFactors(pde, type = polynomial, split = false);

* Partial match of 'type' against keyword 'typeofintegratingfactor'



D_Dx can now compute total and partial derivatives, with respect to names and/or functions (including derivatives) of the jet space. This permits computing in a natural way objects like



where the right-hand side is entered as D_Dx(L(x(t), diff(x(t), t)), diff(x(t), t), t, [x(t)]) and means to differentiate Lxt,x.t with respect to x.t followed by taking the total derivative with respect to t, taking xt as the dependent variable defining the jet space.



L(t, x, x[t]);



D_Dx((61), x[t], t, [x(t)]);



The result above is computed with L already in jet notation but it can equally be computed passing L in function notation:

FromJet((61), x(t));



D_Dx((63), x[t], t, [x(t)]);



or passing the differentiation variable also in function notation

D_Dx((63), diff(x(t), t), t, [x(t)]);



If you need the output not in jetnotation use

D_Dx((61), x[t], t, [x(t)], jetnotation = false);



DeterminingPDE now understands more types of symmetries: evolutionary and general, apart from pointlike and contact.



pde := diff(u(x, t), t, x)+diff(u(x, t), x, x, x)+(diff(u(x, t), x))*u(x, t) = 0;



Compare the determining equations for the point like and evolutionary symmetries of pde




DeterminingPDE(pde, type = evolutionary);

* Partial match of 'type' against keyword 'typeofsymmetry'



Note in the result above the dependency of the infinitesimal _&eta;u: it involves derivatives up to the order of pde minus 1.


Eta_k: the returned table procedure η that provides any desired prolongation of the infinitesimals can now be indexed using independent and dependent variables in jet notation, or their respective numeric positions in the lists of independent and dependent variables (that is jetnumbers notation). Correspondingly, the output will be in jetvariables or jetnumbers notation. This implements a more natural mathematical representation of infinitesimal prolongations while providing an easy way to switch between notations, interactively or within a program,




Consider a problem with two dependent variables ux&comma;t,vx&comma;t, a related infinitesimal generator, and the corresponding η returned by Eta_k

DepVars :=  [u, v](x, t);



G := f -> x*diff(f, x) + diff(f, t) + v*diff(f, u) - u*diff(f, v);



Eta := Eta_k(G, DepVars);



This is the 4th prolongation of ηv, two times with respect to each of x and t, that is ηv,x&comma;x&comma;t&comma;t; you request it using the same notation

Eta[v, [x, x, t, t]];



to see this prolongation in jetnumbers notation just enter the indexation of Η using jetnumbers, so to v corresponds 2 and to x and t respectively corresponds 1 and 2

Eta[2, [1, 1, 2, 2]];



InfinitesimalGenerator now has the option jetnotation to choose the notation for the output, and also accepts infinitesimal generator operators on input, so that it can be used to rewrite in different notation or extend and existing infinitesimal generator operator




Consider the same symmetry of the previous example

G := f -> x*diff(f, x) + diff(f, t) + v*diff(f, u) - u*diff(f, v);



The first prolongation of the corresponding infinitesimal generator operator, with the same notation of G, is

G[1] := InfinitesimalGenerator(G, [u, v](x,t), prolongation = 1, expanded);



Departing directly from this result, rewrite it with jetnumbers notation and extend it to the 2nd prolongation

G[2] := InfinitesimalGenerator(G[1], [u, v](x,t), expanded, prolongation = 2, notation = jetnumbers);



Infinitesimals understands more types of symmetries: evolutionary and general, apart from pointlike and contact, and can compute infinitesimals combining these types, as for instance in And(evolutionary, polynomial), that is, dynamical symmetries with the _&xi; infinitesimals equal to zero and the _&eta; infinitesimals polynomial in the jet variables including all partial derivatives




Consider again a problem with two dependent variables u,vx&comma;t and the following PDE system for them

DepVars := [u,v](x,t);



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

eq[1] := U[t] + 1/2*U[x]^2 + 2*V[] - 2*x = 1/2*(-V[x]^2 + 2*V[x,x] * V[])/V[]^2;



eq[2] := V[t] + diff(V[]*U[x], x)=0;



PDESYS := [eq[1], eq[2]]:

S := Infinitesimals(PDESYS, DepVars, typeofsymmetry = And(evolutionary, polynomial), displayfunctionality = false);



Note that, as expected, in the result above there are dynamical symmetries (the last three), involving the derivatives ut,ux,vt and vx. Dynamical symmetries can also be tested for correctness with SymmetryTest

map(SymmetryTest, [S], PDESYS);



InvariantEquation accepts a new optional argument, explicit, to indicate that the invariant equation to be returned should have the form of an explicit PDE system with all the highest derivatives isolated in the left-hand sides. In addition, this command can now compute the PDE system invariant under a set of generic dynamical symmetries, that is, symmetries where the corresponding infinitesimals depend directly on the derivatives of the unknowns of the problem.




Consider a problem with two independent and two dependent variables, u,vx&comma;t,

declare(u(x, t), v(x, t));

ux&comma;twill now be displayed asu

vx&comma;twill now be displayed asv


and two possible related infinitesimal generator operators, for instance

G[1] := f -> t*diff(f,x) + (t^2+x)*diff(f,u);



G[2] := f -> t*diff(f,t) + (t^3+3*t*x)*diff(f,u) - v*diff(f,v);



To compute the standard invariant equation under both symmetry groups, as an arbitrary function Λ of differential invariants, in Maple 15, instead of the list of infinitesimals corresponding to G1 and G2, you can pass G1 and G2 themselves

InvariantEquation([G[1], G[2]], [u, v](x,t), order = 2, arbitraryfunctionname = Lambda) = 0;



To compute an explicit form of this equation with all the second order partial derivatives of u and v isolated in the left-hand sides, pass the option explicit

InvariantEquation([G[1], G[2]], [u, v](x,t), order = 2, explicit);



A problem involving dynamical symmetries, with the first derivative ux in the infinitesimal generator, and the corresponding invariant PDE family

G[dynamical] := f -> diff(f, x) + diff(f, u)/u[x];



InvariantEquation(G[dynamical], u(x,t), order = 2, explicit);



To verify this result, SymmetryTest also accepts an infinitesimal generator operator as a representation for the symmetry

SymmetryTest(G[dynamical], (89));