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

Online Help

All Products    Maple    MapleSim





computes polynomial solutions for (differential or not) system of equations.


Calling Sequence




Calling Sequence

PolynomialSolutions(PDESYS, DepVars)




an equation or a set or list of them; it can include PDEs, ODEs, non-differential equations and inequations



optional - may be required; a function, or a set or list of them, indicating the dependent variables of the problem

degree = ...


optional - to indicate the upper bound degree of the solution, could be a non-negative integer, or a set of equations where the lhs is one of unknowns (DepVars) and the rhs is the upper bound degree for its solution

dependency = ...


optional - to indicate the dependency of the solution, could be a non-negative integer, a range of them, a name, or a set of names, or a set or list containing any of the previous objects

HINT = ...


optional - a set of equations with unknowns in the lhs and related hints polynomial in the independent variables in the rhs

ivars = ...


optional, a name or set of them indicating additional independent variables, typically not present in the dependency of the unknowns DepVars

numberofsolutions = ...


optional - can be a nonnegative integer or the keyword all, to specify the number of polynomial solutions desired; default is all having degree as upper bound

simplifier = ...


optional - indicates the simplifier to be used instead of the default simplify/size



Given PDESYS, a system of equations for DepVars, possibly including inequations and non-differential equations, PolynomialSolutions computes solutions that are polynomial in the independent variables of the problem. The independent variables are typically the variables DepVars depend on, plus any others optionally specified with ivars = .... PolynomialSolutions also works with anticommutative variables set using the Physics package using the approach explained in PerformOnAnticommutativeSystem.


If DepVars is not given, PolynomialSolutions will consider all the differentiated unknown functions in PDESYS as unknown of the problems. Specifying DepVars however permits not only restricting the unknowns in different ways but also specifying unknowns of the problems which do not appear differentiated in PDESYS.


PolynomialSolutions uses a heuristic algorithm to compute upper bound degrees. The algorithm used extends, for non-autonomous systems of equations, the ideas used in TWSolutions (step 2. of The solving process) for computing solutions to autonomous systems. This extended algorithm is accessible at user level as PDEtools:-Library:-UpperBounds (see PDEtools,Library). To override these upper bounds see the degree option.


PolynomialSolutions is automatically invoked by Infinitesimals, InvariantSolutions and SimilaritySolutions when they receive the optional argument typeofsymmetry = polynomial in which case the dependency and degree can also be specified directly to those commands.


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.

Optional arguments

A number of optional arguments can change the default computational behavior of PolynomialSolutions in ways that, depending on the example or your needs, may be preferred.


degree = nonnegint | set(function = nonnegint)


By default, an upper bound for the degree of the polynomial dependency on the independent variables of the solution is determined by PDEtools:-Library:-UpperBounds. You can optionally specify the upper bounds for the degree(s) of the requested solutions by passing the argument degree = n where n is a nonnegative integer (could be zero) or degree = {F1 = n, F2 = m, ...} where F1, F2, ... are functions of DepVars and the rhs in each equation specifies the requested upper bound degree for the corresponding function in the solution. For the functions not specified in that set, PolynomialSolutions will apply its own heuristic algorithm to determine upper bounds for their degrees.


dependency = name | nonnegint | range(nonnegint) | set(name) | list(name), <or a set or list of any of the previous types>


This option is useful to restrict in different ways the dependency of the polynomial solutions computed. When dependency = n, a nonnegative integer, only polynomial solutions depending on different (permutations of) n independent variables will be computed. When dependency = n..m, that is a range from n to m, only solutions depending on permutations of k variables, where k is in the range n..m will be computed. Alternatively, you can also indicate which permutations of which variables are to be the dependency of the polynomial solutions by specifying the rhs as a set of lists, with each list containing the desired dependency, for example: say the independent variables are x, y, z, then you can specify dependency = {[x, y], [x, t], [y, t]}.


HINT = <polynomial form of the solution>


This option permits indicating a particular form of polynomial solution, so the rhs entering each equation in HINT = {F1 = ..., F2 = ...} is expected to be polynomial in the independent variables of the problem. All the names entering the coefficients of independent variables in the rhs of equations in thee HINT will be taken as solving variables at the time of computing the polynomial solution. This option is useful, for example, to specify a solution where some powers are missing, or where the coefficients of some powers are related to the coefficients of other powers.


ivars = name | set(name) | list(name)


This option permits specifying independent variables of the problem even when they are not present in the dependency of the functions that enter DepVars, the unknowns of the problem. Note that besides those variables specified using ivars = ..., all the variables found in the dependency of the unknowns of problem are also always considered independent variables.


numberofsolutions = nonnegint


The right-hand-side is a positive integer indicating how many solutions PolynomialSolutions will attempt to compute before interrupting the process and returning the solutions found. The default behavior is to compute as many polynomial solutions as can be computed with the upper bounds for degrees used or given by the user (option degree).


simplifier = ...


The right-hand-side indicates the simplifier to be used instead of the default which is simplify/size. This option is of use not just to simplify the solutions. You can specify any procedure to be used as simplifier; in this way you can have the solutions computed by FunctionFieldSolutions post-processed entirely in the way you need before being returned (e.g. discard some, do something else with other ones, etc.).



declare((xi, eta)(x, y));

ξx&comma;ywill now be displayed asξ

ηx&comma;ywill now be displayed asη


sys[1] := diff(xi(x,y),x)*diff(eta(x,y),x)+diff(xi(x,y),y)*diff(eta(x,y),y)+eta(x,y)*(diff(xi(x,y),x,x)+diff(xi(x,y),y,y)) = -1;



sol[1] := PolynomialSolutions(sys[1]);



Solutions can be tested as usual, with pdetest

map(pdetest, [sol[1]], sys[1]);



Compute polynomial solutions of degree = 1 depending on 1 variable

PolynomialSolutions(sys[1], degree = 1, dependency = 1);


Compute polynomial solutions depending on 0 (there are none) 1 and 2 variable

PolynomialSolutions(sys[1], dependency = 0..2);


PolynomialSolutions is invoked by InvariantSolutions and other commands when they receive the optional argument typeofsymmetry = polynomial. In this example, solutions are computed where the degree of the polynomial infinitesimals is requested to be zero

InvariantSolutions(sys[1], typeofsymmetry = polynomial, degree = 0);



An example involving mathematical functions (ln):

sys[2] := [-I*x^3*(diff(xi(x,y),y,y)*y+3*diff(xi(x,y),y))/y, -I*x^2*(-diff(eta(x,y),y,y)*x*y^2+2*diff(xi(x,y),x,y)*x*y^2-3*eta(x,y)*x+3*x*diff(eta(x,y),y)*y+2*diff(xi(x,y),y)*y^2)/y^2, x*(2*I*diff(eta(x,y),x,y)*x^2*y-I*diff(xi(x,y),x,x)*x^2*y-I*x*diff(xi(x,y),x)*y-6*I*x^2*diff(eta(x,y),x)+6*diff(xi(x,y),y)*y^4*ln(x)+3*diff(xi(x,y),y)*y^2+xi(x,y)*y*I)/y, -4*xi(x,y)*y^3*ln(x)-2*xi(x,y)*y+6*eta(x,y)*x*ln(x)*y^2-I*x^2*diff(eta(x,y),x)+4*x*diff(xi(x,y),x)*y^3*ln(x)+2*x*diff(xi(x,y),x)*y-2*x*diff(eta(x,y),y)*y^3*ln(x)-x*diff(eta(x,y),y)*y+2*xi(x,y)*y^3+diff(eta(x,y),x,x)*x^3*I+eta(x,y)*x];



The internal routine computes the following upper bound degrees

PDEtools:-Library:-UpperBounds(sys[2], [xi,eta](x,y));



When the degrees are not specified, PolynomialSolutions automatically calls that internal routine to decide about the degrees, resulting in the following solution

sol[2] := PolynomialSolutions(sys[2]);



pdetest(sol[2], sys[2]);



See Also