Introduction

We consider the linear chain of N pendulums each coupled to the nearest neighbors by the elastic bonds. Let us denote the angle of rotation of -th pendulum by  and the angle velocity by .  Each pendulum experiences the angular moment due to the gravity and the angular moments from the two elastic bonds, which are proportional to the difference in angles of rotation of the coupled pendulums with the coefficient .  Under the assumption that all pendulums have the same moment of inertia, J, the set of equations of motion takes the form Ref. [1]

>

restart:

>	J*diff(omega[i](t),t)=Gamma1[i]+Gamma2[i];

where  is the angular moments from the elastic bonds and  is the gravity angular moment.

The angular moments from the left and right elastic bonds are  and , respectively and hence

>	Gamma1[i]:=kappa*(phi[i+1]-2*phi[i]+phi[i-1]);

The gravity angular moment can be expressed as

>	Gamma2[i]:=-M*d*g*sin(phi[i]);

where  is the gravity constant.

In view of the expressions for  and  , the equations of motion can be rewritten as

>	J*diff(phi[i](t),t$2)=kappa*(phi[i+1](t)-2*phi[i](t)+phi[i-1](t))-M*d*g*sin(phi[i](t));

The above set of equations of motion transforms in the continuous limit to the following partial differential equation

>	J*diff(phi(x,t),t$2)=Kappa*diff(phi(x,t),x$2)-K[G]*sin(phi(x,t));

where , K= h ^2.

In the new spatial and time variables, , , the last equation obtains the standard form of the sine-Gordon equation

>	diff(phi(X,T),T$2)-diff(phi(X,T),X$2)+sin(phi(X,T))=0;

One can see that the system of coupled pendulums is described by the discrete analog to the sine-Gordon equation. In the following, we will demonstrate some of the solutions to the sine-Gordon equation, using the model described above.

Pendulum Model

>	with(plottools):

>	with(plots):

Warning, the names arrow and changecoords have been redefined

Procedure "pendulum" visualizes, in the frame of pendulum model, the solutions to the sine-Gordon equation obtained with the use of Maple V.

Input parameters:
N_Sol - N-soliton sine-Gordon solution,
name - name of the solution,
L0, L1 - space domain for visualization,
T0, T1 - time domain,
nt - number of snapshots,
nx - number of pendulums in the system,
orient - point of view on the system.

>	pendulum:=proc(N_Sol,name,L0,L1,T0,T1,nt,nx,orient)

>	local ndx,nxx,dx,radius,dt,bases_line,j,dd, i,theta,cos_u,sin_u,j1,lines,seq_lines,sol_line,seq_sol_line,b,diamonds,seq_diamonds,L,T:

>

>	assume(ndx,integer);

>	assume(nxx,integer);

>	ndx:=8: nxx:=nx*ndx:

>	L:=L1-L0: T:=T1-T0:

>	dx:=L/nxx: dt:=T/nt:

>	radius:=L/20:

>	bases_line:=line([0,0,0],[L,0,0],color=black,thickness=1);

>	for j from 0 to nxx+1 do

>	dd[j]:=dx*j;

>

od:

>	for i from 0 to nt do

>	for j from 1 to nxx do

>	theta:=evalf(Re(N_Sol(L0+dd[j],T0+i*dt)-Pi/2));

>	cos_u[j]:=evalf(radius*cos(theta));

>	sin_u[j]:=evalf(radius*sin(theta));

>

od:

>	for j from 1 to nx do

>	j1:=j*ndx;

>	lines[j]:=line([dd[j1],0,0],[dd[j1],cos_u[j1],sin_u[j1]],color=blue,thickness=1);

>	diamonds[j]:=point([dd[j1],cos_u[j1],sin_u[j1]],color=black,symbol=diamond):

>

od;

>	seq_lines:=seq(lines[j],j=1..nx):

>	seq_diamonds:=seq(diamonds[j],j=1..nx):

>	for j from 1 to nxx-1 do

>	sol_line[j]:=line([dd[j],cos_u[j],sin_u[j]],[dd[j+1],cos_u[j+1],sin_u[j+1]],thickness=2);

>

od;

>	seq_sol_line:=seq(sol_line[j],j=1..nxx-1):

>	b[i]:=display([seq_lines,seq_diamonds,seq_sol_line,bases_line], color=red):

>

od:

>	display(seq(b[i],i=0..nt), insequence=true,axes=framed,title=name,scaling=unconstrained,orientation=orient);

>

end:

Soliton Solutions

Hierarchy of sine-Gordon multi-soliton solutions can be obtained by means of Backlund transformations. Procedure "Backlund" realizes the algorithm of Backlund transformation in Maple V.
Input parameters:
a1, a2 - parameters of transformation,
phi0 - (N-2)-soliton solution,
phi1, phi2 - two (N-1)-soliton solutions.
The outcome of this procedure is the N-soliton solution.

>	Backlund := proc (a1,a2,phi0,phi1,phi2) RETURN(phi0+4*arctan(((a1+a2)*tan((phi1-phi2)/4))/(a1-a2))) end;

Procedure "Soliton" builds a single-soliton solution.
Input parameters:
x, t - space and time coordinates,
a - parameter of transformation,
x_0 - initial position.

>	Soliton := proc (x,t,a,x_0) local xi,tau: xi:=(x-x_0+t)/2; tau:=(x-x_0-t)/2; RETURN(4*arctan(exp(a*xi+tau/a))) end;

Procedure "TwoSoliton" builds the two-soliton solutions.
Input parameters:
x, t - space and time coordinates,
a1, a2 - parameters of transformation,
x_1, x_2 - initial positions.

>	TwoSoliton := proc (x,t,a1,x_1,a2,x_2) local phi0,phi1,phi2: phi0[0]:=(x,t)->0; phi1[1]:=(x,t)->Soliton(x,t,a1,x_1); phi2[1]:=(x,t)->Soliton(x,t,a2,x_2); phi1[2]:=(x,t)->Backlund(a1,a2,phi0[0](x,t),phi1[1](x,t),phi2[1](x,t)); RETURN(phi1[2](x,t))  end;

Procedure "ThreeSoliton" builds the three-soliton solutions.
Input parameters:
x, t - space and time coordinates,
a1, a2, a3 - parameters of transformation,
x_1, x_2, x_3 - initial positions.

>

ThreeSoliton := proc (x,t,a1,x_1,a2,x_2,a3,x_3) local  phi,phi1,phi2,phi3 : phi2[1]:=(x,t)->Soliton(x,t,a2,x_2); phi1[2]:=(x,t)->TwoSoliton(x,t,a1,x_1,a2,x_2); phi2[2]:=(x,t)->TwoSoliton(x,t,a2,x_2,a3,x_3); phi1[3]:=(x,t)->Backlund(a3,a1,phi2[1](x,t),phi2[2](x,t),phi1[2](x,t)); RETURN(Re(phi1[3](x,t)))  end;

One-Soliton Solutions

Two-Soliton Solutions

Three-Soliton Solutions

Conclusion

 With the use of Maple, the Backlund transformation was employed for derivation of several multi-soliton solutions to the sine-Gordon equation. The solutions were visualized for the coupled pendulum model, which has the sine-Gordon equation as the continuous analog.

References

[1] R.K.Dodd, J.C.Eilbeck, J.D.Gibbon, H.C.Morries, Solitons and Nonlinear Wave Equations (Academic Press, London, 1982).