The Fred Fish Collection 1.5/ffcollection-1-5-1992-11.iso/ff_progs/educ/schoonsc.lzh/Schoonschip/SDocsAMI.LZH/SDocsAMI/Schipman.e

Text File | 1991-06-14 | 213KB | 5,522 lines

            SCHOONSCHIP (*)
         A Program For Symbol Handling.
            M. Veltman

     0. DIFFERENCES WITH OLDER VERSIONS

     1. INTRODUCTION

     2. BASICS

     3. INPUT FACILITIES

     4. TYPE DEFINITION

     5. X, D AND T EXPRESSIONS

     6. FILES

     7. PRINT OPTIONS

     8. END LINE OPTIONS

     9. SUBSTITUTIONS

    10. PATTERNS

    11. CONDITIONAL SUBSTITUTIONS

    12. COMMANDS

    13. PARTICLE PHYSICS

    14. INTERNAL PROCEDURES

    15. CHARACTER SUMMATION

    16. GAMMA ALGEBRA

    17. R-INPUT

    18. STATEMENTS. CONDITIONAL INPUT READING.

    19. LARGE PROBLEM HANDLING

    20. FILE HANDLING COMMANDS

    21. SUMMARY

    APPENDIX A. COMMAND LINE OPTIONS

    APPENDIX B. COMPATIBILITY

First version: January 1964.
Current version: June 1991.

*) Copyright (C) 1991 by Martinus J. G. Veltman.  This version of the
Schoonschip manual may be freely copied on a not-for-profit basis.  All rights
to other versions of the Schoonschip manual are reserved.

A more extensive, printed manual and updated information are available from:

David N. Williams
1238 Westport
Ann Arbor, MI 48103

Email: [e-mail]


0. DIFFERENCES WITH OLDER VERSIONS.

This version of Schoonschip (Jan 1, 1989) differs considerably from the
previous versions. Every effort has been made to avoid changing code
that has been shown to work correctly, and also upward compatibility
was considered very important. To be able to run known problems and to
compare the results is an invaluable and very unique part of Schoonschip.
In this way 25 years of experience are still very much part of this
version.

Modern users tackle ever larger problems, and improvement of Schoonschip
with respect to handling large problems was a high priority. There are
several aspects to this situation. First, new methods to present and
formulate a problem had to be considered. This has led to the introduction
of a new concept, namely character summation. This allows very efficient
generation of diagrams. As yet the main application seems to be high energy
physics, but the concept appears to be of larger generality. More specific
to high energy physics is gamma matrix algebra. Efficient methods to deal
with gamma matrices in other then four dimensions have been incorporated.
This allows application of dimensional regularization to problems with
fermions.

Another important tool in handling large problems is the Freeze command.
It existed in CDC versions of Schoonschip, and has now been implemented
also in this version.

Last but not least the output sorting methods of Schoonschip have been
vastly improved. The previous versions tended to generate very large
disk files and consequently were quite time consuming. This seriously
limited the magnitude of the problems that could be treated, especially
on relatively small systems (PC's). It must be well understood: in
principle there is no reason why Schoonschip should not run equally well
on PC's as compared to mainframes. Of course, there is a difference
due to the different CPU speeds, but that is often more then compensated
by the fact that mainframes usually must deal with a multitude of users. And
disk file handling is not necessarily slower on a PC. The main difference
is that mainframes have essentially infinite disk space, but that advantage
is rapidly disappearing as larger and larger disk systems become available
to PC users. Right now the standard is about 20 Mb, but there are already
very good and inexpensive systems with capacities in the 100 Mb range.

The new sorting methods give an improvement of one or two orders of
magnitude in time and disk space for large problems (producing more then
1 Mb of disk files). Of course, 'reasonable' default parameters are
build in, but for truly large problems things must be tailored to the
specifics of the problem. It is suggested that the section on large
files is read at least once, such as to give an idea of the situation;
if the need arises one can go back and get the details.

Several new statements and commands have been implemented. Some of them
replace older, more cumbersome forms. New statements:

Anti
Beep
Directory
Digits
Dostop
Dryrun
External
Fortran
Freeze
Large
Maximum
Overflow
Precision
Progress
Rationalize
Round
Silence
Showl
Synonym
Nshow
Traditional

Conditional input reading statements:

Goto
Gotoif
Gotoifn

New commands:

Absol
Anti
All
Beep
Dostop
Expand
Extern
Gammas (=old Trick,Trace)
Iall
Ndotpr
Order
Print
Stats

Slight modification:

Integ on CDC versions of Schoonschip truncated the numbers. Later versions
rounded to nearest integer. The truncation has been re-instated, but
the statement 'Round on' may be used to obtain rounding to nearest integer.

B list may now have vector names. All dot-products or vector components
  relating to that vector are factored out.
  In addition the Exclusive option is now available. If the first
  argument in the B-list is the keyword Excl then the subsequent
  names will be the only quantities that will be factored out. In this
  case function names may appear in this B-list. A function not
  mentioned in the list will not be factored out. Thus then functions
  may appear inside the brackets in the output.
  This Excl option has been provided in connection with the Freeze
  command. Here a word of caution: avoid situations where a twice
  occurring index becomes 'split', i.e. one appears outside and one
  appears inside the brackets. In that case be sure that such an index
  is not a created index.
  A word of caution: using the Excl option functions may become reordered.

A D function with or without dummy arguments may now appear in the left hand
  side of a substitution, although not combined with other factors.

The Count command has been slightly enhanced, allowing multiple counts with
one command.

The Symme and Asymm commands have been slightly enhanced, allowing handling
of groups of arguments.

The Spin command allows now vectors as arguments to identify spinors.

The substitution types

Id,Funct,a=...
Id,Funct,p(mu~)=...

may now have function names inbetween the keyword and the last argument.
Then only those functions are considered. Example:

Id,Funct,Epf,p(mu~) = k(mu) + q(mu)


All statements are summarized in the section on Statements. Commands are
discussed in the section on Commands.

New notation:

Long names containing special symbols such as +, - etc may now be used for
algebraic symbols. They must be enclosed in square brackets. Example:
[a+2/3*b] is seen as a symbol with that name.

Entirely rewritten: section on Conditional substitutions.

new sections are:
 Character summation
 Gamma algebra
 R-input
 Statements. Conditional input reading.
 Large problem handling
 File handling commands

It is suggested that one reads (or tries to read) them at least once, to
have some idea as to what is available.

Schoonschip has not been known to be so-called "user friendly", whatever
that may mean. This concerns error reporting as well as syntax. Some, but not
much has been done on error reporting. While important, and this is well
recognized, it is not considered the highest priority. Concerning the syntax,
a number of improvements has been made.

There are a few minor incompatibilities with older versions. Square brackets
[] now have a new function, and cannot be used any more as regular brackets.
The statements DELETE (for deleting blocks) and Printer (to request for
line printer type output, i.e. longer line length) have been replaced by
Bdelete and Lprinter. This because now no difference is made been between
lower and upper case symbols for commands etc. Also, it has been attempted
to make the commands recognizable by the first few (four at most) characters.

The condition code system has been thoroughly reviewed. Although quite
powerful it was too cumbersome to handle. Instead there is now a system
employing familiar concepts: IF, AND, OR, NOT, ELSE and ENDIF.

The handling of exponents has been modified. Before the addition was circular
through 128 to -128. Now this is no more true. The result will be an overflow
error message that can however be switched off (Overflow off statement).

Further there is a new, alternative, notation for gamma matrices.


Acknowlegements. Thanks are due to Drs. E. Remiddi and J. Vermaseren for
inspiring several of the improvements incorporated in this (and older !)
Schoonschip versions.


1. INTRODUCTION.

Schoonschip is a program written in assembler language intended to help
handling large algebraic expressions. Very little is build-in in the sense of
function properties, or integral tables etc, but it offers many facilities to
operate on expressions. Thus if the user knows the type of integrands that can
occur it is easy to let the program do the actual integrations. Schoonschip
never tries to think for the user, it just makes it possible to use the
computer as a tool when doing algebra.

There are provisions for building up a library of Schoonschip statements.
Blocks of statements, performing well defined operations (such as for example
differentiation or integration) may be defined, stored, and when needed
recalled with a single line. In this way a user can build up to his own needs.

In principle the system works as follows. An expression is given to Schoonschip
and subsequently one gives instructions as to what to do. In first instance
Schoonschip works out the given expression term by term, and next each term
passes a series of levels. At each level the user has an opportunity to work on
that term. The result is collected in an output storage area and identical
terms are added. The result can be handled in a variety of ways: it can be
returned to the input for a new round, or it can be written to disk for later
use, etc. Of course, the result is normally printed as well.

This manual explains the available features by way of examples. Some knowledge
of the way that Schoonschip works is of advantage, and at various points some
details will be given. The manual is meant to be read having at the same type
the file with examples at hand. This file is supposedly named Examples.e. To
see then how example 5 works one types

Schip +5 Examples.e

If the output is larger than one screenful one may also specify an output file,
either by the >fnam option or also by simply giving the name as second
argument:

Schip +5 Examples.e outp

The file outp can then afterwards be inspected.
Below the input text of these examples is reproduced also.

2. BASICS.

The first example shows what is meant by working out the initial expression.
The expression must be given on a line wich has a Z in the first column. The
general convention is that a line with a blank or tab in column one is a
continuation of the previous line.

Now the first example:

Example 1.

Z XX = (a + b)^2

The notation ^ implies exponentiation. Also ** (as in Fortran) may be used. XX
is an invented name that identifies the expression if it is to be re-used, or
written to disk etc. It may be part of another expression in later problems.
All that Schoonschip does now is to work this out to a series of terms: a^2,
a*b, b*a and b^2. Thus if nothing else is done this is what will go to the
output. For algebraic variables (as a and b are taken to be by default)
commutation is assumed, thus a*b is recognized to be the same as b*a. The way
Schoonschip handles this is by rearranging every term, setting symbols in an
internally well defined order. For quantities of the same kind this is
generally the same order as that in which they appear in the input.

At this point no further instructions are given, and the program may proceed to
do this work. To signal that all has been said a line with an * in column one
must be given. The further content of the line instructs Schoonschip what to do
next after this task has been performed. Right now the idea is to go on to
another example, and the word 'begin' leads to this action. After this a, b and
XX are lost.

*begin

For massive expressions it is often desirable to group terms in the output. For
instance, they may be grouped with respect to the variable a and the exponent
whith which it may occur. The way to do this is to give a list of quantities to
be factored out on a line with as first character a B. At most 130 quantities
allowed.

B a

Z XX= (a + b)^2

*end

This is about all control that the user has on the output format. Some
additional facilities concern the way numbers are printed. By default
Schoonschip tries to write every number as a rational fraction, but this is not
always possible. Internally all numbers are represented as floating point
numbers, with a 14 bit exponent and a 96 bit fraction. When printing
Schoonschip tries to convert to a rational, using 70 bits as input. Then the
rational is reconverted to a floating point number, and agreement to 84 bits is
required. If that works the number is printed as a rational, otherwise as an
integer or floating point number depending on the number. If printing as a
floating point number the user has control over the number of decimal digits to
be printed. Also the rationalization procedure can be influenced. This is done
by means one or more of three statements:

Precision #
Rationalization #
Digits #

As often in the Schoonschip syntax only the first three (if no confusion
possible two) characters of these statements are significant, and they may be
in upper or lower case. Thus

PRE #

is acceptable instead of Precision.

The # represent numbers specifying decimal digits. If none is given the default
is used. The number following Digits specifies the number of digits to be
printed for floating point numbers. Default is 5. The number following
Rationalization specifies how many decimal digits should be used (sum of
numerator plus denominator digits) when attempting rationalization. Default is
22. If 0 is specified no rationalization attempt is made.  For other then the
default value no check on the remaining digits is done. This may be used to
find a rational approximation for some number.

Numbers are always a problem in symbol handling programs, and the approach
chosen in Schoonschip has come out of many years of trying various
possibilities. As already noted above, every number is put in a floating point
format with a fraction of about 29 decimal digits (96 bits) and 14 bit
exponent. In the course of the calculation one will loose precision and stray
bits will accumulate in the least significant part of the number. Consequently
cancellations will in general not be exact. Schoonschip assumes that two
quantities cancel if 25 decimal digits (80 bits) of the coefficients cancel.
This number can be changed by means of the Precision statement where # is the
desired number of decimal digits. To be precise:  1.E15 + 1 - 1.E15  is 0 if 15
is specified, and is 1 if 16 is given.

The above makes clear to what extend numbers are handled precisely. In general
rationals will be converted properly if the sum of the decimal digits in
numerator and denominator is less than 21.

A number may be given in various ways:

- without exponent or fraction:  1230, 17893
- with fraction: 1.978, 33.127
- with (signed) exponent: 12E13, 178E-17
- with (signed) exponent and fraction: 23.47E15, 18.49E-200
- in hexadecimal notation: 0x10ABC, 0xA4FFF

The latter two are the same as 68284 and 675839. The hexadecimal notation
is actually needed in certain statements (the Directory statement).

Schoonschip will work out multiplications and divisions of numbers directly,
thus 2/3 is immediately converted to 0.6666666...

The effect of the above statements as well as some other features are shown in
the following example. An expression is given, printed, and re-directed to the
input, and new instructions are given. Normally, when re-routing an expression
to the input no output is printed, and one must explicitly asked for that by
means of a line having a P in column one. Schoonschip reproduces such a line
with an additional > sign. The re-direction is by means of the word 'yep' on
the * line. Also the way comments may be given is illustrated. A ! implies
simply end of line, and has no further effect. Also it should be noted that
blanks and tabs are generally ignored (except for their function as first
column character to indicate continuation).

Example 2.

P output    !Only the first two characters of 'output' are significant.

Digits 3
Rationalization 3        ! 0 leads to no rationalization attempt.

Z XX=3.14 + 1/3*a1 + 7.1357689E20*a2    !E20 or E+20 implies 10^20.

*yep

Digits            !This restores to the default option, 5 digits.
Rationalization        !Default: 22 digits, with check.

*end

The *end line implies termination after the problem has been worked out. As
with most Schoonschip input, the * lines are format free, except that the *
must be in column 1. But one may write for example * en  d .

3. INPUT FACILITIES.

While little can be done to the output, there is great flexibility concerning
input. Two basic features are available: BLOCK's and DO loops. A block is a set
of lines that may recur with minor variations and that can be called with a
single line. The structure is very much as macro's in assemblers. The DO-loops
are similar to Fortran do-loops.

A block is delimited by two lines. The first line contains the word BLOCK in
columns 1-5 followed by a name followed by arguments separa- ted by comma's and
enclosed in curly brackets. The last line must contain the word ENDBLOCK in
columns 1-8. When calling the block arguments are substituted, provided they
were enclosed in quotation marks in the block definition. A block name may have
1-6 characters.

Example 3.

BLOCK text{xx,yy}
C This argument is substituted in a call: 'xx'.
  This not: xx.
  Arguments can be glued together: 'xx''yy'.
ENDBLOCK

  To call a block simply give the name with the arguments to be
substituted. Be sure to start in column one, and to enclose arguments
in curly brackets. An example of a call:

text{yes,sir}

A block remains known over *begin lines. It can be deleted by means of a line
having the word BDELETE (four, if no confusion possible three characters
significant, lower case accepted also) starting in column 1 followed by the
name of the block to be deleted.

BDELETE text

Blocks are stored on disk in a file called tape9, and recalled as needed.
Schoonschip keeps a list of names in memory. There is a simple way to delete
entire lines when calling a block. A line with the character ~ in column one is
totally ignored by Schoonschip, not even printed. Suppose we want in one case
lines 1 and 2 of a block, and line 3 in another case. Example:

BLOCK lines{A,B}
'A'C line 1
'A'  line 2
'B'  line 3
ENDBLOCK

Now call the blocks and use ~ to delete lines:

lines{,~}

lines{~,}

Note that an empty argument leads to an empty substitution. Actually if the
final argument(s) are empty it is not even necessary to type comma's. Thus
lines{~}  gives the same as the last example.

It may happen that one wants to call a block with some of the arguments
containing a comma. In that case enclose that argument in curly brackets {}.
When substituting Schoonschip peels away the outer layer of curly brackets. For
example, text{{a, b}, and c} leads to:

C This argument is substituted in a call: a, b.
  This not: xx.
  Arguments can be glued together: a, b and c.

DO-loops are also delimited by two lines. The first line must have DO in
columns 1-2 followed by  name=#,#,# . The word 'name' may have (as is generally
the case with names in Schoonschip) up to 6 characters. The three numbers
represent a range of numbers to be substituted for 'name' in the rest of the DO
loop. The first two specify the range, the last the increment. The DO loop is
terminated by a line containing the word ENDDO in columns 1-5. As in the case
of blocks substitution is done if 'name' occurs enclosed in quotation marks:

DO var=1,7,2
P input            !Normally only the first DO round is printed.
C value of var: 'var'
ENDDO

The numbers may also take negative values. Schoonschip handles this by
attaching the prefix % to the number, which is interpreted as an intrinsic
minus sign when encountered in front of a number. If it occurs elsewhere this %
sign is part of whatever it occurs with.


DO var=-1,1        !The third number is 1 by default.
P input
C value of var: 'var'.
C This may be part of a name, for example XX'var', or an index,
  for example YY(3+'var'). In the last case Schoonschip will interpret
  the % sign as minus and correctly work out the number.
ENDDO

The exit of a DO-loop may be forced prematurely at execution time, by means
of the command Dostop (see substitutions and commands). This is a somewhat
tricky affair, due to the fact that DO-loop expansion is strictly on the
input level, while the Dostop command functions during execution, i.e. after
input has been read up to a line with an * in column 1. Thus a Dostop command
will have effect only after such a line. Therefore, normally, a forced exit
should be effected only for DO-loops that have a line with an * as the last
statement.

There exists also a Dostop statement which is effective just before execution.
It serves to preset the Dostop flag, and at execution time the thus forced
DO-exit may be nullified or set. Again, a *-line should be the last before the
ENDDO. The syntax of this statement is:

Dostop on

or

Dostop off

This sets or clears the forced DO-loop exit flag. Both Dostop statement and
command should normally occur within the same DO-loop. The statement should
preferably occur just before the first substitution or command of the set in
which the Dostop command occurs.

Blocks and DO loops may be nested, up to 10 levels deep. As is evident from the
above, all this is strictly on the input level, and just pure character
substitution (apart from the % sign). It is up to the user to make sure that
sensible Schoonschip input results. Use the statements  P input  and  P ninput
to see or to suppress the actually generated text.

Since the same blocks may occur in many different problems it is useful to have
the blocks stored in some file, and to let Schoonschip read them in before
starting on some problem. This is possible, and is in fact not restricted to
blocks. A line with the word  Read  in columns 1-4 followed by a file name
causes Schoonschip to open that file and read it as normal input. As soon as a
line with the word End in columns 1-3 is encountered Schoonschip switches back
to the normal input file, specified in the call statement. Other files may be
read subsequently, Schoonschip reads all blocks and whatever else, simply
switching input. All blocks read are stored in tape9 and may be used in all
subsequent problems. Restriction: a Read within a Read file is not allowed.

4. TYPE DEFINITION.

In algebraic expressions different types of symbols may occur. The user must
specify beforehand these symbols. The following types may occur: Algebraic
symbols, Indices, Vectors, Functions and Expressions. These are defined on
lines having A I V F or X in column one. Actually there are additional types of
expressions, characterized by D or T in column 1, but we will discuss them
later. Names may have up to six characters, both upper and lower case and
numers allowed, although a name should be distinguishable from a number.
Also the character _ (underscore) may be used in names. If it is not the
first it is not included in the count. The underscore has a function in
certain contexts, to be explained later.

A limited facility is present to handle large names. Sometimes large names
containing other then the characters mentioned may be very useful by way of
mnemonics. Such names can be used, but they must be enclosed in square
brackets. They may contain just about any character except control characters
(such as tab or linefeed) or square brackets themselves. Futhermore they can
only be used for algebraic symbols.

Examples:

Abcd  abc_def 12A3  12_ab f1  f2  [a + b/3]

Illegal names:

Abcdefg  12E3

The last name would actually be understood as a number: 12 * 10^3.


Generally, symbols are simple commuting variables that may have an exponent.
Such exponents must be short integers, that is integers in the range -128 to
+127 inclusive. The extreme values are taken in case of overflow, if error
trapping on that has been suppressed with the Overflow statement.

Indices may occur as algebraic variables, but are really meant to be vector
indices, or function arguments.

Functions are non-commuting quantities, with or without arguments. Of course,
if they are commuting that can be handled too. But if they represent matrices
(with or without indices as arguments) then they must be considered as
non-commuting. In short, functions may be used to represent anything that is
not any of the other types of symbols. Whatever calculational rules they obey
must be given by the user.

Vectors are handled according to the standard rules of vector algebra. To
achieve this dot-products may be formed, denoted by a capital D inbetween two
vector names. Thus, if p and q are vectors then pDq denotes the dot-product
between p and q. ASchoonschip follows the usual summation convention that twice
occuring indices imply summation: p(i1)*p(i1) is interpreted by Schoonschip as
pDq. Also the Kronecker delta is available: it is the special function D which
is build-in. Here an example showing various rules:

Example 4.

A a1,a2,a3        !Algebraic symbol list.
F f1,f2,f3        !Functions.
I mu,nu            !Indices.
V p,q,k            !Vectors.

Z XX = p(mu)*{ a3^-20*a1*q(mu) + a2*a1^7*D(mu,nu)*k(nu)

    + a3*f2(mu,k,q)*f1}        !Note the use of {}.

    + q(mu)*{a3*a2*a1 + f3*f2*f1}

*end

Note that functions are always treated as if they are on the B list. Also
vectors not part of a dotproduct are factorized. Note also the re-arrangement
of the symbols a1, a2 and a3, which is not done for functions such as f1, f2
and f3. Note also that Schoonschip pays no attention to the fact that f2
occurred both with and without arguments. As shown curly brackets may be used
instead of the usual brackets, but they must be paired. Also the user must make
sure that they cannot be confused with BLOCK definitions and calls. If some
special character such as * + , etc occurs in front of the { no problem arises.

Functions and vectors may not have exponents. For functions this a mild
restriction, because one can always add on an argument, and consider that to
be the exponent.

Vectors may have a numerical arguments, for example p(3). This is taken to mean
the third component of p, but only in some really formal sense, and Schoonschip
has no objections against for example p(-3). The only restriction is that the
number must be a short-short number, i.e. less then 32. These numbers are
treated modulo 32, ranging from 0 to 31. Thus p(-3) becomes p(29). In the
following something like p(3) will be called a vector component.  If an index
occurs all by itself, not as argument of a vector or function, it is treated as
an algebraic symbol. Thus one could have mu^3. Also vector components and
dot-products may have an exponent.

Like Fortran, Schoonschip has default assignments for names not mentioned in
any list. Things are pretty obvious in a case such as ff(a1,a2); but it is
ambigous for a case like p(k). Is p a function or a vector? Again, like in
Fortran, the default assignment for xx in a case like f(a1,xx) is an index if
the first character of xx is in the range I-N or i-n, and else an algebraic
symbol. It is always possible to see what Schoonschip guessed using the  P list
 command. This causes a print-out of all the lists of all quantities in a given
problem, but more about these commands later.

The rules for algebraic symbols are the usual ones. They are supposed to
commute with themselves and everything else, including functions. They may
appear with or without an exponent (must be short number), and may be preceeded
by a /. This simply implies a reversal of sign of the exponent. Thus  a/b^3 =
a*b^-3. The exponent may also be an expression in brackets, provided this
expression, when encountered while working out the problem evaluates to a
number. This number is then truncated and rounded to the nearest short integer.
Thus  b^(2-2/3) becomes b^1 = b.

Overflow occurs ff the exponent of an algebraic expression exceeds 127 or is
less than -128. In that case Schoonschip generates en error message. This may
be suppressed with the Overflow statement:

Overflow off

In that case Schoonschip creates in the case of overflow (or underflow) the
exponent 127 (or -128) representing infinity. The error trapping can be turned
on again with the statement:

Overflow on

The Overflow statement may be given in the *fix section and the option given
is then the default.

The rules for dot-products, vector components and indices not vector or
function argument are precisely those of algebraic symbols.

The lists are also used to assign some further properties to the various
objects. If complex conjugation occurs in a problem then the reality properties
must be known. An algebraic symbol may be real (default), imaginary or complex.
If it is complex then its complex conjugate must be designated. All this is
done in the A-list. If a symbol in the A-list is followed by =i it is taken to
be imaginary and the conjugate of the symbol is minus that symbol. A symbol may
also be explicitly designated to be real by the assignment =r. If the symbol is
followed by =c it is assumed that this is a complex symbol, and Schoonschip
creates a new name, by appending C (capital C), and places this directly after
this symbol:

A a1,a2=i,a3=c

implies a1 is real, a2 is imaginary (Conjg(a2)=-a2), a3 is complex, i.e.
Conjg(a3)=a3C and Conjg(a3C)=a3. The symbol a3C is created by Schoonschip.
If so desired it may be renamed by means of the statement

Oldnew a2C=xxx

where xxx stands for the new name. The Oldnew statement may actually be used to
change any existing name, including the build-in names.

Indices, vector components and dot-products are taken to be real. Functions may
also be real, imaginary or complex, and in addition "undefined", which will be
explained below.

Except for =c the definitions can be overwritten, the last definition holds.
This is useful with respect to build-in quantities of which one wishes to
change the reality properties. Overriding with =c leads to the fact that the
following symbol in the list is considered as the conjugate, which is fine if
it was not defined something else before. On the other hand, redefining an =c
assignment leaves its conjugate symbol as real, so that must then be redefined
explicitly also if not real.

In addition one may assign a number to an algebraic symbol. This number must be
between -32 and +32, and its function is to facilitate working with power
series. If one assigns for example the number 4 to a symbol then it is assumed
that powers of this symbol of 4 or higher can be ignored, and if a term
containing the symbol to such a power is seen it is immediately set to zero.
This is extremely useful if not indispensable when substituting series into
series. Somewhat similar one may assign z to a vector; if then that vector
occurs in a dot-product, with an index, or as vector-component it is also
immediately set to zero. Such facilities are very important when dealing with
large expressions. Function arguments are not considered with respect to zero
setting. This is somewhat ambiguous for a case such as p(mu)*f1(...,mu,..) =
f1(...,p,..); this ambiguity is to be resolved by the user, and seems not to
offer any difficulties.

Warning. Assigning a number to a symbol in order to speed up things is not to
be used if both negative and positive powers appear. Something like a^3 may
be deleted before being multiplied with, say, a^-2 in case the number 2 was
assigned to a.

Example 5.

A a1,a2=i,a3=c,a4=c,a5=i=3
V p,q=z,k

Z XX = Conjg(a1 + a2 + a3 + a4 + a5)
Z YY = Conjg(a3C + a4C)
Z ZZ = (a1 + a5)^5
Z AA = p(mu)*{p(mu) + q(mu)} + D(mu,3)*{p(mu) + q(mu)} + pDk

Oldnew a4C=b4,k=K

*end

Note how a5^3 and higher has been eliminated. Note also that the vector k
is replaced by K. The notation D(mu,3) is explained below.

The vector algebra rules are:
    p(mu)*q(mu) = pDq
    p(mu)*D(mu,nu)=p(nu)
    D(mu,nu)*D(nu,la) = D(mu,la)
    D(mu,mu) = n
In the above mu, nu and la are supposedly indices defined in an I-list. The
quantity n is the range of the indices, and may be a number, but also can
be symbolic. Thus when working in 3-dimensional space n would be 3, in four
dimensions n = 4. The default value is 4, since 1905. The way to specify
this value is in the I-list. One writes the number behind the index:

I mu=3,nu=3,la=3

Obviously one is supposed not to mix indices of different range in a
D-function. Schoonschip makes no check for that. If Schoonschip encounters
D(mu,mu) the number found in the I-list is substituted. Also a symbol may be
used, but it is restricted by the requirement that it may be only one character
in length. When encounterd in an I list Schoonschip will immediately enter that
symbol in the algebraic symbol list, and in addition the character followed by
an underscore is entered.

I mu=N,nu=N,la=N

If Schoonschip now encounters for example  D(mu,mu)*D(la,la)  the result
is N^2. The names N and N_ are entered in the symbol table. The name N_ is
used extensively in Gamma algebra involving indices of range N.

As an extension of these well-known rules there is the additional convention
that numbers and vectors may occur whenever indices may occur. Thus,

    p(q)  D(p,q)  D(p,3)  D(3,4)

are perfectly legal and they are worked out as one might guess:

    p(q) = pDq,    D(p,q) = pDq,    D(p,3) = p(3),

and finally, if n1 and n2 are numbers then D(n1,n2) = 1  if n1 = n2, and = 0
if n1 not equal to n2.

These conventions imply a rule for D, namely that D(-x,y)=-D(x,y).

If an index occurs as argument of a function the treatment is conventional:

    D(mu,nu)*f(...,nu,..) = f(...,mu,..)

where now mu may be index, vector or number, and the logical extension:

    p(mu)*f(...,nu,..) = f(...,p,..),

etc.

Despite this simplicity there is a complication that is really quite a
a problem. Consider the following expression:

    D(mu,nu)*f1(...,mu,..)*f2(...,nu,..)

There are two possible answers, namely

    f1(...,mu,..)*f2(...,mu,..)
and
    f1(...,nu,..)*f2(...,nu,..)

The answer is clearly not well defined. They should in fact be identified.
If two such terms arrive in the output Schoonschip should add them up, to
obtain 2*f1(...)*f2(...).

The solution to this problem is a renaming of indices. Indices that are
summation indices appearing twice, and whose name is not really relevant
may be declared in a Sum list:

Sum mu,nu

Now Schoonschip will in both cases rename the indices in the same way, and
the result is identical. The Sum list must occur after the I-list. It is
best placed near the line with an * in the first column. The indices
appearing in a Sum list must be defined before, but not in the *fix section
(explained later). The following example illustrates the Sum command:

Example 6.

I mu,nu,la,ka

Z  XX = D(mu,nu)*f1(a1,a2,mu)*f2(a3,a4,nu)
      + f1(a1,a2,mu)*f2(a3,a4,nu)*D(mu,nu)

Z  YY = D(la,ka)*f1(a1,a2,la)*f2(a3,a4,ka)
      + f1(a1,a2,la)*f2(a3,a4,ka)*D(la,ka)

Sum,la,ka

*end

Note how the indices la and ka are replaced by the invented name Naa.

Now functions. Functions may have arguments, which must be single quantities
separated by comma's. There is an extension involving tables, explained later.
An expression in brackets is also allowed as argument. As a special facility
functions may have characters as argument. Only single characters are legal,
and they are recognized by preceeding them with a ". Thus f1("A,"s) is legal.
See for example section 3.4, Compo for applications. Finally one may have
essentially numerical expressions. An essentially numerical expression is an
expression that works out to a number at execution time. It may include
most anything that works out to a number; it may even contain previously
evaluated expressions, but such expressions must be 'Keep' files, enclosed in
brackets, and be just one number. The number obtained will be truncated
and rounded to the nearest short number. A function containing an expression in
brackets as argument must somehow be replaced before it reaches the output
store, because that is how long Schoonschip retaines the definition of
expressions in brackets. This means that there must be an equation (rather, a
substitution as they will be called) leading to a replacement of such a
function before the line with a * in column one. Example of a function with
legal arguments:

  f1(a1,p,q(3),"X,pDq,17-22,(23*a5-b5),f2)

This function must be replaced before the * line because of last but one
argument. This is no such problem in the following case:

  f2(a3,7-2,pDq,"A)

It is not legal to start with numbers exceeding 127 in absolute value
occurring all by themselves:

  f1(1E25)

is illegal and produces an error. But f1(2.34) is accepted and changed into
f1(2). And

  f1(1-7E25)

is accepted but gives an overflow message at execution time. This is pretty
academic, and it is mentioned only for completeness. For a full understanding
it is necessary to know what is really going on inside Schoonschip. Numbers in
a function argument must be short integers (in the range -128, 127). Thus if
numerical expressions occur as function arguments they must be "integerized".
There is an operational symbol for that, namely Integ. At input time
Schoonschip analyzes this situation only very superficially, and when in doubt
adds the Integ operator to the argument. This happens as soon as a / or * etc
is seen. Thus f1(1E25-1) is translated to f1(Integ(1E25-1)). When this
expression is seen at execution time the argument is normally rounded and
truncated. Overflow occurs if the number is outside the range mentioned.
Integ will by default truncate the number towards 0, i.e. 1.9 becomes 1
and -1.9 becomes -1. Optionally this may be changed with the Round
statement:

Round on

In that case the number is rounded to the nearest integer (i.e. 1.9 becomes
2, -1.9 beomes -2). The statement Round off resets to the default option,
truncate. In all cases the floating point number is first rounded in the very
last 10 bits, to allow for stray bits.

The consequence of this is that composite non-numerical arguments are
to be avoided, for example  f1(3-a)  gives an error report, not at input
time, but when executing. As it may well happen that the symbol a is a
dummy to be replaced by a number to be specified during the calculation
it must be treated this way, and can not be flagged at input time. This will
become clear later.

With respect to complex conjugation the following rules are build in. When
conjugating a product of functions Schoonschip
    reverses the order of all functions;
    conjugates those quantities whose reality properties are known,
        including the function arguments;
    postpones complex conjugation of functions that have been classified
        as u (for undefined) in the F-list.
In this context an expression in brackets is considered a u-function.

Example 7.

A a1,a2=i,a3=c
F f1,f2=i,f3=c,f4=u

Z xx=Conjg{ f1(a1,a2,a3)*f2(a1,a2,a3,f3)*f4(a1,a2,a3) }

*end

A particular problem arises if an expression in brackets occurs as argument of
a non-u-function. In such cases the expressions in brackets are conjugated,
that is the operator Conjg is attached to such expressions. Unfortunately that
is not possible for other types of symbols, thus if a u-function occurs as
argument of a non-u-function subject to complex conjugation then Schoonschip
stops. In such cases the function of which the u-function is an argument must
be made u-type too, which is after all quite logical. A u-function will
generally be replaced by something else later on, and then the complex
conjugation can be worked out.

A number of functions is build-in, including their reality properties, and here
a particular problem arises. The Epf function (the totally anti-symmetric Weyl
tensor) is real in 3 dimensions, where it represents the cross-product of
vectors, but it must be considered as imaginary in 4-dimensional Minkowski
space (because one of the components must be 4). Generally, the default
situation in Schoonschip is 4 dimensions, and thus Epf is considered as
imaginary. This may be changed by mentioning Epf in the F-list with the
option =r.

X-expressions are always considered as undefined with respect to complex
conjugation. They are discussed later.

The build-in quantities are:

Algebraic symbols: i=i.

This is the usual i, and the relation i^2=-1 is build in, although it is
not always applied instanteneously.

Functions: D,Epf=i,G=i,Gi,G5=i,G6=c,G7,Ug=c,Ubg,
       DD,DB,DT,DS,DX,DK,DP,DF=u and DC.

Special rules are build-in for these functions. Some of these functions
must not be used, because they serve special purposes. The function DD is used
internally for all kinds of things.

The function D is the Kronecker delta function and has been explained
before. The Epf is the Weyl tensor, and it may have any number of arguments.
If it has 6 arguments it is assumed to be this tensor in 6-dimensional
space. A special command that reduces products of Epf to at most one Epf
is build in. Furthermore it is assumed that Epf is totally anti-symmetric
in all its arguments, and also it is supposed to commute with all other
functions. Both the D and Epf function are taken to be linear in their
arguments, that is D(-x,y)=D(x,-y)=-D(x,y) and similarly for Epf.

The functions G, Gi, G5, G6, G7, Ug and Ubg refer to gamma matrices and
Dirac-spinors as occurring in relativistic quantum-mechanics. They will
be discussed in a special section. Users not interested in that subject
may forget about them. Inside Schoonschip they account for about 8% of
the code, not worth removing.

The functions DB, DT, DP, DK and DC are numerical functions that are very
useful in many situations. DB with one argument is the factorial, and
DB with two arguments is the binomial function. The definition is:

    DB(n) = n!
    DB(n,m) = n! /{m!(n-m)!}

Internally the calculation of the binomial function is word (=16 bits) bound,
and fails for DB(19,m), m=8,9,... and higher up.

The function DT is the theta-function, and is very useful to switch terms on
and off. It may have any number of numerical arguments and is 1 if all
arguments are positive including zero, and else is zero:

    DT(n1,n2,...) = 0 if one or more n1 negative, else DT =1.

The function DP is the permutation symbol. The arguments are permuted till they
are in ascending order, and the value of DP is zero if two arguments are equal,
and else +1 or -1 depending on the sign of the permutation:

    DP(n1,n2,n3,...) = +1, -1 or 0. Zero if two numbers equal;
                    1 if permutation to smallest first
                    is even;
                    -1 if that permutation is odd.

For example, DP(2,1) = -1.

The function DK is something like a numerical Kronecker delta. It is 1 if
the arguments are equal, else it is zero:

    DK(n1,n2) = 1 if n1=n2, else =0.

The fact that it is explicitly a numerical function makes it different from
the D function. For instance, DK may be part of a function argument
expression as in f1(...,4-2*DK(n1,n2),..)

The function DC is 1 if the sum of the arguments (it may have any number
of arguments) is zero, and else DC is zero. It is primarily intended for
situations where one has some conservation rule. It is also used in
connection with character handling, and then there are various rules.

The function DS is the summation function. Its application for character
summation will be explained in another section. Other than that it must
appear in the form:

    DS(J,J1,J2,( F(J) ),( H(J) ) )
or
    DS(J,J1,J2,( F(j) ) )

In here F and H are expressions that may depend on J. The quantities J1
and J2 must be numerical, and H must be a numerical expression. H is not
limited to short numbers. When working out this function Schoonschip makes
J run from J1 to J2 inclusive, and creates a sum of terms. Each term is of
the form

    F(J)*G(J)

where G(J) is defined by the first G to be one (thus G(J1)=1), and
subsequent G are equal to the product of the previous G and the numerical
expression H for that value of J. This sounds complicated, but is not. The
expression H simply defines a recurrence relation between the coefficients
of the sum. For example, 21 terms of series for e^x are given by:

    DS(J,0,20,(x^J),(1/J))

The recurrence relation G(J)=G(J-1)*H(J) for the coefficients gives 1/J!
as coefficient G(J) of the J'th term. This is a better way of handling
the factorial, both from an economical and numerical point of view, than
writing 1/J!, that is 1/(DB(J)).

There is an important restriction. If more than one DS function occurs
in an expression one must use different names for the summation variable
(J in the above example). Thus use J1, J2, etc.

Example 8.

Digits 20
Ratio 0

Z xx = DS(J,0,20,(1.),(1/J))

*begin

Digits
Ratio

Z yy = DS(J,0,4,(X^J),(1/J))

*end


5. X, D AND T EXPRESSIONS.

So far only Z-expressions occurred in the examples. These expressions are to be
evaluated by Schoonschip. Other expressions may be defined and may be called
when they are needed. Such expressions are X and D expressions. One may have
up to 500 X expressions. As a simple example take the series for cos(x). The
equation for cos(x) is:

    cos(x) = { exp(i*x) + exp(-i*x) }/2

This series may be obtained as follows. First define exp(y) and then
write cos(x) in terms of this exponential (arbitrarily 6 terms are kept):

Example 9.

X EXP(y) = DS(J,0,6,(y^J),(1/J))

Z COS = { EXP{ (i*x) } + EXP{ -(i*x) } }/2

*end

Important rule: any X-expression must have been defined before it can be
referred to. It is permissible to have X-expressions appearing in an X-
expression provided that they were defined before.

The rules for arguments of X-expressions are the same as for functions,
which is why the argument i*x is enclosed in brackets. Here we see how
this is replaced in the right hand side of the EXP definition, so that
indeed this expression in brackets no more appears as function argument.
This method of defining COS may seem to be a waste, but in practice this
is used to define COS once and for all. It is namely possible to specify
an argument for the Z-expression, and to tell to Schoonschip not to throw
away this expression after printing it; then later on one may refer to
COS(x) as if it were also an X-expression. That will be discussed in the
section on files.

Arguments as appearing in the X-expression definition will often be called
dummies in the rest of this manual. They are to be replaced by the arguments
found in the call (in the Z-expression) at execution time. In other situations
some of the arguments may be dummies, others not, as we will see. In those
situations a dummy is to be followed by a wiggle: ~. In X and D expressions
and also in tables (T) all arguments are dummies and the wiggle needs not to
be given.

D-expressions are arrays of X-expressions. This may for example be used
to specify matrices. Everything is the same as for X-expressions, except
for the first argument. In calling a D-expression this argument must be a
number, and this number is then used to select the expression from the
array. Since the expressions in a X or D-expression may again be X or
D-expressions the possibilities are quite extensive. For example, let there
be a 3x3 matrix with the elements (a11,a12,a13),(a21,a22,a23),(a31,a32,a33)
in rows one, two and three. The first part of the following example produces
the determinant of that matrix:

Example 10.

B a11,a21,a31

D rc(n)=a11,a12,a13,
    a21,a22,a23,
    a31,a32,a33

X matrix(n,m)=rc(3*n+m-3)

Z xxx = DS{J1,1,3,(DS{J2,1,3,(DS{J3,1,3,
    { DP(J1,J2,J3)*matrix(J1,1)*matrix(J2,2)*matrix(J3,3) }
    } ) } ) }

*begin

As shown, an X or D-expression can have many arguments. In fact, X or
D-expressions may be arguments of X or D-expressions. Here one must follow an
important rule. To make it possible for Schoonschip to analyze the right hand
side of some expression correctly dummies must be of the same kind as later the
argument replacing the dummy is going to be. The same kind means generally
speaking one of the four cases: symbols with or without exponent, vectors
functions or Tables. Thus functions and expressions (and later files) are of
the same kind. Algebraic symbols must be used as standin for dotproducts,
vector-components and also for short numbers (less than 128 in magnitude, the
same kind that may appear as function argument). Functions may stand for X or
D-expressions, as shown also in the second part of this example. It is best to
play this for sure, and use as dummies really the same kind, i.e. X-expression
type for X-expressions or D-expressions, functions for functions etc. In the
example below the use of for instance  ra instead of  f1  in the definition of
the X-expression  matrix  is advised. Vector-components, dotproducts and
numbers are illegal as dummy. If they are to be substituted in an X-expression
use some algebraic symbol to represent them, as we did using n and m in these
examples.

In the second part of example 10 we define a general X-expression for
a determinant that may be called to compute the determinant of any matrix
occurring in a problem. Two determinants are computed.

F f1

B a11,a21,a31,b11,b21,b31

D ra(n)=a11,a12,a13,
    a21,a22,a23,
    a31,a32,a33

D rb(n)=b11,b12,b13,
    b21,b22,b23,
    b31,b32,b33

X matrix(n,m,f1)=f1(3*n+m-3)

X DET(f1) = DS{J1,1,3,(DS{J2,1,3,(DS{J3,1,3,
    { DP(J1,J2,J3)*matrix(J1,1,f1)*matrix(J2,2,f1)*matrix(J3,3,f1) }
    } ) } ) }

Z detb=DET(rb)

Z deta=DET(ra)

*begin

In the third part of this example it is shown how the X-expression DET
can be made into a D-expression giving determinants for 1x1, 2x2 and 3x3
matrices.

C Example 10.

F f1

B b11,b21,b31

D ra(n)=(a1-a2),0,
    0,(a1+a2)

D rb(n)=b11,b12,b13,
    b21,b22,b23,
    b31,b32,b33

D rc(n)=c11

X matrix(k,n,m,f1)=f1(k*n+m-k)

D DET(n,f1) =
   f1(1) ,
   DS{J1,1,2,(DS{J2,1,2,
     { DP(J1,J2)*matrix(n,J1,1,f1)*matrix(n,J2,2,f1) }
     } ) } ,
   DS{K1,1,3,(DS{K2,1,3,(DS{K3,1,3,
     { DP(K1,K2,K3)*matrix(n,K1,1,f1)*matrix(n,K2,2,f1)*matrix(n,K3,3,f1) }
    } ) } ) }

Z deta=DET(2,ra)

Z detb=DET(3,rb)

Z detc=DET(1,rc)

*end

Several remarks are in order. First, note how items in a D-expression array
must be enclosed in brackets if the expression contains more than one term.
The rule is that each entry must be one term only (an expression is a sum of
terms, each term is a product of factors). An expression enclosed in brackets
counts as one factor in a term. Secondly, there is the question of DS
arguments. For the first argument, the summation index, one must use different
variables for each DS function. Thus J1, J2 and J3 must not be used more than
once. This was mentioned before, and in this example it is relevant.

T-expressions or better Tables are for use as function arguments. There are
also 'character tables' to be discussed elsewhere. Tables represent an array of
quantities that may be selected as function argument and at execution time the
appropriate argument is selected on the basis of the value of the first
argument. The following example shows a complicated way of obtaining f(a) +
f(b) + f(c) :

Example 11.

T List(n)=a,b,c

F f

Z compl = DS(J,1,3,{ f(List(J)) } )

*begin

This is really the idea: to enable summing over a series of arguments that
can then be listed using a Table. The rules for entries in a Table are
simple: they must be valid function arguments. Tables can be nested,
allowing essentially matrices of arguments. The first argument of the
Table in the call selects an item from the corresponding Table list. If
that item is again a Table, then the second Table list is looked up with
the second argument determining which argument to take. And so on.
All arguments are treated as dummies, and Table entries may depend on
them. Since an expression enclosed in brackets may appear in the Table list
that allows for complicated constructions. If such expressions are essentially
numerical, and they must ultimately be converted to a short number the
oprator Integ must be placed in front of them. Also Conjg is allowed.

A x=c

T r1(n)=a11,a12,a13
T r2(n)=a21,a22,a23
T r3(n)=a31,a32,a33

T matr(n,m)=r1,r2,r3

T weird(n,a1,a2)=Conjg(a1+a2),Integ(3*a2)

X XX(a1,a2)=a2*a1

Z sqa13 = DS(J,1,3,{f1(matr(1,J))*f1(matr(J,3)} )

Z weirdo=XX(weird(1,x,7),weird(2,x,7))

*end

There is a subtlety here. Whatever follows Conjg, enclosed in brackets,
is considered an expression. It must not survive as function argument
beyond the * line. Thus if in weirdo we would have had f1 instead of
the X-expression XX then this would be illegal here.

General rule: anything that can occur as function argument can occur as
element in a Table list. This includes for example characters (notation: "X
is the character X). Be careful with numbers: they are treated like
function arguments, and non-integers are truncated.


6. FILES.

Files very much resemble X-expressions, but there is one important difference.
A file contains the result of some Schoonschip calculation. A Z-line defines a
file, with the name as given on that line. A file may have arguments, can be
stored in a variety of ways, and can be part of a problem just as any
X-expression.

Schoonschip has been made with the assumption that files tend to be large.
Elaborate measures have been taken to handle the largest files. The number
of files that can be handled at any one time is limited to about 200.

To begin with, files are divided in local and common files. All the
Z-expressions that have been shown sofar are local. Local files are normally
lost over a * line, except over a *yep. A local file may be kept over a * line
provided that the word  next  is on that line, and provided that the file was
mentioned in a Keep list:

Z xxx(a,b)=(a+b)^2

Keep xxx

*next

Z yyy=xxx(c,d)

*begin

After a *begin the local files are all lost. Schoonschip treats local files
as efficiently as possible. They are kept in memory if there is room, if
they are too big they are stored on disk and recalled if needed.

Common files are kept untill explicitly deleted or till the *end line. They can
be written to disk for use in a later session. Schoonschip keeps all common
files in a sequential file on disk. Great care has been taken that such
expressions, when needed in a problem, are read with the least amount of
input/output activity. The user will normally see nothing of these read/ write
activities, but should still be aware of it when handling large problems.

Computer handled problems have the tendency to become large, that is simply in
the nature of the subject. Except for the simplest cases it is really quite
impossible for a computer to simplify an expression. While it is trivial to
simplify a^2+2*a*b+b^2 to (a+b)^2, it becomes an entirely different matter when
dealing with 1000 or more terms. Of course, with a little help from the user,
simplification can be done, on a rather primitive level. If one recognizes a
pattern such as shown above one substitutes a^2=apb^2-b^2-2*a*b, and the output
collapses to apb^2.

In addition to the classification local and common, files may be indexed
or non-indexed. This makes it possible to have arrays of files, much like
D-expressions. The way a file is defined to be indexed is as follows:

- A local file is defined to be indexed if on the defining Z-line the
  first argument of that file is a number in the range 0-32767. There are
  provisions for situations where this number is an expression, involving
  for instance DO-loop or BLOCK variables, but at execution time such
  expressions must work out to a number. Only numbers and DO-loop or
  block variables may appear in these expressions, and for these latter
  variables numbers must be substituted.

- A common file is defined to be indexed if it appears in the Common
  list with a subscript, preferably the number 0. The implication of
  that is not the existence of the file with the particular index zero,
  but rather that this filename represents a class of subscripted files.

Thus:

Common abc,Xyz,fgh(0),jkl

defines abc, Xyz, fgh and jkl to be common files, and fgh is an indexed
files. When in a subsequent Z-line such a filename occurs it is recognized
and at the end of the calculation the file is written to disk.

For local files the command Keep is of interest:

Keep aaa,bbb,ccc(1),eee

This line, which should occur shortly before a *next line, leads to keeping
of the files mentioned over the *next. For an indexed file one may either
explicitly mention an index (such as for ccc here) and then only that file
is kept. If there are several ccc files to be kept it is sufficient to
mention ccc without any index and then all ccc files are kept.

There are several other commands that relate to files. First, common files
may be written to a named disk file for use in a later problem. This may
be done with the command

Write xxx

All common files that exist at that moment are written (sequentially) to
a file named xxx. Thus xxx will in general contain many files. This
statement must be all by itself, and not be embedded in some problem.
In other words, before and after this Write line there must be a * line
not containing yep or next.

When one or more of the common files contained in xxx are needed one
may enter these files:

Enter xxx

This statement should preferably be the first statement of a Schoonschip
program. It must be before a *fix line, explained below. Schoonschip opens
the file xxx and enters all names in the common file table, and the files
themselves are copied to a diskfile local to Schoonschip (tape7). One may
have several Enter and Write statements. Note: do not confuse Enter and Read.
The latter is for reading normal Schoonschip text from some external file.

Common files may be deleted:

Delete abc,Xyz,fgh(3)

Again, the mentioning of fgh without any index leads to deletion of all
fgh files.

As the reader may guess it is quite a problem to keep all namelists straight
when common files are entered. Normally Schoonschip treats this problem only
when encountering such files in a given problem. Usually that will give no
problems, but difficulties may arise in connection with summation indices (see
Sum declaration). For this reason it may be necessary to enter the names
contained in that file before actually starting on the problem. The statement

Names abc,Xyz,...

is meant for this purpose. If this directive is not given, and Schoonschip
runs into problems then an error exit is taken, asking for the Names line.

Example 12 shows some very simple case. Note that the local file xxx
is lost over the *begin line, and xxx is taken to be a function. Similarly
for common file ccc after a delete. When this problem is run the file
fileC is created. Make sure that there is not already some file by that
name.

Example 12.

P lists

Common yyy,ccc(0)

Z xxx(a,b)=(a+b)^2
Z ccc(3,a,b)=(a+b)^3
Z ccc(4,a,b)=(a+b)^4

Keep xxx

*next

F f1,f2
V p

Z yyy(p)=xxx(c,d) + p(nu)*f2(mu)

Sum mu,nu

*begin
Write fileC
*begin

V q

Z zzz=a1*yyy(q)

Z Abc=xxx(a,b)

Delete ccc,yyy        !The actual delete occurs when this section is done.

*begin

Z xyz=ccc(3,e,f)

*end

The statement  P lists  at the beginning causes Schoonschip to print all
symbols known before execution. Also details such as reality properties or
dimensionality of indices is shown. For X, D, T expressions the type as well as
the nesting depth is shown. Also brackets count in this respect.

At this point it must once more be emphasized to be conscious of the use of
local and especially common files in a problem. If for example yyy is a rather
lengthy common file then things such as (yyy)^4 may lead to very lengthy
calculations. If yyy has 100 terms this gives rise to (100)^4 terms, i.e. 100
million terms that must be sorted. This will fill up all available disk-space,
to name something. And 100 terms is really not that much as these things go.
Just to avoid this kind of disaster Schoonschip has an output limit build in of
about 0.5 Megabyte per file used by Schoonschip. This limit may be changed by
means of the statement

Outlimit,#

where # is the new limit in bytes. What to do if really big expressions
must be evaluated will be discussed later. In this context an expression
is called big when it exceeds 50,000 terms.

7. PRINT OPTIONS.

The following directives influence output. Only the first two characters
of the word following P are releveant.

P brackets    print working out of brackets
P heads        print in the output only the factors outside brackets (B-line)
P input        print input lines (default)
P lists        print lists of all symbols (vectors, functions etc.)
P ninput    do not print input lines
P nlists    do not print lists (default)
P noutput    print no output (default in *yep cases)
P nstats    print no statistics (default)
P output    print output (default, except in case of *yep)
P stats        print statistics

In addition the following directives affect output format:

Screen        try to keep lines less than 80 characters long (default)
Lprinter    go up to 130 characters/line

Printing of the individual files may be affected as well, but only if they
are currently being processed:

Print xxx,yyy,...    print files xxx,yyy,...
Nprint xxx,yyy,...    do not print xxx,yyy,...
Punch xxx,yyy,...    write xxx,yyy,... to a file named tape8 in fortran
            compatible form.

This last directive is useful if the output is to be used for further
numerical output in a fortran program, or for curve plotting etc.
Normally print options stay in effect untill cancelled. Exception: P heads.
The P output option, often used to force output printing in a *yep situation,
survives only one *yep.

8. END LINE OPTIONS.

For the * line the following possibilities exist:

*fix        Do not start execution. All names and expressions defined
        before this statement remain valid till the *end line.
*yep        Start execution. Write the output to disk and feed in again
        as input.
*next        Start execution. Keep all namelists, and those local files
        mentioned in Keep lists. A Keep list extends over one
        *next only.
*begin        Start execution. After this start new problem. Disregard
        all names except those mentioned in the *fix section.
*end        Start execution. Stop after completion.

Not explained so far is the *fix option. This is used whenever names or
X, D or T expressions are to be defined that are valid for all following
problems, including those after a *begin. This *fix section must be the
very first section, and must not contain any Z expressions. If common
files are to be entered it must be in this section.

The sequence shown above reflects the general structure of any Schoonschip
program. First there is a *fix section, and then there may be several *yep,
*next and *begin lines before the final *end is encountered.

The *yep command is extremely useful, but can only be explained properly
later, after discussing substitutions. It is rather unique to Schoonschip,
and of crucial importance when dealing with large problems.

9. SUBSTITUTIONS.

Most things discussed up to now essentially help to define expressions, but do
not really work on those expressions. The main tools for work on expressions
are what will be called substitutions and commands. A substitution basically
amounts to looking at an expression term-by-term, and if certain patterns match
something may be removed from the term, and something else substituted. This
basic tool, for the first time introduced in the 1964 Schoonschip version, is
the essential ingredient of symbol manipulation.

Thus in the first place there is pattern recognition, and secondly there
is a substitution. In this version (1984+), optionally, these two aspects can
be separated. One can first look for a pattern, set some flag indicating the
result of the inspection, and then at a later stage act on that flag.

Commands define certain operations to be done on the terms, and that are of
sufficient generality to warrant building in. For instance, there is a command
that allows the user to specify which functions are commuting with each other.
Schoonschip acts on that by setting these functions in an internally well
defined order, so that terms differing only by functions being placed in
different order become equal. Such an operation can also be done with
substitutions, but is more tedious.

An important concept in substitutions is the use of dummies. These quantities
have already been introduced before in connection with X, D and T expressions,
and here they become even more useful. Let us start with a simple example.
Imagine that some polynomial in x must be integrated, and let this polynomial
be quadratic:

    a*x^2 + b*x

to be integrated from x1 to x2. This integration amounts to using the rule x^n
=> x^(n+1)/(n+1), and then putting the integration limits. This may be done as
a substitution. First look for x to any power (this is the pattern). Then
remove x and substitute by the appropriate expression which is the integral of
that x. The following example shows how this can be done:

Example 13.

Z integr = a*x^2 +b*x

Id,x^n~ = x2^(n+1)/(n+1) - x1^(n+1)/(n+1)

*begin

Schoonschip looks for the pattern "x to any power", and if found removes
that x and instead substitutes the right hand side of this substitution. The
value of the power found is substituted for n in that expression. Here n
is a dummy. To let Schoonschip know that it is a dummy the wiggle ~ must
follow directly behind it.

The notation Id refers to a name used often in the past for this operation,
namely "identity".

The matter to be discussed now is what kind of patterns can be specified.
As an example of the sort of complication that can arise take this integral
again. Suppose there had been a term without any x. What should Schoonschip
do? In this case that should be treated as x^0, but in many other cases such
terms must not be worked on. In the spirit of pattern recognition a term
without x is taken not to fit the pattern specified here, and such a term is
thus not worked on.

But how now to go about that? A classic way to do that is to use an extra
symbol, that we will call dx here:

Z integr = (a*x^2 + b*x + c)*dx

Id,x^n~*dx = x2^(n+1)/(n+1) - x1^(n+1)/(n+1)

Al,dx = x2 - x1

*end

What happens is that if dx and as well x to any power excluding zero is
encountered then the first substitution is done. This leads also to the
removal of dx. If a term without any x (the c term) passes by the first
substitution is not done, and the dx survives. But then the second
substitution is performed. The notation Al is an abbreviation of "also",
but there is more to it, which will be explained below. Generally, Al can
be used with advantage for mutually exclusive patterns. One can not use
Al in case that the first substitution generates a pattern that the second
may have to act on. Since there is a limit on the number of Id statements
it is often necessary to use Al, and its use should be well understood.

There is an equivalent notation to Al, namely placing that substitution on the
same line preceeded by a semicolon (;):

Id,x^n~*dx = x2^(n+1)/(n+1) - x1^(n+1)/(n+1)        ;dx = x2 - x1

There may be several such 'also' statements on one line, but lines should
not exceed 150 characters.

This example shows really most that there is to it. Of course, more complicated
patterns than just an algebraic symbol to some power can be specified, but that
is really just an extension of the same principle. There are substitutions that
are performed if certain functions with certain arguments are present, and one
may specify if the order of these functions is important or not; one may
operate on function arguments, on vectors in a dotproduct etc. Basically,
through the years, things that may be needed have been implemented. As it
happens most of these are quite natural, barely needing a manual, such as the
one above. Let us give another example, to show a number of applications. In
the above integral more complicated things could have occurred, for instance
terms such as x^3*cos(x). To evaluate these one must first do partial
integrations:

   x^3*cos(x) = x^3 * d/dx{sin(x)} = d/dx{x^3*sin(x)} - 3*x^2*sin(x)

Thus, before doing the x-integration one must first do these partial integra-
tions, and that as many times as needed given the highest power of x that
occurs. Assuming that at most x^10 occurs one would write:

Id,10,x^n~*cos(x) = x2^n*sin(x2) - x1^n*sin(x1) - n*x^(n-1)*sin(x)
Al,10,x^n~*sin(x) = - x2^n*cos(x2) + x1^n*cos(x1) + n*x^(n-1)*cos(x)

There are more elegant ways to do this, using X-expressions, but that
is not the point here. That general method is shown anyway, as last part
of Example 13.

The above implies doing these substitutions on ten subsequent Levels, and
substitution will be done as long as x to some power occurs. The final
step, to be taken if no more x present would be the integration of cos(x)
or sin(x):

Id,sin(x) = cos(x2) - cos(x1)        ;cos(x) = - sin(x2) + sin(x1)

If also x to negative powers would occur one would have to treat that
separately. This is where the conditional substitutions comes in handy.
One may test for the presence of negative exponents, and set a flag
depending on the outcome of such a test:

IF Multi,x^-1

This tests for exponents that are a multiple of the exponent shown, here
-1. If so a flag is set. Subsequent substitutions will be done if that
flag is set until an ELSE is encountered. The then following substitutions
will be done if the flag was not set. An ENDIF statement terminates the
conditional substitutions. The typical sequence would be here:

IF Multi,x^-1
 Substitutions to treat x^-n type terms.
ELSE
 Substitutions to treat x^+n type terms.
ENDIF

A NOT following the IF is recognized, and the following sequence gives
identical results:

IF NOT Multi,x^-1
 Substitutions to treat x^+n type terms.
ELSE
 Substitutions to treat x^-n type terms.
ENDIF

IF's may be nested, up to 8 deep.

A futher extension uses AND and OR statements, possibly combined with NOT.
For example, if there are also terms without sin or cos:

IF cos(x)
OR sin(x)
..IF Multi,x^-1
..Substitutions to treat x^-n type terms.
..ELSE
..Substitutions to treat x^+n type terms.
..ENDIF
ELSE
Substitutions to deal with x^n without sin or cos.
ENDIF

A new notation, purely for readability, has been introduced. A . in column
one causes Schoonschip to skip all following periods. In this way one may
indent the nested IF's to show IF depth. See the section on conditional
substitutions for more details.

A few patterns as can appear in the left hand side of a substitution have been
introduced above. The need for those patterns are clear, once one starts on
this kind of problem. Along these same lines a set of patterns has been defined
that appears to be adequate to deal with things as they arise in practice. It
is somewhat difficult to give a complete description, but it has to be done.
Let us do this in two rounds, namely first somewhat sloppy, and then precise.

As long as one deals with a single quantity (including exponent or index or
arguments) one has various options specified by keywords. One such keyword
appeared already above, namely Multi. For algebraic symbols the following
substitution patterns are possible:

Id,a=...        Substitute n times if a^n encountered, n positive.
Id,a^n=...        Substitute once if precisely a^n encountered.
Id,a^n~=...        Substitute once for a, any non-zero exponent
Id,Multi,a^n=...    Substitute m/n times if a^m encountered, and m has
            the same sign as n; leave rest.
Id,Once,a^n=...        Substitute once if a^m encountered, m/n ge 1;
            leave rest.
Id,Funct,a=....        Substitute for a if appearing as function argument.
            The action taken is to enclose the expression
            on the right hand side in brackets and place it
            instead of the argument a. Remarks concerning
            expressions in brackets as function arguments
            apply here. Such functions may not cross * lines
            and must be subject to some substitution before that.
Id,Funct,f1,f2,...,a=...
            Same, but only in the specific functions mentioned

Thus Id,Once,a^2=... when encountering a^7 leads to one substitution, and
a^5 is left.

Of course, Al (or ; and on the same line) may occur instead of Id.
In the above n is a number, except in the third case where it is a dummy.

Similar things may be written down for dotproducts or vector-components.
For single functions one may specify the function including the arguments,
but some or all may be dummies, and one may also have repetitive dummies.
For example:

Id,f1(a~,b,c,a~)=...

leads to a substitution if the function f1 is encountered with as second
and third argument b and c, while any argument on the first or fourth
place will do provided they are the same. Here a is a repetitive dummy.
One could have specified another dummy for the last place:

Id,f1(a~,b,c,d~)=...

and then the substitution is done for any argument on the first or fourth
place, including equal arguments.

The build-function D is special insofar that it is generally not allowed
as part of a substitution pattern. It may however appear all by itself
with or without dummies. Examples:

Id,D(al,be) = ....
Id,D(al~,be) = ...

For single functions one keyword may appear. If a function has nothing but
dummies as arguments, and if the keyword Always appears, then the substitution
will be done even if the argument count is not the same. Thus

Id,Always,f1(a~,b~)=...

is applied also when encountering f1(xx,yy,zz). The argument zz is then
simply dropped. Make sure that the case that there are more dummies than
arguments can not occur.

Finally one may even specify a dummy function:

Id,f1~(a,b,c~,...)=...

The substitution is done for any function whose arguments and argument count
agree.

For vectors a number of different possibilities exist:

Id,p(mu)=...        Substitute for p(mu).
Id,p(mu~)=...        Substitute for p with any index.
Id,Dotpr,p(mu~)=...    Substitute for p if appearing in dotproduct or as
            vector-component.
Id,Dotpr,f1,f2,..,p(mu~)=...
            Same, but only in the specific functions mentioned.

Id,Funct,p(mu~)=...    Substitute if p appears as function argument.
Id,Funct,f1,f2,..,p(mu~)=...
            Same, but only in the specific functions mentioned.

In the last cases things are done as expected for vectors. In all but the first
case it is assumed that the right hand side depends on the index mu. For
example, typically, one could have Id,Dotpr,p(mu~)=k(mu)+q(mu) . Suppose now
pDq is encountered. Schoonschip reads this as p(q), and substitutes q for the
index mu, which leads to kDq+qDq, as should be. If pDp is seen then Schoonschip
invents an index, say Naa, substitutes this index for mu and writes:

    { k(Naa) + q(Naa) } * { k(Naa) + q(Naa) }

A similar thing is done if p is encountered as function argument in case of
the Funct type substitutions:

 f1(...,p,...)    becomes    f1(...,Naa,...)*{ k(Naa) + q(Naa) }

which leads to f1(...,k,...) + f1(...,q,...). Thus linearity of f1 in p is
supposed here. This substitution should therefore not be applied if that is
not the case.

For any other pattern involving more than one quantity substitutions are
straightforward. The only extra options that one has here is that the
ordering of functions may be specified. The keyword Adiso (allow disorder)
indicates that substitution must be done no matter the ordering of the
functions. The keyword Ainbe (allow inbetween) implies that the substitution
must be done if the functions are in the same order, even if there are some
other functions inbetween. If none of these keywords is present then the
substitution is done only if exactly the same pattern is found. The pattern
may involve dummies for exponents, vectors, indices, functions and function
arguments, and one may have repetitive dummies.

As a special option one may also have factors xx^0 where xx is an algebraic
symbol, vector-component or dot-product. Schoonschip requires in that case that
specifically xx is not there.

++++++++
We stress here that for dummies one must (repeat: must) use the same kind
of symbol as that what replaces it at execution time. See the discussion
on this subject in the section on X-expressions.
++++++++

Forty substitution Levels are available. If more Levels are needed a line with
*yep must be inserted. The Level count is printed by Schoonschip next to
every substitution. More levels are needed for a given substitution as the
bracket depth is larger. It is often advantegeous not to use brackets if
not strictly necessary. For example, it is better to write

Id,x^n~ = x2^(n+1)/(n+1) - x1^(n+1)/(n+1)

which needs two levels rather then

Id,x^n~ = (x2^(n+1) - x1^(n+1)) /(n+1)

which needs three levels. Schoonschip generates a substitution for every
bracket pair. If you want to see what Schoonschip does use the option
P brackets.


10. PATTERNS.

In this section a more precise discussion of the substitution patterns is
given. For a first reading this section may be skipped, it is really there only
for reference, in case something special is going on.

The way things are organized in Schoonschip there is a classification
in about 17 classes. In practice one will rarely realize what class a
given pattern belongs to, but for completeness we will discuss possible
patterns on the basis of this classification. We will also indicate what
action is taken once the pattern is found to be present, although that
may be influenced, postponed or even inhibited by means of conditional flags.

The classification is on the basis of what occurs on the left hand side
of the = sign on an Id or Al line. Only products of factors may occur (thus
no + or - sign except in exponents or function arguments), and no brackets
other than associated with a function and its arguments or a vector and its
index. Thus something like a+b or a*(c+d) is illegal. Furthermore, a keyword
may be given, and that influences the way Schoonschip reacts to a pattern.
Finally one will encounter the word repetitive dummy. That is when the same
dummy appears two or more times in the left hand side of a substitution. In
that case Schoonschip verifies that in the pattern the same thing appears in
both places, although the thing itself may be anything.

Here are the various classes, examples will be given later. Below a,b,..
stand for algebraic symbols, n,m,.. for short numbers, p,q,.. for vectors,
f1,f2,.. for functions etc.

 0.    f1(a~,b~,...)        Function, all arguments non-rep. dummies.

    Optional Keyword: Always

    Action: substitute for every such function found provided the
    number of arguments agrees.
    If the keyword  Always  is given then substitute irrespective of
    the number of arguments in the function found. It is up to the
    user to see to it that the number of arguments equals or exceeds
    the number of arguments actually appearing in the right hand side
    of the substitution.

 1.    a^n            Symbol with exponent, no dummy.
    Keyword: Multi
    Action: when encountering a^m divide m by n, and if the result,
    truncated to an integer, comes out to be 1 or more, substitute
        that many times. The remaining exponent is put back. Thus a^2 applied
    to a^7 leads to 3 substitutions and one factor a is left.
    The exponent may be negative: a^-2 applied to a^-7 leads to 3
    substitutions and a remainder a^-1. If n and m have opposite sign
    no substitution is done.

    If the exponent n is absent the keyword Multi is understood, and
    an exponent 1 used.

 2.    pDq^n            Dotproduct with exponent, no dummy.
    Keyword: Multi
    Action: same as in class 1.

 3.    a^n            Symbol with exponent, no dummy.
    Action: substitute once if exactly a^n found.

 4.    pDq^n            Dotproduct with exponent, no dummy.
    Action: see class 3.

 5.    p(mu)            Vector with index, no dummy.
    Action: substitute once if p(mu) found.

 6.    p(mu~)            Vector with dummy index.
    Action: substitute for every p(..) for any index. The substitution
    applies not if the vector p appears as factor in a dot-product
    or as function argument, and also not to vector components such
    as p(3) (i.e. if the index is a number).

 7.    a or mu or pDq or p(n)    Symbol (index, dotproduct, vector component)
    Keyword: Funct
    Action: replace a (or mu etc) when occurring as function argument.
    Note: such functions must be substituted for before the * line,
    because an expression as function argument can not survive a *.
    If functions are mentioned between the keyword and the argument
    then only those functions will be considered.

 8.    a^n or pDq^n        Symbol or dotproduct with exponent.
    Keyword: Once
    Action: substitute once if a^m encountered if m/n positive and
    equal or larger than one. Keep the remainder. Thus a^2 when
    encountering a^7 leads to one substitution and a^5 remains.

 9.    a^n*...f1(mu,b,..)    One function and anything else.

10.    f1(mu,a,b~,..)        One function.

11.    Anything
    Keyword: Adiso
    Action: substitute if all factors found even if the functions
    found are not in the same order as in the left hand side of the
    substitution. Note: Adiso stands for Allow disorder.

    Note: the expression is put at the location of the first function
    removed.

12.    Anything
    Keyword: Ainbe
    Action: substitute if all factors found, with the functions in
    the same order, although there may be other functions inbetween.
    Note: Ainbe stands for Allow inbetween.
    Note: the expression is put at the location of the first function
    removed.

13.    Anything
    Action: substitute if all factors found, with the functions in
    the same order and no other functions inbetween.
    Note: the expression is put at the location of the first function
    removed.

14.    Not used.

15.    p(mu~)            Vector with dummy index.
    Keyword: Dotpr
    Action: substitute for p if p part of a dotproduct appearing with
    a positive exponent.

16.    p(mu~)            Vector with dummy index.
    Keyword: Funct
    Action: substitute if the vector p is found as function argument.
    If one or more function names are mentioned between the keyword and
    p(mu~) then the substitution will be done only in the specific
    function(s) mentioned.

All of this may sound a lot more complicated than it is, all these classes
are really such that they cover most cases that one can imagine. The user
needs not to know to which class a given substitution belongs, and most
substitutions are natural in the sense that it is obvious what action is
to be taken.

We will now give examples, essentially going through all possibilities.
The same starting expression will be used in all cases, and we will use
a *fix section to specify that expression. Then many cases follow, all
separated by a *begin implying a fresh start.

Example 14.

V p,q
A a,b,c,d,e,f,g,h
I mu,nu
F f1,f2,f3

X expr=f1(a,b,p)*f2(a,c,q)*f3(d,e)*f1(g,h)*
    { a^7 + a^-7 + a^2 + pDq^2 + pDp + p(mu) + p(nu) }

*fix

C Class 0, no keyword.

Z xxx=expr

Id,f1(a1~,a2~)=a1^10*a2^20

*begin

C Class 0, keyword Always.

Z xxx=expr

Id,Always,f1(a1~,a2~)=a1^10*a2^20

*begin

C Class 1, keyword Multi.

Z xxx=expr

Id,Multi,a^3 = xyz + hij

*begin

C Class 2, exponent 1, no keyword.

Z xxx=expr

Id,pDq = XYZ + HIJ

*begin

C Class 3, no keyword.

Z xxx=expr

Id,a^2 = a1^7/15

*begin

C Class 5.

Z xxx=expr

Id,p(mu) = - q(mu)

*begin

C Class 6.

Z xxx=expr

Id,p(mu~) = - q(mu)

*begin

C Class 7, keyword Funct.

Z xxx=expr

Id,Funct,a = a27

Id,f1(a1~,a2~,a3~) = 200*a1*a2*a3
Al,f2(a1~,a2~,a3~) = a1^10*a2^11*a3^12

*begin

C Class 8, keyword Once.

Z xxx=expr

Id,Once,a^2 = XXX

*begin

C Class 9.

Z xxx=expr

Id,a^2*f2(a1~,c,p~) = F2(a1,c,p)

*begin

C Class 10.

Z xxx=expr

Id,f1~(a,b~,p~) = F(a,b,p)

*begin

C Class 11, keyword Adiso.

Z xxx = expr

Id,Adiso,f1(g,h)*f1(a~,b~,c~) = F1(a,b,c,g,h)

*begin

C Class 12, keyword Ainbe.

Z xxx=expr

Id,Ainbe,f1(g,h)*f1(a~,b~,c~) = F1(a,b,c,g,h)
Id,Ainbe,f1(a~,b~,c~)*f1(g,h) = F2(a,b,c,g,h)

*begin

C Class 13.

Z xxx=expr

Id,f1(x~,b,p)*f2(x~,c,q) = F(x,b,p,c,q)

*begin

C Class 15, keyword Dotpr.

Z xxx=expr

Id,Dotpr,p(mu~) = - q(mu)

*begin

C Class 16, keyword Funct.

Z xxx=expr

Id,Funct,p(mu~) = - F1(a,b,mu)

*end

11. CONDITIONAL SUBSTITUTIONS.

In the foregoing IF, AND, OR and ELSE have been introduced already.
The general structure is:

IF pattern
 Substitutions
ELSE
 Substitutions
ENDIF

There may be no ELSE. The IF statement may be followed by AND and/or OR
statements. IF, AND or OR may be followed by NOT which inverts the action.
Finally, the pattern may optionally be followed by an = symbol and an
expression. In such a case the substitution is actually done if the
pattern fits. The pattern may be any of the classes discussed in the previous
section.

Inside Schoonschip IF's etc set or clear some bit. One bit is reserved
for any given IF depth. Nesting up to eight deep is allowed, there are eight
bits provided. Here are the rules for bit setting:

A succesful IF (or unsuccesful IF NOT) leads to setting of the bit. An AND (or
AND NOT) statement will be inspected only if the bit is set. If succesful (or
not succesful if AND NOT) the bit remains, else it is cleared. An OR (or OR
NOT) statement will be inspected if the bit is not set. If succesful (or not
succesful if OR NOT) it sets the bit. The substitutions or commands following
such a sequence will be inspected if the bit is set. After an ELSE the
substitutions or commands will be inspected if the bit is cleared.

Do not put any substitutions or commands inbetween the IF, AND or OR
statements if there is an ELSE. The reason is that substitutions and commands
following an ELSE are on the same level as those following the preceeding IF,
AND, OR group. The ELSE becomes ambiguous in such a case. Also, no AND or OR
after an ELSE, which is also ambiguous.

The fact that an expression may be given on the IF, AND, OR lines allows very
compact code. For example, to integrate any polynomium in x (see Example 15):

IF NOT x^-1 = [Log(x)]
AND NOT x^n~ = x^(n+1)/(n+1)
Al,Addfa,x
ENDIF

The command Addfa attaches the factor given, here x. That command will be
executed only if none of the two previous substitutions applied. Note the
use of Al (rather than Id) for the Addfa statement. This may be done because
this statement is not using anything that might be produced by the previous
IF and AND statements.

Note the symbol (we stress, the symbol) [Log(x)].

Here some comments about level assignments. Schoonschip assigns all IF, AND and
OR statements to the same substitution level. IF is as Id, OR and AND as the Al
type assignement. A later ELSE is assigned to the same level as the associated
IF. The first substitution following an IF, AND, OR sequence may have Id or Al;
the level assigned is as usual. If none of the IF etc substitutions actually
perform substitutions then one should use Al. However, if that substitution
needs the completion of the previous IF etc substitutions then Id should be
used. The same holds after an ELSE, where Id must be used for the first
substitution following that ELSE if that substitution needs the completion of
the IF etc substitutions. Note that these latter substitutions may be way up.

If an AND or OR substitution depends on the result of previous IF etc
substitutions then it should not have an Al type assignment as Schoonschip
would use. To force level alignment for such a case simple put a line with Id
before the AND or OR statement, like

IF a1=2*(a1+a2)
Id
AND a1=(a4+a5)

Example:

L 1    IF a3=2*(a1+a2)
L 1    AND a7=5*a1*(a7+a8)
L 3    Id,a1=0
L 4    Id,Count,x,a1,1
    :
L 1    ELSE
L 3    Id,a1=3
    ENDIF
L 5    Id,...

The last level shown (L 5) is the maximum of (level when reaching ELSE, level
when reaching ENDIF). Compare with Al use:

L 1    IF a3=2*(a1+a2)
L 1    AND a7=5*a1*(a7+a8)
L 1    Al,a1=0
L 3    Id,Count,x,a1,1
    :
L 1    ELSE
L 1    Al,a1=3
    ENDIF
L 4    Id,...


12. COMMANDS.

Sometimes certain operations are difficult or impossible to do with
substitutions, and a number of facilities have been build in that deal with
specific situations. They are generally called commands, and they perform
actions at the Level that they have been placed. They generally need at
least one level, and sometimes the number of levels to be used influences
the performance. The general syntax of a command is:

Id,Keyword,parameters separated by commas

in which case Schoonschip uses a number of levels depending on the command.
Alternatively, with # some number < 40:

Id,#,Keyword,parameters separated by commas

in which case Schoonschip sets aside # levels for this command. There is
one command for which this is quite relevant, namely Gammas.

Now to more specifics. Suppose that some function is symmetric in its
arguments, say f1(a,b,c)=f1(b,a,c)=... In such a case one would like the
arguments to be arranged always in the same order. The command

Id,Symme,f1

causes Schoonschip to inspect every function f1 that passes by at this Level,
and arguments are re-arrangered in a well defined way (first defined symbols
first). This is of course much easier than the perhaps very long set of
substitutions that would do the same thing. One would have to know beforehand
what arguments could appear, and then go through all combinations.

For commands the first four, if no confusion possible the first three
characters are relevant. The may be in upper or lower case. The following
commands are available:

Absol        Make the sign of the numerical coefficient plus
Addfa        Add factor
Anti        Inspects functions for characters with an _
Asymm        Function anti-symmetric under interchange of arguments
All        Rounds up all appearances of a vector, or appearances of
        all vectors in a specified function.
Beep        Sent Control-G to the terminal (which normally beeps at that)
Coef        Inspect numerical coefficient
Commu        Re-arrange commuting functions
Compo        Compose names from characters
Count        Count certain occurrences
Cyclic        Function invariant under cyclic permutation of arguments
Dostop        Clears, sets or tests the forced DO-loop exit flag.
Epfred        Reduce products of Epf functions
Even        Function even in sign of arguments
Expand        Expand frozen files
Extern        Call user defined subroutine
Gammas        Throw the book at Gamma matrices
Iall        Inverse of All
Numer        Insert numerical values
Ndotpr        Construct anomalous dot-products (for use with Gammas)
Odd        Function odd in sign of arguments
Order        Order functions as based on the first two arguments
Print        Prints message
Ratio        Rationalize
Spin        Sum over spins of spinor functions Ug, Ubg
Stats        Counts how often this command is called
Symme        Function symmetric under interchange of arguments

We will discuss them one by one. First the general format is shown, and
then some example is given. Commands may also occur in IF etc statements,
but often it is not well defined what means succes or failure. As a rule
succes is defined as 'some action has been taken'. For example, Addfa
will always give succes.

Ordering inside Schoonschip is always done on the basis of 'smallest first',
not only for the purposes of the commands of this section, but also for output
printing of the quantitities not mentioned in the B-list. This means the
following ordering for quantities of different kind:

 Index, Vector, Function, Algebraic symbol, Characters,
 Number (short numbers), Vector-component, Dot-product.

For quantities of the same kind the ordering is according to the moment at
which the quantity was encountered first. For dot-products the earliest
defined vector counts first. To guarantee a certain ordering the quantities
can be given in the appropriate list in the desired order.

With respect to numbers the counting is not entirely as one might expect:
0 before positive numbers up to 127, then 128=-128, -127, -126,..., -1.
This is because of the two's complement notation for numbers.

***    Id,Absol

The coefficient of the term inspected is forced positive. This command
needs no levels.

***    Id,Addfa,expression

The expression specified is attached as a factor. This command is mainly
intended for use with conditional statements; the expression can be attached
depending on previous actions. There are no particular limitations
on the sort of expression that can occur here; anything allowed in a Z
expression or in the right hand side of a substitution is allowed here,
although here no dummies can be specified.

Example 15.

Integration of polynomium.

A a,b,c,d,e,x

Z xxx = a*x^2 + b*x + c + d/x + e/x^2

IF NOT x^-1=[Log(x)]
AND NOT x^n~=x^(n+1)/(n+1)
Id,Addfa,x
ENDIF

*end

The command All (and the associated Iall) has two different syntaxes. In the
first syntax the first argument is a vector (must have been defined before):

***    Id,All,p,N,F

Optionally this list may be followed by the character arguments "F_, "D_
or "V_ (always separated by commas), and possibly an index list, see below.

For the second syntax the first argument is a function (must have been defined
before):

***    Id,All,Fx,N,F

The parameters p,N and F must have been defined previously as vector,
algebraic symbol (it must be a one character symbol) and function.
The parameter N may be absent.

First syntax:
All occurrences of the vector p are considered. If any qualifying p
found the function F is appended. Next this function obtains arguments
reflecting the p found:

- If p(mu) with mu any index is seen this p is removed and the argument
  mu is added to the argument list of F.
- If pDq with any q and a positive exponent (say pDq^n) then the argument
  q is added n times.
- If pDp with a positive power (say n) is seen then a new index is created.
  This index is added 2*n times.
- If p is seen as argument of any function then an index is created. This
  created index replaces p as function argument, and furthermore the index
  is added to the arguments of F.

In the above work, whenever an index is created, it is given the symbolic
dimension N, or the default dimension (=4) if no N specified.
The main use of this command is to facilitate integration with the vector
p as integration variable.

Optionally character arguments may be specified after the list shown above.
The allowed characters are:
 "F_ "D_ "V_
If "F_ seen no function arguments will be inspected. "D_ inhibits dot-product
inspection, "V_ single vectors. Example:

Id,All,p,N,F,"F_,"V_

Only dot-products are considered.

Second syntax:
All arguments of the funtion Fx are considered. If a given argument is
a vector then that vector is replaced by a created index. The function
Fq obtains two new arguments, namely the vector and the created index.
In the final result the arguments of Fq are: first all vectors, then the
corresponding indices. For example, All,Fx,N,Fq applied to Fx(p,k,q)
gives Fx(Naa,Nab,Nac)*Fq(p,k,q,Naa,Nab,Nac).

It is clear that the All command will in general give rise to created
indices. Such indices are often renamed by Schoonschip, in order to
achive a well defined result in the output. This renaming may sometimes
be undesirable, in particular there may be undesirable consequences
when later a Freeze command is issued; the Freeze command may offer
trouble if a created index appears in a pair, one outside and one
inside the brackets. To handle such cases one may assign to the All
command a list of indices after the last function (and the possible
V_ etc). These indices must be defined in the I list, with the same
dimension as that specified in the All command, and they will be
used rather then newly created indices. Example:

I al1=N,al2=N,al3=N
 :
 :
Id,All,p,N,Fx,D_,al1,al2,al3

It may be that more indices are needed then provided in the list. There
are two options here. If the command is as above, and if the list is
exhausted then Schoonschip will issue an error message. If the list is
terminated with the character C:

Id,All,p,N,Fx,D_,al1,al2,al3,"C

then Schoonschip will, after using up al1-al3, create further indices
as needed.

C Example 16.

V p,q
F F
I mu=N,nu=N

Z xx= pDp^2 * pDq^3 * F1(p,p,q,p) * p(mu) * q(nu)

Id,All,p,N,F
P output
*yep
C Showing the dimensionality of the created indices:

Id,F(i1~,i2~,i3~,i4~,i5~,i6~,i7~,i8~,i9~,i10~,i11~)=
 F(i1,i2,i3,i6,i7,i8,i9,i10,i11)*D(i4,i5)

*begin
C A more realistic example.

I al,be,mu,nu
A N,N_
V p,k
F F,F20,F22

Z xx = G(1,1,al,be,p,al,be,p)

Id,All,p,N,F
P output
*yep
Id,F(i1~,i2~) = D(i1,i2)*F20(k) + k(i1)*k(i2)*F22(k)
*end

***    Id,Anti,TA

All function arguments are inspected for character arguments ("X). If
a character with underscore is seen the character table TA is consulted.
If that character appears in that table the underscore is removed.
This command will be discussed further in the section on character
manipulations.

***    Id,Asymm,F1,2,3,4,F2,F3,4,5

This command specifies that f1 is anti-symmetric in arguments 2,3 and 4,
f2 in all arguments and f3 in arguments 4 and 5. If the arguments are not
in the 'first defined first' order the arguments are permuted. If the
permutation is odd a minus sign is attached. If a number in the list is larger
then the number of function arguments that number is ignored.

There is a second syntax for this command that can be used if the arguments
occur in groups:

***    Id,Asymm,F1:2,3,4:7,8,9:12,13,14:

The groups of numbers within colons denote argument groups. They need not to be
sequential. Only the first argument of a group is used in the comparison.
However, if an interchange is needed both groups are interchanged as a whole.
For example, if in the above case argument 7 is to placed before argument 2
than 2 is interchanged with 7, 3 with 8 and 4 with 9.
If the arguments are sequential an even shorter syntax is allowed:

***    Id,Asymm,F1:1-3:7-9:12-14:

The number of arguments in each group must of course be the same.

Note: for symmetric functions see command Symme.

Example 17.

V p,q,k
I mu
A a,b,c,d,e,f,g,h
F F1,F2,F3

Z xx = F1(e,d,c,b,a) + F2(e,d,c,b,a) + F3(e,d,c,b,a)
    + F2(-125,-30,-1,0,30,125)
    + F2(pDq,pDk,kDq,p(3),q(2),F2,7,mu,p,a)
    + f1(e,f,g,d,a,b,c,h,k)

Id,Asymm,F1,2,3,4,F2,F3,4,5
Al,Asymm,f1:1-3:5-7:

*end

The command

***    Id,Beep,#

sends a Control-G to the terminal. This normally results in a beep. It may be
used to signal audibly certain occurrences. Be careful though; one quickly gets
a lot of noise. The number # limits that: at most # beeps will be issued. The
number # must be positive and less than 128. Example:

IF a^10
Al,Beep,3
ENDIF

The Beep statement (not this command) may be used to generate some noise at
termination, or if an error occurs.

The command Coef essentially inspects the numerical coefficient of any term
passing by, and here specifically use with conditional substitutions is
intended. The syntax is:

***    IF Coef,option

Of course, this command can also be used with AND or OR, with ot witthout
a NOT. The possible options are:
    pl    plus
    ng    negative
    eq,#    equal
    lt,#    less than
    gt,#    greater than
    ib,#,#    inbetween
Here # represents a number (any number, not just short numbers). When a
term passes by the coefficient is inspected or compared, and the IF bit
is set or cleared depending on the result. Concerning equal, two numbers
are considered equal if they agree within the number of decimal digits
specified by the Precision statement (25 default). The naming of the
options corresponds closely to the way the IF bit is set:

            y    set IF bit (or clear if IF NOT)
    If Coef,option
            n    clear IF bit (or set if IF NOT)


C Example 18.

A a1,a2,a3,a4,alt1,agt2,aeq15,ai12

Z xxx= 0.5*a1 + 1.5*a2 + 2.5*a3 + 1.E-20*a4

IF Coef,lt,1.        !Add factor alt1 if coefficient < 1.
Id,Addfa,alt1
ENDIF

IF Coef,gt,2.        !Add factor agt2 if coefficient > 1.
Id,Addfa,agt2
ENDIF

IF Coef,eq,1.5        !Add factor aeq15 if coefficient = 1.5
Id,Addfa,aeq15
ENDIF

IF Coef,ib,1,2        !Add factor ai12 if coefficient inbetween 1 and 2.
Id,Addfa,ai12
ENDIF

IF Coef,lt,1E-15    !Delete the term if coefficient < 1E-15.
Id,Addfa,0
ENDIF

*end

As shown, this command can be used effectively to eliminate 'dirt'.

The command Commu is used for ordering commuting functions. The ordering
is done (i) with respect to the name of the function (smallest first, see
the introduction of this section) (ii) number of arguments (iii) arguments.

***    Id,Commu,F1,F2,F3,...

If the commuting functions occur nested between other functions then they are
taken out and placed behind these other functions. Thus the Commu command
may be of consequence even if there is only one function named, and if that
function occurs at most once in a given term.

Example 19.

A a1,a2,a3,a4,a5
F F1,F2,F3

Z xx = F3(a1,a2)*F1(a1,a2,a3)*F1(a4,a5)
 + F1(a1,a2,a4)*F2(a1,a2,a3)*F1(a1,a2,a3)
 + F3(a1,a4)*F2(a1,a2,a3)*F1(a1,a2,a4)*F2(a3,a4,a5)

Id,Commu,F1,F3

*end

The IF bit is set if any of the named functions is present.

The Compo command is quite complicated, and realistic application are not
well suited for description in this manual. We will nevertheless give a
complete description of this command. It involves character manipulation
and may lead to the generation of new symbols including functions. There
is a way to correlate the created name of a function with the arguments
specified. Combined with the use of Tables (Tables can also have characters
in the list) this is a very powerful tool to generate many symbols or also
functions reflecting a topology. For a very simple application see also
the example demonstrating the command Count, Example 21.

***    Id,Compo,"X,TA,<options>,F1,F2,<options>,F3,F4,..

The character argument "X may be absent, or it may be "S or "S_.
The character table argument TA may be absent. If present it specifies
characters for which "X_="X (anti-particle = particle). If not given
the default is used, which may be none, or one defined by means of the
Anti statement.

Briefly, Compo takes the character arguments found in F1 etc, permutes them
into a well defined order (unless "S_ is specfied for "X) and at the same time
permutes argument groups in F1. The characters are then glued together and
either identified with an existing name, or if not existing the name is entered
in some name list, or the term is discarded depending on the options specified.

The functions F1,F2,... are inspected. The arguments are expected to have the
following structure:

    F1(c1,c2,c3,..,cn,/,d1,d2,..,dm,*,arg1a,arg1b,.,*,arg2a,arg2b,
    ..,*,argka,argkb,..)

In here c1..cn and d1...dm are characters, with the notation ". Legal are:
upper and lower case characters and number characters possibly followed by an
underscore. They may also be vectors, in which case the character(s) of the
vector name are used.  Either n or m may be zero, but not both. If m is zero
the / needs not to be given. The arguments arg1a,arg1b etc correspond to
character c1, arg2a,arg2b etc to character c2 and so on. The sum of n and m
must not exceed 6 (not counting the underscores), and not 2 if the name to be
constructed is to be a vector name.

The characters c1-cn are subject to the ordering process, the d1-dm not.

Concerning the argument groups (arg1a,arg1b,..),(arg2a,arg2b,...),...,
(argka,argkb,...) the following:

- an argument group may be empty. This corresponds to two successive *
  separated by a comma;
- the number of argument groups may be less then the number of characters
  c (i.e. k less than n). In that case argument groups k+1, k+2,.. are
  considered empty;
- the number of argument groups may be larger then the number of characters
  c (i.e. k larger than n). Access groups are not considered in the actions
  described below and are simply reproduced.

When encountering such a function Schoonschip inspects the characters and
permutes them according to the standard character ordering (A-Z, a-z, 0-9;
characters followed by an underscore are ordered just before the corresponding
character without underscore: A,B,C_,C etc). The sets of arguments
arg1a,arg1b,.., arg2a,arg2b,.. are permuted in tune with this. Thus if for
example only c1 and c2 are exchanged then the argument list reads afterwards:
     *,arg2a,arg2b,..,*,arg1a,arg1b,..,*,arg3a,...
No permutation is done with respect to the characters d1,d2,...

No permutation is done if the character variable "S_ (no symmetrization)
was given in the argument list of Compo.

Next all characters are glued together, thus forming a name. This name is
searched for in the lists mentioned in 'options'; if found that name is
identified with that variable. If not found the action taken depends again on
the option specification. If a list is mentioned twice then the new name is
added to that list and new occurrences will be identified with that name. If no
list is specified twice in options then the whole term is discarded.

In the option list, enclosed between < >, the characters X A F V I may
appear once, the characters A F V and I also twice. Thus no new entries
can be made to X-expressions, but the X table (which includes also D
and T expressions and files) can be searched. At most one character can
occur twice. There is a default option: <AXIVFA> meaning search all lists,
and if not found insert in algebraic symbol list.

After identification of the name the corresponding symbol is made to be the
first argument of the function, replacing all c and d characters and the
optional /. Then all * are removed. The result is a function with as first
argument the constructed symbol, and the following arguments is what results
after the permutations among the argument groups. In subsequent substitutions
one may work this function out to whatever is required.

C Example 20.

F F1,F2
A a,b,c,d

Z xx =      F1("c,"b,"a,/,"e,*,a1,a2)
    + F1("c,"b,"a,/,"e,*,a1,a2,*,xy)
    + F1("c,"b,"a,/,"e,*,a1,a2,*,xy,*,a2)
    + F1("c,"b,"a,/,"e,*,a1,a2,*,xy,*,b2,*,xz)

    + F2("a,"b,/,"F,*,x,*,y,*,z1)
    + F2("b,"a,/,"F,*,x,*,y,*,z1)
    + F2("F,"c,"b,"a,*,*,z,*,y,*,x)
    + F2("F,"c,"b,"a,*,*,z,*,yp,*,x)


Id,Compo,<AVIFXA>,F1,<FF>,F2
Id,Always,F2(F1~,a~,b~,c~,d~,e~) = F1(a,b,c)
Id,F1~(a~,b~,z1) = F1(a,b)
*begin

Notes: concerning the first group, F1, various possibilities concerning
number of argument groups are demonstrated. The option specified for this
in the Compo command is actually the default option and could have been
omitted. In the second group it is shown how various functions with arguments
can be created, even with different number of arguments. To this purpose
the fake argument z1 was introduced in the first two cases. The function
substitution for F2 works no matter how many arguments, but one must take
care that in the right hand side no undefined quantities appear. This means
that the function F2 should not occur with less than 3 arguments.
Unfortunately it is not possible to handle empty arguments here. The fake
argument z1 is removed in the last substitution.

Note also dummy use in the substitutions. For function dummies we used
a function symbol defined in the F-list (F1 in this case). Disaster may
result if this is not done. It is extremely difficult to analyze for all
possible cases that may occur if that type of error is made, and many
cases will lead to cryptic error messages seemingly unrelated to this.

A second example shows the use of Compo together with Tables. It is a
rather artificial example, but it shows the main ideas. Suppose an electric
circuit must be build up from 4 three-pole elements connected by diodes,
in the configuration shown:

           j1
    i1   ---0-------0---  i3
         j4    |    |j2
        |    |
    i2   ---0-------0---  i4
           j3


The currents i1 and i2 are flowing inwards, i3 and i4 outwards. j1-j4 are taken
to flow clockwise. The 3-pole elements have three external connections called
A, B and C. The connecting elements are diodes, the connections are called B
and C. B of a diode may be connected to a B from a 3-pole, C to the C of a
3-pole. One might think here of emitter and collector of a transistor.  The
main object is now to generate all possible configurations, which is very
simple in this case, one may either have all the diodes oriented clock-wise, or
all oriented counter-clock-wise. Also one wants to exhibit the currents flowing
through the various objects. Once the expression involving all elements with
the currents is obtained explicitly one can go on and work out whatever is
wanted. If the connecting elements are for instance a diode, resistor and
battery in series one can compute all currents as function of the input/output
currents i1-i4, but we will leave this to the imagination of the reader.

In the example below the function v3 represents the 3-pole. The only
combination to be recognized is the combination ABC. Thus only the function
ABC is defined, and in the options of Compo the F-list is mentioned only
once. Things like AAB or ACC will then be thrown away. Below we simply
sum over all possibilities for the connecting lines (i.e. AA, BC and CB)
leaving it to Compo to keep only those combinations that contain exclusively
the functions ABC and BC.

A new feature in this example is the occurrence of characters in the
lists for the Tables Ch and Cg. While not exhibited here there is another
facility build in. Normally one refers to a table-element by means of the
table name followed by a number. One may also refer to table elements by
means of the table name followed by a character. Then the number associated
with that character (given above) is used to pick out the correct element.
This is useful if certain properties have to be associated with a character.

T Ch(n)="A,"B,"C
T Cg(n)="A,"C,"B

F BC,ABC
A i1,i2,i3,i4,j1,j2,j3,j4

Z solu = square("A,"A,"A,"A)

Id,square(c1~,c2~,c3~,c4~) = DS{L1,1,3,(DS{L2,1,3,
    (DS{L3,1,3,(DS{L4,1,3,(
        v3(c1,Ch(L1),Cg(L4),*,i1,*,-j1,*,j4)*
        con(Ch(L1),Cg(L1),*,j1,*,-j1)*
        v3(c3,Cg(L1),Ch(L2),*,-i3,*,j1,*,-j2)*
        con(Ch(L2),Cg(L2),*,j2,*,-j2)*
        v3(c4,Cg(L2),Ch(L3),*,-i4,*,j2,*,-j3)*
        con(Ch(L3),Cg(L3),*,j3,*,-j3)*
        v3(c2,Cg(L3),Ch(L4),*,i2,*,j3,*,-j4)*
        con(Ch(L4),Cg(L4),*,j4,*,-j4)
        ) } ) } ) } ) }

Id,Compo,<F>,v3,con
Id,v3(f1~,a1~,a2~,a3~) = f1(a1,a2,a3)
Al,con(f1~,a1~,a2~) = f1(a1)
*end

The command Count has grown out of the need to have a facility that selects
terms on the basis of certain asymptotic properties. One may know of various
functions and other quantities how they behave as function of some variable for
certain limiting values of that variable (like for example behaviour as
function of x for very large x). With Count one can for instance select terms
that behave for large x as x^n with n larger then some given number. This is
the most typical application. But the command allows many other things, here is
the description.

***    Id,Count,xxx,arg1,#,arg2,#,....

In case that xxx is a function or X-expression the format is:

***    Id,Count,Fx,arg1,#,arg2,#,...,# : arg3,#,...,# : arg4,#,...

The colon's separate groups of arguments.

Optionally, function names preceeded by "F may be specified directly after
the first argument of Count or after the semicolons, if any:

***    Id,Count,Fx,"F,Fy,"F,Fz,arg1,#,arg2,#,...,# :"F,Fc,arg3,#,...,#

In here arg1, arg2 etc may be indices, vectors, algebraic symbols or functions.
As a first step, investigating a term, a number is constructed. This number is
the sum of numbers obtained for individual factors. The number for an
individual factor is the exponent of that factor (if applicable) multiplied by
the number following the corresponding argument in the Count list. Thus if in
the Count list x,7 occurs than a x^3 in a term leads to a contribution of 21 to
the number being constructed. If no exponent (as would be the case for a
function or vector) the number from the list is added once. The contribution of
vector-components or dot-products is computed on the basis of the value
assigned to the corresponding vectors in the list. Thus p,2,q,5 leads to 21 for
pDq^3 and 10 for q(3)^2. In constructing the number function arguments or
vector indices are not investigated. However, function argumnts of functions
specified with the "F option are counted as single occurences. Thus, the
statement

Id,Count,xxx,"F,Fa,a,35,b,1

leads to the count 38 for the term  b^2*Fa(a,b,c).

The action taken next depends on what occurs as first argument in the
Count list (i.e. xxx above):
- If xxx is a number then the constructed number is compared with xxx.
  If the constructed number is equal or larger than xxx the term is kept
  Else the term is deleted.
- If xxx is an algebraic symbol, vector component or dot-product the
  constructed number is made to be the exponent of that symbol and the
  combination is attached to the term.
- If xxx is a function or X-expression then the number is made to be the
  argument of that function or X-expression and the combination is attached
  to the term.
  A multiple count can be made. The occurrence of a colon (:) in the count
  list signals that subsequent counts must be put in subsequent function
  arguments. Thus if two colons occur a three argument function is created.
  The list up to the first colon is used to compute the value of the first
  argument, the argument list between first and second colon determines the
  value of the second argument, etc. Example: consider the term

    a^3*b^2*pDk

  with p and k vectors. The command

    Id,Count,Fc,a,1,b,2 : p,2,k,3

  (Fc defined before to be a function) generates a two argument function Fc:

    Fc(7,5)*a^3*b^2*pDk

  The fact that Fc may also be an X or D-expression allows for very compact
  but quite complicated counting. If Fc is a non-numeric X or D expression
  then possibly several substitution levels are needed to work out the
  result, and in this case Schoonschip does not automatically count that.
  For purely numeric X and D expressions only one level is needed. To insure
  proper level spacing in case of non-numeric Fc write a dummy substitution
  involving Fc directly before the Count command and use Al for the Count
  command:

    Id,XxxX=Fc
    Al,Count,Fc,a,1,b,2 : p,2,k,3

  where XxxX is not occurring anywhere else.

In the following example we do not only demonstrate Count, but show also
some other application of Compo. The coefficients a1-a5 are constructed and
entered in the A-list (remember default options Compo is <AFVIXA>). Also
the use of Keep and *next is shown.

Example 21.

A x,y
T tt(n) = "1,"2,"3,"4,"5

C Here a complicated way to make
C    pow(x) = a1*x + a2*x^2 + a3*x^3 + a4*x^4 + a5*x^5.

Z pow(x) = DS(J,1,5,{f1(/,"a,tt(J))*x^J})

Id,Compo,f1
Id,f1(y~) = y

Keep pow
*next

Z xx = pow(x)

Id,Count,3,x,1

Keep pow
*next

Z xx = pow(y)

Id,Count,f1,y,2,a3,10

Keep pow
*next
V p,q
A AA

Z xx = pow(y)*f1(a2,a3)*pDq^2

Id,Count,AA,y,2,f1,-4,p,1,q,3

*end

The commands Cyclic and Symme are analogous to Asymm, except that invariance
under cyclic permutation or simply exchange of arguments is implied.

***    Id,Cyclic,F1,2,3,4,F2,F3,4,5

***    Id,Symme,F1,2,3,4,F2,F3,4,5

For the command Symme the alternative syntaxes used to denote groups of
arguments can be used:

***    Id,Symme,F1:2,3,4:7,8,9:12,13,14:
***    Id,Symme,F1:1-3:7-9:12-14:

As to Cyclic, the arguments are permuted following the pattern specified in
the Cyclic list, which may make things pretty obscure as the following
example shows. The arguments specified are permuted till 'smallest first'.

Example 22.

A a,b,c,d,e

Z xxx = f1(e,d,c,b,a) + f2(e,d,c,b,a) + f3(e,d,c,b,a)

Id,Cyclic,f1,2,5,4
Id,Symme,f2,f3,2,3,4

*end

***    Id,Dostop,on
***    Id,Dostop,off
***    Id,Dostop

The command Dostop may be used to set, clear or test the forced DO-loop exit
flag. If this flag is set then the next ENDDO encountered is taken to be
satisfied. This command may be used to execute a set of substitutions
and commands followed by a *yep repeatedly till some condition is satified.
Here a typical example:

Z xx = a^10

DO J=1,100
Dostop off
Id,a1^n~=a1^(n-1)*b
IF NOT a1
..Id,Dostop,on
ENDIF
*yep
ENDDO

*end

The DO-loop sequence will be re-executed 100 times or till no more a1 present.
In the case shown the cycle is run 10 times and the result is b^10. Note
that:
- The Dostop statement and command are within the same program segment (i.e.
  there is no line with an * inbetween);
- The last line of the DO-sequence contains an * in column 1.
Refer to the remarks on the Dostop statement for more details.

The Dostop command may have other or no parameters:

Id,Dostop,off
Id,Dostop

In the last case the Dostop flag is tested, but not modified. The command
may be used in conjunction with an IF:

IF Dostop
...
ENDIF

A set flag implies 'yes'.

The command Epfred leads to reduction of products of Epf with equal number of
arguments to one Epf.

***    Id,Epfred

The simplest case is for two arguments:
   Epf(i1,i2)*Epf(i3,i4) = D(i1,i3)*D(i2,i4) - D(i1,i4)*D(i2,i3)
In three dimensions this is the equation that rewrites the product of two
cross products in terms of dot-products. If p, q and k are vectors, than the
pseudo-scalar (k.pxq) is given by  Epf(k,p,q). If pp, qp and kp are also
vectors then the product (k.pxq)*(kp.ppxqp) can be rewritten in terms of dot-
products. Similar relations hold in higher dimensions. Note: the product of
two Epf of different dimension is not reduced.

Example 23.

V p,q,k,pp,qp,kp

Z xxx = Epf(k,p,q)*Epf(kp,pp,qp) + Epf(i1,i2,i3,i4)*Epf(i1,i2,j3,j4)

Id,Epfred

*end

The commands Even and Odd specify that some function is even or odd with
respect to change of sign of certain arguments. Minus signs of such arguments
are removed.

***    Id,Even,f1,2,3,4,f2,f3,4,5

***    Id,Odd,f1,2,3,4,f2,f3,4,5

Example 24.

F f1,f2,f3,f4

Z xxx = f1(-a1,-a2,a3,-a4) + f2(-a1,-a2,a3,-a4) + f3(-a1,-a2,a3,-a4)
    + f4(-a1,-a2,a3,-a4)

Id,Even,f1,2,3,f2
Id,Odd,f3,2,3,f4

*end

The command Expand occurs in combination with frozen files. See the section
on freezing a file. Syntax:

***    Id,Expand,fname

In here fname is the name of a frozen file. All frozen subfiles referred
to through the function DF or expanded.

***    Id,Extern,arg1,arg2,...

The command Extern allows entering an of external routine as integral
part of Schoonschip. First one needs the statement External:

External filename

The statement External, specifying an external file, leads to loading of that
file in working space. The command Extern leads, at execution time, to a jump
to the first location of that file. If that file contains position independent
executable code then manipulations on expressions can be performed. This
requires an understanding of the formats used inside Schoonschip, and supposes
the ability to generate such a file.

The interface provides acces to all arrays, and also utilities such as
print routines etc inside Schoonschip can be used. The information will
not be given here, but is available. Roughly speaking, a whole series
of addresses is passed on as a structure on the stack. The arguments are
passed on in the form of an array.

In principle this facility allows the creation of special packages
designated for specific problems.

***    Id,Iall,p,F
***    Id,Iall,F

Inverse of All for the two possible syntaxes. Do not use Iall if the indices
that occur as argument may have dimensional restrictions (Dim_N or Dim_4)
as created when doing gamma algebra, command Gammas. The command Ndotpr is
to be used in such cases.

***    Id,Gammas, loop indices + options, Trace, loop indices + options

This command will be discussed in a separate section: Gamma algebra.

The command Numer can be used if numerical values must be inserted for
certain quantities. The format is:

***    Id,Numer,arg1,#,arg2,#,...

The numbers need not to be short numbers, they can be anything. Function
arguments are not considered. The arguments may be algebraic symbols,
vector components or dot-products.

Example 25.

V p,q

Z xxx = a1^2*pDq^3/p(4)

Id,Numer,a1,2,pDq,1.E10,p(4),1.E5

*end

The command

***    Id,Ndotpr,F1

is closely related to the Gammas command and will be discussed in the section
on Gamma algebra.


***    Id,Order,F1,F2,...

This command searches for the functions F1, F2.... and builds a chain on
the basis of the first two arguments. First the function F1 is searched.
The second argument is taken, and looked for in other functions. If found,
the new function is chained to the previous. Etc.

One index is kept in the collected Faa, namely the first seen.

There are two additional options for this command. Specifying the character "C
(for collect) as first arguments leads to collection of all arguments except
the first two into one function. Specifying a number as first argument gives
that number as first argument to the collected functions of the first chain
collected, that number+1 to the second, etc. The option "C may be combined with
this. If the number given is zero no first argument is kept. Examples
(the output is reproduced here):

Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,Faa

x1 = + Faa(1,aaa)*Faa(1,bbb)*Faa(1,ccc)*Faa(1,ddd) + 0.



Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,"C,Faa

x1 = + Faa(1,aaa,bbb,ccc,ddd) + 0.



Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,90,Faa

x1 = + Faa(90,aaa)*Faa(90,bbb)*Faa(90,ccc)*Faa(90,ddd) + 0.



Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,90,"C,Faa

x1 = + Faa(90,aaa,bbb,ccc,ddd) + 0.



Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,0,Faa

x1 = + Faa(aaa)*Faa(bbb)*Faa(ccc)*Faa(ddd) + 0.



Z x1 = Faa(4,5,ddd)*Faa(2,3,bbb)*Faa(1,2,aaa)*Faa(3,4,ccc)
Id,Order,0,"C,Faa

x1 = + Faa(aaa,bbb,ccc,ddd) + 0.

***    Id,Print,#,Message

This command can be used to print a message at execution time. The number
# limits the number of times the message is printed. Everything after the
third comma, including blanks, up till the end of the line is printed when
this command is encountered at execution time. Example:

Id,2,Print,  Hello world.

The message "  Hello world." is printed at most twice.

The command Ratio is specifically there to facilitate integrations. It
is used to rationalize a product of factors that are linear in the integration
variable. The simplest case is:
    1/(x+a) * 1/(x+b) = {1/(x+a) - 1/(x+b)}/(b-a)
Since in Schoonschip expressions cannot have a negative exponent (except when
they are purely numerical) one cannot directly write such things. The way to
do that is to introduce a symbol to represent an expression appearing with
negative exponent, for example xpa = x+a. Then the equation becomes:
    xpa^-1*xpb^-1 = {xpa^-1 - xpb^-1}*bma^-1
Here the [] notation for symbols comes in very conveniently. One may write:
    [x+a]^-1 * [x+b]^-1 = {[x+a]^-1 - [x+b]^-1}/[b-a]
If the exponents are large this becomes quite complicated, and that is where
Ratio comes in. In the command one must specify the two factors and their
difference, in the case mentioned one would write:

***    Id,Ratio,[x+a],[x+b],[b-a]

Ratio works for all cases of exponents that may occur, positive or negative.

C Example 26.

A a1,a2,a2ma1
F f1
B b2,b3,b4,b5

Z xx=f1(8,4)

Id,f1(n~,m~)=
    { b2*a1^n*a2^m
    + b3*a1^-n*a2^m
    + b4*a1^n*a2^-m
    + b5*a1^-n*a2^-m
    }

Id,Ratio,a1,a2,a2ma1
*begin

C Here the use of Ratio with [] names.

B [b-a]

Z xxx = 1/[x+a]^3 * 1/[x+b]^2

Id,Ratio,[x+a],[x+b],[b-a]
P output
*yep
C Just checking...

Id,[x+a]^n~ = (x+a)^(3+n)*(x+b)^2/[x+a]^3/[x+b]^2
Al,[x+b]^n~ = (x+a)^3*(x+b)^(2+n)/[x+a]^3/[x+b]^2
Id,b = [b-a] + a
*end


***    Id,Spin,loop indices or momenta

This command is discussed in the section on particle physics.

***    Id,Stats,#

This commands provides for some statistics. The counts are printed at
conclusion of a section (delimited by a * type line). Four counts may
be kept, specified by the number # which may be absent implying 0, or
one of numbers 1, 2 or 3. No error message is given if the number exceeds
3 or is negative; Schoonschip takes the number modulo 4. Every time
this command executes one is added to the appropiate count. Example:

IF a^3
Id,Stats,2
ENDIF

This construction counts the number of terms with a^3. The result is
printed at termination.


13. PARTICLE PHYSICS.

There are a few build-in facilities that are particularly useful to particle
physics. We refer here to gamma-matrices and traces of products of gamma
matrices.

The special functions G,Gi,G5,G6,G7,Ug and Ubg are reserved to denote gamma
matrices and spinors. Since in a given calculation more than one loop of
gamma-matrices can occur all functions have a loop index. Gamma's with
different loop indices are supposed to commute. The relation to the standard
notation for these quantities is (old notation):

    G(L,mu)        gamma-matrix with index mu of loop L.
    Gi(L)        the identity matrix of loop L.
    G5(L)        = G(L,1)*G(L,2)*G(L,3)*G(L,4).
    G6(L)        = Gi(L) + G5(L).
    G7(L)        = Gi(L) - G5(L).
    Ug(L,m,p)    spinor loop L, particle mass m, momentum p, spin 1/2.
    Ubg(L,m,p)    Conjg{Ug(L,m,p)}*G(L,4).
    Ug(L,mu,m,p)    spin 3/2 spinor.
    Ubg(L,mu,m,p)    Conjg{Ug(L,mu,m,p)}*G(L,4)

With the Schoonschip version of Jan 1, 1989 new notations have been introduced
for the gamma matrices. The above notation is still accepted, but the new
is more flexible and we will use that.

In this new notation gammas have two loop indices. They may also have more than
one index. The order of these two-index gammas is immaterial; at some point,
when traces or spin summation or whatever is to be done (usually with the
command Gammas) the gammas are chained on the basis of these two loop indices.
Example:

    Ug(i3,M,q)*G(i1,i2,mu)*G6(i0,i1)*Ubg(i0,m,p)*G(i2,i3,nu,al)

This will be chained into one gamma string (called G-string in the following):

    Ubg(i0,m,p)*G(i0,"s,"6,mu,nu,al)*Ug(i0,M,q)

equivalent to the old sequence

    Ubg(i0,m,p)*G6(i0)*G(i0,mu)*G(i0,nu)*G(i0,al)*Ug(i0,M,q)

This takes the pain out of the process of ordering the gammas.
Inside G-strings "4, "5, "6 and "7 may occur next to Gi, G5, G6 and G7 but
they mean the same.

An anti-particle spinor may be represented as a particle spinor with -m
instead of m. The G's satisfy the rule:

  G(L,"s,"4,...,mu,nu,..) =
   - G(L,"s,"4,...,nu,mu,..) + 2*D(mu,nu)*G(L,"s,"4,.....)

which is the usual anti-commutation rule. All G are treated by Schoonschip as
imaginary, which corresponds to a hermitean set. In complex conjugation
the order of the G is to be reversed (i.e. the order inside a G-string is
reversed). G5 is imaginary, G6 and G7 are each others complex conjugate.

The commands Gammas and Spin allow for reduction of a product of G's to
at most 2 G's, Trace taking and Spin-summation. The build-in equations
can handle 4-dimensional and N-dimensional situations, with ot without G5's.

The command

***    Id,Spin,L1,p,...

leads to spin summation. Schoonschip looks for pairs of spinors Ug and Ubg
with the same arguments except the loop index (one of the loop indices must
be mentioned in the list), and replaces such pairs by the appropriate
combination. Instead of a loop index also vectors may serve as identification.
With the command

Id,Spin,p

or

Id,Spin,L1

the expression

    Ug(L1,m,p)*Ubg(K1,m,p)

is replaced by

    - i*G(L1,K1,p) + m*Gi(L1,K1)

Similarly for spin 3/2 spinors:

    Ug(L1,mu,m,p)*Ubg(K1,nu,m,p)

is replaced by:

   { D(mu,nu) - 1/3*i*G(L1,K1,mu)*p(nu)/m + 1/3*i*G(L1,K1,nu)*p(mu)/m

    - 1/3*G(L1,K1,mu,nu) + 2/3*Gi(L1,K1)*p(mu)*p(nu)/m^2 }

    * { - i*G(L1,K1,p) + m*Gi(L1,K1) }

The command Gammas can be used to do work on G-strings. See the section on
gamma algebra.

Example 27 gives the complete calculation for muon decay in the V-A theory.
It is not repreduced here.

The Compo command is very useful if one wants to calculate diagrams.
The possible vertices can be given in terms of X-expressions. For a
given topology one sums over all possible propagators. Separate examples
exist for such cases.


14. INTERNAL PROCEDURES.

Some insight in how all this actually works inside Schoonschip is really
indispensible, and this section provides for some details. An example (Example
28 followed by Example 29) shows how to do a problem that could easily explode
if not worked out carefully.

Consider the expression:

Z XX = (a*x^2 + b*x)*dx

The process starts with reading the input. The input is encoded, and placed
into memory. Names are placed in arrays. This encoding stops when the line with
the * is encountered. Then Schoonschip starts working out the Z expressions,
one after the other. This happens at Level 0. At Level 1 one term after the
other passes by. In this case the first term passing by is the the term
a*x^2*dx. No new term is emitted then till this term has passed 40 Levels, and
at each Level the user has the opportunity to work on that term. Then this term
is collected in the output store, a large area of more than 40 kbytes. There
are provisions for handling overflow of that area, but more about that later.
Only when that term is stored is the next term issued, here b*x*dx.

The advantage of this procedure is that virtually no storage is needed for the
intermediate results. Often symbolic programs work out the whole expression
before going to the next level. Then one finds inside the initial expression,
the expression as it becomes after the first Level, and so on. The same
expression, in various stages of processing may then be found many times in
memory. This leads very quickly to memory overflow, which is not easily
manageable.

On the other hand, when collecting terms in the output store a substantial
reduction in the number of terms may take place. For instance, to take a very
trivial example, the initial expression (a+b)^2 leads to 4 terms, and all of
these 4 terms go through all 40 Levels (actually Schoonschip notes how many
Levels are active, and skips the empty Levels). If one were to collect these
terms immediately after the first Level there will then only be three terms:
a^2 + 2*a*b + b^2. That is what happens at the output store: identical terms
are recognized, and the coefficients are added rather then keeping the terms
separately (here that applies to a*b). Thus term collecting will in general
lead to a reduction in number of terms, and in fact this is usually very
substantial.

This fact was of course quickly realized, and an option is available to do this
term collecting at any time inbetween the substitutions and commands. This is
done through the *yep line. When encountering this line Schoonschip processes
all substitutions up to that point and then collects all terms in the output
store. Next this output store is emptied on the disk, and then read in again,
term by term. Again each term then passes through all Levels, possibly to
another *yep, till all substitutions have been exhausted. It is up to the user
to put these *yep lines judiciously in case of a large problem.

As may be clear from the above this procedure has the added advantage that
after a *yep the full 40 Levels can be used again. Thus there is basically no
limit on the amount of substitution and commands that can be done.

The assignment of substitutions and commands is essentially automatic. The user
has a number of options here. Putting Id in columns 1-2 of a substitution
assigns that substitution to the next Level. The characters Al put the
corresponding substitution on the same Level. Thus substitutions that do not
interfere with each other can so be put on the same Level: the first has Id,
the second Al in columns 1-2. Also, one may want some substitution to be done
at a number of consecutive Levels. In such cases one simply places a number
after the Id or Al. Thus Id,7,... implies that the corresponding substitution
is inspected for at 7 consecutive Levels.

When reading the input Schoonschip prints the associated Level in front of the
line. To understand this numbering it must be realized that working out
brackets requires Levels, namely one Level per nesting. Thus in the last
example the first substitution is put at Level 2, because Level one is used to
work out the brackets. In fact, working out the brackets is very much like a
substitution; the initial expression is translated to something like $AAA^2,
where $AAA is a symbol invented for this purpose, and at Level 1 the
substitution

Id,$AAA = a+b

is placed. For this reason the $ symbol must not be used in names. This process
may be seen in detail by requesting printing of these $ expressions by means of
a  P brackets  directive. Also X-expressions may require Levels, they are like
build-in substitutions. As soon as an X-expression materializes at some Level
Schoonschip substitutes its definition.

To make the whole process transparant we will here reproduce the contents of
memory for a simple case somewhere in the middle of a calculation. Consider:

Z xxx = (a*x + b)*dx

Id,x*dx = (x2^2 - x1^2)/2

*end

Typically at some point the following may be found in memory:

Level 0: $AAA*dx

Level 1: dx    and    a*x + b

Level 2: dx*a*x

Level 3: a    and    $AAB/2

Level 4: 0.5*a    and    x2^2 - x1^2

Level 5: - 0.5*a*x1^2

Levels 6-40: skipped

In output store:    0.5*a*x2^2

At this point the action is at Level 5. A little time later the term
-0.5*a*x1^2 will arrive at the output store, and that exhausts the work at
Level 4. Then Schoonschip goes back to Level 1 and produces the next term,
b*dx. After that has passed to the output store (for simplicity we have not
included the substitution for this one) Schoonschip goes all the way back to
Level 0, finds that the problem is all done, and passes to the next stage,
namely printing of the contents of the output store.

This rather complicated procedure has the great advantage that only very little
memory is used at any one time. One finds bits and pieces all the way down from
Level 0 to the output store, and Schoonschip keeps on climbing up and down all
Levels till all work at all Levels is exhausted. In dealing with large problems
one must have some idea of this procedure in order to organize the calculation
in the most efficient way. Any substitution with more than one term in the
right hand side leads to multiplication of the number of terms generated with
some factor, depending on how many terms occur in that right hand side, and
also on how often the sustitution is actually done.

To see how much work is done by Schoonschip use the directive  P stats. Then
some statistics are printed, of which in this context the most interes- ting
ones are the number of multiplications and the number of terms. One
multiplication is counted for every time two terms (not factors) are multiplied
together. Thus  (a*x + b)*(c*x + d)  implies four multiplications. Often the
count comes out higher than expected at first sight due to for instance the way
brackets are worked out. The number of terms is simply a count of the terms
that arrive at the output store. That would be 4 in this case. Another example:
(a + b)^4 leads to 2^4=16 multiplications, and then to 16 terms, and after
sorting in the output store one will have 5 terms. In actual fact, the count
for multiplications comes in this case to 81, but we will not bore the reader
to explain this in detail. Mainly this is because Schoonschip begins by setting
a 1 before getting to the actual expression. In practice the number of terms
and also the number of multiplications are a good indication of the complexity
of a problem, and the time needed is roughly proportional to these numbers. For
large expressions with many terms most time is spent sorting the terms in the
output store. Try to avoid more than 100,000 terms. If one gets in this kind of
situation it is necessary to examine in detail the organization of the problem,
and the separation in various parts using *yep. See also the sections on large
problem handling and file handling commands. The largest calculation done so
far involved as many as 1,000,000 terms, but it is not known how much diskspace
was used. The present version needs about 20 seconds for 10,000 terms or
100,000 multiplications, but this must be seen as a very rough low estimate. If
diskwriting is involved times may increase drastically. The calculation
mentioned used 20 minutes on a CDC 7600, but that was counting only cpu time,
not actual time. It would probably take many hours on a 68000, assuming enough
diskspace. The important point is of course that at least there is no
limitation due to Schoonschip itself, and given time and diskspace it will work
its way through. If P stats is specified it will print statistics every time
8192 (= 2^13) terms have passed through, so that one can see some action.

In particular series expansions where the argument expanded in is again a
series can very easily lead to an enormous number of terms. Suppose some
function, f(y), is given in terms of a series expansion, and suppose also y is
a series expansion in terms of a variable x. Now suppose that the series
expansion of f in terms of x up to x^10 must be found. If y is a polynomium
involving up to x^9, thus 10 terms, then substitution of this in y^10 leads to
10^10 terms, which would take roughly 20*10^6 seconds if nothing else would
grow out of bounds. Such problems must be worked out really carefully, and in
Examples 28, 29 we have reproduced a substantial part of such a problem, enough
to understand the principle.

15. CHARACTER SUMMATION.

Characters have become quite useful in generating diagrams. Typically
a character is associated with every particle in the theory. Anti-particles
have the same character as the particles but appended with an underscore
(_). Certain particles are their own anti-particle. There is a way to let
Schoonschip know which particles are their own anti-particle.

In generating diagrams one must first have a list of vertices. The name
for a vertex is composed of the characters that correspond to the particles
entering that vertex. In that name the characters must be ordered in a
well defined way: alphabetically, upper case before lower case before numbers,
characters with an underscore before those without an underscore. Thus:
A_AB_BC_C......Z_Za_ab_b...1_12_2... Here some examples:

AWW    Aww    U_U    AG_G    Ue_e    Ubt_    U_b_t    U

Vertices have indices and momenta as parameters. Four particle vertices
have no momentum dependence.

The list of vertices must be given in terms of X-expressions. Each vertex
must have sufficient parameters to cover all cases. For a given particle
one may have momentum, vector index and spinor index. Even if the vector
and spinor index will normally not occur simultaneously they need to be
carried along. A 3-vertex will thus have 9 parameters. Examples:

X U_UW(AL,al,P,BE,be,Q,GA,ga,K) =
    C*D(AL,BE)*(Q(GA)-P(GA)) + C*D(AL,GA)*(P(BE)-K(BE)) +
    C*D(BE,GA)*(K(AL)-Q(AL))

This is a vertex for three vector particles. The spinor indices al, be, ga
are not used. Here two spinor vertices:

X Ubt_(AL,al,P,BE,be,Q,GA,ga,k) = i*G(ga,be,AL) + avc*i*G(ga,be,AL,G5)

X Ue1_(AL,al,P,BE,be,Q,GA,ga,k) = i*G(ga,be,AL,G6)

Note that spinor indices usually appear in reverse order. This is the
vertex for a vector particle (charged W) coupling to a fermion and an
anti-fermion (bottom and top or electron-neutrino 1). Here a fermion
propagator:

X t_t(L1,l1,L2,l2,K)=NOM(K,Mt)*G(l2,l1,K) + NOM(K,Mt)*Gi(l2,l1)*Mt

NOM is the usual propagator factor, 1/[KDK + Mt^2].

In this way all vertices and propagators must be defined. Now suppose
some diagram must be calculated, say W selfenergy (the charged W's are
represented by U and U_). After the type declarations all vertices and
propagators must be given in terms of X-functions:

C Calculation of charged vector boson (U, U_) self-energy.

F Fx,F2,B22,B21,B1,B0,VE3,PROP

I AL=N,al,BE=N,be,GA=N,ga,MU=N,mu,NU=N,nu,MUP=N,mup,NUP=N,nup,
  L1=N,l1,L2=N,l2,L3=N,l3,L4=N,l4,L5=N,l5,L6=N,l6,L7=N,l7,L8=N,l8,
  L9=N,l9,L0=N,l0

I Mu4,Nu4

V P,Q,K

C The use of these character tables, the Anti statement and the G line will be
C explained below.

T TAP: W,Z
T TFE: t,b

Anti,TAP

G 1

X t_t(L1,l1,L2,l2,K)= i*NOM(K,Mt)*G(l2,l1,K) + NOM(K,Mt)*Gi(l2,l1)*Mt
X b_b(L1,l1,L2,l2,K)= i*NOM(K,Mb)*G(l2,l1,K) + NOM(K,Mb)*Gi(l2,l1)*Mb


G 3

X Ubt_(AL,al,P,BE,be,Q,GA,ga,K)= i*G(ga,be,AL,G6)
X U_b_t(AL,al,P,BE,be,Q,GA,ga,K)= i*G(be,ga,AL,G6)
X Wt_t(AL,al,P,BE,be,Q,GA,ga,K)= i*[1-8/3s^2]*G(be,ga,AL) + i*G(be,ga,AL,G5)
X Wb_b(AL,al,P,BE,be,Q,GA,ga,K)= i*[4/3s^2-1]*G(be,ga,AL) - i*G(be,ga,AL,G5)

G

C First establish the topology, for example the simple two 3-vertex, two
C propagator diagram. Note that no _ may be used in file names.

Z IUUB=SELF("U,"U_)

C Now a character summation. I1 is the given input character,
C in this case the "U representing the positively charged W.
C The sum in DS goes over all characters J1 and J2 such that the name
C U J1 J2 properly symmetrized corresponds to some X-expression.
C In this case that will only be some b, b_, t, t_ combinations for J1, J2.
C The symbol 'Sym' implies symmtrization factor based on the characters
C following. If they are identical (will not happen here) a factor
C 1/2! will be added.
C The subsequent numbers, 2,3,5,6, imply that only X-expressions in
C groups 2,3,5 and 6 will be inspected. That is then the meaning of
C the G lines above: they specify a group number for the X-expressions
C following. Default is 0, and if no groups have been specified all
C will be considered.
C Whenever a match is found a term in the summation arises: the
C function DIB with the characters I1, J1, J2 and I2 as arguments.
C The function DC is used for various purposes; here it provides
C a factor -1^1 if both characters J1 and J2 appear in table TFE.
C If one uses "F_ rather then "F the factor is provided none of the
C characters appear in the table TFE.
C The second number 1, the exponent, may be omitted and is then 1.
C This is the factor -1 for a fermion loop. The "F in the DC function
C stands for factor.
C Other uses for DC are summarized later.

Id,SELF(I1~,I2~)=
   DS(I1;J1;J2;Sym;J1;J2,2,3,5,6,(DIB(I1,J1,J2,I2)
  *DC("F,TFE,-1,1,J1,J2) ))

C This is essentially the diagram. Mu4 and Nu4 are the external U and U_
C indices, P is the loop momentum, Q is the U momentum and K = P + Q.
C The * are used by the command Compo. In for example VE3 that command
C re-arranges the characters I1, K1 and K2 in the character order defined
C before. Every interchange also gives rise to an interchange of the
C argument groups delimited by the *.

Id,DIB(I1~,K1~,K2~,I2~)=
   VE3(I1,K1,K2,*,Mu4,mu,Q,*,L1,l1,-K,*,L3,l3,P)*
   VE3(-K1,I2,-K2,*,L2,l2,K,*,Nu4,nu,-Q,*,L4,l4,-P)*
   PROP(K1,-K1,*,L1,l1,K,*,L2,l2,K)*
   PROP(K2,-K2,*,L3,l3,P,*,L4,l4,P)

C Compo searches the X-expression list for the names composed of the first
C few characters that appear as arguments of the functions VE3 etc. and if
C found keeps the term, else makes it zero.

Id,Compo,<X>,VE3,PROP

C Compo has now composed the name and performed the necessary symmetrization.
C Now the functions themselves can be substituted. AA is a dummy name here.

Id,VE3(AA~,MU~,mu~,P0~,L2~,l2~,Q~,L1~,l1~,P~)=
       AA(MU,mu,P0,L2,l2,Q,L1,l1,P)
Al,PROP(AA~,L4~,l4~,Q~,L3~,l3~,P~)=AA(L4,l4,L3,l3,Q)

C At this point the full expression for the diagram has been obtained.
C The next step is to do the loop integral. The loop momentum appears
C in the propagators through the functions NOM, and as arguments in the
C Gamma matrices.

Id,Commu,NOM
Id,NOM(P,M~)*NOM(K,M0~)=F2(M,M0)
Id,Gammas,"C

C Remove K as G argument, replacing it by the four dimensional Q
C and the loop momentum P. No index is created by this work, and the
C dimensionality of MU is irrelevant.

Id,Funct,K(MU~)=P(MU)+Q(MU)

C Now collect all P in the function Fx.

Id,All,P,N,Fx
*yep

C The P-integration can be done:

Id,F2(M~,M0~)*Fx(MU~,NU~) = D(MU,NU)*B22(M,M0) + Q(MU)*Q(NU)*B21(M,M0)
Al,F2(M~,M0~)*Fx(MU~) = Q(MU)*B1(M,M0)
Al,F2(M~,M0~)=B0(M,M0)

C Do Anomalous traces.

Id,Gammas,"A
*end


In this case only one diagram is evaluated simply because there are no
more vertices listed. If a complete set of vertices is given the complete
result obtains.



Character tables.

Character tables are distinguished from other tables (that can be used as
function arguments) by means of the colon (:) following the name.
To every character possible there corresponds a location in the table,
zero by default. Any character mentioned gives a 1 and a -1 in the
location for its antiparticle (denoted by a appended underscore).
Specific numbers may be assigned, for example

T TAB: A=3:5,B=7,a,z=3

This assigns 3 to A, 5 to A_, 7 to B, -7 to B_, 1 to a, -1 to a_,
 3 to z and -3 to z_.

Important: all numbers appearing in character tables must be short integers
 (-129 < # <128).

The function DC uses such tables. Other character manipulations often
need a table to specify which particles are their own anti-particles.
Except for DC calculations such an anti-particle table may be given
before a *fix, and is then the default for the character function DS
and the command Compo for example. In all cases one may specify a
particular anti-particle table for the specific case: for DS as an
argument before the group numbers, for Compo anywhere in the list.

Anti statement and command. The Anti statement

Anti,TAA

establishes character table TAA as the default anti-particle table. This
is used by default by DS and Compo work. The statement may be given in the
fix section and is then valid by default for all other sections.
The command:

Id,Anti,TXX

leads to inspection of all function arguments. The table TXX is used to
determine which particles are their own anti particles, and correspondingly
a possible appended undescore is removed.



Character summation function DS.

General format:
    DS(C1;C2;C3;..;Sym;C4;C5,..,TX,#1,#2,...,(Expression) )
                    ^--^---^--^  ^  ^  ^
The ^ indicate optional arguments. The characters C1, C2 etc must be followed
by a semicolom; they may be characters, or else they are taken as dummies. A
preceeding - sign adds or removes an underscore. The summation goes over all
names that fit the name of an X-expression. For example, if C1="A and there are
two additional dummies mentioned then DS searches for all X-expressions with a
name of three characters of which one is an A. C2 and C3 become then the other
two characters and may as such be used in the Expression.

If the symbol Sym is mentioned then a symmetrization factor is provided
based on the characters following this symbol.

If a table TX is mentioned it is taken to be the antiparticle table, listing
all characters X for which X=X_.

If group numbers are specified only X-expressions in the groups mentioned
are considered.

Example:
    DS("A;J3;-J3;"B;Sym;J3,-J3,2,(Dic("A,J3,"B) )

Every X-expression name containing characters of the form AXX_B (or AX_XB)
leads to a term in the sum. For example the following names fit the pattern
twice:
 AEBE_  (with J3="E and J3="E_)
 Z_ZAB  (with J3="Z and J3="Z_)
The order of the characters in the name is not of importance here. This
order is however important when using the command Compo. That command
orders the characters before searching the namelists.


The character function DC.

DC always equals some numerical factor depending on the character arguments.

DC("F,TFE,#1,#2,C1,C2,...)
DC("F_,TFE,#1,#2,C1,C2,...)
 The value of the DC is #1^#2 (if #2 absent is taken to be 1) provided all
 characters C1,C2 etc appear in the table TX. Else it is 0. For "F_ the
 other way around. Here an example of a character table TX:

T TFE: t,b

DC("P,TX,#,C1,C2,...)
 Compute and multiply with a permutational factor determined by the occurence
 of identical characters in C1, C2 etc. The number # is used as exponent.
 For example, with the value 2 for # and the characters "A "A "A "B "B the
 value (3!*2!)^2 obtains. The table TX lists particles that are their own
 anti-particles (X_ = X). Here an example of such a character table:

T TAP: W,Z

DC("C,TX,C1,C2,...)
DC("C_,TX,C1,C2,...)
DC("T,TX,C1,C2,...)
DC("T_,TX,C1,C2,...)
 Compute the sum of the 'charges' of C1,C2,.. as listed in table TX. If zero DC
 is 1, else 0. If the character "C_ is used the opposite. If the character "T
 is used keep the term if the sum is positive including zero. If "T_ is used
 keep if < 0. Here an example of such a character table: 1 is assigned to
 particle Z, and also 1 to its antiparticle Z_. If the second 1 is not
 given it is taken to be the opposite of the first one (thus here -1) for the
 antiparticle.

T TX: Z=1:1


16. GAMMA ALGEBRA.

The equations and algoritms used in this section will not be derived here.
The derivations can be found in a publication (M. Veltman, Gammatrica, 1989,
to be submitted to either Nuclear Physics or Computer Physics Communications).

The treatment of gammas has become quite complicated, but things have been
organized in such a way that for most cases the default options will do
the necessary. Essentially, other then four dimensional gamma algebra can
be done. It is nonetheless essential that a number of things are well
understood.

The only quantities for which other than four dimensionality can be specified
are indices. There is no way to specify the dimensionality of a vector, or
of a dotproduct. In doing gamma matrix manipulations Schoonschip takes
vectors to be four dimensional, i.e. G(L,p) contains only G(L,1) to G(L,4).
That might be seen as a restriction, but it is not. Refer to the "C option
discussed below.

The type of non-four dimensional vectors in the sense just mentioned occurring
in practice are loop momenta. There are several ways to deal with that.
The easiest way seems to be to first do the loop integrations before
doing the gamma algebra. First all gamma's are collected using the "C
option (see below), and then occurring loop momenta are replaced by four-
dimensional momenta or index pairs with N dimensional range. These can be
handled properly. For the moment it will be assumed then that all momenta
occurring as arguments of the gammas matrices are four dimensional, but
that indices may either be four or N-dimensional. No provisions have been
made to consider indices with ranges other then these two, although one
may use any algebraic symbol instead of N.

New notations have been implemented. Instead of one loop index the gamma's may
now have two loop indices. This very much eases the task of ordering the
gamma's properly when generating them by means of some automatic procedure.
Gamma's can be rounded up and put in the proper sequence on the basis of
the indices. The notation is:
    G(i1,i2,mu),  Gi(i1,i2), G5(i1,i2),  G6(i1,i2),  G7(i1,i2)
Gi is the unit matrix. The meaning of G6 and G7 is as before:
    G6 = Gi + G5,  G7 = Gi - G5.
The ordering is based on the indices:
    G(i1,i2,mu) * G(i3,i4,nu) * G(i2,i3,al) = G(i1,i4,mu,al,nu)
which is about the same as the old notation
    G(L,mu)*G(L,al)*G(L,nu)
One may in fact directly use the multi-index notation G(i1,i3,mu,al,nu).
It actually was used internally (but with only one loop index) since a long
time. Also Gi, G5, G6 and G7 may appear in that list:
    G(i1,i2,mu,G5,al,be,G6,ga,Gi,la,G7)
A string is called a trace if the first and second index are the same.
Otherwise the expression is called a gamma string, or shortly string.
A string may be odd or even depending on the number of arguments not counting
Gi, G5, G6 and G7. Thus the last shown is an odd string. Traces of odd strings
are always zero.

To avoid prolifiration of indices one may preferably use integer numbers
instead. For example:
    G(1,2,mu) * G(3,4,nu) * G(2,3,al) = G(1,4,mu,al,nu)
When dealing with more then one string number ranges may be reserved for
the different strings, thus avoiding confusion. Example:

X Vert(n,mu) = G(n,n+1,mu,G6)

Z xx =  Ubg(1,mm,p)*Vert(1,mu)*G(2,3,nu)*Ug(3,mn,q)
      * Ubg(10,mn,k)*Vert(10,mu)*Ug(11,me,qq)

When starting work on gamma matrices Schoonschip begins by rounding up the
gammas. For two index gammas the ordering is determined by the indices.
For gammas with one index (the old notation) the ordering is based on the
order in which they appear in the expression considered. By default the
strings are normalized, i.e. direct neigbour equal arguments are eliminated
( G(....,X,X,...) = D(X,X)*G(........) ) and traces of an odd number of
gammas (not counting G5 etc) are set to zero. Optionally that normalization
may be suppressed.

After rounding up the strings and traces appear with only one loop index.
The index is chosen from the indices seen: the smallest number (or earliest
mentioned index) is taken. Indices are 'smaller' then numbers.

   G(1,2,mu,al) * G(3,4,nu,G5) * G(2,3,la)  =>

                                G(1,"s,"4,mu,al,nu,G5,la)

The character argument "s indicates a string rather then a trace. The "4
is the unit G matrix, the need for this argument will become clear below.
The 1 is now the loop index. Another example:

   G(i1,2,mu,al) * G(3,i1,p,G5) * G(2,3,la)  =>

                                G(i1,"t,"4,mu,al,p,G5,la)

For brevity these objects will be called G-strings in the following.
The arguments may be indices, vectors or Gi-G7.

At this point there are now two types of G strings, namely "s or "t strings.
This very first phase of the work is called collecting. Normalization is
optional. Optionally one may stop the work at this point.

The next step is to apply all the known algorithms to these objects.
Optionally one may specify which strings should be worked on, either by
a specific loop index or by number range. More about that below.
Schoonschip starts by considering all arguments in the G-string. If
all indices have the (default) range 1-4 then the string becomes a four-
dimensional G-string. Occurring vectors are considered four dimensional.
If a string becomes four dimensional the character argument "s or "t is
changed in "S or "T. Some work is done on the strings:

- adjacent identical arguments are eliminated. This includes for traces
  first and last argument.
- for "S and "T strings the G5, G6 and G7 are anti-commuted to the
  left and the result is placed instead of the "4 argument.
- simple cases such as the trace of the identity are completely worked out.

Examples:

I mu,nu,al=N,be=N

    G(1,"s,"4,mu,nu,al)    => unchanged.
    G(1,"t,"4,mu,nu,al)    => 0       (odd trace).
    G(1,"s,"4,mu,al,al,nu)    => N * G(1,"S,"4,mu,nu)
    G(1,"t,"4,mu,al,be,mu)    => 4 * G(1,"t,"4,al,be)
    G(1,"t,"4,G5,mu,G6,nu)    => G(1,"T,"6,mu,nu)
                => 4 * D(mu,nu)
    G(1,"s,"4,G5,mu,G6,nu)    => G(1,"S,"6,mu,nu)
                => G(1,"S,"4,mu,nu) + G(1,"S,"5,mu,nu)

The last step belongs also to the class of doing simple cases. The expansion
of G6 would not have been done if there had been more index arguments.
Optionally one may stop the work here.

The next step is sum-splitting. N-indices in "s or "t strings are split
in a four dimensional and an N-4 dimensional part. As a convention the
quantity N_ is understood and used as N-4. Here are the equations for
the case of two index pairs:

I mu,nu,al=N,be=N

   G(1,"s,mu,nu,al,be,..,al,be) =>
            G(1,"S,mu,nu,al,be,..,al,be)
        +/- G(1,"s,"_,be) * G(1,"S,mu,nu,al,..,al)
        +/- G(1,"s,"_,al) * G(1,"S,mu,nu,be,..,be)
        +/- G(1,"s,"_,al,be,al,be) * G(1,"S,mu,nu,..)

The sign is determined by the convention that the indices to be split are first
moved to the very left. They are taken to anticommute with all four-dimensional
indices and vectors, and to commute with G5, G6 and G7. Optionally, for traces
containing an even number of G5 or for strings independent of the number of G5
one may specify anticommutation with G5. In that case G6 and G7 are expanded
before the sum-splitting is done. For traces with an odd number of G5
commutation is used even if the anticommutation option is specified, simply
because the trace is otherwise not well defined. The outcome would not be
invariant for a cyclic rotation of the arguments.

Note the "_ character argument. The range of the indices in an "_ string
is from 4 to N. Both the string and trace of the unit "_ are one:

    G(1,"s,"_) = 1
    G(1,"t,"_) = 1

Other then that "_ strings are treated as the other non-four dimensional
strings. For example elimination of a direct pair:

    G(1,"s,"_,...,al,al,...) = N_ * G(1,"s,"_,.....)

Sum-splitting requires that all N-indices occur in pairs. This no real
restriction as the pairs need not to occur in one and the same string,
but for example one index may occur in a string and the other in another
string or even some other function.

If a string contains only N-range indices then it is called pure, and
no sum-splitting is done. Index pair eleimination and trace evaluation are
done directly on such a string.

Sum-splitting is done by default. Optionally work may be stopped here.

The next step is the unification of G-strings. By default this is not done,
because it is not always advantegeous, and because it may be necessary to
indicate explicitly which strings are to be unified. The unification is
based on the Chisholm's equation:

  G(1,"X,a1,a2,...,mu,b1,b2,...) * G(2,"T,mu,c1,c2,...,cn)
    =   2 * G(1,"X,a1,a2,...,c1,c2,...,cn,b1,b2,...)
      + 2 * G(1,"X,a1,a2,...,cn,...,c2,c1,b1,b2,...)

where "X may be "S or "T. The application requires

- the G-strings involved must be four-dimensional.
- they must have one index in common (mu in the above).
- at least one of them must be a trace.

The general rule is that it is advantageous if the G-strings have other
arguments then the explicitly shown index in common. That may be either
vectors or indices. Thus there is an advantage if for example c1 and b1
are the same, because in the second term that can be worked out.
This work is called unification, and optionally one may stop the work here.

The next step is to eliminate index pairs in the G-strings. For four-
dimensional strings there is the Kahane algorithm which eliminates all
pairs in a given string in one sweep, for "s and "t strings there is a
single pair algorithm that can be applied repeatedly. This is done by
default. One may specifically allow or inhibit index pair elimination
in _ type strings seperately. Optionally one may stop the work here.

The next step is the elimitation of vector pairs in four dimensional strings.
This is also a single pair algorithm that can be applied repeatedly.
It is called the P-algorithm. Optionally one may stop the work here.

The final step is to actually evaluate the traces, and to reduce the
four dimensional strings to a standard form. This is called the W-operation
(for final work).

In summary, the following is done:

- Rounding up of all strings. This step cannot be avoided. All occurring
  G are rounded up, even those that are not to be worked on. By default
  the strings are normalized.
- Sum-splitting. By default. With optionally Anticommuting G5 if an even
  number of G5 present.
- Unification. Not done by default.
- Index pair elimination, also for pairs in _ type strings (the latter
  may be inhibited with the i-option) Done by default.
- P-algorithm for four dimensional strings. By default.
- Work: final traces and reduction for four dimensional strings.

The options are characterized by a character, namely N, A, S, U, I, P and W.
The command for all this is

Id,Gammas

By default work is done on all occurring strings. For most cases, using
the two-index G notation this will do. If there are single index G's
(the old notation) then it must be possible to specify which are strings
and which traces. By default they are taken to be strings. If a trace is
intended loop indices must be mentioned:

Id,Gammas,Trace,i3,i4

In strings i3 and i4 the "s is replaced by "t.

As soon as one or more specific index is mentioned in the Gammas command only
loops with the loop indices as occurring in the list will be worked upon.
For any individual loop index options may be specified. Options may be on
or off. The are turned on by the appropriate character argument, and turned
off if the argument is followed by an undersore (_). Furthermore one may,
in case numbers are used as loop indices, indicate a range of loop numbers.
Here is the syntax:

Id,Gammas,C1,C2,i1,1-4:C3,C4,Trace,i2:C4,C5,i3,9-10

C1, C2 etc are character arguments, either one of these:

"N  "N_ "A "A_ "S  "S_  "U  "U_  "I  "I_  "P  "P_  "W  "W_ "i  "i_

In addition there is the option "C. It is synonym for turning all
options except "N off, i.e. only collecting and normalization is done,
with the further difference that no specialization to four dimensions
is ever done. This is very essential if there is some integration vector
where this vector is not four dimensional. Typically, if n-dim integration
is to be done one first collects all G with the "C option, then the
integrations are done, and after that the remaining work can be
done through another Gammas command.

To avoid normalization specify "N_ in addition to "C.

The first mentioned character arguments define the default. If none is
mentioned the default is "N,"A_,"S,"U_,"I,"P,"W,"i. The "i refers to index
pairs in N_ (i.e. "_) type strings.

G strings with loop indices mentioned after the Trace argument are forced
to be traces ("t).

A loop index may also be specified by a number range. Any G-string with a
loop index within the range (inclusive the values mentioned) are considered.
If the loop index or the range is followed by a colon then the following
character arguments define the options for specific loop. Those options
override the default options.

Example:

Id,Gammas,"A,"U,1-9:"A_,10-20:"U_,"I_

Strings with loop indices 1-9 and 10-20 are considered. Unification is
attempted on loops 1-9. Loops 1-9 have commuting G5 with respect to
sum-splitting, 10-20 anticommuting for traces with an even number of G5  or
strings for any number of G5. No index pair elimination is attempted on 10-20
loops, but index pairs in N_ type strings are still worked on. To inhibit that
a "i must be mentioned in addition.

Please note the use of the colon (:). This is because at least in principle it
is not excluded to also use character arguments as loop indices for two-index G
(they are inbetween numbers and indices with respect to ordering). Several
characters are illegal in this respect: "S,"T,"s and "t, at least if they occur
as the second argument in a two-index G.


As noted before, in all gamma operations all vectors are considered four-
dimensional. There are at least two ways to handle things. Commands to
simplify the work have been introduced.

Consider a case in which there occurs some momentum p is to be integrated
over N-space, and suppose this p occurs as G argument:

    G(1,2,al,be,p,al,be,p)

(the two index notation is and will be used from now on). The first step is
to get the p out. A new command, essentially a combination of existing
commands can be used here:

Id,All,p,N,F

In this command p is a vector, N is an optional argument specifying the
range of the indices to be created, and F is a function defined in an
F-list. This command rounds up all p, also those occurring in functions and
dot-products, and collects them in the function F. Example:

V p
F F
S N

Z xx =  pDq*pDp*F1(aa,bb,p)*p(mu)
Id,All,p,N,F
*end

This is the output:

    xx = + F1(aa,bb,Naa)*F(Naa,mu,q,Nab,Nab) + 0.

In here the quantities Naa and Nab are created indices with range N.
If one substitutes
    F(i1~,i2~,i3~,i4~,i5~) = p(i1)*p(i2)*p(i3)*p(i4)*p(i5)
then the original expression re-emerges. This may actually be done
more easily with the command Iall, the inverse of All:

Id,Iall,p,F

searches for F and restores to the original expression.

Both All and Iall have also another syntax, see the description elsewhere
as well as the example further down.

The All command may now be used to eliminate the p from the G-string. Next
integration may be done, for example:

Id,F(i1~,i2~) = D(i1,i2)*F20(k) + k(i1)*k(i2)*F22(k)

where k is a four-dimensional vector. After this gamma work may be done.
Here is the full example with output:

I al,be,mu,nu
S N,N_
V p,k
F F,F20,F22

Z xx = G(1,1,al,be,p,al,be,p)

Id,All,p,N,F
Id,F(i1~,i2~) = D(i1,i2)*F20(k) + k(i1)*k(i2)*F22(k)

Id,Gammas
*end

 xx = + F20(k) * ( 64 - 32*N_ )  +  F22(k) * ( 16*kDk )

It should be emphasized that the symbol N, occurring in the All command
must be defined in the symbol list, together with the symbol N_. If
such a symbol occurs already as range in an index list this is done
automatically, but in this case that did not happen. The command All
will not work otherwise. Also p and F must have been defined before,
either implicit or explicit. N cannot be defined implicit, because
it would be taken as an index rather then an algebraic symbol.
Again, N_ is supposed to be N-4.

The command All is really a combination of three existing substitutions,
namely

Id,p(mu~) = ...
Id,Dotpr,p(mu~) = ...
Id,Funct,p(mu~) = ...

In addition All handles the creation of the function F with its undetermined
number of arguments smoothly.

The substitutions shown have been modified slightly. Now the range of the
index mu is taken into account. If an index is created in the course of the
work for these substitutions it is given the range of mu.

The second method for dealing with vectors in G-strings is as follows. Let
there be a string containing several vectors as aguments:

    G(1,1,mu,G5,p,q,nu,G5,q,p)

Now use command All specifying the function G rather then the vector p:

Id,All,G,N,F

Again, N, N_ and F must have been defined before. This command takes
out all vectors from the specific function mentioned (here G) and collects
them, together with the indices created, into the function F1:

F F1
I mu,nu
V p,q

Z ft = G(1,1,mu,G5,p,q,nu,G5,q,p)

Id,All,G,N,F1
*end

The result is:

 ft = + G(1,1,mu,G5,Naa,Nab,nu,G5,Nac,Nad)*F1(p,q,q,p,Naa,Nab,Nac,Nad)

Now the gamma work can be done. The result is rather messy, and it is displayed
here (slightly edited) for a simpler case:

F F1
I mu,nu
V p,q
A N,N_

Z ft = G(1,1,mu,G5,p,nu,G5,q)

Id,All,G,N,F1
P output
*yep

ft = + G(1,1,mu,G5,Naa,nu,G5,Nab)*F1(p,q,Naa,Nab)

Id,Gammas
P output
*yep

ft =      + 4*F1(p,q,Dim_N_,Naa,Dim_N_,Naa)*D(mu,nu)
     + 4*F1(p,q,Dim_4,mu,Dim_4,nu)
    + 4*F1(p,q,Dim_4,nu,Dim_4,mu)
    - 4*F1(p,q,Dim_4,Naa,Dim_4,Naa)*D(mu,nu) + 0.

As is clear Schoonschip has added on prefixes to the indices inside
the function F1 to show the range. The function F1 with those prefixes
cannot be handled by any substitution or command except the command
Ndotpr, specially created for this situation. It works out the F1
arguments and creates various symbols analogous to dotproducts (but
they are not, they are symbols) showing the summation range:

Id,Ndotpr,F1
P output
*end

ft = 4*p(mu)*q(nu) + 4*q(mu)*p(nu) + D(mu,nu) * ( 4*pq_ - 4*pq4 ) + 0.

In here pq_ means the dotproduct of p and q but only components 4 to N
enter in the dotproduct. Similarly pq4 denotes a dotproduct with only
the first four components entering. Obviously pq4 + pq_ = pDq, where
pDq is the normal dotproduct.

The symbols pq_ and pq4 are algebraic symbols. They are created during
execution, and if a symbol list is asked for in a subsequent section
(after another *yep for example) the A-list would be:

A i=i, N, N_, pq_, pq4

Just for curiosity: if the A option had been specified in the Gammas
command the term pq_ would have come out with the opposite sign. That
is because there is one G5 inbetween p and q.

Here is once more the example, but without the intermediate printing:

F F1
I mu,nu
V p,q
A N,N_

Z ft = G(1,1,mu,G5,p,nu,G5,q)

Id,All,G,N,F1
Id,Gammas,"A
Id,Ndotpr,F1
*end

ft = 4*p(mu)*q(nu) + 4*q(mu)*p(nu) + D(mu,nu) * ( - 4*pq_ - 4*pq4 )


This concludes the discussion. For the rest of this section some more
examples.

C G collection including spinors.

I mu=N,nu=N
V p,q

Z xx = G(i1,i2,mu)*G(i2,i3,nu)*Ubg(i1,M,p)*Ug(i3,M,q)

Id,Gammas,"C
*end

    xx = + Ubg(i1,M,p)*G(i1,"s,"4,mu,nu)*Ug(i1,M,q) + 0.

C No problems with complex conjugation:

I mu=N,nu=N
V p,q

Z xx = Conjg( G6(i0,i1)*G(i1,i2,mu)*G(i2,i3,nu)*Ubg(i0,M,p)*Ug(i3,M,q))

Id,Gammas,"C
*end

    xx = + Ubg(i3,M,q)*G(i3,"s,"4,nu,mu,G7)*Ug(i3,M,p) + 0.

where a G6 was included.

A string containing only N-indices is called pure. All index pairs can be
eliminated, and traces can be evaluted completely. Here an example
involving a string and a trace:

I mu=N, nu=N, al=N, be=N, ga=N

Z xx = G(i1,i2,mu,ga,nu,al,be,ga)
     + G(i1,i1,mu,ga,nu,al,be,ga)
Id,Gammas,"C
P output
*yep

xx = + G(i1,"s,"4,mu,ga,nu,al,be,ga) + G(i1,"t,"4,mu,ga,nu,al,be,ga)

Id,Gammas
*end

xx = + D(mu,nu)*D(al,be) * ( 8 - 4*N )
     + D(mu,al)*D(nu,be) * ( - 8 + 4*N )
     + D(mu,be)*D(nu,al) * ( 8 - 4*N )

     +   G(i1,"s,"4,mu,nu,al,be) * ( - N_ )
     - 2*G(i1,"s,"4,mu,be,al,nu) + 0.

Except the pair elimination nothing has been done about the string. One could
actually bring the strings into some normal form, but the advantages of that
are unclear, and it is also dubious as to what is the best normal form. The
work involved and the number of terms generated is considerable. For this
reason nothing has been implemented. But a possible way will be discussed now.

Define the function AG to be totally antisymmetric in all its arguments
except the first which is the loop index. If the number of arguments beyond
the first is m it is equal to the totally antisymmetric combinations of m
gammas divided by m!. Examples:

     AG(L)          = Gi(L)
    AG(L,mu)       = G(L,mu)
    AG(L,mu,nu)    = 1/2 * { G(L,mu)*G(L,nu) - G(L,nu)*G(L,mu) }
    AG(L,mu,nu,al) = 1/6 * { G(L,mu)*G(L,nu)*G(L,al) - .... }
    :
    :

Any string can be written as a linear combination of such functions AG:

    G(L,"s,m1,m2,m3,...) = a0*AG(L) + a1*AG(L,n1) + a2*AG(L,n1,n2) + ...

For example:

    G(L,"s,"4,mu,nu) = D(mu,nu)*AG(L) + AG(L,mu,nu)

For the case of three indices:

    G(L,"s,"4,mu,nu,al) =
        D(nu,al)*AG(L,mu) - AG(L,nu)*D(mu,al) + AG(L,al)*D(mu,nu)
         + AG(L,mu,nu,al)

The number of terms increases faster then the number of terms for a trace.
For four indices the number of terms is 10 (3 for a trace), for five it is 11
and for six it is 76 (15). Here a program that computes this expansion for the
case of four indices (where only a0, a2 and a4 are non-zero):

I mu=N, nu=N, al=N, be=N, b1=N, b2=N, b3=N, b4=N

Z xx = { 1/(4*DB(4)) * G(L,"t,"4,mu,nu,al,be,b1,b2,b3,b4)} * AG(L,b4,b3,b2,b1)
       + 1/(4*DB(2)) * G(L,"t,"4,mu,nu,al,be,b1,b2) * AG(L,b2,b1)
       + 1/4 * G(L,"t,"4,mu,nu,al,be) * AG(L)

Id,Gammas
Id,Asymm,AG,2,3,4,5,6
*end

Note that AG was specified to be anti symmetric in more arguments then actually
occur. The excess is simply ignored by Schoonschip.

The time involved is considerable because of the large traces to be computed.
For six indices the time to evaluate AG is about 150 seconds (M68000).
The method shown is however not the most efficient.

17. R-INPUT.

Sometimes it is desirable to work on a very large input expression, larger
than Schoonschip can accomodate in its input space. The R-input facility
is designed specifically for this purpose. More precisely, it is geared
towards input that is exactly of the form as normal Schoonschip output.
Put an R in column 1 of the line with the file name; Schoonschip
will read the subsequent input and transform it into the same format
that is used in *yep situations. After a subsequent *yep the expression
can be worked on. As an example consider a case given before producing the
output

xxx = + [b-a]^-1
  * ( [x+a]^-1 - [x+b]^-1 ) + 0.

To be sure that all symbols have the same meaning specify the P lists
option in the problem that produces that output, and include these
lists in the new input. Then put an R in column 1 and a blank in column 2
of the line with xxx:

A i=i, [b-a], [x+a], [x+b]

F D, Epf=i, G=i, Gi, G5=i, G6=c, G7, Ug=c, Ubg, DD, DB, DT, DS, DX,
  DK, DP, DF=u, DC

R xxx = + [b-a]^-1
  * ( [x+a]^-1 - [x+b]^-1 ) + 0.

*yep

Id,[b-a]^-1=bma
*end

There is no limit on the length of the expression other than available
disk space.

R-input can be very useful if one wants to edit expressions or process
parts of large expressions. It may also be used effictively to compare
outputs. To this purpose put the secons expression behind the first
but put an M (for minus) in column 1 rather then an R:

A i=i, [b-a], [x+a], [x+b]

F D, Epf=i, G=i, Gi, G5=i, G6=c, G7, Ug=c, Ubg, DD, DB, DT, DS, DX,
  DK, DP, DF=u, DC

R xxx = + [b-a]^-1
  * ( [x+a]^-1 - [x+b]^-1 ) + 0.

M xxx = + [b-a]^-1
  * ( [x+a]^-1 - [x+b]^-1 ) + 0.

*yep

B [b-a]

*end

18. STATEMENTS. CONDITIONAL INPUT READING.

Several statements have already been mentioned before. Here is the complete
list.

Showl        Show some statistics of large disk files being written.
Nshow        Switches Showl off.
Write fname    Write all common files to disk file fname.
Enter fname    Enter common files from disk file fname.
Bdelete b1,..    Delete blocks
Read fname    Start reading external file fname.
End        End of an external file.
Screen        Print in output lines up to 80 characters (default).
Lprinter    Print in output lines up to 130 characters.
Anti TX        Defines character table TX to contain the default anti-
        particle list. May appear in *fix section.
Beep options
        If no options all beep requests are cleared.
        If #,t issue # beeps at termination.
        If #,* issue # beeps when concluding a section (* delimited).
        If #,e issue # beeps in case of an error.
Common ...    Common declaration.
Delete ...    Delete files.
Directory    Defines directories to be used for large files. See section
        on file handling.
Digits        Defines number of digits to be printed for floating point
        numbers.
Dryrun #    Do a 'dry run'. Print at most # terms at completion.
External fnam    Read fnam into memory. Command Extern executes that file.

Fortran type output has been shown to need often considerable editing.
The section of Schoonschip producing this has been rewritten. By default
the fortran output has only complete terms on any given line (if possible)
rather then the compressed form desirable in the old days when cards were
used. The compressed form is still available though. In addition, one may
specify how many continuation lines any given statement may have. Also
one may direct Schoonschip to place brackets around negative exponents.
Finally one may optionally direct Schoonschip to supplement every integer
with a decimal point, as some Fortran compilers require this.
All this may be achieved with the Fortran command. Every item is optional,
the defaults being: no compression, 9 continuation lines/statement, no
brackets, no . in integers, fortan type output.

Fortran #,Brackets,Compression,.,A

Only the first character of Brackets and Compression is significant and may
be lower or upper case. A minus sign in front of Brackets, Compression or .
switches back to the default, for example Fortran -Brackets instructs
Schoonschip not to put brackets around negative exponents.

The exponent of a number is normally shown using the character E (e.g.
1.23E+10). If a number of digits (Digit statement) larger than 5 has been
specified then D will be used instead (1.23D+10).

Finally, to specify output for the A-compiler mention the character A
on the Fortran statement.

Freeze xfile    Freezes file xfile. See section on large problem
            handling.
Keep fil1,...    Keep files over a *next
Large #        # is a number in the range 1 to 5 inclusive. Default is 2. It
        specifies the number of intermediate output files to be used
        for large file sorting. See section on file handling commands.
Maximum #    Specifies the maximum size of intermediate output subfiles.
        Default is 110 000. See section on file handling commands.
Names fname    Enter names of a common file.
Nprint fil1,..    Do not print file1,..
Oldnew xx=yy    Renames a quantity.
Outlimit #    Sets a limit of # bytes on disk usage. In case of large file
        usage this sets the limit on total disk space used for the
        intermediate output files. Default: 500 000 = 0.5 Mb.
Overflow off    Suppresses short number (exponents, function arguments)
        overflow error trapping. May appear in *fix section.
Overflow on    Reactivates overflow error trapping.
Print ...    Specifies files to be printed.
Precision #

This specifies the precision required for dealing with numbers. This number #
applies internally at various instances. In the output two terms are taken to
cancel if the addition gives a cancellation up to # digits. Comparing numbers
with the Coef command uses the precision criterium. Also, when writing terms to
disk every number is truncated to 10 digits if # above is 9 or less. This saves
considerably on disk space. The default is 22 digits.

Progress    In case of no output to the terminal print a . to the
        terminal every 128 terms to show progress.
Punch ...    Specifies files for which fortran output must be made.

Rationalize #

Schoonschip by default tries to rationalize numbers. The number # specifies
to how many digits the numbers must agree. For example, Schoonschip will
rationalize Pi = 3.141592654.. to 22/7 = 3.142857143... if 3 is specified.
Specifying 5 gives 355/113 = 3.14159292... which actually agrees 7 digits.
It should perhaps be noted that after every rationalization Schoonschip
actually performs the division and compares the result with the input number,
just to be sure. If 0 is put for # no rationalization is done. The default
is 22 digits, with check up to 26 digits.

Round on    Numerical expressions as function arguments to be converted
        to short integers are normally obtained by truncation. If
        Round on the number is rounded to nearest integer. Round
        off resets to the default, truncation.
Silence        Instructs Schoonschip not to print "Ready" to the screen and
        wait for an answer for certain PC's that normally clear the
        screen immediately at termination.
Sum ...        Specifies indicies to be summation indices.


Synonym name1=name2

        Every occurrence of name1 between single quotes is replaced
        by name2. This is very much like replacements of BLOCK
        arguments, except that it is not limited to a block.
        The end of the range of validity of some set of synonyms is
        defined by the synonym statement without any arguments.
        At most 16 synonyms allowed.

Traditional    Do traditional sorting. See section on file handling commands.

The conditionional input reading statements may be used to formulate small
variations on a given problem. The idea is to define some parameters in the
beginning of a problem, and then to read input as a function of those
parameters. Many variations upon a given problem can then be run simply
by changing a few parameters in the beginning.

The parameters are called _Sw0 to _Sw9 and their default values are 0.
The initial value of the parameter _Sw0 may actually be set on the command line
when invoking Schoonschip. To this purpose use the notation S=#, where # must
be a number in byte range (-128, 127). Example:

Schip S=7 Ifile

The initial value of _Sw0 will be 7.

The _Swx may be changed by means of a Set statement. The syntax is:

Set _Sw? = expr

with ? a number in the range 0 - 9, and expr a simple numerical expression
(see below) in byte range, i.e. -128, 127. Example:

Set _Sw3 = 7

Every occurrence of _Sw3 is replaced by the number 7. This includes actual
occurences within any given expression, for example

    ... a^_Sw3 ...

is read as  a^7. Other example:

Set _Sw5 = _Sw5 + 1

In addition the variables _Sw0 - _Sw9 may occur in a Gotoif (or Gotoifn)
statement. Here is the syntax:

Gotoif expr1, expr2 ? expr3

Expressions expr1, expr2 and expr3 must be simple numerical expressions,
defined below. They evaluate to a number. Expr1 must evaluate to a number
in the range 0 - 99. The other two expressions are evaluted on a 16 bit
basis (range -32000, 32000). The question mark ? may be >, < or =. The
expressions are compared and if the condition is true all following lines
are skipped until a line with an @ symbol in column 1 is seen. This @
symbol may be followed by a number, and if this number is equal to the
value of expr1 the skipping stops, else continues. If there is no number
after the @ symbol the skipping stops always.

The statement

Gotoifn expr1, expr2 ? expr3

is analagous to the above except that the skipping starts if the condition
is not true. Finally

Goto expr1

leads to an unconditional start of skipping.

The expressions may contain numbers separated by the operators + - | & * and /.
The operator | stands for logical OR and & is the logical AND. Precedence: +
etc as usual, | as +, & as *. The division is integer division, for example 3/2
equals 1. Furthermore the variables _Sw0 to _Sw9 are considered to be numbers
with whatever value that they have been set to (zero initially).

Here is a simple example, showing also the use of the Synonym statement:

Synonym Xxx = _Sw0

Set _Sw9 = 3
Set _Sw1 = 2-3*(22/2-4)
Set _Sw2 = 2-(22&2-4)*_Sw9
Set _Sw3 = 6
Set _Sw4 = 1 | 0x20

Z xx = (a + b) ^ 3 + a0^'Xxx' + a1^_Sw1 + a2^_Sw2 + a3^_Sw3 + a4*_Sw4

Gotoif 20, _Sw3 > 5

Id, b = 20*c
Goto 21

@20
Id,b = a + c

@21
*begin

Here is the output in case the value 62 was specified as initial value for
_Sw0, by means of a command line specification: Schip S=62 ... If no S=#
parameter present on the command line the value of _Sw0 would have been 0
giving 1 instead of a0^62.

xx = a0^62 + a1^-19 + a2^8 + a3^6 + 3*a4 + 6*a*c^2 + 12*a^2*c + 8*a^3 + c^3

Note the notation for a hexadecimal number, 0x20 (= 32 decimal). An OR with 1
produces 0x21, i.e. 33 decimal. The AND of 2 with 22 is 2 (in hexadecimal 22 =
0x16, which gives 0x02 when AND'ed with 0x02).

In the above case, since the condition is true, skipping starts immediately
after the Gotoif statement, and continues till the line with @20 is met. Thus
the problem reads:

Z xx = (a + b) ^ 3 + ...

Id,b = a + c
*begin

If _Sw3 is not set, or set to some value equal or less than 5 the problem
will be read as

Z xx = (a + b) ^ 3 + ...

Id, b = 20*c
*begin

Use of

Gotoifn 20, _Sw3 < 6

instead of the earlier Gotoif statement would give the same results.

If no skipping is going on lines with an @ in column 1 are ignored.


19. LARGE PROBLEM HANDLING.

Considerable attention has been focussed on the question of large output.
The traditional output sorting method of Schoonschip is inadequate for
truly large problems, with more then 50 0000 terms in the output.
Moreover, as small computer systems do not have infinite large disk
space (typically 20 Mb) a method economizing on that is important.

The traditional system works as follows. Generated terms arrive at the
sorting routine and are compared with the terms already present in the
output store. If found, coefficients are added. If not found, and there
is space left the term is entered in the output store. Else the term
is simply written to disk, and further adding of terms to the output
store is inhibited. This method is quite wasteful as far as disk space
is concerned. The timing depends crucially on the disk system, and
is generally slow.

The new method uses up to five output files. If the output store is full
the content of the output store is dumped on, say, file1, and sorting
resumes. If again the output is full the store is dumped on, say, file2,
etc. If the maximum number of files is reached then merging is done
rather then straight dumping. Assume for example that a maximum of three
output files has been specified. Assume now that already three files,
file1, file2 and file3 have been created. At this point, when the output
store is again full, a merge takes place. The smallest file (say file2)
is selected, and merged with the contents of the output store to a
new file, called file2a (for example, naming conventions are given below).
And so on. When the whole problem is finished there are then three
possibly very large files. As a final step these three files are
piecewise merged into the output store and printed etc.

With this method the disk usage is already considerably less than with
the traditional method, because only sorted expressions are written
to disk. Still, the disk use may be quite more than the final size of
the result; each of the above three files may well be of the order of
magnitude of the final size.

If disk space is really crucial then the above method may be used
specifying usage of only one file. The first overflow produces the
file. The second produces a merging of the file and storage, giving
rise to a new file. Disk usage is maximum at the moment that the last
part of the original file is read, and the new file is almost written
out. That disk usage is then about twice the size of the final result.

To deal with this final factor of two a fractured file system has been
implemented. A fractured file is a file split up in smaller files.
Each of these smaller files is a normal file to the operating system;
only one at the time is opened for reading or writing. Moreover, after
reading they are immediately deleted. In the case described one would
for example produce file1, fractured up into five files called file1_0
to file_5. When merging this with the output store file2, fractured
into file1a_0 to file1a_7 (for example) is created. At the moment that
the last subfiles are being created most of the subfiles of file1
will have been deleted. The maximum disk space used with this method
is usually about equal to the size of the final file plus an overshoot.
This overshoot may be one extra subfile size. In addition of course
the overshoot is problem dependent; computing the difference of two
large but equal expressions leads to a final size of zero, but the
intermediate result may at one point be as large as that of one expression
alone. Schoonschip assumes that an overshoot at least as large as the
size of the output memory is allowed. This is used to skip the last merging,
thus dumping the last output store onto file2 and then merging (possibly
very large) file1 with this much smaller file2 while printing.

This method appears to be the best one can do concerning disk usage.
The timing is reasonable, but goes up quadratically with the size
of the final file. To give an idea, a 6 Megabyte final result takes
about 6000 seconds merging time, depending on the system (M68000
assumed).

If space is no issue then more then one dump file may be specified.
The sorting time decreases roughly linearly with the number of files.
This is of course very problem dependent.

A very important factor is also output memory size. Sorting time
decreases roughly linearly with increasing memory size. To allow for
adaption to particular systems the size of the output memory may
now be specified on the command line when calling Schoonschip.
However, be careful with systems having dynamic memory management
such as the Sun. If to much memory is specified then the system will
accept that and swap memory onto disk as needed. This is of course
very counterproductive. It would bring Schoonschip virtually to a halt.

Also the format of numbers plays a role. Integers (limit 2 000 000 000)
take less space on the disk then most other numbers (6 versus 14 bytes
for anyone term). Thus if all numbers can be made integer by means
of some overall factor then that will improve both speed and output size.
The factor can be divided out later, or whatever. If a precision of
less then 9 digits is specified (N 9 or Precision 9) then all
numbers written to disk will be rounded such as to fit in 6 bytes.

Of importance is the way an expression is factored. This factorization
is under control of the user through the use of the B-list. In the
output store the terms are stored precisely as they are printed:
  head1 * ( tail11 + tail12 + ...) + head2 * (tail21 + ...) + ...
Without factoring much more space would be used:
  head1*tail11 + head1*tail12 + ...
Too much factoring is also wasteful:
  head1 * (tail1) + head2 * (tail2) + ....

To adequately allow tailoring of a problem a number of facilities have
been provided. Notably, for a large problem, a "dry run" may be executed.
If that is specified then Schoonschip will not write any file, but simply
discard any full output store. An estimate of the time and disk space
needed will be made and printed. The estimate is for minimum disk space
(i.e. only one output file to be used). Optionally a limited number of
terms in the output will be printed, to inspect for optimal factorization.

If more then one device is available for storage then it might be desirable
to split up the output files over different devices or directories.
Also this may be done.

Finally the maximum size of the subfiles may be specified.

The naming of the files is as follows. All names are of the form
  TAPxyyyL
where x and yyy are hexadecimal numbers. The equivalent of file1_0,
file1_1...file1_10,... etc. above is TAP6000L, TAP6001L ... TAP600AL,....
The equivalent of file1a_0 etc is TAPB000L etc. File2_0 is TAP7000L,
file2a_0 is TAPC000L, etc. Thus the two groups of output files are
TAP6 through TAPA and TAPB through TAPF. File TAP6 when merged with
storage produces file TAPB and conversely.

Also the "Yep" file has been made into a fractured file. The name used
is TAP4yyyL, with yyy starting at 000. In this way the disk usage is
minimized in the case of a *Yep.

A useful tool in handling large problems is the Freeze command. Suppose
there exits a large common file that must be worked on further. In
particular, suppose that work must be done on certain factors. If
the file has, say, 10000 terms then that work must be done 10000 times.
To cut down on the work as well on the size of the problem the
following may be done.

First, when producing the file specify on the B-list those factors on
which the work must be done. For example, if an expression must be
integrated over some variable x, with X1, X2 and X3 denoting x dependent
factors:

Common xfile
B x,X1,X2,X3
Z xfile = ....
 Substitutions, commands
*begin

The result will be of the form:

 xfile = x * (terms1...) + x^2 * (terms2...) + X1 * (terms3...) etc.

There may be many terms inside the brackets. As the file must be a common
file it now resides on disk. The subsequent command (after the *begin)

Freeze xfile

produces the following result. The file xfile is read and split up in one
main file and possibly many 'frozen' subfiles. The main file will still
be called xfile, and is as follows:

 xfile = x * DF(xfile,1) + x^2 * DF(xfile,2) + X1 * DF(xfile,3) etc.

The subfiles are denoted as x_file:

 x_file(1) = terms1
 x_file(2) = terms2
 x_file(3) = terms3
 :
 :

The frozen subfiles are not directly accesible like other files. They
may be referred to only by means of the DF function. There is a command,
Expand, that allows substution of the subfile for the DF function. For
example,

Z xx = DF(xfile,3)
Id,Expand,xfile
*end

will produce for xx the contents of x_file(3). This may also be used
to restore the file to its original shape:

Common xfilp
B x,X1,X2
Z xfilp = xfile
Id,Expand,xfile
Delete xfile
*begin

The new file xfilp will be precisely as the original xfile. Deleting
(but not replacing) a frozen main file leads to deletion of all frozen
subfiles.

It is clear that the work on the frozen main file xfile will be much
less voluminous since it will have many less terms. After the work has
been done one may re-establish the complete file using the Expand command.

Freeze is a very powerful tool. It must however be used with some care.
Most importantly: file arguments are not, repeat not, transferred to
the subfiles. For example, defining

Z xfile(a1,a2) = ...

and subsequently freezing xfile leads to a number of subfiles. Using
now xfile with some other arguments,

Z ha = xfile(mu,nu)

and subsequently expanding the subfiles will not lead to the replacement
of a1 and a2 in the subfiles by mu and nu. Thus as a general rule a
file to be frozen should not have arguments.

Particularly tricky are created indices here. If such indices are
summation indices then it may happen that of such a pair of indices
one appears outside parenthesis, and one inside, and thus may become
part of a frozen subfile. Since Schoonschip often renames summation
indices there may then result a situation where the index outside
is renamed, while that inside remains the same. See the discussion
at the All command.


20. FILE HANDLING COMMANDS.

This section assumes that the reader is familiar with the section on large
file handling. The commands may be in upper or lower case, and only the
first two (three if confusion possible) characters are significant.

To specify Traditional sorting:

Traditional

Whatever the default is and will be is a matter of time and experience.

The specify the new method:

Large #

where # is a number in the range 1 to 5 inclusive. Default is 2. It specifies
the number of output files to be used.

To specify the maximum size of the subfiles:

Maximum #

where # is the maximum size of the subfiles in bytes. Default is 110 000.

For each of the subfiles a prefix (directory) may be specified. One may
either specify a collective prefix for all subfiles regardless of the
first number (6-F), and/or specify individual prefixes. Here is the
syntax:

Directory #,prefix1,#,prefix2,#,prefix3,...

For any subfile the number designating the subfile is compared with
the chain. The prefix inbetween two numbers (including the first
but not the second) that have a range including the file number
will be used. If the number is less than 1000 hex (=4096) then only
the last three hexadecimal digits of the file number are used, else
all. The prefix is simply glued in front of the name TAP... as described
before. The special notation . (just one period) designates no prefix.

It should be noted that Schoonschip accepts hexadecimal numbers with
the notation 0x... where ... are hexadecimal digits. For example
0x100 is the same as 256.

Here some examples.

Directory 0,/usr/tmp/,10,/user1/tmp/,100,.

The numbers must be in ascending order. This statement must be the
very first in any Schoonschip program, and it must be in a *Fix section.

Files TAPx000L through TAPx009L are prefixed with /usr/tmp/:
 /usr/tmp/TAP6000L
for example. Files TAPx00AL through TAPx063L are prefixed with
/usr1/tmp/. Files TAPx0064L and up get no prefix. There is collective
sharing of directories, for example TAP6001L and TAPB001L get the same
prefix.

Directory 0x4000,/usr/tmp/,0x6000,.,0xB000,/usr/tmp1/

The prefix /usr/tmp/ is assigned to files TAP4yyyL and TAP5yyyL.
Files TAP6yyyL through TAPAyyyL get no prefix, and files TAPB000L up
get /usr/tmp1/. Files TAP0yyyL through TAP3yyyL (not yet used) get
no prefix.

Default: no prefix.

The old statement

Outlimit #

specifies in all cases the maximum number of bytes that can be written.
Default: 500 000.

To obtain information on the size of the various files being written
use the statement

Showlength

It causes Schoonschip to print the total size and the name of the last
subfile after completion of that file. The statement

Nshow

Switches it off. The statement

Dryrun #

causes Schoonschip to do a dry run as described before. The number #
specifies the maximum number of terms that will be printed. This
statement may appear also after a yep for example. If # is 0 or absent
no dry run is made.



21. SUMMARY.

Lines with a C in column one (excluding Common) are comment lines.
Lines with a blank in column one are taken to be continuation lines (also
for C-line continuations).

Lines with a ~ in column one are ignored.

A ! signals the start of comments on a line, but otherwise is seen as
end-of-line.

  Print options:

P brackets         First 2 characters significant.
P heads            First 2 characters significant.
P input            First 2 characters significant.
P lists            First 2 characters significant.
P ninput        First 2 characters significant.
P nlists        First 2 characters significant.
P noutput        First 2 characters significant.
P nstatistics        First 2 characters significant.
P output        First 2 characters significant.
P statistics        First 2 characters significant.
Lprinter        Print output lines till 130 characters.
Screen            Print output lines till 80 characters.

External file reading:

Read fname        Start reading from external file fname.
            In fname no Read statements allowed.
End            Switch back to normal input and close the file.
            A subsequent reading of that same file starts
            again at the begin.

Common file manipulations:

Enter Cfile        Enter common files contained in file Cfile.
            Must be in first section, terminated by *fix
            There may be several Enter statements in that section.
Write Cfile        Write common files to file Cfile.

Blocks and DO-loops:

BLOCK Name{arg1,...}    Defines Block Name. In text arguments between ''.
            Call: Name{brg1,...}   Name must start in col 1.
            If an argument contains comma's this argument must
            be enclosed in {}. Concerning nesting: Schoonschip
            strips away one layer of {} at a time.
ENDBLOCK

DELETE Name1,Name2,...    Delete blocks Name1,...

DO L1=n1,n2,n3        Optional n3. If absent is taken to be 1. In text
ENDDO            argument L1 between ''.

  File related statements:

Common Name1,Name2(0),Name3,..        Defines common files.
Delete Name1,Name2(5),Name3,..        Delete files.
Keep Name1,Name2(5),Name3,....        Keep local files over a *next.
Names Name1,Name2(5),Name3,...        Enter namelists of these files.
Nprint Name1,Name2(5),Name3,..        Do not print these Z-expressions.
Print Name1,Name2(5),Name3,...        Print these Z-expressions.
Punch Name1,Name2(5),Name3,...        Write to tape8 in Fortran compatible
                    form.

In certain lists the name of an indexed file may appear without index. In
that case the command applies to all files with that name. This holds for
Delete, Keep, Nprint, Print and Punch.

Various 'first-column' types:

*            Start execution or go on to next section. Options:
             fix  yep  next  begin  end
             The *fix section must be the first section.
             All names, but not expressions in brackets are
             kept over a *yep.
             *next as *yep, except that local files not mentioned
             in a Keep list are deleted.
             All except fixed quantities and common files are
             deleted over a *begin.
             *end signals end of input file.
A a1,a2=x,..        Algebraic symbol list. If x is a number then powers
             of a2 equal or higher than x are set to zero.
             Alternatively x may be c, r or i, denoting reality
             properties. Default is r. Constructions such as
             a2=3=c are allowed.
Al            Substitution or command on same Level. On a line
             starting with Id subsequent ; are read as Al,
B b1,b2,..        List of symbols to be factored out in output.
            Legal: symbols, vectors, dotproducts, vector comp.
            If a vector name is mentioned all dotproducts and
            vector components referring to that vector are
            factored out.
D Name(n,..)=xpr,xpr,..    Data expression. Expressions must be single terms.
F f1,f2=x,..        Function list. Reality properties may be specified
             through x, legal are i,c,r and u. Default is r.
I i1,i2=x,..        Index list. The dimension x may be a number or a
             single character algebraic variable, defined before
             in an A-list.
Id            Substitution or command on next free Level. See Al.
Oldnew a1=b1,a2=...    Change name a1 into b1 etc.
Outlimit #        Change output byte limit. Default: 500 000.
Sum i1,i2,..        Declares i1,i2,.. to be summation indices. This is
             not related to the summation indices of the DS
             function, but indices appearing twice according
             to the Einstein summation convention.
             Indices in this list must have been defined before.
T Name(n,,,)=sy1,sy2,..    Table.
T Name: "X=1:1,..    Character table.
V p1,p2=z,..        Vector list. Names of 1 or 2 characters. The optional
             z implies that p2 is to be set to zero as soon as
             it occurs, also in vector-component or dot-product.
X Name(arg,..)=xpr    X-expression.
Z Name(arg1,...)=xpr    Z-expression. If arg1 is a number or simple numerical
             expression Name is a subscripted file. The number
             must be in the range 0-32767.
             Here a simple numerical expression may contain
             numbers, or block or DO-loop arguments that become
             numbers, separated by +-* or /.

The general structure of a substitution or command involves several elements
that can be separated in groups. All groups and elements must be separated by
comma's.

The first group is the Id or Al itself (with possibly ; instead of Al,)
optionally followed by a number:
    Id,    Al,    ;    Id,#,    Al,#,    ;#,
The number specifies on how many Levels the substitution or command is to
be applied.

The next group may contain one item, namely a keyword. This only for
substitutions, not commands. Valid keywords are:
    Multi    Funct    Dotpr    Ainbe    Adiso    Always    Once
This group may be empty.

The next group either defines a pattern followed by a = sign or is a command
followed by arguments separated by comma's (if any). Patterns are products of
factors, with dummies designated by a ~ following the symbol. Not all factors
can be dummies. See section 10.

The available commands and their formats are:

Absol    Force coefficien positive.
Addfa    Add factor.
     Id,Addfa,expression
All    Collect vectors p into function F. Created indices may be assigned
    a dimension. First syntax:
     Id,All,p,N,F
    possibly followed by the character arguments "F_, "D_, and/or "V_
    which inhibit function argument, dot-product or single vector
    inspection (example: Id,All,p,N,F,"F_).
    Second syntax:
     Id,All,F1,N,F
    Collect all vectors of function F1 into F. Substitute a created
    index in F1, and also as additional argument of F.
Anti    Check function arguments for characters, and if _ present remove
    that if character mentioned in anit-particle chcracter table.
     Id,Anti,TA
Asymm    Re-arrange arguments of anti-symmetric function.
     Id,Asymm,f1,2,3,4,f2,f3,4,5
     Id,Asymm,F1:2,3,4:7,8,9:12,13,14:
     Id,Asymm,F1:1-3:7-9:12-14:
Beep    Generate a beep on the terminal.
     Id,Beep
Coef    Inspect numerical coefficient.
     IF Coef,option
     options:    pl    plus
            ng    negative
            eq,#    equal
            lt,#    less than
            gt,#    greater than
            ib,#,#    inbetween
Commu    Re-arrange commuting functions.
     Id,Commu,f1,f2,f3,...
Compo    Compose names.
     Id,Compo,<options>,f1,f2,<options>,f3,f4,..
     options: AFIVX with AFV possibly twice. Optionally "S_ suppresses
     symmetrization of the name. Optionally a character table may be
     specified, to be used if characters with an underscore appear.
Count    Count certain occurrences with certain weigths.
     Id,Count,xxx,arg1,#,arg2,#,....
    If xxx number then term kept if count equal or larger than xxx.
    If xxx symbol or vector-component or dot-product xxx^# is made.
    If xxx function or X,D expression then xxx(#) is made. In that case
    a multiple count can be made:
     Id,Count,Fx,arg1,#,..,# : arg2,#,..,# : arg3,#,...
    Now Fx(#1,#2,#3,...) is made with #1 determined by the arguments up
    till the first colon, #2 by the arguments between first and second
    colon etc.
Cyclic    Function invariant under cyclic permutation of the arguments.
     Id,Cyclic,f1,2,3,4,f2,f3,4,5
Dostop    Set, clear or test Dostop flag.
     Id,Dostop,X
    where X = On, off or test. Default test.
Epfred    Reduce products of Epf functions.
Even    Function even in sign of arguments.
     Id,Even,f1,2,3,4,f2,f3,4,5
Expand    Expand frozen subfiles (appearing as DF(fname,#) ).
     Id,Expand,fname
Extern  Jump to user defined routine.
     Id,Extern,arg1,arg2,...
Iall    Inverse of All.
     Id,Iall,p,F
     Id,Iall,F
Numer    Insert numerical values.
     Id,Numer,arg1,#,arg2,#,...
Odd    Function odd in sign of arguments.
     Id,Odd,f1,2,3,4,f2,f3,4,5
Order    Order functions on the basis of their first two arguments.
     Id,Order,F1,F2,...
Print    Print a message, maximally # times.
     Id,Print,#,Message
Ratio    Rationalize.
     Id,Ratio,xpa,xpb,bma
Stats    Count passage in one of four counters (0-3). Result printed at end.
     Id,Stats,#
Symme    Re-arrange arguments of symmetric function.
     Id,Symme,f1,2,3,4,f2,f3,4,5
     Id,Symme,F1:2,3,4:7,8,9:12,13,14:
     Id,Symme,F1:1-3:7-9:12-14:

  Three commands are special to problems of relativistic quantum mechanics:

Gammas    Collect, Reduce and/or take trace of products of G's.
     Id,Gammas,options,L1,L2-L3:options,Trace,L3,L4-L5:options,...
     options are designated by characters: "C collect only, "A anomalous
     trace, "S do spinsum, "U unify strings, "I do index pair reduction,
     "i do index pairs in _-type strings, "P do P-tricks, "W do final work.
     All options except "C may be followed by an underscore, implying
     switching off. The "C option when not combined with anything else
     gives normalization, however without ever specialization to
         four dimensions (essential if there are non-four-dimensional vectors)
         Default: "A_,"S,"U_,"I,"i,"P,"W
Spin    Replace pairs of Ug,Ubg by spin-summation expression. The spinors may
     be defined by loop indices or vectors.
     Id,Spin,L1,p,...
Ndotpr    Create special dot-products. Closely related to Gammas command.
     Id,Ndotpr,F1

A number of special functions is build in. They are:

D        Delta function.

Epf        Anti-symmetric Weyl tensor. May have any number of arguments.

DD        Internal purposes (used to represent X and D expressions and
        files).

DS        Summation function. Format:
        DS(J1,#,#,(xpr1),(xpr2))    xpr2 numeric, optional.
        The sum over the given range is constructed. The numerical
        coefficient is by recursion, using xpr2. The first coefficient
        is 1. Example: e^x = DS(J,0,20,(x^J),(1/J)) + O(x^21).
        Caution: summation symbols such as J may be used only once
        in a given expression.
        Character summation:
        DS(C1;C2;..;Sym;C3;C4;TX,..,2:4,7,(xpr))

Numerical functions (may be part of expressions that must be numerical
such as for instance expressions occurring as exponents, or with a negative
exponent, but not of simple numerical expressions such as Z-expression index):

DB        DB(n) = n!    DB(n,m) = n!/{m! (n-m)!}
        DB with two arguments is word-bound, fails if n=19, m=8,9,..

DT        DT(n1,n2,..)    1 if all arguments positive or zero, else 0.

DK        DK(n1,n2)    1 if n1=n2, else 0.

DP        DP(n1,n2,..)    1 if permutation to smallest first is even,
                else 0. Order normal: -127,..,0,...,+127.
                0 if two arguments equal.
DF        DF(xfile,#) or DF(xfile,#1,#2)
                The last case is equivalent to the first
                with # = 100*#1 + #2.
DC        DC(n1,n2,..)    1 if sum of all arguments is 0, else 0.
        DC("X,.....)    "X is option character. May be "C, "F, "T
                with or without underscore following.
  Special functions relevant to particle physics are:

     G(L,mu)    Gi(L)    G5(L)    G6(L)=Gi(L)+G5(L)    G7(L)=Gi(L)-G5(L)
     Ug(L,m,p)    Ug(L,mu,m,p)    Ubg(L,m,p)    Ubg(L,mu,m,p)
Use -m for anti-particle spinors.

New notation:
     G(i1,i2,mu,nu,..,G6,..)  Gi(i1,i2)  G5(i1,i2)  G6(i1,i2)  G7(i1,i2)
Internally generated G-strings:
     G(L1,"s,"4,mu,nu,..,G5,..)        General 4 and N dim mixture.
     G(L1,"t,"4,mu,nu,..,G5,..)        General 4 and N dim mixture.
     G(L1,"S,"X,mu,nu,........)        4-dim. "X may be "4, "5, "6 or "7.
     G(L1,"T,"X,mu,nu,........)        4-dim. "X may be "4, "5, "6 or "7.
     G(L1,"s,"_,mu,nu,........)        N-4 dim.
     G(L1,"t,"_,mu,nu,........)        N-4 dim.


APPENDIX A. COMMAND LINE OPTIONS.

The standard usage is:

Schip file1 file2 options

Schoonschip input is supposedly contained in file1, the output is written
to file2. Fortran compatible output (directive Punch) is written to tape8.
If file2 absent then the output is written to standard output, i.e. the
screen. If in addition file1 absent then the standard input (the keyboard)
is used as input. When doing that remember that *end terminates the run.
Also errors lead to termination. Normally Schoonschip echo's the input lines
back to the screen.

Alternatively input, output and punch file (tape8 by default) can be
designated by means of the notations i=, o= or f= (the f stands for Fortran
compatible; upper case accepted as well):

Schip i=file1 o=file2 f=file3

This cannot be combined with the first method.

All options are optional. First one may specify certain options by
preceeding them with a - sign. These options are:
 s    For Schoonschip versions running on a PC with bitmap screen.
    The "Ready" line and the requested keyboard input are suppressed
    if s (for silence) specified.
 b    Certain Fortran compilers do not accept negative exponents without
    brackets (for example A**-3). If b specified brackets are written.
    The default is no brackets.
 p    Show progress by printing a point (.) to standard output every
    128 terms.
 .    Place a . after every integer in the output. Some Fortran compilers
    insist on this.
Also upper case characters may be used. Example:

Schip file1 file2 -b.p

Options b, . and p apply.

These options may also be selected inside a Schoonschip program by means of
the statements

Silence
Fortran options
Progress on
Progress off

These statements are discussed elsewhere (section Miscellaneous).

Another option leads to noise (Control-G is sent to the terminal) upon
completion. This may be specified as b=# where # is the number of beep's
the terminal is to receive. The option S=# where # is a number in the range
-128, 127 inclusive implies setting of the initial value of the parameter
_Sw0 to the value #. Example:

Schip file1 file2 b=10 s=19

Upon completion 10 beeps will be sent to the terminal (with some interval).
The initial value of _Sw0 is 19.

Most important, one may now specify memory usage to Schoonschip. There
are two large storage areas used during execution, called the input space
and the output space. The input space contains the expressions, substitutions,
etc. The output space is where the final result is collected. Performance
in case of large expressions is very sensitive to the size of the output
store. The larger the better. As an heritage of the old CDC days Schoonschip
has always been very frugal in memory usage. The build-in size of in- and
output space used to be 20 Kb and 50 Kb respectively. Given that nowadays
few machines have less than 1 Mb of memory that seems to frugal.

The version of Jan 1, 1989 is more expansive. To begin with an amount of
about 80 Kb is used separately for buffers etc. This used to be much less.
Default sizes for in- and out space are machine dependent, but typically
100 Kb and 250 Kb are taken. The total memory usage (excluding Schoonschip
itself, which is about 100 Kb) comes then to about 450 Kb.

The in- and out sizes may now be specified on the command line. To this
purpose one uses the notation IS=# and OS=# (lower case accepted also)
where the # stand for number specifying magnitude in Kb. Thus the old
situation is obtained with this command line:

Schip file1 file2 IS=20 OS=50


Finally a number # preceeded by a + sign can be specified on the command
line. Then Schoonschip skips the first # problems on the input file. Every
occurrence of a *end line counts as one problem. Example:

Schip +5 Varia Out

Problem five in file Varia is executed.
Some other examples:

Schip Infil Outfil -bp

The file Infil is taken to contain the input, output is written to Outfil.
Dots are printed when starting a problem, and further every 128 terms.
Brackets are placed around negative exponents.

Schip +1 i=Varia o=Vario -p

Problem 1 of Varia is executed, the output is written to Vario and meanwhile
dots on the screen show progress.


APPENDIX B. COMPATIBILITY.

Programs working with older 68000 versions will work provided the square
brackets [] are taken out and replaced by for example curly brackets.
In addition there is a slight change in Integ (evalution of numerical
expressions as function arguments). It now truncates, rather then rounding
to nearest integer. The statement 'Round on' may be used to re-instate
rounding (CDC versions of Schoonschip truncated).

The command Trick is now called Gammas, but will still be accepted. The block
delete command, DELETE (all upper case) has been replaced by BDELETE (case
insensitive, only the first four characters significant). The rarely used
statement 'Printer' has been replaced by Lprint.

Programs that executed on previous (CDC) versions of Schoonschip will
also run with this version with minor, mainly cosmetic modifications. The
main differences are in the use of lower case characters in this version,
and furthermore different notations for BLOCK and DO-loop arguments.

- Block arguments in the text of the block must be embedded in quotes.
  The same holds for DO arguments. These latter can now take negative
  values in all cases. Use of {} obligatory. Block arguments, in a call,
  may now have comma's provided they are enclosed in {}.
  The word COPY is no more needed when calling a block.
  Block names may at most be 6 characters in length.
- The complex variable I is now written as i. If needed the statement
  Oldnew i=I takes care of this.
- The S-list is now the A-list. However, S is still accepted.
- ID and AL are now Id and Al. However, both are accepted.
- GI is now Gi.
- CONJG and INTEG are now Conjg and Integ.
- Various keywords and commands have sometimes slightly different spelling,
  ODDXX is now Odd.
- The Print options have different format. For example, PRINT INPUT
  is now P input.
- Dummies are now characterized by a following ~ instead of a +.
- An exponent may now also be denoted by ^ instead of **.
- The special function DX is no more implemented. It is used internally
  for purposes relating to the Gammas command.
- Characters as function argument are denoted by "X instead of =X.