Application Center - Maplesoft

App Preview:

Differential Equations in Maple 16

You can switch back to the summary page by clicking here.

Learn about Maple
Download Application




Differential Equations in Maple 16

Summary

 

Maple 16 continues to push the frontiers in differential equation solving and extends its lead in computing closed-form solutions to differential equations, adding in even more classes of problems that can be handled. The numeric ODE, DAE, and PDE solvers also continue to evolve. Maple 16 shows significant performance improvements for these solvers, as well as enhanced event handling.

• 

Maple 16 integrates new solving methods for 1st, 2nd, and higher order nonlinear ODEs. The new methods can solve additional 1st order Abel and other families of equations, and a number of 2nd and higher order families of equations not admitting point symmetries.

• 

For both ordinary and partial differential equations, all symmetry algorithms have been extended to automatically handle problems involving anti-commutative variables, making all this DE functionality easily available for problems that involve non-commutative variables, as occur frequently, for example, in physics.

• 

Event handling for the numeric ODE and DAE solvers has been significantly enhanced to avoid triggering on spurious events as well as to increase performance.

• 

The numeric PDE solvers are now able to take advantage of the compiler, yielding a tremendous performance boost and allowing you to handle larger problems.

 

Ordinary Differential Equations (ODEs)

 
  

Using new algorithms, the dsolve command can solve new nonlinear ODE families of  1st, 2nd, 3rd and 4th order, all of them parameterized by arbitrary functions of the independent variable.

New solvable 1st order nonlinear ODE families

 

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

`y'` = (f[3]*y^3+f[2]*y^2+f[1]*y+f[0])/(g[1]*y+g[0])

  

where `≡`(y, y(x)) is the unknown and the `≡`(f[i], f[i](x)) and `≡`(g[j], g[j](x)) are arbitrary functions of x. The biggest subclass of Abel equations known to be solvable, the AIR 4-parameter class, was discovered by our research team. New in Maple 16, two additional 1-parameter classes of Abel equations, beyond the AIR class, are now also solvable.

  

 

  

Examples

PDEtools[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 '`

(1)
  

This equation, of type Abel 2nd kind, depending on one parameter alpha, is now solved in terms of hypergeometric functions

ode[1] := diff(y(x), x) = -y(x)*(-3+x)*((-9+2*alpha)*y(x)-9)/(x*(54-36*x+6*x^2-3*alpha+2*alpha*x)*y(x)+9*alpha+81-54*x+9*x^2)

diff(y(x), x) = -y(x)*(-3+x)*((-9+2*alpha)*y(x)-9)/(x*(54-36*x+6*x^2-3*alpha+2*alpha*x)*y(x)+9*alpha+81-54*x+9*x^2)

(2)

dsolve(ode[1])

_C1+(1/128)*(128*(alpha-9/2)^5*y(x)^4*(-y(x)+(2/9)*y(x)*alpha-1)^((-9+8*alpha)/(-9+2*alpha))*(x*y(x)+3)^2*hypergeom([5, (-9+8*alpha)/(-9+2*alpha)], [(-18+10*alpha)/(-9+2*alpha)], y(x)-(2/9)*y(x)*alpha+1)-69984*(-9/2+(alpha-9/2)*y(x))*(alpha-9/8)*(3/2+(-3/2+x)*y(x))*(-y(x)+(2/9)*y(x)*alpha-1)^(6*alpha/(-9+2*alpha)))/((alpha-9/2)^4*y(x)^4*(alpha-9/8)*(x*y(x)+3)^2) = 0

(3)
  

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

proc (x) options operator, arrow; F(x) end proc, proc (y) options operator, arrow; (P[1](x)*y+Q[1](x))/(P[2](x)*y+Q[2](x)) end proc

  

where G(x) and the four P[i](x), Q[j](x) 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.

  

The following ODE family, which depends on an arbitrary function G(x), is representative of the next difficult problem beyond Abel equations, that is, a problem involving 4th powers of y(x) in the right-hand side.

ode[2] := diff(y(x), x) = (G(x)^2*y(x)^4-(diff(G(x), x))*y(x)^2+x)/(2*G(x)*y(x))

diff(y(x), x) = (1/2)*(G(x)^2*y(x)^4-(diff(G(x), x))*y(x)^2+x)/(G(x)*y(x))

(4)

 

We solve it here in implicit form to avoid square roots obscuring the solution

sol[2] := dsolve(ode[2], y(x), implicit)

_C1+(-G(x)*y(x)^2*AiryBi(-x)+AiryBi(1, -x))/(-G(x)*y(x)^2*AiryAi(-x)+AiryAi(1, -x)) = 0

(5)

odetest(sol[2], ode[2], y(x))

0

(6)

A generalization of the problem above, solvable in Maple 16, involving an arbitrary function G(y(x))

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

diff(y(x), x) = 2*G(y(x))*x/(2-(D(G))(y(x))*x^2+G(y(x))^2*x^4-2*y(x)*G(y(x))*x^2)

(7)

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

_C1+(-2*y(x)+G(y(x))*x^2)/((2*I)*exp(y(x)^2)+(-2*y(x)+G(y(x))*x^2)*Pi^(1/2)*erf(I*y(x))) = 0

(8)

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

0

(9)

New solvable nonlinear ODE families of 2nd, 3rd, and 4th order

 
  

Using new algorithms developed by our research team, the dsolve command in Maple 16 can additionally solve two new nonlinear ODE families for each of the 2nd, 3rd and 4th order problems, with the ODE families involving arbitrary functions of the independent (x) or dependent (y(x)) variables.

  

 

Examples

 
  

A 4th order ODE family

ode[4] := diff(y(x), x, x, x, x) = 5*y(x)*(diff(y(x), x, x, x))+(10*(diff(y(x), x))-10*y(x)^2-1/x)*(diff(y(x), x, x))-15*y(x)*(diff(y(x), x))^2+(10*y(x)^3+3*y(x)/x)*(diff(y(x), x))-y(x)^5-y(x)^3/x

diff(diff(diff(diff(y(x), x), x), x), x) = 5*y(x)*(diff(diff(diff(y(x), x), x), x))+(10*(diff(y(x), x))-10*y(x)^2-1/x)*(diff(diff(y(x), x), x))-15*y(x)*(diff(y(x), x))^2+(10*y(x)^3+3*y(x)/x)*(diff(y(x), x))-y(x)^5-y(x)^3/x

(10)
  

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

PDEtools:-DeterminingPDE(ode[4])

{_xi[x](x, y) = 0, _eta[y](x, y) = 0}

(11)

Using new algorithms, this problem is nevertheless solvable in explicit form in terms of Bessel functions

dsolve(ode[4])

y(x) = (-_C2-2*_C3*x-_C4*x^(3/2)*BesselJ(3, 2*x^(1/2))-x^(3/2)*BesselY(3, 2*x^(1/2)))/(_C1+_C2*x+_C3*x^2+_C4*x^2*BesselJ(4, 2*x^(1/2))+x^2*BesselY(4, 2*x^(1/2)))

(12)

 

 

Another problem not admitting point symmetries, of 3rd order

ode[5] := diff(y(x), x, x, x) = (4*y(x)-1/x)*(diff(y(x), x, x))+3*(diff(y(x), x))^2+(-6*y(x)^2+3*y(x)/x-x)*(diff(y(x), x))+y(x)^4-y(x)^3/x+x*y(x)^2-y(x)

diff(diff(diff(y(x), x), x), x) = (4*y(x)-1/x)*(diff(diff(y(x), x), x))+3*(diff(y(x), x))^2+(-6*y(x)^2+3*y(x)/x-x)*(diff(y(x), x))+y(x)^4-y(x)^3/x+x*y(x)^2-y(x)

(13)

dsolve(ode[5])

y(x) = (1/240)*(-240*_C2*x*hypergeom([1/3, 1/3], [2/3, 2/3, 4/3], -(1/9)*x^3)+15*_C2*x^4*hypergeom([4/3, 4/3], [5/3, 5/3, 7/3], -(1/9)*x^3)-480*_C3*x^2*hypergeom([2/3, 2/3], [1, 4/3, 5/3], -(1/9)*x^3)+16*_C3*x^5*hypergeom([5/3, 5/3], [2, 7/3, 8/3], -(1/9)*x^3)-720*MeijerG([[1], []], [[2/3, 2/3, 1/3], []], (1/9)*x^3))/(x*(_C1+_C2*x*hypergeom([1/3, 1/3], [2/3, 2/3, 4/3], -(1/9)*x^3)+_C3*x^2*hypergeom([2/3, 2/3], [1, 4/3, 5/3], -(1/9)*x^3)+MeijerG([[1, 1], []], [[2/3, 2/3, 1/3], [0]], (1/9)*x^3)))

(14)

 

 

A 2nd order nonlinear ODE problem for which point symmetries exist but are of no use for integration purposes (they involve an unsolved 4th order linear ODE).

ode[6] := diff(y(x), x, x) = x*(diff(y(x), x))^3*y(x)+x^2*(x-1)*(diff(y(x), x))^3+(-3*x+1)*(diff(y(x), x))^2

diff(diff(y(x), x), x) = x*(diff(y(x), x))^3*y(x)+x^2*(x-1)*(diff(y(x), x))^3+(-3*x+1)*(diff(y(x), x))^2

(15)

sol[6] := dsolve(ode[6])

(_C2*AiryAi(1/4-y(x))+AiryBi(1/4-y(x)))*exp(-(1/2)*y(x))/(Intat(exp(-(1/2)*_a)*(_C2*AiryAi(1/4-_a)+AiryBi(1/4-_a)), _a = y(x))+_C1)+x = 0

(16)

odetest(sol[6], ode[6])

0

(17)

 

 

A 3rd order ODE problem illustrating improvements in existing algorithms: in previous releases this equation was only solved in terms of uncomputed integrals of unresolved RootOf expressions; now the solution is computed explicitly as a rational function

ode[7] := diff(y(x), x, x, x)+4*y(x)*(diff(y(x), x, x))+3*(diff(y(x), x))^2+6*(diff(y(x), x))*y(x)^2+y(x)^4 = 0

diff(diff(diff(y(x), x), x), x)+4*(diff(diff(y(x), x), x))*y(x)+3*(diff(y(x), x))^2+6*(diff(y(x), x))*y(x)^2+y(x)^4 = 0

(18)

sol[7] := dsolve(ode[7])

y(x) = (3*x^2*_C1+6*_C2*x+6*_C3)/(x^3*_C1+3*_C2*x^2+6*_C3*x+6)

(19)

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

0

(20)

Anticommutative Variables

 

For both ordinary and partial differential equations, all symmetry algorithms have been extended to automatically handle problems involving anti-commutative variables, making all this  functionality easily available for problems that involve non-commutative variables. These problems often occur in advanced physics computations.

Examples: Ordinary Differential Equations (ODEs)

 

The dsolve command can now solve ODEs that involve anticommutative variables set using the Physics package.

with(Physics, Setup)

[Setup]

(21)

Set first theta and Q as suffixes for variables of type/anticommutative

Setup(anticommutativepre = {Q, theta})

`* Partial match of  'anticommutativepre' against keyword 'anticommutativeprefix'`

 

[anticommutativeprefix = {Q, _lambda, theta}]

(22)

Consider this ordinary differential equation for the anticommutative function Q of a commutative variable x

diff(Q(x), x, x)-Q(x)*(diff(Q(x), x)) = 0

diff(diff(Q(x), x), x)-Q(x)*(diff(Q(x), x)) = 0

(23)

Its solution using dsolve involves an anticommutative constant _lambda1, analogous to the commutative constants _C1

dsolve(diff(diff(Q(x), x), x)-Q(x)*(diff(Q(x), x)) = 0)

Q(x) = tan((1/2)*(_C1*_lambda1)^(1/2)*(x+_C2)*2^(1/2))*(_C1*_lambda1)^(1/2)*2^(1/2)

(24)
  

 

Examples: Partial Differential Equations (PDEs)

 
  

Many of the commands in PDEtools can now naturally handle anticommutative variables, these are: D_Dx, DeterminingPDE, dsubs, Eta_k, FromJet, FunctionFieldSolutions, InfinitesimalGenerator, Infinitesimals, InvariantSolutions, PolynomialSolutions, ReducedForm, and ToJet, as well as all the routines within the PDEtools[Library]. This makes it possible to tackle super PDE problems, that is, PDE systems involving anticommutative functions and variables. In addition, this permits the use of the PDE mathematical tools with the Physics package.

  

During the development of this generalization of PDEtools commands to handle anticommutative variables, the symmetry methods were also improved in a number of places. Together, this work sets a new benchmark for state-of-the-art symmetry analysis and the computation of exact solutions for partial differential equations.

 

Both dsolve and pdsolve can now solve PDEs that involve anticommutative variables set using the Physics package.

with(PDEtools), with(Physics):

  

Set first theta; and Q; as suffixes for variables of type/anticommutative

Setup(anticommutativepre = {Q, theta})

`* Partial match of  'anticommutativepre' against keyword 'anticommutativeprefix'`

 

[anticommutativeprefix = {Q, _lambda, theta}]

(25)
  

Consider this partial differential equation for the anticommutative function Q of commutative and anticommutative variables x, theta

diff(Q(x, y, theta), theta, x) = 0

Physics:-diff(diff(Q(x, y, theta), x), theta) = 0

(26)
  

Its solution using pdsolve

pdsolve(Physics:-diff(diff(Q(x, y, theta), x), theta) = 0)

Q(x, y, theta) = _F2(x, y)*_lambda2+_F4(y)*theta

(27)
  

Note the introduction of an anticommutative constant _lambda2, analogous to the commutative constants _Cn where n is an integer. The arbitrary functions _Fn introduced are all commutative as usual and the Grassmannian parity (on right-hand-side if compared with the one on the left-hand-side) is preserved

Physics:-GrassmannParity(Q(x, y, theta) = _F2(x, y)*_lambda2+_F4(y)*theta)

1 = 1

(28)
  

Consider this PDE system with one unknown anticommutative function Q, which has of four variables: two commutative and two anticommutative. To avoid redundant typing and display of redundant information on the screen, use PDEtools:-declare, and PDEtools:-diff_table, which also handles anticommutative variables by automatically using Physics:-diff when Physics is loaded

PDEtools:-declare(Q(x, y, theta[1], theta[2]))

Q(x, y, theta[1], theta[2])*`will now be displayed as`*Q

(29)

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

Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[1])+Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[2])-Physics:-diff(Physics:-diff(diff(Q(x, y, theta[1], theta[2]), y), theta[1]), theta[2]) = 0

(30)

pde[2] := q[theta[1]] = 0

Physics:-diff(Q(x, y, theta[1], theta[2]), theta[1]) = 0

(31)
  

The solution to this system:

pdsolve([pde[1], pde[2]])

Q(x, y, theta[1], theta[2]) = _F4(x, y)*_lambda3+(_F9(x)+_F8(y))*theta[2]

(32)

 

 

 

The dsubs command also works with anticommutative variables, though natively without using PerformOnAnticommutativeSystem. By inspection, it is clear that the derivatives in pde[2] can be substituted in pde[1]reducing the problem to a simpler one:

dsubs(pde[2], pde[1])

Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[2]) = 0

(33)

pdsolve(Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[2]) = 0)

Q(x, y, theta[1], theta[2]) = _F4(x, y)*_lambda3+_F5(x, y)*theta[1]+(_F9(x)+_F8(y))*theta[2]+(_F11(x)+_F10(y))*Physics:-`*`(_lambda4, theta[1], theta[2])

(34)
  

Substituting this result for Q back into pde[2], then multiplying by theta[1] and subtracting from the above also leads to the PDE system solution.

  

Using differential elimination techniques, ReducedForm in this example arrives at the same result as dsubs

PDEtools:-ReducedForm(pde[1], pde[2])

`casesplit/ans`([Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[2])], [])

(35)
  

Another command updated to handle anticommutative variables via PerformOnAnticommutativeSystem is casesplit; with this linear system in Q and its derivatives it returns

casesplit([pde[1], pde[2]])

`casesplit/ans`([Physics:-diff(diff(diff(Q(x, y, theta[1], theta[2]), x), y), theta[2]) = 0, Physics:-diff(Q(x, y, theta[1], theta[2]), theta[1]) = 0], [])

(36)
• 

With the core functionality in place, most the symmetry commands that work on top can now also handle anticommutative variables, most of them natively, without going through PerformOnAnticommutativeSystem.

  

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, theta[1] and theta[2]; we use here the capital greek letters Xi and Eta for the anticommutative infinitesimal symmetry generators and the corresponding lower case greek letters for commutative ones

Physics:-diff(Q(x, y, theta[1], theta[2]), theta[1]) = 0

(37)

Setup(anticommutativepre = {Eta, Xi}, additionally)

`* Partial match of  'anticommutativepre' against keyword 'anticommutativeprefix'`

 

[anticommutativeprefix = {Eta, Q, Xi, _lambda, theta}]

(38)

S := ([xi[1], xi[2], Xi[1], Xi[2], Eta])(x, y, theta[1], theta[2])

[xi[1](x, y, theta[1], theta[2]), xi[2](x, y, theta[1], theta[2]), Xi[1](x, y, theta[1], theta[2]), Xi[2](x, y, theta[1], theta[2]), Eta(x, y, theta[1], theta[2])]

(39)

PDEtools:-declare(S)

Eta(x, y, theta[1], theta[2])*`will now be displayed as`*Eta

 

Xi(x, y, theta[1], theta[2])*`will now be displayed as`*Xi

 

xi(x, y, theta[1], theta[2])*`will now be displayed as`*xi

(40)
  

The corresponding InfinitesimalGenerator

InfinitesimalGenerator(S, Q(x, y, theta[1], theta[2]))

proc (f) options operator, arrow; Physics:-`*`(xi[1](x, y, theta[1], theta[2]), Physics:-diff(f, x))+Physics:-`*`(xi[2](x, y, theta[1], theta[2]), Physics:-diff(f, y))+Physics:-`*`(Xi[1](x, y, theta[1], theta[2]), Physics:-diff(f, theta[1]))+Physics:-`*`(Xi[2](x, y, theta[1], theta[2]), Physics:-diff(f, theta[2]))+Physics:-`*`(Eta(x, y, theta[1], theta[2]), Physics:-diff(f, Q)) end proc

(41)
  

The table-function that returns the prolongation of the infinitesimal for Q is computed with Eta_k, assign it here to the lower case eta to use more familiar notation (recall q[] = Q(x, y, theta[1], theta[2]))

eta := Eta_k(S, q[])

eta

(42)
  

The first prolongations of eta with respect to x and  theta[1]

eta[Q, [x]]

diff(Eta(x, y, theta[1], theta[2]), x)-Physics:-`*`(diff(xi[1](x, y, theta[1], theta[2]), x), Q[x])-Physics:-`*`(diff(xi[2](x, y, theta[1], theta[2]), x), Q[y])-(diff(Xi[1](x, y, theta[1], theta[2]), x))*Q[theta[1]]-(diff(Xi[2](x, y, theta[1], theta[2]), x))*Q[theta[2]]

(43)

eta[Q, [theta[1]]]

Physics:-diff(Eta(x, y, theta[1], theta[2]), theta[1])+Physics:-`*`(Q[x], Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]))+Physics:-`*`(Q[y], Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]))-Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1])*Q[theta[1]]-Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1])*Q[theta[2]]

(44)
  

The second mixed prolongations of eta with respect to x, y and  x, theta[1]

eta[Q, [x, y]]

diff(Eta(x, y, theta[1], theta[2]), x, y)-Physics:-`*`(diff(xi[1](x, y, theta[1], theta[2]), x, y), Q[x])-Physics:-`*`(diff(xi[2](x, y, theta[1], theta[2]), x, y), Q[y])-(diff(Xi[1](x, y, theta[1], theta[2]), x, y))*Q[theta[1]]-(diff(Xi[2](x, y, theta[1], theta[2]), x, y))*Q[theta[2]]-Physics:-`*`(diff(xi[1](x, y, theta[1], theta[2]), y), Q[x, x])-Physics:-`*`(diff(xi[2](x, y, theta[1], theta[2]), y), Q[x, y])-Q[x, theta[1]]*(diff(Xi[1](x, y, theta[1], theta[2]), y))-Q[x, theta[2]]*(diff(Xi[2](x, y, theta[1], theta[2]), y))-Physics:-`*`(diff(xi[1](x, y, theta[1], theta[2]), x), Q[x, y])-Physics:-`*`(diff(xi[2](x, y, theta[1], theta[2]), x), Q[y, y])-(diff(Xi[1](x, y, theta[1], theta[2]), x))*Q[y, theta[1]]-(diff(Xi[2](x, y, theta[1], theta[2]), x))*Q[y, theta[2]]

(45)

eta[Q, [x, theta[1]]]

Physics:-diff(diff(Eta(x, y, theta[1], theta[2]), x), theta[1])+Physics:-`*`(Q[x], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[1]))+Physics:-`*`(Q[y], Physics:-diff(diff(xi[2](x, y, theta[1], theta[2]), x), theta[1]))-Physics:-diff(diff(Xi[1](x, y, theta[1], theta[2]), x), theta[1])*Q[theta[1]]-Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[1])*Q[theta[2]]+Physics:-`*`(Q[x, x], Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]))+Physics:-`*`(Q[x, y], Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]))-Q[x, theta[1]]*Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1])-Q[x, theta[2]]*Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1])-(diff(xi[1](x, y, theta[1], theta[2]), x))*Q[x, theta[1]]-(diff(xi[2](x, y, theta[1], theta[2]), x))*Q[y, theta[1]]-Physics:-`*`(Q[theta[1], theta[2]], diff(Xi[2](x, y, theta[1], theta[2]), x))

(46)
• 

The DeterminingPDE for this system

DeterminingPDE([pde[1], pde[2]], S)

{-Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]) = 0, -Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[2]) = 0, -Physics:-`*`(Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]), theta[1])-Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[2]) = 0, -Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1])+Physics:-`*`(Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]), theta[2]) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), y), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), y), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), y) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[2](x, y, theta[1], theta[2]), x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[2](x, y, theta[1], theta[2]), x), theta[2]))+diff(xi[2](x, y, theta[1], theta[2]), x) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x, x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x, x), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), x, x) = 0, diff(Xi[1](x, y, theta[1], theta[2]), x)-Physics:-`*`(Physics:-diff(diff(Xi[1](x, y, theta[1], theta[2]), x), theta[2]), theta[2])-Physics:-`*`(Physics:-diff(diff(Xi[1](x, y, theta[1], theta[2]), x), theta[1]), theta[1]) = 0, diff(Xi[2](x, y, theta[1], theta[2]), x)-Physics:-`*`(Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[2]), theta[2])-Physics:-`*`(Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[1]), theta[1]) = 0, Physics:-diff(Eta(x, y, theta[1], theta[2]), theta[1]) = 0, Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[2]) = 0, Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), y), theta[2]) = 0, Physics:-diff(diff(Eta(x, y, theta[1], theta[2]), x, y), theta[2]) = 0, Physics:-diff(Physics:-diff(Eta(x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1]) = -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), x), Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[2]) = Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[2])+Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[1]))+Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[2]))-(diff(xi[1](x, y, theta[1], theta[2]), x)), Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1]) = 0}

(47)
  

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({-Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]) = 0, -Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[2]) = 0, -Physics:-`*`(Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]), theta[1])-Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[2]) = 0, -Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1])+Physics:-`*`(Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]), theta[2]) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), y), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), y), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), y) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[2](x, y, theta[1], theta[2]), x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[2](x, y, theta[1], theta[2]), x), theta[2]))+diff(xi[2](x, y, theta[1], theta[2]), x) = 0, -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x, x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x, x), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), x, x) = 0, diff(Xi[1](x, y, theta[1], theta[2]), x)-Physics:-`*`(Physics:-diff(diff(Xi[1](x, y, theta[1], theta[2]), x), theta[2]), theta[2])-Physics:-`*`(Physics:-diff(diff(Xi[1](x, y, theta[1], theta[2]), x), theta[1]), theta[1]) = 0, diff(Xi[2](x, y, theta[1], theta[2]), x)-Physics:-`*`(Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[2]), theta[2])-Physics:-`*`(Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[1]), theta[1]) = 0, Physics:-diff(Eta(x, y, theta[1], theta[2]), theta[1]) = 0, Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), x), theta[2]) = 0, Physics:-diff(diff(Xi[2](x, y, theta[1], theta[2]), y), theta[2]) = 0, Physics:-diff(diff(Eta(x, y, theta[1], theta[2]), x, y), theta[2]) = 0, Physics:-diff(Physics:-diff(Eta(x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(xi[1](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Physics:-diff(xi[2](x, y, theta[1], theta[2]), theta[1]), theta[2]) = 0, Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[1]) = -Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[1]))-Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[2]))+diff(xi[1](x, y, theta[1], theta[2]), x), Physics:-diff(Xi[1](x, y, theta[1], theta[2]), theta[2]) = Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[2])+Physics:-`*`(theta[1], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[1]))+Physics:-`*`(theta[2], Physics:-diff(diff(xi[1](x, y, theta[1], theta[2]), x), theta[2]))-(diff(xi[1](x, y, theta[1], theta[2]), x)), Physics:-diff(Xi[2](x, y, theta[1], theta[2]), theta[1]) = 0})

{Eta(x, y, theta[1], theta[2]) = _F8(x, y)*_lambda5+(_F32(x)+_F31(y))*theta[2], Xi[1](x, y, theta[1], theta[2]) = _F28(y)*_lambda7+_C2*theta[1]+(_C1-_C2)*theta[2], Xi[2](x, y, theta[1], theta[2]) = _F29(y)*_lambda9+_C1*theta[2], xi[1](x, y, theta[1], theta[2]) = _C2*x+_C3, xi[2](x, y, theta[1], theta[2]) = _F30(y)}

(48)
  

Substituting into S, you get the symmetry infinitesimal lists

subs({Eta(x, y, theta[1], theta[2]) = _F8(x, y)*_lambda5+(_F32(x)+_F31(y))*theta[2], Xi[1](x, y, theta[1], theta[2]) = _F28(y)*_lambda7+_C2*theta[1]+(_C1-_C2)*theta[2], Xi[2](x, y, theta[1], theta[2]) = _F29(y)*_lambda9+_C1*theta[2], xi[1](x, y, theta[1], theta[2]) = _C2*x+_C3, xi[2](x, y, theta[1], theta[2]) = _F30(y)}, S)

[_C2*x+_C3, _F30(y), _F28(y)*_lambda7+_C2*theta[1]+(_C1-_C2)*theta[2], _F29(y)*_lambda9+_C1*theta[2], _F8(x, y)*_lambda5+(_F32(x)+_F31(y))*theta[2]]

(49)
• 

Infinitesimals also works with anticommutative variables natively; the related result comes specialized

Infinitesimals([pde[1], pde[2]], q[], S)

[1, _F4(y), _F2(y)*_lambda7, _F3(y)*_lambda9, _F1(x, y)*_lambda5+(_F6(x)+_F5(y))*theta[2]], [x, _F10(y), _F8(y)*_lambda7+theta[1]-theta[2], _F9(y)*_lambda9, _F7(x, y)*_lambda5+(_F12(x)+_F11(y))*theta[2]], [0, _F16(y), _F14(y)*_lambda7+theta[2], _F15(y)*_lambda9+theta[2], _F13(x, y)*_lambda5+(_F18(x)+_F17(y))*theta[2]]

(50)
  

To verify this result you can use SymmetryTest - it also handles anticommutative variables natively.

map(SymmetryTest, [[1, _F4(y), _F2(y)*_lambda7, _F3(y)*_lambda9, _F1(x, y)*_lambda5+(_F6(x)+_F5(y))*theta[2]], [x, _F10(y), _F8(y)*_lambda7+theta[1]-theta[2], _F9(y)*_lambda9, _F7(x, y)*_lambda5+(_F12(x)+_F11(y))*theta[2]], [0, _F16(y), _F14(y)*_lambda7+theta[2], _F15(y)*_lambda9+theta[2], _F13(x, y)*_lambda5+(_F18(x)+_F17(y))*theta[2]]], [pde[1], pde[2]])

[{0}, {0}, {0}]

(51)
  

To see these three list of symmetry infinitesimals with a label in the left-hand-side, you can use map

map[3](zip, `=`, S, [[1, _F4(y), _F2(y)*_lambda7, _F3(y)*_lambda9, _F1(x, y)*_lambda5+(_F6(x)+_F5(y))*theta[2]], [x, _F10(y), _F8(y)*_lambda7+theta[1]-theta[2], _F9(y)*_lambda9, _F7(x, y)*_lambda5+(_F12(x)+_F11(y))*theta[2]], [0, _F16(y), _F14(y)*_lambda7+theta[2], _F15(y)*_lambda9+theta[2], _F13(x, y)*_lambda5+(_F18(x)+_F17(y))*theta[2]]])

[[xi[1](x, y, theta[1], theta[2]) = 1, xi[2](x, y, theta[1], theta[2]) = _F4(y), Xi[1](x, y, theta[1], theta[2]) = _F2(y)*_lambda7, Xi[2](x, y, theta[1], theta[2]) = _F3(y)*_lambda9, Eta(x, y, theta[1], theta[2]) = _F1(x, y)*_lambda5+(_F6(x)+_F5(y))*theta[2]], [xi[1](x, y, theta[1], theta[2]) = x, xi[2](x, y, theta[1], theta[2]) = _F10(y), Xi[1](x, y, theta[1], theta[2]) = _F8(y)*_lambda7+theta[1]-theta[2], Xi[2](x, y, theta[1], theta[2]) = _F9(y)*_lambda9, Eta(x, y, theta[1], theta[2]) = _F7(x, y)*_lambda5+(_F12(x)+_F11(y))*theta[2]], [xi[1](x, y, theta[1], theta[2]) = 0, xi[2](x, y, theta[1], theta[2]) = _F16(y), Xi[1](x, y, theta[1], theta[2]) = _F14(y)*_lambda7+theta[2], Xi[2](x, y, theta[1], theta[2]) = _F15(y)*_lambda9+theta[2], Eta(x, y, theta[1], theta[2]) = _F13(x, y)*_lambda5+(_F18(x)+_F17(y))*theta[2]]]

(52)

Numerical PDE solutions with compile

 

The compile option has been added to the numeric pdsolve command, to allow more efficient computation of PDE numerical solutions.

Consider the following example (Klein-Gordon). Using the compile option, the solution is available 6 times faster than before. In many circumstances, even larger speed increases will be seen.

 

PDE := diff(u(x, t), t, t) = diff(u(x, t), x, x)+a*exp(beta*u(x, t))+b*exp(2*beta*u(x, t))

diff(diff(u(x, t), t), t) = diff(diff(u(x, t), x), x)+a*exp(beta*u(x, t))+b*exp(2*beta*u(x, t))

(53)

pden := pdsolve(eval(PDE, [a = 1, b = 1/2, beta = -1/2]), {u(0, t) = 0, u(1, t) = 0, u(x, 0) = exp(-2*x)*sin(Pi*x), (D[2](u))(x, 0) = 0}, numeric, spacestep = 1/100, timestep = 1/100, compile = true):

pden:-plot3d(t = 0 .. 10, grid = [40, 200]);

 

 

Legal Notice: © Maplesoft, a division of Waterloo Maple Inc. 2012. Maplesoft and Maple are trademarks of Waterloo Maple Inc. This application may contain errors and Maplesoft is not liable for any damages resulting from the use of this material. This application is intended for non-commercial, non-profit use only. Contact Maplesoft for permission if you wish to use this application in for-profit activities.