# Introduction to CollierLink

Numerical evaluation of Passarino-Veltman functions | Computations with CollierLink |

Setting and Getting Parameters | Compiling Functions with CollierLink |

CollierLink extends the analytic capabilities of *Package*-X by supplying a fast and stable numerical implementation of Passarino-Veltman functions provided by the COLLIER library.

This tutorial illustrates how to use CollierLink. To make the most of CollierLink, it is recommended that you are fairly experienced with *Mathematica*, and have used *Package*-X before. Although not necessary, it is also helpful to have prior experience with using the COLLIER library.

## Numerical evaluation of Passarino-Veltman functions

Normally, the Passarino-Veltman functions PVA, PVB, PVC, PVD and PVX in *Package*-X do not numerically evaluate. Instead they must be turned into analytic expressions by LoopRefine before they can be evaluated. When CollierLink is initialized, the COLLIER library is loaded into the *Mathematica* runtime, and definitions are added to the Passarino-Veltman functions so they can be numerically evaluated.

PVA[r,m_{0}] | numerically evaluates with the COLLIER library. |

PVB[r,n_{1},s,m_{0},m_{1}] | numerically evaluates . |

PVB'[r,n_{1},s,m_{0},m_{1}] | numerically evaluates . |

PVC[r,n_{1},n_{2},s_{1},s_{12},s_{2},m_{0},m_{1},m_{2}] | numerically evaluates . |

PVD[r,n_{1},n_{2},n_{3},s_{1},s_{2},s_{3},s_{4},s_{12},s_{23},m_{0},m_{1},m_{2},m_{3}] | numerically evaluates . |

PVX[r,n_{1},n_{2},…,s_{01},s_{12},s_{23},…,m_{0},m_{1},m_{2},…] | numerically evaluates the general Passarino-Veltman function . |

UVDiv[PVx][r,…] | numerically evaluates the UV divergent polynomial of the Passarino-Veltman function. |

Passarino-Veltman functions that can be numerically evaluated with CollierLink.

In[1]:= |

When CollierLink loaded, the COLLIER library is initialized with init_cll(6,6,''). This allocates sufficient memory for the evaluation of Passarino-Veltman functions of up to rank 6 and with up to 6 denominator factors.

## Setting and Getting Parameters

The COLLIER library provides a number of global parameters which influence the numerical evaluation of Passarino-Veltman functions, which may be modified with SetCollierLinkOptions.

CollierLinkOptions[] | get the current values of global parameters. |

SetCollierLinkOptions[namevalue] | set new values for global parameters. |

Getting and setting parameters of the COLLIER library.

parameter name | default value | |

"MaxRank" | 6 | highest rank for which Passarino-Veltman functions can be numerically evaluated |

"Mode" | 1 | branch of COLLIER library to use for numerical evaluation. 1=COLI, 2=DD, 3=both branches |

"InvEpsUV" | 0.0 | numerical value of ultraviolet poles |

"MuUV" | 1.0 | value of 't Hooft mass parameter in logarithms associated with ultraviolet divergences. |

"InvEpsIR" | {0.0,0.0} | numerical values of infrared {, } poles |

"MuIR" | 1.0 | value of 't Hooft mass parameter in logarithms associated with infrared divergences. |

Some of the global parameters settable by SetCollierLinkOptions.

The option "MaxRank" specfies the highest rank for which the Passarino-Veltman functions can be numerically evaluated. To calculate higher rank Passarino-Veltman functions, set "MaxRank" to a higher number.

The COLLIER library offers two independent numerical implementations of the Passarino-Veltman functions: the COLI branch programmed by Ansgar Denner, and the DD branch programmed by Stefan Dittmaier. When CollierLink is initialized, the COLI branch is active by default, but it may be changed by toggling the "Mode" setting at any time during the *Mathematica* runtime.

This feature is useful to internally crosscheck the numerical implementations of the Passarino-Veltman functions in the COLLIER library.

Once a setting has been modified with SetCollierLinkOptions, all further numerical evaluations will be carried out with these settings until they are changed again. To check the current settings, use CollierLinkOptions[]:

## Computations with CollierLink

In this section, the partial width is constructed and evaluated with CollierLink to illustrate a typical workflow. The integrals are set up with LoopIntegrate, and all kinematic conditions are applied, as is typical for calculations with *Package*-X. However, instead of calling LoopRefine, the expression is manipulated at the level of Passarino-Veltman functions, and ultimately numerically evaluated directly.

In[1]:= |

In[1]:= |

Hypothetical charged scalar loop:

In[13]:= |

Once the amplitude has been constructed, couplings and masses should be renormalized to render the amplitude finite, and the limit to should be taken. Below are some functions to help carry out this task:

LoopRefine[expr,PartUVDivergent] | computes the UV divergent pole part of expr. |

SeparateUV[expr] | extracts rational polynomials of UV origin, and obtains the behavior of expr. |

Tools for renormalizing and taking the limit .

In this example, the amplitude is free of UV divergences, so no parameters need to be renormalized.

Despite its finiteness, observe that the W boson contribution to the amplitude contains explicit dependence on , which is multiplying UV-divergent Passarino-Veltman functions in several places, *e.g.*

8 mW^{2} PVC[1,0,0,0,0,mH^{2},mW,mW,mW], and

-2 (-1+) mW^{2} PVB[0,0,mH^{2},mW,mW]

Since the COLLIER library is unable to algebraically handle , the rational polynomials of UV origin of this kind must be separated out explicitly.

To obtain the total width, the amplitude must be squared, which in turn requires the conjugate of the amplitude. Since the tensors and are real, only the scalar coefficient functions multiplying them need to be conjugated. For this, you can use the *Package*-X utility function X`Utilities`CollectByTensorStructures to conjugate the coefficient functions.

X`Utilities`CollectByTensorStructures[expr,Conjugate] | organizes expr by tensor structures and applies Conjugate to each coefficient. |

Conjugating just the scalar functions.

When squaring this amplitude, the external polarization sum can be straightforwardly taken by contracting the μ and ν indices of the amplitude with the μ and ν indices of its complex conjugate.

In[19]:= |

The decay width is constructed by multiplying the calculated squared amplitude with the phase space factor and by dividing by the flux factor of . The result is an expression involving various Passarino-Veltman functions that can be numerically evaluated.

In[20]:= |

When the numerical evaluation of an expression is attempted, separate COLLIER library function calls are made for each Passarino-Veltman function in the expression as part of *Mathematica*'s standard evaluation sequence. The kernel then combines them and ultimately returns a result. Despite being computationally expensive, results of individual Passarino-Veltman functions are not remembered, and each one in the expression is recalculated anew which is quite inefficient. Therefore, computing with CollierLink in the way described above is suitable for light-weight computations. But for heavy-duty computations involving hundreds (or even thousands) of Passarino-Veltman functions, direct evaluation can take a lot of time.

## Compiling Functions with CollierLink

Using CollierCompile, larger expressions can be evaluated much more efficiently by creating and compiling a program which uses the COLLIER library. This keeps *Mathematica*'s kernel at bay until the final result is obtained. Furthermore, since the program is guaranteed to make calls of the Passarino-Veltman coefficient functions in a predetermined and fixed order, the program can take advantage of COLLIER's global cache system to avoid recalculation of previously computed Passarino-Veltman functions.

CollierCompile[{x_{1},x_{2},…},expr] takes an expression expr and returns a CollierCompiledFunction which evaluates this expression using the COLLIER library when provided numerical values for x_{1}, x_{2}, ….

CollierCompile[{x_{1},x_{2},…},expr] | compile expr to be evaluated using the COLLIER library. |

Compiling expressions for evaluation with the COLLIER library.

CollierCompile holds its arguments unevaluated, and definitions made earlier in the *Mathematica* session will not be inserted into its argument. Use Evaluate to override this nonstandard behavior to force evaluation of its argument before compiling the function.

### Using the cache system

Each time a CollierCompiledFunction is created, a new cache is designated to it. In order to properly use COLLIER's cache system, it needs to be "taught" which Passarino-Veltman functions need not be recalculated and can be remembered. Therefore CollierCompile automatically primes its cache by evaluating the function at several random values of its arguments x_{1}, x_{2}, … before returning a CollierCompiledFunction ready for you to evaluate.

But, in order to take full advantage of the cache system, it is important to specify parameters of the function which will not change from one evaluation to the next (*e.g.* fixed coupling constants and masses). Otherwise, in the course of priming the cache system, it will inadvertently be taught that these parameters can change, potentially leading to far fewer remembered Passarino-Veltman functions. You can specify the constants and their values using the Constants option.

Keeping the mechanics of the cache system in mind, you can use CollierCompile to create and compile a program to evaluate the partial width. Suppose you are interested in making a parameter scan only over the hypothetical scalar boson mass and Higgs portal coupling mS and λp. Then it is wise to specify them as function arguments, and the declare the remainder e, Nc, Qf, v, mH, mW, mt as constants.

Since the Standard Model masses and couplings were declared constants, the Passarino-Veltman functions making up the W-boson and top-quark contributions were calculated and remembered when the cache was primed at the time the CollierCompiledFunction was created. The only Passarino-Veltman functions which were recalculated to construct the plot are the select few that make up the scalar boson contribution.