abstract

A.I.R. is a program for the reduction of loop integrals, appearing in calculations in high energy physics phenomenology, to members of a set of linearly independent, "master", integrals. The method was first proposed by Laporta in [arXiv:hep-ph/0102033], but a computer implementation was hindered by the appearance of large intermediate algebraic coefficients. In A.I.R. we introduced two new features that keep the coefficients as small as possible. The program requires modest input from the user and can be used for generic calculations in perturbation theory

publication

Automatic Integral Reduction for Higher Loop Perturbative Calculations

technical

The code is written entirely under the platform of MAPLE9. All the routines are located in the main file, whereas the user input is given by an input file that the user supplies. For more details check the documentation below.

AIR documentation

This document describes how the Automated Integral Reduction package of maple routines works. The idea behind it is to use integration by parts identities (ibp's) to relate a big number of loop integrals to a small number of linearly independent ones that we call master integrals. The algorithm follows mainly the one suggested by Laporta in [arXiv:hep-ph/0102033] with changes that have to do with memory and cpu management: [return to the top]

The problem arising in this algorithm is that the coefficients of the integrals grow explosively in difficult two loop cases, occupying the whole memory of the machine and thus forcing maple to stall. The solution employed here is to "mask" the coefficients during the reduction process (substitute them with symbolic aliases and save them in files), perform the reduction and "unmask" them back at the final stage of obtaining the reduced integral.

For reasons of flexibility the whole algorithm is broken in three succesive stages that can be performed independently : [return to the top]

using AIR

[return to the top]

Note: an easy way to avoid retyping the above list of commands is to construct a script file. With the input file ready, one creates a directory dedicated to the reduction, named for example PENTAGON. In Pentagon one copies the input_pentagon.map file and the main.map file. The needed script will be a file of the following form :

currentdir("path to the PENTAGON directory");
read "input_pentagon.map";
read "main.map";
SEEDGEN("seeds.map", [1,2,3,4,5], [2,5], [0,4], [0,4]);
Reducer("seeds.map","calc.map",".");
tidy_list("seeds.map",".");
melt_all_f(".");

Then one runs from the command shell, being inside the PENTAGON directory, the command
maple "script_pentagon.map";
and all the steps are performed. If one wishes to change something in the input file, the above command only is run to perform again the reduction.

[return to the top]

configuration file

When the >read ".../config.map"; command is given, maple reads the user constructed configuration file. The latter contains all the input that the user needs to give to the reducing procedure. Namely, the identically zero integrals, the master integrals (if any is known), the integration by parts equations, the numerical test-values of the kinematical variables that are used to check whether a coefficient is zero, during masking, and the values of three variables that control the masking and the interactive behaviour of the program, are all determined in the config.map file.

The first object to be declared in the config.map file is a list of conditions that determine wether an integral is identically zero or not. This list should be called ZERO_TOPOLOGIES (in capital). It has to be something like :

ZERO_TOPOLOGIES:=[
ThetaF(nu1)+ThetaF(nu7)=0,
ThetaF(nu1)+ThetaF(nu2)+ThetaF(nu3)<2,
...,NULL]:

The list of conditions works as follows: when an integral is checked, every condition is checked with the ThetaF function working as a theta-function. The first condition above, for example, checks whether nu1 and nu2 exist. If one of them exists (i.e it is bigger than zero indicating that the corresponding propagator is present in the denominator) the result is of course non-zero and the condition fails. In this case nothing happens and the next condition is checked. If both nu1 and nu7 are zero or negative the condition is valid and the integral is set to zero (presumably we have decided that for kinematical reasons one of these two propagators should be there for the integral not to vanish).

[return to the top]

Hence, the conditions in ZERO_TOPOLOGIES are of the type OR (the integral is zero if one of them is met). Consequently for an integral to be processed as non-zero ALL of the conditions have to be met.

[return to the top]

Next, one has to declare the ibp templates to be used. This is achieved by editing the list ibp_equations This is a list with the ibp equations expressed in the form

(d-2-nu1-nu2-nu3)*I(nu1,nu2,nu3) - nu1*I(nu1+1,nu2-1,nu3) - ... + s*nu3*I(nu1,nu2,nu3+1)...

where s,t,u,... are the kinematical variables of the problem and nu1,nu2,nu3,... are the exponents of the relevant integrals (denoted by I), in the standard form. Note that the program assumes that each element of the list is the left hand side of the relevant ibp with the right hand side equal to zero.

Despite the fact that one could construct a maple procedure for calculating and returning the ibp equations, this is not advisable because the geneq routine is called once for every seed, so for a big number of seeds it creates an unnessescary computational cost. We usually create such routines and write their output to a file, from which we paste it in the config file.

[return to the top]

Next one needs to declare in the list MASTERS the integrals that the user knows to be masters and wants them masked during reduction. The form of the list is

MASTERS:=[I(1,1,1,1), I(1,0,1,0),...]:

Note that if an empty list is declared there will be no masking of master integrals.

There is no absolute need to predetermine the integrals that are identically zero (in ZERO_TOPOLOGIES), though some of them will appear as master integrals in the result, overloading the reduction. Hence, any integral known to vanish should preferably be declared as such. It will then be discarded whenever met without any cost in the reduction procedure.

The same applies for master integrals. In principle these should be among the output of the reduction algorithm, but any prior knowledge (obtained from experience) that an integral is a master one will facilitate the reduction algorithm. Examples are shown in the default configuration files.

[return to the top]

Next, the check_values variable is a list of 4 lists of numerical values for each kinematical variable, as shown in the default config files. These are the values that the program will use to determine whether a given coefficient is zero or not. Despite the fact that for large coefficients curious numerical coincidences are not likely (the case where a coefficient vanishes not identically but at the specific values of the kinematical variables), it is better to be in the safe side and give the check_values as unrelated as possible. The variable to be set is check_values, a list of lists of numerical values for each kinematical variable and one for the dimension:

check_values:=[ [s=0.23, t=0.34, d=4,001] ,
[s=-0.24, t=234.1, d=-98.12] ,
... ]

Each numerical set corresponds to a parameter space point on which the value of every masked coefficient is checked throughout reduction. This means that one shouldn't declare too many parameter space points, otherwise the reduction will be overloaded. Three of four points are usually enough for one loop reductions, and not much more will do the two loop case as well.

note: in rare cases it has happened during testing that the Reducer routine is bailing out in the middle of the reduction throwing an error of the form "DIVISION BY ZERO". This happens whenever one of the points of numerical values is accidentaly making a coefficient vanish, when all other points give a non-zero value for the coefficient. When, subsequently, this coefficient is appearing in a denominator, its numerical value is calculated and a division by zero is created. Whenever such an instance occurs, the program is throwing warnings to the user before division by zero happens. The user then should change the numerical values in check_values to circumvent the problem.

[return to the top]

Next, one has to determine the integer values of the three global variables MAXLENGTH and MAXSIMPLIFY and MAPLEMAXSUB. We explain below what is the meaning of these variables and how can the user manipulate through them the way the reuction is peformed.

MAXLENGTH is the length (in units of characters through maple's length routine) of a coefficient above which the coefficient is masked while Reducer runs. Masking is happening whenever check_values or MASTERS are declared as non-empty lists, so in the case that they are both empty no masking is performed and the value of the variable is immaterial. In the case of masking, however, a large value of MAXLENGTH, of the order of 1000 or bigger, means that Reducer is carrying most of the computational weight of substitutions and simplifications. If this stays in affordable limits it is optimal to use these values for MAXLENGTH. If it doesn't, which is the case in any reduction with many kinematical variables and a tensor depth higher than 2, it is recommended to use a value of MAXLENGTH of the order of 100. Then the masking is more efficient and sustitutions and simplifications are deferred to a later stage of the program, namely to the tidy_list routine. In that case the gauss elimination proceeds without a problem.

MAXSIMPLIFY is the length of a coefficient above which no simplification is performed in a specific part of tidy_list, during unmasking. This variable can safely stay at the order of 1500 for non-extreme cases, but it could also be used, in conjunction with MAPLEMAXSUB (see below), to deal with extremely complicated reductions.

[return to the top]

MAPLEMAXSUB is the length of a coefficient above which tidy_list is remasking the coefficient, deferring any simplification and nested substitution to melt_all_f. A value of 100-500 is activating the remasking feature, while a value bigger than 2000 is practicaly deactivating it. A comment is due here for the effect of this, second masking. During the original masking, in Reducer, master integrals together with their coefficients are aliased. Gauss elimination increases significantly the size of the coefficients and their treatment becomes cumbersome during unmasking because of the presence of the master integrals. Moreover, whenever both masking procedures are activated, one has, in the coefficent files aliases with q symbols, coming from pure coefficient masking, and aliases with K symbols containing masters, nested deeply in each other. tidy_list is undoing this nesting. If the size of the coefficients is large, tidy_list is overloaded and it then pays to perform a second masking with expressions that purely contain kinematical variables. The routine melt_all_f is then used to perform nested substitutions and simplifications over the new, aliased coefficients bearing the symbol f. It is this part of the reduction that actually carries the larger computational weight. The use of MAPLEMAXSUB efficiently isolates the difficult part from the rest of the reduction.

[return to the top]

file management

All the files that the package creates and uses are located in the RESULTS_DIR directory that is given as an input to the main reducing routine (Reducer). RESULT_DIR will contain the directories RESULTS_DIR/ICED, RESULTS_DIR/MELT, RESULTS_DIR/MELTK and RESULTS_DIR/RESULTS. Moreover there a directory is created for each distinct topology of integrals. For example, if the symbolic name for the integrals is I, one will see directories like RESULTS_DIR/I_1_3_5, containing the files for reduced integrals belonging to te topology 1,3,5. In these directories each specific integral has its own file, e.g. RESULTS_DIR/I_1_3_5/I_2_-1_1_-4_2.map. Next, in order to locate the equations in which every specific integral is (useful in backsubstitution) include-files are created ending in _incl, inside the topology directories.There is a directory RESULTS_DIR/I_1_3_5/INCLUDE where files with names like I_2_-1_1_-2_1.inc are found. These files are updated continuously during the reduction process.

Every frozen coefficient is saved in the RESULTS_DIR/ICED. directory. The RESULTS_DIR/ICED directory for reasons of file management is broken in subdirectories each containing 100 coefficients, named sequentially, e.g. RESULTS_DIR/ICED/ICED4. In each subdirectory there is a directory RESULTS_DIR/ICED/ICED4/EXPR where each coefficient's expression is written in its own file , RESULTS_DIR/ICED/ICED4/EXPR/qexpr_123.map for example,in the form of a maple equation. For each coefficient there is also a numerical value written in the directory RESULTS_DIR/ICED/ICED4/NUM. Moreover the freezed master integrals and their combinations in monomials are written in the directory KEXPR, in files like RESULTS_DIR/ICED/ICED4/KEXPR/kexpr_23.map . In case remasking is activated the remasked expressions are kept in RESULTS_DIR/ICED/ICED4/FEXPR. In the ICED directory one finds also the counter files for q-coefficients, K-coefficients and f-coefficients.

Next there is a directory named RESULTS_DIR/MELTK. After the end of the reduction algorithm we are left with expressions that contain the to-be-reduced integrals as functions of frozen coefficients and master integrals. Apropriate routines are then employed to substitute the explicit expressions of each frozen object, in a process called unmasking. Once a master integral is unmasked it is archived in MELTK for future use since the unmasking procedure can be computationally expensive.

After the unmasking procedure the resulting equation is the one we want so it is archived in RESULTS_DIR/RESULTS for further use.

For a sketch of the directory tree that the program creates see [directory tree]

[return to the top]

seed generation

To run the seed generating routine one types :

SEEDGEN("filename", [maxtop], [#smallest prop,#biggest prop], [#smallest tensor, #biggest tensor], [smallest dotted, #biggest dotted])


where all the entries with # are integers. The way the routine works and the meanining of te arguments is explained below .
The task of generating the set of integrals that will be inserted in the ibp equations (seeds), in a prescribed order of increased complexity, is performed by the routine SEEDGEN.

The first argument of SEEDGEN is the filename where the seeds will be written.

In the whole program, a given integral is represented as a function with integers as arguments. Each argument represents a specific propagator and the integer is the exponent of the propagator in the loop integral. If the integer is a negative number the propagator is inverted so it actually appears as an irreducible numerator in the loop integral. The set of integrals can be classified according to the number of propagators that appear (with a positive exponent). Each such class can be subdivided in sets of integrals that have the same propagators (with a positive exponent). This is called a topology.

The next argument of SEEDGEN, maxtop, is the list of propagators involved in the reduction, including the possible negative propagators that might appear only as irreducible numerators. the latter is the case in the double box topology, for example, where there are 7 propagators but there are another two combinations of external momenta that appear as irreducible numerators in the ibp, increasing the number of propagators to 9.

The rest three arguments are lists of two integers each.

[return to the top]

The routine begins by opening the file for the seeds and writting some comments on it containing some of the input arguments of the routine. Then for each class of integrals (from the class with prop_range[1] propagators till the class with prop_range[2] propagators) all the topologies are built in a list. Each element of the list is another list that contains the integers representing the propagators of the topology. For each such topology the seeds with tensor_range[1] number of negative powers of propagators and all the range of excessive powers of propagators is built and written in the file. Next seeds with tensor_range[1]+1 and all the range of excessive powers are built, e.t.c untill the upper range of tensors, tensor_range[2].
Thus the seeds of a given topology are built begining from the scalar integrals and proceeding to the tensor and dotted tensor integrals.

note: it is recommended that the arguments of SEEDGEN are such that the integrals of interst are themselves contained as seeds in the seed file, because only then full reduction is guaranteed.

[return to the top]

main reduction

This stage is performed by running
Reducer(SEED_FILE,CALC_SEED,RESULTS_DIR);
The three arguments of Reducer are the file containing the seeds (output of SEEDGEN), the file in which all calculated seeds are written (kind of log file) and the directory where all the results will be written.

The tasks performed by this routine are


[return to the top]

Below we explain which are the priority criteria, that determine for which integral are the ibp's to be solved.

priority criteria priority is a subroutine called from inside eqs_solver. Its task is to find the priority integral given the ibp equation as input. After checking for fake equations (of the type 0=0), the routine builds a list of the integrals involved in the equation. Then the list is passed from three different "sieves", the priority criteria, each of which excludes some of the integrals. The remaining integrals pass on the next criterio. The criteria are
  1. More important topology (find the more important topology among the ones of the integrals in the list, and discard the integrals that do not belong to this topology).For the moment this criterion seems to just be discarding the previously frozen master integrals.
  2. Bigger number of propagators (find the maximum of the number of propagators of the integrals and discard the integrals that have less than this maximum).
  3. Bigger number of excessive powers of propagators (find the number of propagators raised to a higher than the first power in each integral. Find the maximum of these numbers and discard the integrals that do not have this maximum).
  4. Bigger number of irreducible numerators (find the maximum number of irreducible numerators (negative powers of propagators) and discard the integrals that do not have this maximum).
  5. Terminating criterion : choose the first of the remaining integrals in the list.
[return to the top]

unmasking of the coefficients

The main unmasking routine is tidy_list("seeds.map","RESULTS_DIR") with arguments the seed file and the directory where the results are. This routine is loading the seedfile and reads sequentially all the seeds. For each seed the relevant file is read and if existing (if not the integral is itself a master), the show_int routine is called. There the expression for the integral is checked for masked coefficients. The q-coefficients are unmasked first, through melt_q. Then the K-coefficients are unmasked, through melt_K. The master integrals are collected and their coefficients are simplified if their length doesn't exceed the value of MAXSIMPLIFY. The seed then is written in RESULTS_DIR/RESULTS and the next seed is read.

note: in case the MAPLEMAXSUB variable is within reachable limits, every expression that exceeds its value is remasked. This is happening inside the melt_k and melt_q routines. The large coefficients are remasked at the moment they are generated avoiding the creation of copies of them as they are passed by value from the melt routines to show_int.

[return to the top]

Directory Tree



results_dir
   I_1_3_5_7
       I_1_-1_2_0_1_0_2.map
       INCLUDE
          I_1_-1_0_2_0_1.inc
    ICED
      ICED0
          EXPR
              qexpr_121.map
          KEXPR
              kexpr_121.map
          FEXPR
              fexpr_121.map
          NUM
              qnum_121.map
      counter.map
      kcounter.map
      kcounter.map
    MELTK
       MELTK1
           kexpr_21.map
    RESULTS
        PB_1_4_7
            PB_1_-1_0_2_0_0_1.map

note: For information on the purely technical details of how each specific routine works the reader is deferred to the comments of the code itself, in the main file of the package.