Essay Writing Service http://StudyHub.vip/A-Computational-Approach-For-The-Analyt 👈

1. ELSEVIER Computer Physics Communications 90 (1995) 102- ! 16
ComputerPhysics
Communications
A computational approach for the analytical solving of partial
differential equations
E.S. Cheb-Terrab, K. yon Btflow
Departamento de F~ica Te6rica, lnstituto de Ffsica, Universidade do Estado do Rio de Janeiro, Rio de Janeiro, RJ 20550, Brazil
Received 18 November 1994; revised 15 May 1995
Abstract
A strategy for the analytical solving of partial differential equations and a first implementation of it as the PDEtools
software package of commands, using the Maple V R.3 symbolic computing system, are presented. This implementation
includes a PDE-solver, a command for changing variables and some other related tool-commands.
Keywords: Partial differential equations; Analytical solutions; Symbolic computing
PROGRAM SUMMARY
"Etle of the package or program: PDEtools
Catalogue number: ADBY
Program obtainable from: CPC Program Library, Queen's Uni-
versity of Belfast, N. Ireland (see application form in this issue)
Licensing provisions: none
Operating systems under which the program has been tested:
UNIX systems, Macintosh, DOS (AT 386, 486 and Pentium
based) systems, DEC VMS, IBM CMS
Programming language used: Maple V Release 3
Memory required to execute with typical data: 8 Megabytes
No. of lines in distributed program, including test data, etc.: 5617
Keywords: partial differential equations, analytical solutions, sym-
bolic computing
Nature of mathematical problem
Analytical solving of partial differential equations (PDEs).
Methods of solution
Standard methods such as the characteristic strip for first-order
PDEs, reduction to canonical form of second-order PDEs with
defined type, separation of variables, etc.
Restrictions concerning the complexity of the problem
Besides the inherent restrictions of the methods here implemented,
this first version of the PDEtools package cannot tackle systems
of PDEs.
Typical running time
It depends strongly on the PDE to be solved, usually taking from
a few seconds to a few minutes.
Unusualfeatures of the program
There are no restrictions as to the kind of PDE that the program
can try to solve. Furthermore, the User can optionally participate
in the solving process by giving the solver an extra argument
(the HINT option) as to the functionalfor,n of the indeterminate
function. Also, the package permits the User to perform changes
of variables in PDEs and to test the results obtained by the PDE-
solver.
0010-4655/95/$09.50 (~ 1995 Elsevier Science B.V. All rights reserved
SSDI 0010-4655 (95)00083-6

2. E.S. Cheb-Terrab, K. yon Biilow/ Computer Physics Communications 90 (1995) 102-116
LONG WRITE-UP
103
1. Introduction
This paper presents a general plan for a computational approach towards the analytical solution of partial
differential equations (PDEs), and an implementation of the first part of this plan as the PDEtools package of
commands. The package consists of a PDE-solver (called pdsolve) and some other tool-commands for working
with PDEs.
There are no "a priori" restrictions as to the types of PDEs that pdsoive can try to solve. Furthermore, the
PDEtools package allows the User to look for analytical solutions of a PDE both by using the solver directly or
by participating in the solving process in an interactive manner. This participation is appropriate when pdsolve
fails to solve the given PDE or when different types of solutions are wanted.
The exposition is organised as follows. In Section 2, the objectives and a general plan for a PDE-solver are
discussed. Section 3 is dedicated to the mathematical solving methods, including a discussion about the nature
of the problem, a list of the methods available in this version of the PDEtools package, and an explanation
concerning the possible participation of the User in the solving process; it also contains a brief description of the
computational structure of the pdsolve command. Section 4 displays a summary of the package's commands,
followed by a detailed description 1 of the most important ones (pdsolve and dchange), containing examples
that can be regarded as simple input/output tests. A more general test (209 examples) is included with the
PDEtools source held by the CPC Program Library. Finally, Section 5, Conclusions, contains a brief discussion
about this work and its possible extensions.
2. Strategy for a PDE-solver
2. I. The objectives of a PDE solving command
The first point to be discussed, with respect to a program that intends to obtain the analytical solution of
PDEs, is what the program should return as the result. This is not obvious, since a PDE may have many
different types of solutions. Concerning this point, we recall that
- the general solution of a PDE of nth order and k independent variables depends on n arbitrary functions of
k- 1 variables;
- a complete solution of a PDE with k independent variables depends on at least (Y'~=l hi) arbitrary constants,
where ni represents the differential order of the PDE w.r.t, each of the k variables.
The meaning we are giving here to the complete solution of a higher order PDE is a natural extension of
that given in the first-order case. Complete solutions can usually be obtained through the total separation of
the independent variables and integration of the resulting non-coupled system of ordinary differential equations
(ODEs).
Though there are other possible classifications, these are the ones we proposed as delimiters for the range
of types of solutions we are interested in; that is, given a PDE, when the solver-command pdsolve succeeds, it
should return
the most general solution it can find or, at least, the non-coupled system of ODEs obtained after separating
all the variables, giving the User the option of asking for the integration of these ODEs.
I Aside from this, the package itself contains an On-Line help in standard Maple format which can be viewed as the User's manual for
all the routines.

3. 104 E.S. Cheb-Terrab,K. yon Billow~ComputerPhysicsCommunications90 (1995)102-116
As auxiliary tools, we proposed that the commands of the package should permit the User to make changes of
variables (dchange command), indicate hints for solving the given PDE (the HINT option of pdsolve explained
below), test the results obtained by pdsolve (pdtest command) and build, from a result returned by pdsolve,
the resulting expression for the indeterminate function (build command, useful when the strategy followed by
pdsoive makes use of separation or change of variables).
2.2. The general plan
Let us classify the methods which may lead to the desired types (see the previous subsection) of solutions
into symmetry methods (those relying on the use of the theory of invariance under Lie groups of transformations,
see [ 1-3] ) and standard methods (the other ones, see [4-6] ).
Though it seems clear to us that a PDE-solver should make use of the systematic symmetry methods, these
methods usually map the task of solving PDEs into a task of the same type (requiring the solving of the system
of PDEs determining the generators of the invariance group) instead of into tasks already known to the system.
On the other hand, standard methods permit the mapping of the task of solving a PDE into the tasks of
realising algebraic manipulations, evaluating integrals and solving ODEs 2, all of which are already implemented
in Maple.
For these reasons, we split the general objective of analytically solving PDEs into three parts:
- the implementation of standard methods for solving a single PDE,
- the implementation of standard methods for solving a system of coupled linear PDEs,
- the implementation of symmetry methods.
The PDEtools package here presented is a first version of the first part of this plan, and thus does not make
use of symmetry methods.
3. An approach using standard methods
All standard known methods for solving PDEs have restricted success. Some of them have a clear prescription
of when and how to be applied (herein called deterministic methods), e.g. the characteristic strip method,
whereas other methods, such as the separation of variables, work in a more heuristic manner. Indeed, there is
as yet no systematic way to determine "a priori" what will be the submethod (by sum, product, or anything
else) for separating the variables in an arbitrary PDE 3
In addition, the possibility of formulating the problem of solving a PDE using one method does not end
the discussion: all methods map a problem into another problem, and the latter still needs to be solved. As
a consequence, almost all methods, deterministic or not, introduce trial-and-error as unavoidable part of the
process.
Finally, there are PDEs which can be tackled by more than one method, as well as PDEs (the majority) for
which we do not know any specific method of solution.
Taking the above three points into account, it became clear to us that a wide-range PDE-solver could
not depend only or even mainly on deterministic methods. Instead, the solver should be able to take decisions
concerning the method to be employed in any case, the trial strategy, and what to do when the strategy followed
at first fails (perhaps try another method...). Therefore, our proposal was to develop routines implementing
deterministic methods, to be used right at the beginning, when possible, and invest hard on algorithms for
2We did not work on routines for solvingintegralsor ODEs,exceptfor a subroutineto administerthe solvingof coupledsystemsof
ODEs which,in turn, makescallsto the standardint anddsolvecommands.
3Thoughsymmetrymethodscan be relatedto separationof variables,this relationis clearonly in a few cases (see I1,3]).

4. E.S. Cheb-Terrab,K. yon Billow~ComputerPhysicsCommunications90(1995) 102-116 105
separating variables, to be used both when a PDE cannot be tackled with the implemented deterministic
methods or when those methods have mapped the original PDE into a problem that the system fails to solve.
As for the reason for selecting the ancient method of separation of variables for the last attempt to solve any
PDE, we would like to recall that, though there is no guarantee of success, generally speaking, there are no "a
priori" restrictions as to the PDEs which can be tackled with this method.
3.1. The deterministicmethods
As mentioned above, we denominate deterministica method having a clear prescription of when and how to
be applied. A brief summary of the methods falling in this category which are implemented in this release of
the PDEtoolspackage follows below.
- The PDE has only one partial derivative: the program tries to build the associated quadrature.
- The PDE is of first order:
(i) The program looks for the characteristic strip and, if possible, returns a general solution built with differ-
ential invariants. At present, to obtain this type of solution it is necessary that the building of the strip not
involve the extension of the configuration space to include the derivatives of the indeterminate function as
coordinates.
(ii) When the use of the characteristic strip method is indicated to pdsoive by the User (via the HINT option
explained below), the program returns, in order of preference:
(a) a general solution using method (i) above;
(b) a parameterisedsolution for the characteristic strip, obtained after integrating the coupledsystem of ODEs
of the strip;
(c) a partially solved or completely unsolved strip of coupledODEs, with a warning message.
(iii) The PDE matches the pattern
( ff--~f (x, y.... )) ( ~y g(X, y.... )) - ( ff--ff (x, y.... )) ( ff-~g(x, y) ) =O (1,
where f(x,y .... ) is the indeterminate function: the program knows how to build a general solution
in this case. When the first-order PDE does not match this pattern, the subroutine looks for a general
multiplicative factor, depending on either x or y, in order to map the PDE, when possible, into another
PDE that does match it. This also implies the determination of g(x,y .... ), since the coefficients of the
derivatives of f(x, y.... ) almost never appear as (O/Ox)g(x, y) and (O/Oy)g(x,y), but as the result of
these derivations.
(iv) The PDE matches the patterns
f(Xl ..... Xn) -- g(Pl ..... p.) = ~ xiPi (2)
i=1
where Pi = (cg/Oxi) f(Xl ..... Xn); or
q)(f(xl ..... x,) ,Pl ..... P,) = 0 (3)
(no explicit dependence on the independent variables). In both cases, the program knows how to build a
complete solution.
- The PDE has only mixed partial derivatives: the program looks for the possible functions with such func-
tionality as to annul all the mixed partials, and uses those functions to build a solution.
- The PDE is of second order, involves derivatives w.r.t, no more than two variables, and its type (hyperbolic,
parabolic or elliptic) can be determined. In these cases, the PDE is first reduced to a canonicalform through

5. 106 E.S.Cheb-Terrab,K.yonBUlow/ ComputerPhysicsCommunications90(1995)102-116
a change of variables (using the dchange command) and then tackled using separation of variables. The
change of variables is unambiguous, but the submethod for separating the variables is not deterministic. The
change of variables that will, in each case, be appropriate to put the PDE in canonical form is determined
by independent subroutines.
All other PDEs are first tackled through separation of variables.
3.2. The heuristic algorithm for separating the variables
The main idea of the method of separation of variables consists in the introduction of unknown functions,
one for each of the independent variables of the PDE, for which one builds a system of uncoupled ODEs
equivalent to the original PDE. That system is obtained by realising algebraic manipulations, after replacing
the original indeterminate function by an explicit mathematical expression, as for example f(x,y, z) by
qb(fl (x), f2 (Y), f3(z ) ).
To determine what would be the appropriate explicit form of q~, we implemented a heuristic algorithm, i.e.
one that proposes a form for q~ whose success cannot be determined "a priori". Concerning the algorithm itself,
it seemed reasonable to us to build q~ with selected terms of the general sum of possible products, given in our
imaginary example by
fl (x) + f2(Y) + f3(z) + fl(x)f2(Y) + fl(x)f3(z) + f2(Y)f3(z) + fl(x)f2(Y)f3(z). (4)
For instance, separation by sum and by product would be obtained by selecting only the first three terms or
just the last term of Eq. (4), respectively. Note that there are no "a priori" restrictions as to the functional
form of fl, f2 or f3. Within the frame of this proposal, the selection of terms is realised considering some
general aspects of the given PDE (such as linearity, the occurrence of mixed partials, and so on), as well as
a classification of the independent variables into: differentiation variables, variables explicitly appearing in the
PDE but not as derivation variables, and variables appearing in the PDE only through the functional dependence
of the indeterminate function.
When the proposed q~ leads to a partial separation of variables, pdsolve was programmed to reenter itself
with the part containing the non-separated variables as argument, applying the whole strategy once again to
that part. This usually results in a mixed combination of separation of variables and deterministic methods to
solve a single given PDE.
3.3. The HINT option of pdsolve
As was already mentioned, there is no general, ever-efficient method to solve PDEs, and this is the greatest
handicap of any PDE-solving program. Therefore, we propose that pdsolve should permit an active participation
of the User in the solving process. To this end, and also to allow for an easy future extension of pdsoive's
internal capabilities, the command was designed so as to always follow a specific instruction concerning how to
tackle the received PDE; we called this instruction HINT, and, in some sense, it plays the role of a computational
ansatz.
The HINT can be given by the User; otherwise, it will be automatically generated by one of the subroutines
of pdsolve. In both cases, the HINT may be an indication of either a solving method already known to pdsolve,
then used to build a mathematical expression for the indeterminate function, or a submethod for separating the
variables, in which case the HINT will itself be a mathematical expression (see Subsections 3.2 and 4.2.2). In
any case, if the proposed expression succeeds in annulling the PDE 4 or in leading to a complete separation of
the variables, it is returned as the required solution.
4A specialroutine (pdtest command)was createdto simplifya PDE w.r.t, a proposedsolution.

6. E.S. Cheb-Terrab,K. yon Billow~ComputerPhysicsCommunications90(1995)102-116 107
As for the User's specification of a HINT, a noteworthy possibility is that of proposing afunctional HINT; that
is, to propose the indeterminate function as an expression involving an unknown function, perhaps more than
one and possibly depending on many variables each, mapping the original PDE into another PDE. A special
subroutine was created to administer the solving process in this case. Functional HINTs significantly increase
pdsolve's possibilities of finding a solution using Users' advices.
3.4. The computational structure of the pdsolve command
The structure we developed for the package's PDE-solver pdsolve consists of an implementation of the ideas
of the previous subsections as independent program-modules, which are executed sequentially when pdsolve
is called. As mentioned before, pdsolve was also programmed to call itself, possibly using a different solving
strategy when the one followed at first does not succeed at all or has only reduced the problem to a smaller
one. The purpose of the most relevant modules, in the order in which they are called, can be summarised as
(i) to collect, from an analysis of the structure of the PDE, all the information relevant to its solution (info
module) ;
(ii) to build a HINT (see Subsection 3.3), leading to the general or complete solution, when the PDE belongs
to a family recognised by the program (see Subsection 3.1), and reenter pdsolve indicating this HINT;
(iii) to propose a submethod for separating the variables (see Subsection 3.2), when the PDE does not belong
to any recognised family;
(iv) to use the HINT proposed by the User or built by pdsolve through one of the two previous modules, trying
to solve the PDE. When no success is obtained, no HINT was proposed by the User and the HINT tried
by pdsoive was built by module (ii), one more trial is realised, looking for a separation of the variables
using a submethod obtained through module (iii);
Iv) to select the remaining PDE (when a partial separation of variables happens) and reenter pdsolve with
this remaining PDE as argument.
Note that the core of the solver is inside module (iv), including all the subroutines related to the actual
separation of the variables and to the administration of any proposed HINT.
Depending on the PDE, pdsolve returns one of three possible results: a solution, the result of a partial
separation of variables, or the PDE itself (when no solution is found). In addition, a short report is displayed,
indicating any ODEs found when separating variables, as well as any arbitrary functions and changes of
variables that may have been introduced by pdsolve during the solving process.
4. The PDEtools package
4.1. Summao'
A brief review of the commands of the package is as follows5 :
- pdsolve looks for the general solution or the complete separation of the variables in a given PDE. The main
options the User has are: to ask for the automatic integration of the system of non-coupled ODEs obtained
through separation of variables, and/or to suggest a HINT to be taken as the departure point in searching for
the PDEs' solution (see Subsection 4.2.2).
- pdtest tests a solution found by pdsolve for a given PDE by making a careful simplification of the PDE
with respect to this solution.
5This subsectionand the nextone containsomeinformationalreadypresentedin the previoussections;this was necessaryto producea
completedescriptionof the package.

7. 108 E.S. Cheb-Terrab,K. yon Biilow/ ComputerPhysics Communications90 (1995) 102-116
- dchange performs changes of variables in PDEs and other algebraic objects (integrals, sums, limits, etc..... ).
This command is useful to change the format of a PDE from one that is difficult to solve to one that is
solvable.
- strip evaluates the characteristic strip associated to a first-order PDE; i.e., it builds the coupled system of
ODEs equivalent to the original PDE.
- splitstrip evaluates the strip associated to a PDE as does the strip command, but returns this strip split, as
much as possible, into subsets, each one with ODEs coupled among themselves but not coupled to the ODEs
of the other subsets.
- build takes the result found by pdsolve and with it constructs, when possible, an explicit expression for the
indeterminate function.
4.2. Description
A detailed description of the PDEtools package's commands is found in the On-Line help. Therefore, a
description, followed by some commented examples which can be viewed as simple input~output tests, will be
given here only for the most relevant commands, namely pdsolve and dchange.
4.2.1. Command name: pdsolve
Feature: Partial Differential Equation (PDE) solver
Calling sequence 6.
> pdsolvo(PDE) ;
> pdsolve (PDE, f, HINT=..., INTEGRATE) ;
Parameters:
PDE - a PDE
I - (optional, may be required) the name of the indeterminate function
HINT = . . . - (optional) indicates a method of solution to be taken as departure point
INTEGRATE - (optional) indicates the automatic integration of the set of uncoupled
ODEs found while separating the PDEs' variables
Synopsis:
Given a PDE, pdsolve's main goal is to find an analytical solution for it. There are no "a priori" restrictions
as to the type, differential order or number of independent variables of the PDEs it can try to solve. When
successful, the command returns, in order of preference,
- a general solution,
- a quasi-general solution, i.e. a solution containing arbitrary functions, but not in sufficient number or not
having enough variables in their functionality to constitute a general solution,
- a set of non-coupled ODEs with all the variables separated, integrated (when possible) if the option
INTEGRATE is indicated.
This command recognises and solves an increasing number of PDE families which can be tackled using
standard methods (see Section 3). When the given PDE belongs to an unrecognised family, the command
uses a heuristic algorithm, which looks for an efficient submethod for separating the variables, by taking into
account the specific structure of the PDE.
When an incomplete separation of variables is reached, the program calls itself (now with a smaller problem),
possibly using different methods of solution on each round. This results in a wide combination of methods for
solving the given PDE.
6In whatfollows,the input can be recognisedby the Mapleprompt>.

8. ES. Cheb-Terrab, K. yon Biilow / Computer Physics Communications 90 (1995) 102-116 109
The pdsolve command usually introduces new functions to express the solution for the indeterminate function.
For example,
f(x,y,z) = _fl(x) +_f2(y) +-f3(z).
The rule for composing the names of these introduced functions is: their first character is always the underscore
.... symbol (in agreement with standard Maple rules), followed by the name of the indeterminate function, and
ending with a number corresponding to the position of the variable inside the functionality of the indeterminate
function (when the introduced function depends on only one variable).
Finally, when the given PDE contains derivatives of more than one function, an indication of which function
should be considered as the indeterminate function is required.
4.2.2. The optional arguments for pdsolve
As mentioned above, two optional arguments are allowed when calling pdsolve:
(i) the User can ask for the automatic integration of the system of ODEs found by pdsolve while separating
the variables (option INTEGRATE; when present, it must be the last argument). The task of integrating
the uncoupled ODEs is then sent by pdsolve to the Maple standard dsolve command;
(ii) the User can give a HINT indicating a method of solution or a form for the indeterminate function (see
the examples below). When given, the HINT is taken by pdsoive as the departure point in looking for the
solution, and has priority with respect to any other method. When the given HINT just leads to a smaller
problem (partial solution of the PDE), that priority holds only in the first round.
The arguments which can be used at present with the HINT=... option are
- HINT='+', forces pdsolve to begin by looking for a solution trying to separate the variables by sum (see
Subsection 3.2) ;
- HINT=' *', forces pdsolve to begin by looking for a solution trying to separate the variables by product;
- HINT=... (any algebraic expression).., forces pdsolve to begin by looking for a solution trying to simplify
the PDE or to separate the variables taking the indeterminate function as equal to the indicated algebraic
expression. Functional HINTs containing functions of many variables are also allowed (see Subsection 3.3);
- HINT=strip (only implemented for first-order PDEs), forces pdsolve to look for a solution by trying to
solve the associated characteristic strip (see Subsection 3.1).
Examples 7
> PDE := diff(f(x,y,z),y)'2*exp(2*y)+diff(f(x,y,z),x)/cos(x)/z=diff(f(x,y,z),z);
(if___} )2 ~xf(X,y,z) c9 f(x,y,z ) (5)
PDE:= f(x,y,z) e(2y)+ cos(x)z -Oz
> pdsolve (") ;
(f(x,y,z) =_fl(x) +_f2(y) +-f3( Z ) )&Where
" c) _f2( y ) = e( -2V ) -c2' ~x -fl ( x ) = -cl c°s( x )' -~z -f3( z ) = -c2 + --z
That is, when pdsolve succeeds in solving a PDE, the result is returned using the &Where function; to the
left comes the result found for the indeterminate function, and to the right comes a list. In this case, the list
contains a set of ODEs for the functions _fl, .t2 and _f3, introduced by pdsolve when building the result.
7In Maple, " meansthe lastexpressionand .... meansthe secondlast expression.Also, specialcare was taken to keep the input and
outputshownalongthis paperwithalmostexactlythe sameformatand aspectas that whichappearson the computerscreen.

9. Ii0 E.S. Cheb-Terrab, K. con Billow~Computer Physics Communications 90 (1995) 102-116
Note also the introduction of arbitrary constants -cl .... when separating the variables. One should also expect
the appearing of arbitrary constants _C1.... of integration if one asks for the integration of the ODEs using the
INTEGRATE option.
Any of the results obtained by pdsolve can be tested using the pdtest command, which takes the PDE as
first argument and the result found by pdsolve as the second one, and returns 0 when the result checks OK:
> pdtest(PDE, ") ;
To see the resulting expression for the indeterminate function f(x, y, z) (in this case, a completesolution), it
is possible to use the build command,
> build("") ;
f( x, y, z ) = sin( x ) -cl + _C 1 - _c~ + _C2 + -c2 z + ..cj In( z ) + _C3 (6)
Let us consider a simpler example,
> PDE := x^2*diff(f(x,y,z),x)+diff(f(x,y,z),y)+...
(c9 ) (~___~ ) ~zf(X,y,z) =x2f(x,y,z
) s i n ( y ) (7)
PDE:=x2 ~xf(X,y,z) + f(x,y,z) +
> combine (build(pdsolve (PDE)), trig) ;
1 sin (-Y- x +-CI) sin(y) (8)
f(x,Y,z)=eX-fl Y+---Cl,z-2arctanh - ( 1 ) - ( 1 )
x sin --+_C1 sin --+_C1
x x
A general solution was returned 8 , in terms of an arbitrary function _fl with two differential invariants as
arguments.
As an example of a second-order equation (hyperbolic type) where a change of variables is automatically
introduced by pdsolve, consider
> PDE := 1/4*diff(f(x,y,z),x,y) +2*diff(f(x,y,z),y,y)=diff(f(x,y,z),x,x);
PDE:=-~ f(x,y,z) +2 f(x,y,z) = -~x2f(x,y,z) (9)
> pdsolve(PDE) ;
x, y, z ) = _fl( z, ..~1 ) + _f2( z, ~2 ) ) &Where [
( f(
( _fl ( z, -sOl), _f2( z, _~2 ), are arbitrary functions. ),
({ ( )
l 1 lx/]~ ,g2=y-x - + ~ (10)
&and _~l=y-x -8 8
That is, a general solution was obtained, after changing the variables in order to put the given PDE into
canonical form. The transformation equations are displayed in the result, and the change of variables was
realised by dehange.
8combine is a standard Maple command, here used to compact trigonometric expressions.

10. E.S. Cheb-Terrab. K. eon Bidow / Computer Physics Communications 90 (1995) 102-116 111
Two other examples, illustrating separation of variables in non-trivial algebraic structures, follow below.
( 1) Hamilton-Jacobi equation in elliptic coordinates:
> PDE := -diff(S(t,xi,eta,phi>,t) = 1/2*diff(S(t,xi,eta,phi),xi)-2*...
+i (gs(t,s,qq5))* (l-77*) 1 (wJJ*g2 (&+&T)
2 mu* (12 - 7j2) +2 m& (t2 - v2)
+a(O+b(T) + >
5* - r1* t2 - r1*
(11)
where cl(t), b(r]) and c(d) are arbitrary functions. In the context of the Hamilton-Jacobi formalism (see
[ 71)) one is usually interested only in a complete solution, and this can be obtained via
> pdsolve (PDE);
(S(t,5,7,4) =-S,(t) +-S2([) +53(v) +S4(+) )&Where
[i
(;-S3(~))2=-2C~r;$t +2*- C_l;T212+2b~)$
(12)
The build command can be used to transform the result above into an explicit expression for S( t, 5,~~ 4 ).
(2) An example of Poisson’s equation in spherical coordinates:
> PDE := Diff(r^2+diff(psi(r,theta,phi),r),r)+l/sin(theta)*...
A complete solution is given by
> pdsolve (PDE);
-2 (-$Pl(r))-UN(r)
r

11. 112 E.S. Cheb-Terrab, K. yon Biilow/ Computer Physics Communications 90 (1995) 102-116
a 2
Ol~b2 _4'3( 4, ) = -c3 _4,3( 4, ), (14)
002_q92(0)=__~2(0)_c1_ (~o -~2(O)) cos( 0 ) -c_3-@2( 0 ) "~]
sin(O) sin( 0 )2 j]
Note that, since this PDE is linear, a general solution can be built as a linear combination of complete solutions.
To conclude this subsection, let us consider the possible User's participation in the solving process, using the
HINT option. The following equation cannot be solved by pdsolve in a direct manner:
> PDE := f(x,y)*diff(diff(f(x,y),x),y)+diff(f(x,y),x)*diff(f(x,y),y)=l;
PDE:=f(x,y) f(x,y) + f(x,y) f(x,y) =1 15)
Two complete solutions can be found by giving rather simple HINTs:
> build (pdsolve (PDE, HINT= '+' ) ) ;
f( x, y ) = -cl x + _CI + y-- + _C2 16)
-Cl
> build (pdsolve (PDE, HINT=' * ' ) ) ;
f( x, y ) = x/2_cl x +_cI ~ Y_--~I
+_C2 17)
while a general solution can be obtained by giving a functional HINT (see Subsection 3.3) inferred from the
result above:
> HINT=F(x,y)^(I/2) ;
HINT= v/F--(x, y ) (18)
> pdsolve(PDE, ") ;
(f( x,y ) = v/-F2( x ) + ..FI(y) + 2xy +_C1 y +_C2) &Where
[ ( _F1( y ), _F2( x ), are arbitrary functions. ) ] (19)
4.2.3. Command name: dchange
Feature: Performs changes of variables in algebraic expressions and procedures
Calling sequence:
> dchange (tr, target) ;
> dchange (tr, target, itr, newvars, ~known' =..., cunknown' =..., simp_proc) ;
Parameters:
tr
target
itr
newvars
an equation or a set of them corresponding to the transformation from
the old (in the Ihs) to the new (in the rhs) variables
- an algebraic expression, procedure (program) or equation; or a list or
set of them
- (optional, may be required) the inverse transformation
- (optional, may be required) a list containing the new variables

12. E.S. Cheb-Terrab,K. yon Biilow/ ComputerPhysics Communications90 (1995) 102-116 Ii3
known=... - (optional) an equation having, on the LHS, the string "known", and on
the RHS, the name of a function or a set of names of functions
unknown=... - (optional) an equation having, on the LHS, the string "unknown", and
on the RHS, the name of a function or a set of names of functions
simp_proc - (optional) a simplification procedure
Synopsis:
d c h a n g e realises changes of variables in algebraic expressions (which can be limits, sums, integrals, PDEs,
integro-differential equations, etc.) and in procedures 9 .
This command was meant as a unified command, with the purpose of changing variables in a mathematical
sense (see below). In addition, it can use any specific indication for the inverse transformation, in which
case a different algorithm for changing variables in derivatives is used. This is particularly useful when the
transformation involves special functions not known to the system (see the examples).
This command can change variables using two different criteria. The first one, applied by default to known
functions (functions with differentiation rule known by the Maple system), changes the functional dependence
using the explicit relation between the old and new variables. For example, if the transformation is given by
x=( + ~7, Y=¢- ~7 (20)
the dchange command will transform known functions as in
cos -~cos ((-
The second criterion, applied by default to unknown functions (functions whose differentiation rule is unknown
to the Maple system), changes the functional dependence taking into account only the implicit relation between
the old and new variables. For example, with the transformation given by Eq. (20), the dehange command
will transform any unknown function (say f) as in
It is possible to change these defaults and force dchange to apply a specific criterion to a given function,
by specifying it using the known--.., or unknown--.., options, where "..." means either the name of the
function or a set with names of functions.
Additionally, it is possible to indicate the use of any standard or special procedure for the automatic
simplification of the resulting expression. This is useful when not obvious mathematical equivalences must be
taken into account, or just to compact the resulting expression. No simplification of the result is realised unless
explicitly indicated.
The conventions for the arguments are
- the arguments which have their position fixed are the first and second (the transformation and the "target").
All the other (optional) arguments may appear in any order after the second one;
- the old and new variables must be of type name. The possibility of giving variables of type function, which
will permit the direct study of the invariance groups of a PDE, are expected to be included in the next version
of the PDEtools package;
- the sets of transformation equations must contain ONLY old (new) variables in the left hand side (LHS)
and ONLY new (old) variables in the RHS, as in, for example, Eq. (20). When an indication of which are
the new variables is given, the order of the two sets inside the arguments passed to dchange is not important;
9The capabilitiesfor changingvariablesin proceduresare restrictedto the caseof simplemappings,not containingconditionalsor loops.
Furthermore, only the global variablesappearinginsidethe givenprocedurecan be changedusingthe dehange command,not the local
ones.

13. 114 E.S. Cheb-Terrab,
K.yonBillow/Computer
PhysicsCommunications
90(1995)102-116
- the new variables must he indicated as a list.For example, with the transformation Eq. (20), possible lists
indicating the new variables are [~,r/] or [r/,~:]. Note that, since for Maple f(~:,r/) ~: f(r/,~), the order
given to the new variables in the list is relevant. Also, when a function depends on more variables than those
which are being changed, the variables not entering the process are all put to the left.
Examples
As a unified command for changing variables, dchange may be useful in many different contexts. Concerning
PDEs, dchange can be used for realising changes of the independent variables, mapping a given PDE into a
more convenient one. For example, in
> PDE := diff(f(x,y),x)+g(x,y)+diff(f(x,y),y)=0;
0 x 0 x,
PDE:=~xf( ,y)+g(x,y) +~yf( y) =0 (21)
the change of variables
> tr := {x--xi+eta, y=xi-eta};
tr := {x = ~7+ ~:,Y = ( - ~7} (22)
can be performed in a rather simple manner via
> dchange (tr,PDE) ;
o-~f(s~, N) + g((,N) =0 (23)
reducing the number of differentiation variables by one.
It is also possible to use dehange to change variables in operators:
> L := f -> x*diff(f,y)-y*diff(f,x);
L:=f--~x f -y f (24)
> tr := {x = r*s^(i/2), y = r*(l-s)^(I/2)};
:: {x =r~/s, y =r lx/i--L~-s}
tr (25)
> dchange (tr, L, expand) ;
f --~ -2 lv/]-i~-
s v/7 ~ss (26)
As the last example, let us discuss a case when the giving of the inverse transformation makes a difference.
Consider the following differential equation:
> PDE : = sqrt (1-sin(phi) ^2*k^2)*diff (f (u,v, r,phi) ,phi)=G(u, v,r,phi)*sin(phi) ;
PDE:=v/1-sin((b)2k2 (~---~f(u,v,r, fb)) =G(u,v,r, qb)sin(fb) (27)
A change of variables from ~bto w, where w represents an elliptic integral of the first kind and am(w) represents
its amplitude,
> tr := {phi=am(w)};

14. E.S. Cheb-Terrab, K. yon Biilow/ Computer Physics Communications 90 (1995) 102-116 115
tr := { ~ = am(w) } (28)
takes the given PDE into
> dchange(tr,PDE) ;
v/i - sin( am(w) )2k2 (~ f(u,v,r,w)) =G(u,v,r,w) sin( am(w) ) (29)
~am(w)
cg"a,
A simplification of this PDE does not become apparent since the system does not know how to evaluate the
derivative of the amplitude of an elliptic integral (appearing in the denominator). Now, the giving of the inverse
trans|brmation equation,
> itr := {w=Int (i/sqrt (1-sin (rho) -2*k ^2), rho=0., phi) } ;
1 dp (30)
itr:= w= ~v/l_sin(p) 2k2
usually solves this type of problem, since dchange was programmed to take advantage of this extra information;
in this case it leads to
> dchange (tr, PDE, itr, simplify) ;
cgwf(u,v,r,w) = G(u,v,r,w) sin( am(w) ) (31)
To conclude, the system does not know the equivalences between Jacobi and trigonometric functions. Such
mathematical equivalences can usually be put in a substitution set and given as an optional argument (the
"simplification procedure") to dchange:
> Jaeobi := {sin(am(w))=sn(w)};
Jacobi := { sin( am( w ) ) = sn( w ) } (32)
> dchange(tr,PDE,itr,u -> simplify(subs(Jacobi,u))) ;
3--~f(u,v,r,w) =G(u,v,r,w) sn(w) (33)
In this case, for instance, this technique would permit the introduction of equivalences for the complete set
of Jacobi functions and elliptic integrals.
5. Conclusions
Solving PDEs is a major concern, both with respect to the complexity of the task and to its relevance in
the mathematical representation of problems in almost all branches of science. Now, taking into account the
algorithmic character of many of the existing solving methods, it is clear that computational approaches can
play an important role in the progress in this area.
In this context, the goal of the material here presented was to contribute both to the discussion of what would
be a computational strategy for the problem and to the implementation of that strategy using the algebraic
computing resources available nowadays. As far as we know, the PDEtools package here presented is the first
concrete implementation of a PDE-solver in general purpose symbolic computing systems.
On the other hand, this release of the package is just a first version of the first part of the plan proposed
in Subsection 2.2. As such, it does not make use of the theory of Lie of the invariance of PDEs with respect

15. 116 E.S. Cheb-Terrab,K. yon Billow/ ComputerPhysicsCommunications90 (1995)102-116
to Lie groups of transformations, and can be improved in many ways, as for example by implementing the
Lagrange-Charpit, Legendre and Riemman methods, to mention but a few. Nevertheless, we think that the
relevant task of having a first PDE-solver, with an organised structure from which to grow, has been obtained.
An important remark, considering there is still no general method able to solve all possible PDEs, is that great
emphasis was put in the interactive character of the package (the HINT option and the dchange command).
We believe this is a basic feature any PDE-solving package should have, since it is improbable that a general
method for solving all PDEs will be discovered in the near future. Also, it acts here as a useful alternative path
until the general plan is implemented.
Concerning the possible extensions of this work, they can be divided into three categories, related to: the
interface, the computational capabilities and the mathematical methods. Some of the possible improvements
falling into these categories are
- to give the User the option of building a 'pdsolve/method' (a method of solution associated to a given family
of PDEs) through a friendly interface;
- to introduce a kind of "memory" (a library in ASCII format, generated by the pdsolve command) which
would record the relationship between successful HINTs given by the User and the structure (recorded in the
info module of pdsolve) of the corresponding PDEs;
- to complete the implementation of a reasonable collection of standard methods;
- to introduce techniques for working with systems of coupled linear PDEs;
- to introduce symmetry methods for solving (systems of) PDEs.
These improvements are expected to be included in future versions, allowing the User to take advantage,
at the same time, of the PDEtools package here presented, the liesymm package, useful for building the
determining equations for the generators of invariance groups, and the diffgrob_2 package, useful for calculating
the elimination ideals and integrability conditions of a system of PDEs - see [8].
References
I1] EJ. Olver,Applicationsof Lie Groupsto DifferentialEquations(Springer,Berlin, 1986).
12l G.W.Blumanand S. Kumei,Symmetriesand DifferentialEquations,AppliedMathematicalSciences,Vol.81 (Springer,Berlin, 1989).
131 WillardMillerJr.,Symmetryand Separationof Variables,EncyclopaediaofMathematicsand its Applications,Vol.4 (Addison-Wesley,
Reading, MA, 1977).
141 R. Courantand D. Hilbert,Methodsof MathematicalPhysics(lnterscience,New York,1961).
[5] V.I.Smirnov,A Courseof HigherMathematicsIV: IntegralEquationsand PartialDifferentialEquations (PergamonPress, Oxford,
1964).
16] ER. Garabedian,PartialDifferentialEquations(Wiley,New York,1964).
17] L. Landauand E. Lifchitz,Mrcanique,PhysiqueThroriqueTome1(Mir, Moscow,1966).
I81 E.L. Mansfield,and E.D. Fackerell,DifferentialGrrbner Bases,MacquarieUniversitypreprint92/108 (1992). lnternetaddressfor
the sourcecode:euclid.exeter.ac.uk(pub/liz).