
                   Help file for CONLAW versions 1,2,3
                   ___________________________________


                          Thomas Wolf, Oct. 1997


 Purpose:
 --------

 The procedures CONLAW1, CONLAW2, CONLAW3 try to find conservation laws
 for a given single/system of differential equation(s) (ODEs or PDEs)

     df(ui,...) = wi(x,uj,...,df(uj,...),...)                            (1)

 CONLAW1 tries to find the conserved current p_i by solving

     df(p_t,t) + df(p_x,x) [+ ...] = 0    modulo (1)                     (2)

 directly. CONLAW2 tries to solve determining equations for characteristic
 functions q_i such that

     df(p_t,t) + df(p_x,x) [+ ...] = sum_i q_i*( df(ui,...) - wi )       (3)

 holds. CONLAW3 tries to find p_i and q_j by solving (3) directly.
 All three procedures have the same syntax. They have two parameters,
 both are lists. The first parameter specifies the equations (1), the second
 specifies the computation to be done. One can either specify an ansatz for
 p_i, q_j or investigate a general situation, only specifying the order of the
 characteristic functions or the conserved current. For a more detailed
 description see the file conlaw.tex.


 Syntax:
 -------

 CONLAWi(problem,runmode);             where i=1,2,3

 problem ~ {equations, ulist, txlist}

           equations ... list of equations,
                         each has the form df(ui,..) = ...
                         where the LHS (left hand side) df(ui,..)
                         is selected such that 
                         - The RHS (right h.s.) of an equations must
                           not include the derivative on the LHS
                           nor a derivative of it.
                         - The LHS of any equation must not occur in any
                           other equation nor any derivative of the
                           LHS.
                         - Each of the unknown functions occurs on the
                           LHS of exactly one equation

           ulist     ... list of function names, which can be chosen freely
	   txlist    ... list of variable names, which can be chosen freely

 runmode ~ {mindensord, maxdensord, expl, flist, inequ}

           mindensord ... the minimum of the highest order of derivatives in u
                          in p_x1 for CONLAW1
                          in q_j for CONLAW2,CONLAW3
           maxdensord ... the maximum of the highest order of derivatives in u
                          in p_x1 for CONLAW1
                          in q_j for CONLAW2,CONLAW3
           expl       ... (t/nil) whether or not the charac. functions q_i
                          or conserved current may depend explicitly on
                          the variables of txlist
	   flist      ... unknown functions in any expressions p_i, q_j
                          which have been assigned before calling CONLAW
                          in order to investigate a special ansatz for
                          the p_i or q_j, 
                          also all parameters and parametric functions in 
                          the equation that are to be calculated such that 
                          conservation laws exist,
                          if there are no such unknown functions then
                          input the empty list: {}
           inequ      ... inequ is a list of expressions non of which
                          may be identically zero for the conservation
                          law to be found, if there is no such expression
                          then input an empty list: {}


 How to formulate an ansatz:
 ---------------------------

 An ansatz for a conservation law can be formulated by specifying one
 or more of the functions p_i for CONLAW1, one or more of the functions
 q_i for CONLAW2, one or more of p_i,q_i for CONLAW3.

 The `i' in p_i stands for a variable name, the `i' in q_i stands for
 an index - the number of the equation in the input system of equations
 with which q_i is multiplied to give the RHS of (1).

 There is a restriction in the structure of all the expressions for
 p_i, q_j that are specified: they must be homogeneous linear in some
 unknown function or constant. (This is necessary because the
 different conservation laws are identified on the basis of free
 constants or functions and if there are terms without a free
 constant/function as multiplier then the program will not take these
 terms into consideration when deciding whether the conservation law
 is of high enough differential order and thus possibly drop this
 conservation law when listing all relevant conservation laws.)

 All such functions and constants must be
 listed in flist (see above). The dependencies of such functions
 must be defined before calling CONLAWi. This is done with the
 command DEPEND, e.g.

 DEPEND f,t,x,u$

 to specify f=f(t,x,u).
 If one wants to have f as a function of derivatives of u(t,x), say
 f depending on df(u,t,x,2), then one can  *not* write 

 DEPEND f,df(u,t,x,2)$  % wrong

 but instead

 DEPEND f,u!`1!`2!`2$   % correct

 if txlist has been specified as {t,x}. As t is the first variable and
 x is the second variable in txlist and u is differentiated ones wrt. t 
 and two times wrt. x we therefore get u!`1!`2!`2. The character ! is the
 exempt character to allow special characters like ` to occur in an
 identifier name.

 Comments:
 ---------

 1. The input to CONLAW1, CONLAW2, CONLAW3 is the same apart from:
 - an ansatz for q_i is ignored in CONLAW1
 - an ansatz for p_i is ignored in CONLAW2
 - the meaning of mindensord, maxdensord is different in CONLAW1 on
   one hand and CONLAW2,CONLAW3 on the other (see above).

 2. It matters how the differential equations are input, i.e. which
 derivatives are eliminated. For example, the Korteweg - de Vries
 equation if input in the form df(u,x,3)=-u*df(u,x)-df(u,t) instead of
 df(u,t)=-u*df(u,x)-df(u,x,3) in CONLAW1 and choosing maxdensord=1 then
 P_i will be of at most first order, Div P of second order and df(u,x,3)
 will not be substituted and no non-trival conservation laws can be found.
 This does not mean that one will not find low order conservation laws at
 all with the substitution df(u,x,3)=..., one only has to go to 
 maxdensord=2 with longer computations as a consequence compared to the 
 input df(u,t)=-u*df(u,x)-df(u,x,3) where maxdensord=0 is enough to find 
 non-trivial conservation laws.

 3. It is not the case, that for any conserved current p_i, satisfying (2),
 there must exist characteristic function(s) q_i such that they satisfy (3).
 One can therefore not specify a known density p_t for CONLAW3 and hope to
 calculate the remaining p_i and the corresponding q_i with CONLAW3. What one
 can do is to use CONLAW1 to calculate the other components of p_i. But this
 restriction for CONLAW3 does not imply that it misses conservation laws.
 If (1) is a totally non-degenerate system then for each current p_i
 satisfying (2) there exists a current P_i differing from p_i only by a curl
 (-> trivial conservation law) such that P_i satisfies (3) for some suitable
 q_i.

 4. The q_i are uniquely determined only modulo the original equations (1).
 If one makes an ansatz for q_i then this freedom should be removed by having
 the q_i independent of the LHS's of the equations (1) and independent of
 derivatives of the LHS's of (1). If the q_i were allowed to depend on
 anything, (3) could be solved for one q_i in terms of arbitrary p_j and other
 q_j, giving a triviality and not a conservation law. Also, these q_i would
 be singular for solutions of the differential equations as the expression
 of the differential equation would appear in the denominator.

 5. Any ansatz for p_i made for CONLAW1 or p_i,q_j made for CONLAW2 should
 as well be independent of the LHS's of the equations (1) and independent of
 derivatives of the LHS's of (1).

 Flags:
 ------

 LISP (PRINT_:= NIL/0/1/ ...)$
 print_=nil suppresses all CRACK output, if print_=n (an integer) then
 CRACK prints only equations with at most n terms

 LISP (LOGOPRINT_:=t/nil)$
 print of a logo at the start of CONLAWi or not

 CRACKHELP()$
 for other flags regarding the solution of the overdetermined PDE-system 

 OFF BATCH_MODE$
 to solve the system of conditions with CRACK interactively


 Requirements:
 -------------

 REDUCE 3.5 or higher and 
 the files crack.red, conlaw0.red and one of the files
 conlaw1.red, conlaw2.red, conlaw3.red depending which
 program should be used

 Either read in files with

 IN "crack.red","conlaw0.red","conlaw1.red"$

 (and appropriate paths) or compile them before with

 FASLOUT "crack"$
 IN "crack"$
 FASLEND$
 FASLOUT "conlaw0"$
 IN "conlaw0.red"$
 FASLEND$
 FASLOUT "conlaw1"$
 IN "conlaw1.red"$
 FASLEND$
 BYE$

 and load them later with

 LOAD crack,conlaw0,conlaw1$

 conlaw2, conlaw3 are treated like conlaw1.


 Examples:   (see also conlaw.tst)
 ---------

 (A CRACK-procedure nodepnd is used to clean up after each run and
  delete all dependencies of each function in the list of functions 
  in the argument of nodepnd.)

   lisp(print_:=nil);  % to suppress output from CRACK

 - a single PDE:

   depend u,x,t$
   conlaw1({{df(u,t)=-u*df(u,x)-df(u,x,3)}, {u}, {t,x}},
           {0, 1, t, {}, {}})$
   nodepnd {u}$

 - a system of equations:

   depend u,x,t$
   depend v,x,t$
   conlaw1({{df(u,t)=df(u,x,3)+6*u*df(u,x)+2*v*df(v,x),
             df(v,t)=2*df(u,x)*v+2*u*df(v,x)           }, {u,v}, {t,x}},
           {0, 1, t, {}, {}})$
   nodepnd {u,v}$

 - a system of equations with ansatz:

   depend u,x,t$
   depend v,x,t$
   depend r,t,x,u,v,u!`2,v!`2$
   q_1:=r*df(u,x,2)$
   conlaw2({{df(u,t)=df(v,x),
             df(v,t)=df(u,x) }, {u,v}, {t,x}},
           {2, 2, t, {r}, {r}})$
   nodepnd {u,v,r}$

 - for the determination of parameters, such that conservation laws exist:

   depend u,x,t;
   conlaw1({{df(u,t)=-df(u,x,5)-a*u**2*df(u,x)-b*df(u,x)*df(u,x,2)
                     -c*u*df(u,x,3)}, 
            {u}, {t,x}},
           {0, 1, t, {a,b,c}, {}});
   nodepnd {u};

 - for first integrals of an ODE-system including the determination of
   parameter values s,b,r such that conservation laws exist:

   depend x,t;
   depend y,t;
   depend z,t;
   depend a1,x,t;
   depend a2,y,t;
   depend a3,z,t;

   p_t:=a1+a2+a3;
   conlaw2({{df(x,t) = - s*x + s*y,
	     df(y,t) = x*z + r*x - y,
	     df(z,t) = x*y - b*z},
	    {x,y,z},{t}
	   },
	   {0,0,t,{a1,a2,a3,s,r,b},{}});

   nodepnd {x,y,z,a1,a2,a3};




