Demonstration of the REDUCE Package CRACK
for Investigating Partial Differential Equations

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 T_EX format (primarily for use with the "http://www.software.ibm.com/network/techexplorer/">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:

• output using subscripts to indicate derivatives (on dfprint) – the CRACK default;
• output using the operator "df" to indicate derivatives (off dfprint).

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>>;
liepde({{df(y,x,2)*x**4-df(y,x)*(2*x*y+x**3)+4*y**2},{y},{x}},"point"},{});

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,

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

  {c_5,c_6},

  {}}}

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)