Demonstration of the REDUCE Package CRACK
for Investigating Partial Differential Equations



  1. Introduction
  2. Input to CRACK
  3. Control and Run CRACK
  4. Output from CRACK
  5. Canned Examples


Thomas Wolf Thomas Wolf [twolf(at)] and Andreas Brand (Jena)


The CRACK package attempts to solve an overdetermined system of ordinary or partial differential equations (ODEs/PDEs) with at most polynomial nonlinearities.


The latest version is available from


A manual for CRACK is available in tex, dvi, ps, pdf format as well as a more detailed description with emphasis on some of the computer algebra algorithms [dvi, ps, pdf] . (LATEX documents will be properly formatted by your web browser only if you have installed the IBM techexplorer or equivalent plug-in). This demonstration is based on the CRACK manual.

Applications of CRACK

Overdetermined systems of DEs most frequently occur when other "differentiable objects", for example, other DEs or a metric of some Riemannian space, are investigated concerning their properties in some open neighbourhood (not discrete properties or properties at a single point).   Examples are the investigation of DEs concerning:

  • Lie symmetries (point, contact or generalized symmetries);
  • conservation laws;
  • the use of ansδtze for finding
    • an integrating factor for a DE,
    • a Lagrangian equivalent to an ODE,
    • a factorization of an ODE into a first order ODE plus lower order PDEs.

In these cases, typically another program is used to cast the mathematical problem into an overdetermined system of PDEs and then call CRACK.     Examples are the programs LIEPDE, CONLAW, LAGRAN, DECOMP to investigate DEs and the program CLASSYM to find Killing-vectors and -tensors for a given space-time metric.

As CRACK has a number of integration facilities built in, it can also be used to solve non-overdetermined DE-systems directly if they are not too difficult.   An example is the program APPLYSYM, which takes as input Lie symmetries (computed, for example using LIEPDE beforehand) and uses QUASILINPDE to solve a linear first-order PDE to find the symmetry and similarity variables.   To solve this PDE, CRACK is called with the corresponding (non-linear, non-overdetermined, autonomous) characteristic ODE system.

Running CRACK

A feature of CRACK that is not supported by this web-based demonstration (mainly for reasons of security) is its ability to be used interactively.

Variable dependences

CRACK does not use explicit functional notation but rather works with dependent variables that have been declared to depend implicitly on other independent variables using REDUCE depend statements.   Hence, the terms function and dependent variable are used synonymously.

However, this web interface uses functional notation to specify such dependences, from which it generates the appropriate depend statement.   Specify here all variable dependences as a comma-separated list of functional forms, e.g. to declare f to depend on x and y, and g to depend on x, use f(x,y), g(x)

[As a convenience, the syntax "f, g(x,y)" is interpreted here (only) as "f(x,y), g(x,y)".   Alternatively, dependence information can be included in the CRACK input fields below.]  

Input to CRACK

The following four input fields correspond to the four arguments to the CRACK operator.   Each should be a (comma-separated) sequence of one or more elements and the second and last may be empty.   (The example input relates to the CRACK user guide, §3.2: Integrating exact PDEs, also available below as a "canned" example.)

  1. required – PDEs: partial differential equation(s) or expression(s) that must vanish identically, e.g.
    2*df(f,y)*df(g,x) + 2*df(f,x,y)*g + g*df(g,x)^3 + x*df(g,x)^4 + 3*x*g*df(g,x)^2*df(g,x,2) + g^2*(y^2 + x*sin y + x^2*exp y)

  2. optional – NVEs: algebraic or differential expressions that must not vanish identically

  3. required – DepVars: dependent variables (representing functions or constants) to solve for, e.g. f, g
    You may optionally include the independent variables on which they depend, by using functional notation here instead of in the dependence field above, e.g. f(x,y), g(x)

  4. optional – OtherVars: additional independent variables in which the PDEs have to be satisfied identically
    You may optionally include dependent variables that depend on them, by using functional notation here instead of in the dependence field above.

Control and run CRACK

CRACK provides a number of control variables (flags), of which only the following can be changed in this web interface:

  • print_ = The maximum number of terms of equations that are output. The value nil suppresses all intermediate output.   (The CRACK default is 8.)
  • print_more = Print more information about the PDEs if this value is t.
  • proc_list_ =
    A quoted Lisp list of names of CRACK procedures. Click here for details; see below for examples.

Use subscripts to indicate derivatives (on dfprint) – the CRACK default.

Return a transcript of the REDUCE session showing input as well as output.

Output TEX format (primarily for use with the "">IBM techexplorer or equivalent plug-in).

Please email any comments or problems to the maintainer of this demonstration.

Output from CRACK

The output is a list of solutions, which is the empty list { } if CRACK finds a contradiction, i.e. there is no solution. Each solution consists of a list with the following four elements:

  1. A list of any remaining unsolved conditions on the functions and constants in list 3 below in the form of partial differential expressions that must vanish identically.
  2. A list of solutions in the form "function = expression".
  3. A list of functions and constants that either appeared in input field 3 or are constants/functions of integration. They are either completely arbitrary, or if unsolved conditions remain in list 1 above then they have to satisfy these.
  4. A list of algebraic or differential expressions that must not vanish identically for this solution to be valid. For example, non-linear problems can have different solutions valid for different cases and it could be that one solution is valid for f = 0 and the other for f >> 0.

For example, the earlier input example corresponds to the example on integrating exact PDEs in section 3.2 of the CRACK user guide and gives essentially the following output, where variables of the form c_i represent new constants and functions that result from integrations:

Canned Examples

The input fields below can be copied into the fields of the input form above and the form submitted for execution by CRACK, or the examples can be run directly by simply clicking the appropriate "Run" button.   (Either way, the above control fields apply.)

Investigating the point symmetries of an ODE

The following "real life" example demonstrates the role of the OtherVars field.   This overdetermined system is generated when investigating the point symmetries of ODE 6.97 in Kamke's book using the following CRACK input:

depend y,x;
load_package crack,liepde;   off nat;
symbolic <<;print_:=1000; print_all:=t>>;
and then renaming xi_x --> xi, eta_y --> eta, y!`1 --> y1 .
  1. PDEs: 2*df(eta,x,y)*x^5*y1 + df(eta,x,2)*x^5 - df(eta,x)*x^4
    - 2*df(eta,x)*x^2*y + df(eta,y,2)*x^5*y1^2
    - 4*df(eta,y)*x*y^2 - 2*df(xi,x,y)*x^5*y1^2
    - df(xi,x,2)*x^5*y1 - df(xi,x)*x^4*y1 - 2*df(xi,x)*x^2*y*y1
    + 8*df(xi,x)*x*y^2 - df(xi,y,2)*x^5*y1^3
    - 2*df(xi,y)*x^4*y1^2 - 4*df(xi,y)*x^2*y*y1^2
    + 12*df(xi,y)*x*y^2*y1 - 2*eta*x^2*y1 + 8*eta*x*y
    + x^3*xi*y1 + 6*x*xi*y*y1 - 16*xi*y^2
  2. NVEs: omit
  3. DepVars: xi(x, y), eta(x, y)
  4. OtherVars: y1

The output should be essentially as follows


  {xi= - log(x)*c_6*x - c_5*x,

   eta= - 2*log(x)*c_6*y - 2*c_5*y - c_6*x  + c_6*y},



The following examples relate to sections of the CRACK user guide and illustrate the operation of various components of CRACK. These examples are not typical applications but are intended to demonstrate individual CRACK modules, hence the value of print_ – the maximum number of terms of equations that are output – is automatically set to 50 (the normal CRACK default is 8). The extra assignment involving proc_list_ (click here for details) is to disable all other modules.

All the following examples have the following common settings:

print_ := 50; print_more := nil

§3.2: Integrating exact PDEs

  1. PDEs: 2*df(f,y)*df(g,x) + 2*df(f,x,y)*g + g*df(g,x)^3 + x*df(g,x)^4 + 3*x*g*df(g,x)^2*df(g,x,2) + g^2*(y^2 + x*sin y + x^2*exp y)
  2. NVEs: omit
  3. DepVars: f(x,y), g(x)
  4. OtherVars: omit
  5. proc_list_ := '(integration)

§3.3: Direct separation of PDEs

  1. PDEs: df(f,y) + z*f^2 + (z+h)*df(g,x) + h*y*g^2
  2. NVEs: omit
  3. DepVars: f(x,y), g(x)
  4. OtherVars: h(z)
  5. proc_list_ := '(separation)

§3.4: Indirect separation of PDEs

  1. PDEs: f*g - x*df(f,x)/2 - df(g,y) - (1+x^2)*y
  2. NVEs: omit
  3. DepVars: f(x), g(y)
  4. OtherVars: omit
  5. proc_list_ := '(factorize_to_separation subst_level_3 separation gen_separation2)

Original design by Francis Wright and Thomas Wolf
Maintained by Thomas Wolf [twolf(at)]
Last updated 10 January 2006