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

Online Help

All Products    Maple    MapleSim

DifferentialGeometry Tutorials


Recursion Operators for Integrable Equations




Procedures Illustrated

The program InverseTotalDiff

The  KdV Equation

The  Sine-Gordon Equation

Conservation Laws for the Sine-Gordon Equation



In the subject of integrable systems of differential equations there are many different definitions of  integrability.  One definition declares a system of pde to be integrable if the equation admits an infinite hierarchy of higher order symmetries.  For evolution equations, these higher order symmetries can be viewed as higher order evolution equations who (local) flows commute with the flow of the given  evolution equation.


The higher order symmetries of an integrable equation can be generated inductively by a recursion operator which maps one higher order symmetry to the next one in the hierarchy.  Recursion operators for integrable equations typically involve the formal inverse of the total derivative operator


In this application you will learn to create the recursion operators for some well-known integrable equations and to use these operators to generate higher order generalized symmetries. We shall also verify directly that the higher order symmetries so constructed are indeed symmetries.


For a detailed discussion of higher order or generalized symmetries and recursion operators, see P. J. Olver,  Applications of Lie Groups to Differential Equations

(2nd Edition)  Chapter 5.


The Maple code in the section "The program InverseTotalDiff must be executed prior to executing the examples.


Procedures Illustrated

This tutorial illustrates the use of the following packages and procedures

DifferentialGeometry, JetCalculus, DGsetup, TotalDiff, HorizontalHomotopy, GeneralizedLieBracket, Transformation, DifferentialEquationData, Prolong, LieDerivative, EulerLagrange, Noether,  HorizontalExteriorDerivative


The program InverseTotalDiff

Let g = g(x, u, ux, u_xx.. ) is a function of a single independent variable x, a dependent variable u and its derivatives ux, u_xx..  to some order k(that is, a function on the jet space J^k(R,R) ) and let f= D_x(g), where D_x is total differentiation with respect to x. Then the program InverseTotalDiff(f) given below reproduces g (up to an additive constant). This command is easily constructed from the horizontal homotopy operator in the variational bicomplex which is implemented in the JetCalculus package.



with(DifferentialGeometry): with(JetCalculus):

Preferences("JetNotation", "JetNotation2");



InverseTotalDiff := proc(f)

local L;

if  Tools:-DGinfo("FrameBaseDimension") <> 1 then

error("Number of Independent Variables in Current Frame  Must Be 1");


L := f &mult Tools:-DGvolume("biform");




We test the program InverseTotalDiff with an example:

DGsetup([x], [u], E, 1);

frame name: E

E > 

g:= u[1]*u[2]^2;

E > 



E > 

f := TotalDiff(u[1]*u[2]^2,x);


E > 



E > 



The  KdV Equation


The KdV equation is the evolution equation u_t = u_xxx + u*u_x.  The recursion operator is  for the  KdV equation is:

R(f) = D_xx(f) + 2/3*u[0]*f +1/3*u_x*D_x^(-1)(f).

DGsetup([x], [u], M, 1):


Define the KdV flow by the  right-hand side of the KdV equation.

M > 

KdVFlow := u[3] + u[0]*u[1];




Define the KdV recursion operator:

M > 

KdVRecursion := exp ->  expand(TotalDiff(exp,[2]) +2/3*u[0]*exp +1/3*u[1]*InverseTotalDiff(exp));




Define the first generalized symmetry Q_0 for the KdV equation and generate the higher symmetries using the recursion operator.

M > 

Q0 := u[1];



3rd order (the KdV flow itself)

M > 

Q1:= KdVRecursion(Q_0);



5th order:

M > 

Q2:= KdVRecursion(Q_1);



7th order:

M > 

Q3:= KdVRecursion(Q_2);



9th order:

M > 

Q4 := KdVRecursion(Q_3);




Check that each of the flows Q0, Q1, Q2, Q3 commute with the KdV flow using the generalized Lie bracket command. For this we use the functions KdVFlow, Q0, Q1, ... to define generalized vector fields:

M > 

GeneralizedLieBracket( KdVFlow*D_u[0], Q0*D_u[0]);


M > 

GeneralizedLieBracket( KdVFlow*D_u[0], Q1*D_u[0]);


M > 

GeneralizedLieBracket( KdVFlow*D_u[0], Q2*D_u[0]);


M > 

GeneralizedLieBracket( KdVFlow*D_u[0], Q3*D_u[0]);


M > 

GeneralizedLieBracket( KdVFlow*D_u[0], Q4*D_u[0]);





The  Sine-Gordon Equation

For the Sine-Gordon equation u_xt = sin(u), the recursion operator is:

R(f) = D_xx(f) + u_x*f -u_xD_x^(-1)(u_xx*f).


We use this operator to generate the first few higher order symmetries in the Sine-Gordon hierarchy.

M > 


M > 

DGsetup([x], [u], M, 1):


Define the Sine-Gordon recursion operator:

M > 

SGRecursion := exp ->expand(TotalDiff(exp,[2]) + u[1]^2*exp - u[1]*InverseTotalDiff(u[2] *exp));




Define the first generalized symmetry P0 and generate the higher symmetries.

M > 

P0 := u[1];




3rd order

M > 

P1 := SGRecursion(P0);




5th order

M > 

P2 := SGRecursion(P1);




7th order

M > 

P3 := SGRecursion(P2);


M > 


Now we change these into evolutionary vector fields on the jet space for u, viewed as function of the two variables x, t. For this we need the transformation phi

defined below.

DGsetup([x,t], [u], SG,1);

frame name: SG

SG > 

phi := Transformation(SG, M,[x=x, u[0]=u[0,0]]);


SG > 

phi7 := Prolong(phi,7,Matrix([[1,0],[0,0]]));


SG > 

Y[0] := evalDG(Pullback(phi7,P0)*D_u[0,0]);


SG > 

Y[1] := evalDG( Pullback(phi7,P1) * D_u[0,0]);


SG > 

Y[2] := evalDG( Pullback(phi7,P2) * D_u[0,0]);


SG > 

Y[3] := evalDG( Pullback(phi7,P3) * D_u[0,0]);


SG > 


To check that these are symmetries, first construct the differential equation data structure for the Sine-Gordon equation, prolong this to the 7 jet, and convert to a transformation.


Delta0 := [u[1,1] -sin(u[0,0])];


SG > 

Delta:= DifferentialEquationData(Delta0, [u[1,1]]);


SG > 

Phi := Transformation(Delta, 7):


We now apply the test for a generalized vector field  X to be be higher order symmetries. We prolong the vector X to order 2, Lie differentiate the Sine Gordon equation with respect to the prolonged vector field, and  substitute from the differential equation and its derivatives (via the Pullback command)

SG > 

CheckSymmetry := X-> simplify(Pullback(Phi,LieDerivative(Prolong(X,2), Delta0[1]))):

SG > 

seq(CheckSymmetry(Y[i]), i =0..3);





Conservation Laws for the Sine-Gordon Equation

This is a continuation of the  previous section.  First we show that each of the generalized symmetries of the Sine-Gordon equation actually a variational symmetry. We recall that a vector field  X is a variational symmetry of  a Lagrangian if the Lie derivative of the Lagrangian with respect to the prolongation of the vector field is a total derivative. This latter condition may be checked by applying the EulerLagrange and checking that the result is zero


SG > 

lambda := evalDG((1/2*u[1,0]*u[0,1] - cos(u[0,0]) )*Dx &w Dt);




The Euler-Lagrange form  for lambda yields the sine-Gordon equations.

SG > 

Delta := EulerLagrange(lambda);

SG > 



SG > 

CheckVariationalSymmetry := EulerLagrange @ LieDerivative;


SG > 

seq(CheckVariationalSymmetry(Prolong(Y[i],1), lambda), i=0..3);

SG > 





The conservation laws for these higher order symmetries can be found using from Noether's theorem which is implemented in the command Noether. We check that the horizontal exterior derivative of these forms vanish on solutions to the sine-Gordon equation -- as required.

SG > 

omega[0] := Noether(Y[0],Delta);


SG > 



SG > 

omega[1] := Noether(Y[1],Delta);


SG > 




We remark that the formulas for this conservations can be simplified by the addition of an exact 1-form.