PDEtools - Maple Programming Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Differential Equations : PDEtools : Symmetries : PDEtools/ReducedForm





reduces one given PDE system with respect to another given PDE system


Calling Sequence




Calling Sequence

ReducedForm(PDESYS_1, PDESYS_2, RedVars)




a PDE or a set or list of them; it can include ODEs and not differential equations



same as PDESYS_1



optional - may be required; a function or a list of them indicating the (reducing) variables of the problem



optional - check whether the two systems PDESYS_1 and PDESYS_2 are consistent between themselves before reducing PDESYS_1



ReducedForm receives two PDE systems, PDESYS_1 and PDESYS_2, in that order, and reduces PDESYS_1 with respect to PDESYS_2. In some sense, ReducedForm is the "differential equation" command equivalent to simplify/siderels. ReducedForm also works with anticommutative variables set using the Physics package using the approach explained in PerformOnAnticommutativeSystem.


Generally speaking, that is equivalent to taking the highest derivative of each equation in PDESYS_2, isolating it and using the equation to replace occurrences of this highest derivative in PDESYS_1, and at the end simplifying the resulting system taking into account its integrability conditions. In more technical words, the output is the reduced form of PDESYS_1 modulo the radical differential ideal of PDESYS_2


If RedVars is not specified, ReducedForm will consider all the differentiated unknown functions in PDESYS_2 as (reducing) variables of the problems.


The reduction process performed by ReducedForm consists of the following steps


[-] Departing from PDESYS_1 = [eq1, eq2, ...], a new system PDESYS_tmp = [Y1 - eq1, Y1 - eq2, ..., Yn - eqn] is constructed introducing a set of auxiliary variables {Y1, ..., Yn}, where n is the number of equations in PDESYS_1.


[-] One new system of equations is now built with the equations in PDESYS_tmp and in PDESYS_2 and a differential elimination process is ran ranking the auxiliary variables Yn higher than the dependent (reducing) variables - say F1 ... Fk - of PDESYS_2. So this ranking is of the form [[Y1, ... Yn], [F1, ... Fk]] and hence the elimination process runs using lexicographical ordering when comparing any Yn with any Fk but with the less expensive total degree ordering when comparing the Yn between themselves and the Fk between themselves.


[-] From the output of the differential elimination process, only the equations containing the Yn are preserved, so substituting the auxiliary Yn by zero results in the desired reduction of PDESYS_1 with respect to PDESYS_2, with the maximum number of Fk removed from the problem.


Note that it is possible to reduce one PDE system (PDESYS_1) using another one (PDESYS_2) in cases where the two systems are not consistent with each other, and that generally speaking the reduction obtained is useless in that its solution does not solve any of the two given systems. So you may want to request a check for consistency before proceeding with the reduction - for this purpose add the keyword checkconsistency anywhere in the calling sequence passed to ReducedForm - an example of this is at the end of the Examples section.


To avoid having to remember the optional keywords, if you type the keyword misspelled, or just a portion of it, a matching against the correct keywords is performed, and when there is only one match, the input is automatically corrected.


To input PDE systems conveniently, avoiding redundant typing, and to display these systems compactly, without redundancies, use diff_table and declare

with(PDEtools, ReducedForm, declare, diff_table, dsubs);



U := diff_table(u(x,y,z,t)):


ux,y,z,twill now be displayed asu


Consider now the PDE system

pde[1] := U[x,y,z] + U[t,y,z] + U[t,x,z] - U[t,t];



Reduce it using:

pde[2] := U[x] = 0;



ReducedForm(pde[1], pde[2]);



In some cases, as this example above, the same result can be obtained using dsubs in a less expensive computational way.

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



Note that the reduced forms returned by dsubs and ReducedForm do not include the reducing equation pde[2]. Consider the difference between these reductions and a casesplitting of the system conformed by both pde[1] and pde[2]: the output may be similar and may include pde[2] (or its differential consequences)

PDEtools:-casesplit([pde[1], pde[2]]);



A more involved example where, by construction, the reduced form is zero; use declare to display the equations compactly, without redundancies

declare((u, v)(x, y));

ux,ywill now be displayed asu

vx,ywill now be displayed asv


U, V := diff_table(u(x,y)), diff_table(v(x,y)):

PDESYS_2 := [V[]*U[x,x] - V[x], U[x,y]*V[y], V[y,y]^2-1];



Construct now PDESYS_1 as a (possibly nonlinear) combination of lists constructed using PDESYS_2, for instance the derivative with respect to x of the square of each equation in PDESYS_2 minus the derivative with respect to y of of the same equation

PDESYS_1 := diff(map(`^`, PDESYS_2, 2), x) - diff(PDESYS_2, y);



By construction, thus, PDESYS_1 is completely reduced by PDESYS_2

ReducedForm(PDESYS_1, PDESYS_2);



Consider two systems that are inconsistent with each other, that is: the solutions of one system can never be solutions of the other one, for example:

ode[1] := diff(y(x), x,x) = ((-alpha-beta*y(x))*x^2-2*x*diff(y(x),x))/x^2;



ode[2] := diff(y(x),x) = -h*(y(x)-kappa)/rho;



You can directly test the consistency of two equations using casesplit

PDEtools:-casesplit([ode[1], ode[2]]);

Warning: System is inconsistent

Nevertheless, if you substitute in ode[1] the value of y' from ode[2] you obtain an expression involving y(x)

dsubs(ode[2], ode[1]);



isolate((14), y(x));



Because the systems are inconsistent with each other, this value of y(x) solves neither ode[1] nor ode[2]:

odetest((15), [ode[1], ode[2]]); # not [0, 0]



So calling ReducedForm you would obtain the reduction obtained above using dsubs, which is of no use generally speaking.

ReducedForm(ode[1], ode[2]);



isolate(op([1,1], (17)), y(x));



The optional argument checkconsistency is of use in these situations, enforcing a check for consistency between the two systems, and when the systems are not consistent an error is returned

ReducedForm(ode[1], ode[2], checkconsistency);

Error, (in PDEtools:-ReducedForm) the given systems of equations are inconsistent with each other

ReducedForm also works with anticommutative variables, using the approach explained in PerformOnAnticommutativeSystem.




Set first θ and Q as suffixes for variables of type/anticommutative (see Setup)

Setup(anticommutativepre = {theta, Q});

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




A PDE system example with one unknown anticommutative function Q of four variables, two commutative and two anticommutative; to avoid redundant typing in the input that follows and redundant display of information on the screen, use PDEtools:-declare, and PDEtools:-diff_table, that also handles anticommutative variables by automatically using Physics:-diff when Physics is loaded

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

Qx,y,θ1,θ2will now be displayed asQ


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;



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



By inspection, it is clear that pde[1] is reducible by pde[2]

ReducedForm(pde[1], pde[2]);



One way of solving this PDE system is then to start solving this reduced equation





Substituting this result for Q back into pde[2], then multiplying by θ1 and subtracting from the above gives the PDE system solution, that in this case can also be obtained passing the whole system directly to pdsolve.

See Also