This is the manual for the routines and programs that are called SUMMER.
These programs are to be used with version 3.0 or later of FORM. At the
moment of writing this version is not yet available. It should become
available by the end of 1998. The current status (4-jun-1998) is that the
main programming has been finished, and only small items are added. For the
rest it still needs much debugging and of course the manual. The manual is
currenlty being written in collaboration with A. Heck (who wrote a very
good tutorial for FORM). The publication date of the manual will determine
the publishing date of version 3 to a large extend.

When you are using the SUMMER package, please refer to the paper
(hep-ph/9806280).

The SUMMER package consists of:

1: a general header file nndecl.h which contains all necessary declarations.
2: a number of procedures for internal use. These are:
3: a number of procedures for external use. These are:
4: a number of FORM programs that illustrate the applications.
5: two C programs. One can be used to evaluate the numerical value of specific
   integrals. The other was used to evaluate the value of the special
   constants. 
6: This manual file.
7: The file mel.tex which contains the publication.
8: The FORM programs bfx.frm (x=2,3,4,5,6,7) together with the header file
   bfn.h which were used to evaluate the values of the series at infinity.
9: The header file meltran.h for the examples that involve Mellin transforms
   and integrals.

Notations:
Sums are in general over parameters j1,...,jm in which m is some maximum
value that can be set with the parameter MAXWEIGHT in nndecl.h. The current 
default value is 10.
The sums themselves are indicated by the functions sum1,...,summ. The 
arguments are: sum1(j1,j1min,j1max). One may notice that one sum function
might have sufficed because the presence of j1 fixes the sum, but this saves
much pattern matching.
The relevant objects in the sums can all be distinguished by a number 1,...,m
also. At the critical moment all these objects that carry an argument with a
j1 (or other j of course but j1 is used here in a generic sense) are renamed
into theta1, delta1, sign1, den1, fac1, invfac1, bino1, S1. That way the
summation program can see better whether it has all occurrences (it is
only allowed to sum if indeed it takes all of these objects).
In general the notation is:
	sum(j,min,max)    : implies summation over the rest of the term.
    sign(n)           = (-1)^n
    theta(n)          = theta_(n)
    delta(n)          = delta_(n)
    den(n)            = 1/n
    fac(n)            = fac_(n) = n!
    invfac(n)         = invfac_(n) = 1/(n!)
    bino(n,j)         = binom_(n,j) = (n!)/(j! (n-j)!)
	S(R(m1,...,mk),n) = $S_{m_1,\cdots,m_k}(n)$ (see paper)
The general program assumes that the only parameters present are the j1,
...,jm and a parameter N which can occur in the boundaries of the first sum 
(as in sum1(j1,1,N)). The presence of other parameters may complicate 
matters. The routines that simplify the combinations of theta,delta and sum 
functions make moreover the assumption that N >= 0 and all j >= 0. It 
should be possible to relax these conditions, but this has not been tested.

The way to study the examples should be:
1: read the commentary in the indicated file(s)
2: run the file with the command
     form -l file
   as in
     form -l a1
   (the extension .frm does not have to be given)
3: Have a look at the output in the file file.log (like a1.log)

File a1.frm:  (reduction to the basis)

   First read the commentary in the file a1.frm
   Run this program with the command
     form -l a1
   This causes the output to be written in the log file only (a1.log)
   rather than on the screen.

File a2.frm:   (summing (n-j),j pairs, using the tables, using the theorem)


For the bfn programs one should consider the following first
   Method:
       1: construct an expression FF that contains all objects to be
          calculated in the notation E(indices)*S(indices) with
            S(indices) = S(R(indices),inf).
            Bracket the equation in E.
       2: construct (one by one) the various identities between the
          S-functions at infinity.
          Substitute in these equations all values of S-functions with
          a lower weight. Then substitute all S-functions that remain
          by the corresponding E-bracket in the expression FF.
          In the beginning this is trivial of course.
       3: Of the resulting equation one takes the first S-function and
          'moves it to the left hand side'. This is substituted in the
          expression FF. Note that now one of the E-brackets is not trivial
          any longer. Bracket FF in E again.
       4: Generate the next equation and substitute what can be substituted.
          then, single out the first remaining S-function and substitute
          again in FF. etc.
       5: If an equation becomes trivial (0) it can be ignored.
       6: In the end only a few undetermined variables will be left.
          These are new objects. One may try to choose a different set and
          make a substitution in the output FF.
       7: The expression FF contains now brackets in E of the type
          E(indices) * ( expression ) which can be used to extend the
          tables by changing this into
          Fill Stab#(indices) = expression;
          Actually it means S(R(indices),inf) = expression;
More commentary is in the files.
The details of treating the equations are in the file bfn.h

File bf2.frm:    (Obtain the weight two values at infinity)
File bf3.frm:    (Obtain the weight three values at infinity)
File bf4.frm:    (Obtain the weight four values at infinity)
File bf5.frm:    (Obtain the weight five values at infinity)
File bf6.frm:    (Obtain the weight size values at infinity)
File bf7.frm:    (Obtain the weight seven values at infinity)

It should be clear from the above files how to construct the weight eight
program. It is expected to take about two/three weeks or more on a PII-300
processor:
bf2:     0.07 sec on PII-300
bf3:     0.23 sec on PII-300
bf4:     2.03 sec on PII-300
bf5:    19.85 sec on PII-300
bf6:   563.51 sec on PII-300
bf7: 21187.68 sec on PII-300

File mel1.frm:   (Mellin transform)
File mel2.frm:   (Very difficult Mellin transform)
File mel3.frm:   (Integral)
File mel4.frm:   (Very difficult Integral)
File mel5.frm:   (Same very difficult integral, but with different algorithm)

File test.frm:   (Testing a sum from the tables)

The programs e.c and ev.c are given without much commentary. e.c should be 
selfexplanatory and ev.c is just a quick and dirty hack to calculate the 
needed sums to 20 digits. They are not guaranteed to work much beyond 
this. How dirty is the hack? it does not know negative numbers! All 
intermediate results have to be positive. With a package for multiple 
precision calculations one should be able to do much better. With the 
application of some convergence techniques one should also be capable of 
doing much better. But for less that 3 hours hacking it is not too bad.
The program num.c is for the numerical integration by Monte Carlo method of 
a given function f. This allows for numerical integration in the case that 
other programs are absent (to provide checks). For commentary on the use of 
VEGAS one should look elsewhere.

NOTES and DISCLAIMERS

These routines have not been fully optimized. I would not be amazed if 
someone manages to make them much faster. I am also not claiming that they 
are 100% bugfree. I take bugs out if I see them. If you run into one, let 
me know (after checking the latest version first).