This page mostly explains the syntax of Mathematica FIRE. To see the syntax of c++ FIRE read the recent paper in ArXiV and download the full package from GIT

To create a start file one sets the following:

startinglist = <set of IBP's> (they can be generated by the IBP code).

RESTRICTIONS = <set of regions> (defining the regions of vanishing integrals)
It is important to define proper restrictions for the code to work effectively. Alternatevly one can run later Prepare with a special option, however automatic identification of all restrictions is not guaranteered. Restrictions form a list of "regions", where a region is a set of numers equal to -1, 0 and 1. the length of such a list should be equal to the number of indices. If a list of such a form is present, it means that all integrals belonging to such a region are equal to zero. For example, a region {-1,-1,0,0} means that all integrals with first two non-positive indices are equal to zero (0 in the region definition stands for abritrary).

SYMMETRIES = <list of permutations> (defining the permutations of indices leaving the integrals unchanged)
If the diagram has symmetries, it is very important to specify all of them. For example, if the diagram has two internal independent symmetres, one has to specify all 3 members of this list - the symmetries and their product.

ODDSYMMETRIES = <set of pairs: {permutation, sign definition}> (the sign definition is a set (s_1,...s_n) of 1s and  -1s: the integral after such a permutation is multiplied by s_1^a_1*..*s_n^a_n)

CONDITIONALSYMMETRIES = <set of pairs: {permutation, region}> (the region is where the symmetry should be applied defined the same way)

HeavyPoints: the list of indices corresponding to massive-massive and massive-massless bubbles - see the paper for details

EVENRESTRICTIONS: a more complicated and rare setting - see the paper for details

Prepare[]: transform all this data into an internal format.

Prepare[AutoDetectRestrictions->True]: same, but the restrictions are defined automatically acording to ideas of R. Lee. Starting from version SBases_3.1.0

SaveStart[file_without_extension]: save this data in a start file.

After saving a start file one can quit the kernel and load the start file later without defining all the options mentioned above. For complicated cases where the autodetection of restrictions took much time it is recommended to do this way for Mathematica to work more efficiently.

LoadStart[file_without_extension,pn]: load a start file where pn is the problem number (needed for rule mappings). I recommend using a positive integer here.

RULES[region]:=G[x_]->... creats a rule for a this region; the rules can be saved in a file with extension "rule" to be loaded automatically with a start file or a bases file

SBasisM[pn]={list of regions}: specify the list of regions; advanced topic; see the paper for details;

Burn[]: prepare the code to the evaluation of integrals; transforms the start files, the bases and the rules into an internal format and perform an optimization

SaveData[file]: save the result of the Burn[] command in a file

In complicated problems it is recommended to save the data file and quit the kernel afterwords.

LoadData[file]: load the result of the Burn[] command from a file

F[pn,indices]: reduce the integral to masters; if you are going to evaluate something time-consuming, it is not recommended to run this command from the Mathematica front-end because long notebook files slow down the performance.

SaveTables[file,list of integals]: save the tables for the given list of integrals into the file (saving tables without specifying a list has been reported to have a bug that can't be corrected fast; option turned off in version 3.2.0);

LoadTables[list of files]: load the tables from a list of files;

ClearTables[]: clear the tables from RAM;

EvaluateAndSave[ListOfIntegrals,FileForTables]: evaluate the integrals in a special memory-economy mode and save them into the tables file; can't be used for further evaluations because of constant memory cleanup. Complicated evaluations should be performed with the use of this command and not with F[...] one. When running evaluations like that you are adviced either to use a batch system on a cluster or to run in from console with the math << input.m command.

Options:

UsingIBP: usually set to True, but if switched to False turns the Laporta part off. Only possible
if s-bases are available;

DatabaseUsage: a number between 0 and 4 (starting with version 3.2.0, in older version the maximum is 3), determines how heavily the database should be used;

MemoryLimit: default value: Infinity; measured in MB, if it is a finite number, the code increases the database usage upon reaching this memory limit (available starting with 3.3.0)

QLinkPath: should be set properly to use the database must point at the QLink program;

DataPath: should be set properly to use the database the code creates up to 5 directories (files if the new version of QLink is used) with the path starting with DataPath each of those being a database. It is important to a local hard drive and not a network path when setting this option.

UsingFermat: a setting indicating whether the Fermat program is used for substitutions;

FLinkPath: should be set properly to use Fermat, must point at the FLink program;

FermatPath: should point at the Fermat program in order to use it;

DirectIBP: (available in version 3.0.1): if True, the code uses IBPs directly as if it is an s-basis;

LeeIdeas: if True, the code omits some of the IBPs according to the ideas of R.Lee (default option is True in version 3.2.0)

BucketSize (available starting from 3.0.1 with the new version of QLink): defines the bucket size of the database engine; the bigger the array, the faster the database works; you should try to make the bucket array size not smaller than the number of entries in the database divided by 4; default value is 21 and stands for 2^21; the setting is passes to QLink at QLink initialization; the size of one bucket entry is 8 bytes per database; with the database usage set to 4 FIRE uses 5 databases resulting in 8*(2^21)*5 bytes = 80 MB of RAM used for the bucket array with the default setting 21; with this setting the database works effective enough with up to 2^21 * 4 (about 8 * 10^6) entries in the database, slowing down logarifmically afterwards.

S-bases

To use the s-bases one has to create or load a start file the same way with the one used before.

BuildBasis[region,ordering]: try to build a basis with the specified ordering;

BuildBasis[region]: try to build a basis trying random orderings;

Info[region]: list the sectors in the region with the information on existing bases;

BuildAll[region]: try to construct automatically the bases in all sectors in the region;

SaveSBases[file_without_extension]: save this data in a file.

LoadSBases[file_without_extension,pn]: load a bases file where pn is the problem number (needed for rule mappings)