### 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:- The seed integrals are generated in a specific order of increasing complexity (see laporta)
- Each seed is inserted in the ibp identities.
- Each identity is processed as follows
- front substitution : possible integrals from previous identities are substituted.
- from the resulting set of integrals one is chosen according to some specified priority criteria (see laporta)
- the identity equation is solved for that integral and archived.
- back substitution : this last integral is substituted everywhere in the previously archived identities
- the algorithm moves to the next identity (for the same seed)

- the algorithm moves to the next seed.

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 :

- the seed generation
- the reduction with masking of coefficients
- the unmasking of coefficients

### using AIR

**step 1: write the configuration file.**

As explained in the configuration paragraph this is the file where all the input from the user is inserted. The ibp equations, the identically zero integrals, the known master integrals etc are all determined there. The format is explained in the configuration paragraph and can also be seen in the default config.files.

It is in the configuration file that the variables that control the masking of coefficients are detrmined by the user. Depending on their value two different types of masking will or will not be performed during reduction.

note: the configuration file defines as well the symbolic names of the integrals and the kinematical variables of the problem. That is happening by default in the ibp declaration. So if the user writes the ibp equations denoting the integrals by PB(1,0,1,...,1) for example, the program will adopt te name PB for the integrals. This cannot be changed during or after runtime. In what follows we will adopt the symbolic name 'I' for the integrals.**step 2: load the package.**

Since the package is running under the maple platform, to run the routines one has to run maple and then load the main.map (or main) file with the command:

>read("path to AIR directory/main.map");

where the "path to AIR directory" should be the full path to the directory where the routines are saved. Alternatively, one can copy the main.map and the config.map file in a new directory where the reduction will take place, use the command currentdir("path of the new dir") and then perform the read command using the short path "./main.map"**step 3:load the configuration file**

That is done by typing>read("path to config.map"); **step 4: generate the seeds.**

Inside the maple environment the command>SEEDGEN( "seedpath",[#sm.prop,#gr.prop], [#sm.tensor,#gr.tensor], [#sm.dotted,#gr.dotted] ) ;

generates the seed file in the location specified by "seedpath". The paramaters are explained in seed generation .**step 5: perform the reduction.**

The main reduction is performed with the command>Reducer("seedpath","calcpath","results_dir");

where seedpath is the path to the file that contains the seeds (output of SEEDGEN), calcpath is the path to a file that will be created and will contain the seeds for which the whole algorithm has already run, and ,finally "results.dir" is the path to a directory in which all the results of Reduction and, later, of unmasking, will be stored. This directory*has to have already been created by the user*when Reducer runs [that's because we don't want Reducer to be able to run in directories where reduction has been performed previously - this can cause considerable confusion].**step 6: unmask the coefficients and get the result.**

Usually the integrals in which the user is interested are contained as seeds in the seedfile. Whenever this is the case the use of the command>tidy_list("seedfile","results.dir");

will unmask all master integrals and masked coefficients, and write the reduced integrals in the directory RESULTS.DIR. Then the command>show_int(I(a,b,c,d,...),"results.dir");

will return to the screen the desired integral.

If the second masking routine is enabled, through the variable MAPLEMAXUSUB (see configuration), then the command>show_int(I(a,b,c,d,...),"results.dir");

will return the reduced integral with masked coefficients aliased as f[i]. To unmask these coefficient the user has to type the command>melt_all_f("results.dir");

This could be a resource consuming process in the case of complicated reductions. After that the command>show_int(I(a,b,c,d,...),"results.dir");

will return the reduced integral with the coefficients still masked, but now the command>show_f(#num,"results.dir");

with #num being the index of a specific f, will return the symbolic value of the coefficient as a function of the kinematical variables and the dimension. The command>show_full_int(I(a,b,c,d,...),"results.dir");

then returns the full reduced expression for the integral.

note: the latter command will return, in the case of complicated integrals, a potentially huge expression the size of which may overcome the threshold that the interactive graphic platform of maple has for returning expressions on the screen. This will result in the interactive platform bailing out without any warning whatsoever. This has no consequence on the data, but the user has to launch maple through the command line environment to see the result. If the command line environment is used, nothing of the above can happen.

If there was no masking at all used during reduction the command>show_int(I(a,b,c,d,...),"results.dir");

will indeed return the wanted integral. This command should also be used when the desired integral does not belong to the set of seeds, though it is recommended to run, in the case of masking, first the tidy_list.

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 :

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

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.

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.

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

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.

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:

[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.

### 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 :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.

- prop_range defines the number of propagators in the smallest topology and the number of propagators in the biggest topology.
- tensor_range defines the smallest sum of negative exponents (usually set to zero) and the biggest sum of negative exponents.
- dot_range defines the smallest sum of excessive powers of propagators (usually also set to zero) and the biggest sum of excessive powers of propagators.

[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 runningReducer(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

- loading the next seed from the SEED_FILE and checking whether the seed has already been calculated in CALC_SEED.
- creating the set of ibp equations for the specific seed with the subroutine geneq.
- picking each equation and
- performing the front substitution with sub_eqs.
- freezing the master integrals with freeze_k.
- freezing the coefficients with freeze_q.
- solve the equation with eqs_solver(this passes through the routine priority that finds the priority integral).
- store the current equation with store_eqs.
- modify the include files with mod_incl.
- make the back substitution with back_sub.

- next equation.
- write the recently calculated seed in CALC_SEED.
- next seed.

[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

- 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.
- 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).
- 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).
- 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).
- Terminating criterion : choose the first of the remaining integrals in the list.

### 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.