The Maple PDE solver, pdsolve, can now systematically tackle and in many cases successfully solve coupled systems of Partial Differential Equations.

- There are no restrictions (but for the computer resources) to the number of equations, unknown functions, or independent variables present in the system.

- The PDE system may also include inequations, additional Ordinary Differential Equations, and algebraic constraints involving the unknowns and the independent variables.

- The new routines are prepared to tackle PDE systems of type linear, and polynomially nonlinear including nonpolynomial coefficients. The latter are systematically uncoupled using techniques for polynomial systems, by means of a differential extension approach (see PDEtools[dpolyform]).

In previous releases, Maple became famous for its high performance in finding "Exact Solutions for Differential Equations". The new ability to find exact solutions to PDE systems as the ones described makes Maple 7 unique among all Computer Algebra Systems. For some examples of the type of problems which can now be tackled, see the Examples section of pdsolve,system.

Nonlinear ODEs

Summary: A new implementation of symmetry methods, for systematically determining, when they exist, point symmetries for Ordinary Differential Equations, was added to Maple's dsolve. For nonlinear problems, this turns the already sophisticated Maple's ODE solver into the most advanced one among those available in computer algebra systems.

A new full implementation of symmetry methods using a formal approach was prepared and incorporated into Maple's dsolve. The ODE point symmetries are computed by formally uncoupling and solving the underlying linear Partial Differential Equation system. These symmetries are then used to integrate the ODE using standard methods.

The Maple implementation of this systematic approach works with polynomially nonlinear as well as with nonpolynomial ODEs, and also in the presence of arbitrary parameters or functions. The new symmetry routines are in use by default in dsolve and can also be invoked directly by using the appropriate optional arguments (see dsolve,Lie and DEtools[symgen]). Examples:

infolevel[symgen] := 2:      # turn ON userinfo for symmetries

PDEtools[declare]( y(x), prime=x );

diff(y(x),x,x) = -3*diff(y(x),x)^2/y(x)-2*diff(y(x),x)/x+1/(x^6*diff(y(x),x)*y(x)^6);

A 3-dimensional symmetry group is found and used to build an implicit solution as follows:

dsolve((2), Lie, way=formal, implicit);

   -> Computing symmetries using: way = formal

   <- successful computation of symmetries.

An example from Kamke's book, parametrized by an arbitrary function , where only the new symmetry routines succeed in solving the problem:

diff(y(x),x,x) = (3*diff(y(x),x)^2*f(x) - 3*y(x)*diff(y(x),x)*diff(f(x),x)
+ y(x)^2*diff(f(x),x,x) - 6*y(x)^5)/(f(x)*y(x));

dsolve((4), y(x), implicit);

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 5
   -> Computing symmetries using: way = formal

   <- successful computation of symmetries.

For second order nonlinear ODEs, a new algorithm was developed, to compute symmetries, and from there the ODE solution, when symmetries of the form , exist. In these lists,  represent the infinitesimals of the symmetry generator . Instead of solving a PDE system, as for instance done in the formal approach, for symmetries of these forms, their computation can be performed without solving any auxiliary differential equations. Example ( is an arbitrary function of its argument):

diff(y(x),x,x) = (x^2*diff(y(x),x)^2 + exp((y(x)*x-2)/x)*G(diff(y(x),x)*exp(-(y(x)*x-1)/x))*x^2 + diff(y(x),x))/x^2;

dsolve((6));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

   <- successful computation of symmetries.

For first order nonlinear ODEs, a new algorithm was developed, to compute symmetries, and from there the ODE solution, when symmetries of the form  exist. The algorithm follows the presentation in "First order ODEs, Symmetries and Linear Transformations", {Seventh Rhine Workshop on Computer Algebra, Austria, 2000} (see dsolve, references). This algorithm is of remarkable generality and enables dsolve in Maple 7 to solve a variety of new ODE families. Examples, one from Kamke's book:

x*diff(y(x),x)+a*y(x)-f(x)*g(x^a*y(x)) = 0;

dsolve((8));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 4
   -> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

   <- successful computation of symmetries.

diff(y(x),x) = LambertW(x)*exp(exp(x)*y(x))/((1+LambertW(x))*exp(x))-1/(x*exp(x))-y(x);

dsolve((10));

   -> Computing symmetries using: way = 3-> Computing symmetries using: way = 4
   -> Computing symmetries using: way = 5
   -> Computing symmetries using: way = patterns

   <- successful computation of symmetries.

infolevel[symgen] := 0:      # turn OFF userinfo on symmetries

Linear ODEs

Summary: All the linear ODE routines were revised and various new solving approaches were added, leading to solutions to ODE families not solvable in previous Maple releases. The impact of these changes is quite significant -- the changes affect linear ODEs both with rational and nonrational coefficients.

A complete re-organization of the userinfo solving information was performed, so that it is now possible to accurately follow the solving path by issuing

infolevel[dsolve] := 3:

There have been radical improvements in the determination of solutions, for second and higher order linear ODEs, in terms of special functions, when they could be obtained as particular cases of the generalized hypergeometric MeijerG function. Consider the following second and fifth order linear ODEs from Kamke's book:

diff(y(x),x,x) = -2*x*diff(y(x),x)/(x^2-1)+v*(v+1)*y(x)/(x^2);

dsolve((12));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
<- No Liouvillian solutions exists
-> Trying a solution in terms of special functions:
   -> Bessel
   -> elliptic
   -> Legendre
   -> Kummer
      -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
   -> hypergeometric
      -> heuristic approach
      -> hyper3: Equivalence to 2F1, 1F1 or 0F1 under 'a power @ Moebius'
      <- hyper3 successful: received ODE is equivalent to the 2F1 ODE
   <- hypergeometric successful
<- special function solution successful

x^10*diff(y(x),x$5)-a*y(x) = 0;

dsolve((14));

Methods for high order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 5; missing the dependent variable
trying a solution in terms of MeijerG functions
<- MeijerG function solution successful

The Maple implementation of Kovacic's algorithm was entirely rewritten. The new implementation is much faster and can reliably tell whether a given second order linear ODE, with rational coefficients, admits Liouvillian solutions. The algorithm also works in the presence of symbolic parameters in the coefficient field. Also new, dsolve will now attempt to return a Liouvillian solution first. Example:

x^2*diff(y(x),x,x)+a*diff(y(x),x)-(b^2*x^2+a*b)*y(x) = 0;

dsolve((16));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
   A Liouvillian solution exists
   Reducible group (found an exponential solution)
   Group is reducible, not completely reducible
   Solution has integrals. Trying a special function solution free of integrals...
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Kummer
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
      -> hypergeometric
         -> heuristic approach
         -> hyper3: Equivalence to 2F1, 1F1 or 0F1 under 'a power @ Moebius'
            -> trying extended approach, based on solving the ODE satisfied by the "derivative" of y(x)
               -> ODE succesfully computed; trying to solve: diff(diff(y(x),x),x) = -a*(2*x+b*x^2+a)/(b*x^2+a)/x^2*diff(y(x),x)+y(x)*b/x^2*(2*x*a+b^2*x^4+2*b*x^2*a+a^2)/(b*x^2+a)
            <- extended approach, failed in solving the ODE for the "derivative" of y(x)
      -> Mathieu
         -> Equivalence to the rational form of Mathieu ODE under 'a power @ Moebius'
            -> trying extended approach, based on solving the ODE satisfied by the "derivative" of y(x)
               -> ODE succesfully computed; trying to solve: diff(diff(y(x),x),x) = -a*(2*x+b*x^2+a)/(b*x^2+a)/x^2*diff(y(x),x)+y(x)*b/x^2*(2*x*a+b^2*x^4+2*b*x^2*a+a^2)/(b*x^2+a)
            <- extended approach, failed in solving the ODE for the "derivative" of y(x)
      -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
      <- Heun successful: received ODE is equivalent to the "HeunD" ODE, case "c = 0"
   <- Kovacic's algorithm successful

In connection, a new mechanism was added to dsolve so that when a Liouvillian solution is too complicated, using the information on the underlying Galois group, dsolve reformulates the problem attempting a simpler form using special functions. Example:

1/576*(128*x^2-101*x+108)*y(x)/(x^2*(x-1)^2)+diff(y(x),x,x)=0;

dsolve((18));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Trying a Liouvillian solution using Kovacic's algorithm
   A Liouvillian solution exists
   Octahedral Galois group S4_SL2
   Basis solution with radicals (size = 108):
[x^(1/4)*(-1+x)^(5/12)*hypergeom([-1/24, 5/24],[2/3],-1/(-1+x)), x^(1/...
   -> attempting a simpler form using special functions
      (the Liouvillian form can be obtained using DEtools[kovacicsols])
   <- returning simpler solution using special functions (size = 47)
<- Kovacic's algorithm successful

From the information displayed, in this example, the simplification obtained by means of this mechanism resulted in a solution forty times more compact.

New methods have been added for higher order ODEs based on factoring Linear Differential Operators in various ways (see DEtools[DFactor] and DEtools[DFactorLCLM]). Example:

x^2*diff(y(x),x,x,x)-2*(n+1)*x*diff(y(x),x,x)+(a*x^2+6*n)*diff(y(x),x)-2*a*x*y(x)=0;

dsolve((20));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 3; missing the dependent variable
Equation is the LCLM of -2*x/(2*(2*n-1)/a+x^2)*y(x)+diff(y(x),x), a*y(x)-2*n/x*diff(y(x),x)+diff(diff(y(x),x),x)
trying differential order: 1; missing the dependent variable
checking if the LODE is of Euler type
-> Attemtping a differential factorization
   trying exponential solutions
   checking if the LODE is of Euler type
   1, exponential solutions found
   exponential solutions successful
<- differential factorization successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
<- solving the LCLM ode successful

The following is an example where this new differential factorization combines with the new methods for finding hypergeometric solutions.

diff(y(x),x,x,x) = (-8784+26985*x-17850*x^3-21235*x^2)*diff(y(x),x)/(-5565*x-11025*x^4+12390*x^2+4200*x^3)+(-11025*x^4-29800*x+34675*x^2+22050*x^3+8904)*diff(y(x),x,x)/(-5565*x-11025*x^4+12390*x^2+4200*x^3)+(-2750*x*y(x)-120*y(x)-1050*x^2*y(x))/(-5565*x-11025*x^4+12390*x^2+4200*x^3);

dsolve((22));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 3; missing the dependent variable
Equation is the LCLM of -y(x)+diff(y(x),x), 2/21/(-1+x)/x*y(x)+1/105*(170*x-63)/(-1+x)/x*diff(y(x),x)+diff(diff(y(x),x),x)
trying differential order: 1; missing the dependent variable
trying linear constant coefficient
checking if the LODE has constant coefficients
<- constant coefficients successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Kummer
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
      -> hypergeometric
         -> heuristic approach
         <- heuristic approach successful
      <- hypergeometric successful
   <- special function solution successful
<- solving the LCLM ode successful

Maple can now detect rational fourth order linear ODEs whose solutions are obtained by multiplying solutions of two second order equations (see DEtools[symmetric_product]). Example:

4*y(x)*x^2 + 1/x*diff(y(x),x) - diff(y(x),x,x) - 1/x*diff(y(x),x,x,x) + diff(y(x),x,x,x,x) = 0;

dsolve((24));

Methods for high order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
trying differential order: 4; missing the dependent variable
Equation is the symmetric product of diff(diff(y(x),x),x)+(-1/4-x)*y(x) and diff(diff(y(x),x),x)+(x-1/4)*y(x)
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful

Various alternative approaches have been added for second order nonrational linear ODEs containing arbitrary parameters or functions, leading to solutions not achieved in previous Maple releases. Example:

diff(y(x),x,x)-x^(-n)*diff(y(x),x)+(-x^(-1-n)*n-2*x^(-2*n))*y(x) = 0;

dsolve((26));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
   <- BRANCH 6 successful. Symmetry is:, [0, exp(-Int(1/(x^n),x))]
<- linear_1 successful

A new method for determining transformations mapping a nonrational linear ODE into a rational one was incorporated in Maple's dsolve. This method has noticeable impact in the ability for dsolve to tackle nonrational linear ODEs. Example:

x^2*diff(y(x),x,x)+y(x)/ln(x) = 0;

dsolve((28));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a quadrature
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
      <- BRANCH 1 successful. Symmetry is:, [0, z]
   <- linear_1 successful
   Change of variables used:
      [x = exp(t)]
   Linear ODE actually solved:
      u(t)-t*diff(u(t),t)+t*diff(diff(u(t),t),t) = 0
<- change of variables successful

A more difficult example (number 32 from Kamke's book) where this technique is combined with methods for finding special function solutions new in Maple 7 is the following:

diff(y(x),x,x) + (1/2*diff(g(x),x,x,x)/diff(g(x),x) -
3/4*diff(g(x),x,x)^2/(diff(g(x),x)^2) + (1/4-v^2)*diff(g(x),x)^2/g(x)+diff(g(x),x)^2)*y(x) = 0;

dsolve((30), y(x));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      -> elliptic
      -> Legendre
      -> Whittaker
         -> hyper3: Equivalence to 1F1 under 'a power @ Moebius'
         <- hyper3 successful: received ODE is equivalent to the 1F1 ODE
      <- Whittaker successful
   <- special function solution successful
<- change of variables successful

In Maple 7, dsolve explores the possibility of mapping the solving of one ODE type into the solving of another ODE type, and takes advantage of this when possible. For example, the following linear ODE, depending on an arbitrary function parameter , is now solved by using routines for Riccati type ODEs:

diff(y(x),x,x)-(f(x)^2+diff(f(x),x))*y(x) = 0;

dsolve((32), y(x));

Methods for second order ODEs:
--- Trying classification methods ---
trying a symmetry of the form [xi=0, eta=F(x)]
checking if the LODE is missing 'y'
-> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
-> Trying changes of variables to rationalize or make the ODE simpler
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Heun: Equivalence to the GHE or one of its 4 confluent cases under 'a power @ Moebius'
   -> Tackling the "Normal Form" of the given linear ODE:
      trying a symmetry of the form [xi=0, eta=F(x)]
   -> Tackling the linear ODE using alternative approaches:
      trying 2nd order exact linear
      trying symmetries linear in x and y(x)
      trying to convert to a linear ODE with constant coefficients
         testing BRANCH 1 ->
<- unable to find a useful change of variables
-> Tackling the linear ODE using alternative approaches:
   trying 2nd order exact linear
   trying symmetries linear in x and y(x)
   trying to convert to a linear ODE with constant coefficients
      testing BRANCH 1 ->
   trying to convert to an ODE of Bessel type
   -> trying reduction of order to Riccati
      trying Riccati sub-methods:
         trying Riccati_symmetries
         <- Riccati particular solution successful
      <- reduction of order to Riccati successful
   <- reduction of order to Riccati successful

The algorithms for computing particular solutions to nonhomogeneous linear ODEs were rewritten and new algorithms added. Among the new features, Maple's dsolve can now compute d'Alembertian particular solutions free of integrals with which much simpler general solutions to nonhomogeneous ODEs are returned.  Example:

diff(y(x),x,x) - y(x)*x = (4*x^3+1)*ln(x)/(x*sqrt(x));

dsolve((34));

Methods for second order ODEs:
--- Trying classification methods ---
trying a quadrature
trying high order exact linear fully integrable
trying differential order: 2; linear nonhomogeneous with symmetry [0,1]
trying a double symmetry of the form [xi=0, eta=F(x)]
-> Try solving first the homogeneous part of the ODE
   checking if the LODE has constant coefficients
   checking if the LODE is of Euler type
   trying a symmetry of the form [xi=0, eta=F(x)]
   checking if the LODE is missing 'y'
   -> Trying a Liouvillian solution using Kovacic's algorithm
   <- No Liouvillian solutions exists
   -> Trying a solution in terms of special functions:
      -> Bessel
      <- Bessel successful
   <- special function solution successful
   -> Determining now a particular solution to the non-homogeneous ODE
      building a particular solution using variation of parameters
      particular solution has integrals (!)
      -> trying a d'Alembertian particular solution free of integrals
      <- d'Alembertian particular solution free of integrals successful
<- solving first the homogeneous part of the ODE successful

Much simpler algorithms for mapping linear ODEs into ones having constant coefficients were incorporated in dsolve in Maple 7. For instance, for this third order ODE, example number 21 of Kamke's book, the solution is now the following:

diff(y(x),x,x,x)+3*a*x*diff(y(x),x,x)+3*a^2*x^2*diff(y(x),x)+a^3*x^3*y(x);

dsolve((36));

Methods for third order ODEs:
--- Trying classification methods ---
trying a quadrature
checking if the LODE has constant coefficients
checking if the LODE is of Euler type
trying high order exact linear fully integrable
trying to convert to a linear ODE with constant coefficients
<- successful conversion to a linear ODE with constant coefficients

All the methods used for tackling second order linear ODEs are now available directly at user level by giving optional extra arguments to Maple's dsolve. These methods can be tried separately, in sequence, or in any desired order. A list of the methods available can be seen via:

`dsolve/methods`[2, "linear_homogeneous all methods"];

One can now tackle a linear ODE using different choices of methods and then choose, among the different solutions returned, the one most convenient for the problem under consideration.

The ability to solve linear ODEs using different solving methods also represents a new and powerful tool for studying Liouvillian, special functions, and the relations between them. For example

ode := diff(y(x),`$`(x,2)) = -y(x)-2*x*diff(y(x),x);

sol_h := dsolve(ode,[hypergeometric]);

Classification methods on request
Methods to be used are: [hypergeometric]
----------------------------
* Tackling ODE using method: hypergeometric
--- Trying classification methods ---
trying a solution in terms of hypergeometric functions
   -> heuristic approach
   <- heuristic approach successful
<- hypergeometric solution successful

sol_B := dsolve(ode,[Bessel]);

Classification methods on request
Methods to be used are: [Bessel]
----------------------------
* Tackling ODE using method: Bessel
--- Trying classification methods ---
  -> searching for a solution in terms of Bessel functions
  <- solution in terms of Bessel functions successful

From the output above, any of the two hypergeometric functions entering  is equal to the linear combination of the Bessel functions entering , for some particular values of , . To determine the exact relation, one could equate the expressions, expand in series, and solve for the coefficients . For example, the following hypergeometric function

h1 := eval( rhs(sol_h), {_C1=1,_C2=0} );

can be expressed in terms of Bessel functions as follows:

e1 := h1-rhs(sol_B)=0;

series(lhs(e1),x,2);          # expand in series

coeffs(convert((44),polynom),x);  # coefficients of x

_C_values := solve({(45)},{_C1,_C2});  # compute _C

eval(e1,_C_values);

Now, the hypergeometric function can be isolated, resulting in the desired identity:

isolate((47),h1);

In the same way, it is now possible to use dsolve to investigate the relationship between hypergeometric and Liouvillian functions, whenever that relationship exists. For an example, see dpolyform.

convert/StandardFunctions knows more about the MeijerG, ModifiedMeijerG and the 2F1 form of hypergeometric functions.

assume(n,nonnegint);

convert(hypergeom([-n,-n],[1/2-2*n],z),StandardFunctions);

n := 'n':

convert/MeijerG (or convert/ModifiedMeijerG) now converts most mathematical expressions in terms of elementary and special functions to their equivalent MeijerG (or ModifiedMeijerG) representation via  where  is to be viewed as a function of  (or equivalently, to ModifiedMeijerG form via ).

Often, one seeks to transform all subexpressions of a given expression that are of a given type by some well defined transformation. A new command subsindets has been introduced to promote the efficient implementation of this common pattern of expression manipulation.

expr := sin( x * ( x + 1 ) + ( x + 1 ) * ( x + 2 ) );

subsindets( expr, '`*`', expand );

expand( expr );

There is now an implementation of Primfield (computation of a primitive description of an algebraic extension) for finite fields Fp. See Primfield for details.

Compute the subfields of an algebraic field extension that is given by one root of an irreducible polynomial. See Subfields for details.

Logical assertions involving the universal and existential quantifiers of predicate calculus may be represented by the new top-level functions forall and exists.

forall( x, x > 0 );

These functions do not attempt to evaluate truth values of given assertions, rather, they act as placeholders to represent assertions for interpretation by other applications.  Except for some basic canonicalization and error-checking, they are inert.

The functionality of convert/decimal has been expanded to be able to convert any base from  to  to decimal. The first argument may be either any integer or floating-point number, or a string representing one of these two.

convert("10001101", decimal, binary);

convert("1A.C", decimal, hex);

convert("Maple.7", decimal, 36);