PDEtools - Maple Programming Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Differential Equations : PDEtools : PDEtools/dpolyform





compute a differential polynomial form for a given system of non-polynomial equations


Calling Sequence





Calling Sequence

dpolyform(sys, no_Fn, opts)




single expression or an equation, or a set or list of them



(optional) specify that all auxiliary functions _Fn (n integer) introduced in the process are to be eliminated before outputting



(optional) argument(s) accepted by the Maple casesplit command



The dpolyform function receives an equation or expression, or a set or list of them, containing some unknown functions of one or many variables, possibly containing non-polynomial objects (fractional powers, mathematical functions, etc.) and returns an equivalent differential polynomial (DP) system of equations.


The DP returned is equivalent to the given system in that any solution (value of the unknown functions) of the input is also a solution of the output DP system. This DP returned is differential polynomial in that it is entirely polynomial in the unknowns and its derivatives, with coefficients entirely rational in the independent variables. In this sense, dpolyform has the concrete ability to compute differential polynomial representations for non-polynomial objects.


The mathematical expressions dpolyform can represent in DP form include almost all the functions of the mathematical language, arbitrary compositions of them with the operations +,,^,@, including in that abstract powers, inverse functions constructed with @@, functions represented as ODE solutions using DESol, algebraic expressions represented using RootOf, integrals represented with Int, int or Intat, etc. The only exceptions are mathematical functions related to Zeta (e.g. Psi and GAMMA), not admitting a polynomial differential equation representation.


This routine has enormous potential in that it permits the use of the existing methods for polynomial systems, for example, differential elimination (see, for example, DifferentialAlgebra, DEtools[Rif], or casesplit), to solve, or in general work with, non-polynomial systems in a systematic way.


The dpolyform command can be used to also decouple non-polynomial systems of differential or algebraic equations (unlike the output of casesplit, the output of dpolyform is DP), or in the computation of identities for special functions. The dpolyform subroutines are used by the Maple dsolve, pdsolve and casesplit commands when solving ODE and PDE systems, in order to triangularize non-polynomial systems using techniques for polynomial ones.


By default, dpolyform is expected to return rather fast, outputting a DP system equivalent to the input system, representing the non-polynomial objects by means of auxiliary functions _Fn... (n is an integer) which in turn satisfy DP equations. Thus, the output of dpolyform consists of three lists.


-  The first list contains DP equations of the form "DP_expression = 0".


- The second list consists of inequations of the form "DP_expression <> 0".


- The third list consists of 'back substitution equations', showing which non-polynomial object is represented by each auxiliary function _Fn introduced.


By giving the optional argument 'no_Fn', a second process is run to remove all the _Fn functions introduced in the first step, ending with a DP system (which can be a single DP equation) that involves only the unknown functions found in the given input. This system that is free of auxiliary functions is obtained by running a differential elimination process ranking all the auxiliary _Fn higher than the unknown functions present in the input. For details on rankings, see DEtools[checkrank].


The dpolyform routine also accepts the same optional arguments that are accepted by casesplit.



For ease of reading, these functions are declared to be displayed in a compact way. Also, derivatives are displayed as indexed objects.

declare(g(x,y), _F1(x,y), _F2(x,y), _F3(x,y));

gx&comma;ywill now be displayed asg

_F1x&comma;ywill now be displayed as_F1

_F2x&comma;ywill now be displayed as_F2

_F3x&comma;ywill now be displayed as_F3


Consider the following non-polynomial expression.

e1 := g(x,y) = tan(2*x-y^(1/2));



A differential polynomial system (DPS) equivalent to e1 is given by:

DPS := dpolyform(e1);



To view the expression above in the usual Maple format, use the macro show.




A sequence of three lists is returned. The first list contains the Equations of the problem, the second list contains the Inequations, and the third list contains the back-substitution equations, specifying which non-polynomial object is represented by each auxiliary function _Fn.

Concerning the lists of equations and inequations, two remarks are in order. First, the DPS returned by dpolyform represents an expression a bit more general than the given input. For example, to exactly represent tan2x+y polynomially, initial conditions need to be introduced for the DPS returned by dpolyform. Second, while performing differential elimination, or various other manipulations on the DPS returned, Maple solves a system slightly more general than the input. However, in the solution, all the functions _F1, _F2, ... are replaced by the restricted objects they represent (the back substitution equations returned by dpolyform) to produce a valid solution.

To obtain a DPS satisfied by e1 which, in turn, only involves the original unknowns (no _F1, _F2, ...), call dpolyform with the optional argument 'no_Fn'. In such a case, the output has the same format as that produced by the casesplit command.

dpolyform(e1, no_Fn);



As in casesplit, the '&where' in the display above is obtained using a `print/foo` mechanism. The real structure of this result is of the form `casesplit/ans`( [ equations ], [ inequations ] ), and can be seen by using:


`casesplit/ans`([diff(g(x,y),x) = 2*g(x,y)^2+2, diff(g(x,y),y)^2 = 1/4/y*g(x,y)^4+1/2/y*g(x,y)^2+1/4/y],[diff(g(x,y),y) <> 0, -g(x,y)^2-1 <> 0])

To verify that this nonlinear PDE system

pde_sys := [op( map(op,(5)) )];



for gx&comma;y is satisfied by e1, use the Maple pdetest command.




pdetest( (7), pde_sys);



Note that, while the solution of the given expression e1 is included in the solution of the DP output by dpolyform, the opposite is not true. The solution of the DP problem is slightly more general. It contains an arbitrary constant.




Moreover, due to the nonlinear character of this example, if, in pde_sys, one excludes the inequation returned by dpolyform, then pde_sys also admits singular solutions







and e1 is not included in the singular solutions g=±I.

The dpolyform routine can handle systems of equations containing most functions known to Maple, including fractional or abstract powers, as well as arbitrary compositions of these objects. A useful side effect of this is that, by asking for the DP form of a special function, one receives the polynomial differential equation it satisfies. For example,

declare(f(x), y(x), prime=x);

fxwill now be displayed asf

yxwill now be displayed asy

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


y(x) = BesselJ(n,x);



dpolyform((13), no_Fn);



For the following, see also hypergeom and DEtools[hyperode].

y(x) = hypergeom( [a,b], [c], f(x));



dpolyform((15), [y,f], no_Fn);



In the input above, y&comma;f means that yx expressed as a function of fx is wanted. If not given, this ordering is the one casesplit finds simpler.

For the following, see also MeijerG and DEtools[hyperode].

y(x) = MeijerG( [[a],[b]], [[c],[d]], f(x));



dpolyform((17), y(x), no_Fn);



In the input above, 'y(x)' means that in the output yx is expressed as a function of the other unknowns of the system (here fx). This is equivalent to giving y&comma;f or yx&comma;fx.

It is evident from the last two results by dpolyform that, for some values of a, b, c, d, and f(x), there is a relation between the hypergeometric and the more general MeijerG functions. This relation is actually given by:

hypergeom([a,b],[c],f(x)) = convert( hypergeom([a,b],[c],f(x)), MeijerG);



More complicated cases are also handled. For example, the complete Elliptic integral of the third kind (see EllipticPi)

P(nu,k) = EllipticPi(nu,k);



is represented in DP form, not by an ODE, but by a PDE system.

dpolyform((20), no_Fn);



The dpolyform command can handle expressions involving more abstract representations as DESol, RootOf or @@. For example, consider the inverse of the dawson function.

y(x) = `@@`(dawson,-1)(x);



The differential polynomial representation of this object is an Abel equation of the 2nd kind which happens to admit symmetries separable by product.

dpolyform((22), no_Fn);




_1st_order&comma;_with_symmetry_[F(x)*G(y),0]&comma;_Abel&comma;2nd type&comma;class C


By using dpolyform to obtain the differential equation satisfied by a given expression, it is possible to establish identities for special functions, or relations between them and simpler Liouvillian (for example, exponential and trigonometric) functions. As an example illustrating the mechanism, consider yx as the following hypergeometric function.

a3 := y(x) = hypergeom([1],[2],-2*I*x);



A polynomial (in this case linear) ODE satisfied by yx is given by:

e3 := dpolyform(a3, no_Fn);



The ODE above also has a solution in terms of Liouvillian functions, which can be obtained by using Kovacic's algorithm. See DEtools[kovacicsols].




a3_bis := dsolve((27),[Kovacic]);



This means that the hypergeometric function appearing in a3 is equal to the right-hand side of a3_bis for some particular values of _C1 and _C2. The actual values of _C1 and _C2 can be obtained by expanding in series. For that purpose, first build an expression equating a3 to the solution of the ODE.

e4 := a3 - a3_bis;



Next, compute the series of the right-hand side. In this case, it suffices to compute it up to order 2.




Now, to solve for _C1 and _C2, build a system with the coefficients of x.

sys := {coeffs(convert((30),polynom),x)};



Finally, produce:

ans_C := solve(sys,{_C1,_C2});



It can be proved that this solution for _C1 and _C2 is independent of the order of the series. This is always the case when dealing with linear ODEs provided that the system "sys" includes all the unknowns _Cn. At these values of _C1 and _C2, our equation relating hypergeom([1],[2],-2*I*x) with &ExponentialE;2Ix becomes




from where the hypergeometric function can be isolated, resulting in the desired identity.




In this easy case, this relation can be verified by means of a black box, table-lookup approach by using:







The approach discussed above, however, does not rely on table lookups and can be used in general, provided that Maple can compute the series of the expressions involved. When the right-hand side of the departing expression ('a3' in the example above) is an integral, this approach is useful for computing its exact value when the integral can be expanded in series and its differential polynomial form can be solved exactly. In the same way, the approach can be used to compute identities between different special functions by directing dsolve to solve the DP problem by using different solving methods, for example, first by using method 'hypergeometric' or 'MeijerG', and then solving the same problem by using method 'Bessel', 'Whittaker', or 'elliptic'.

Finally, it is possible to use dpolyform to solve algebraic (nondifferential) systems as well. As an example of this, consider the following non-polynomial, nondifferential system of equations for the unknowns yt,zt.

declare((y,z)(t), prime=t);

ytwill now be displayed asy

ztwill now be displayed asz

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


sys := [t-tan(y(t)+z(t)-ln(y(t))) = 0, y(t)-exp(-y(t)+z(t)+arctan(t)) = 0];



Due to the non-trivial non-polynomial expressions involved, the Maple solve command in previous releases failed to solve this problem for yt and zt. By using dpolyform you can solve sys as follows. First compute a differential polynomial form for sys.

dpolyform(sys, no_Fn);



DP_sys := [op( map(op, (39)) )];



Second, solve DP_sys using dsolve

sol_DP_sys := dsolve(DP_sys, explicit);



This solution to DP_sys includes the solution to sys for some particular values of the integration constants _C1&comma;_C2 involved. To determine _C1&comma;_C2, substitute the above into sys.

sys_C := eval(sys, sol_DP_sys);



The next step is to solve sys_C for _C1&comma;_C2. We must expand sys_C in a series. It is sufficient to find a few terms from which you can get a solution. For computational reasons, use three intermediate steps.

z1 := map(lhs, sys_C):       # take left-hand-sides

z2 := map(series, z1, t, 1): # compute series

z3 := simplify( map(convert, z2, polynom) );



Now solve for _C1&comma;_C2:

_EnvAllSolutions := true;  # see ?solve,details



sol_C := solve({op(z3)},{_C1,_C2});



where, by convention, _Z1~ is an integer (see solve). Finally, the solution above leads to the solution for the nondifferential sys, by evaluating sol_DP_sys at these values of the integration constants. To see this, take for instance the solution containing the imaginary unit




sol_sys := eval( sol_DP_sys, (46) );



This solution can be verified by substituting into sys.




simplify( expand(eval( sys, sol_sys ) ));





Cheb-Terrab, E.S. "A Computational Approach for the Exact Solving of Systems of Partial Differential Equations." Submitted to Computer Physics Communications, 2001.

See Also