5.12.2 Multiple polylogarithms

The multiple polylogarithm is the most generic member of a family of functions, to which others like the harmonic polylogarithm, Nielsen's generalized polylogarithm and the multiple zeta value belong. Everyone of these functions can also be written as a multiple polylogarithm with specific parameters. This whole family of functions is therefore often referred to simply as multiple polylogarithms, containing Li, G, H, S and zeta. The multiple polylogarithm itself comes in two variants: Li and G. While Li and G in principle represent the same function, the different notations are more natural to the series representation or the integral representation, respectively.

To facilitate the discussion of these functions we distinguish between indices and arguments as parameters. In the table above indices are printed as m, s, n or p, whereas arguments are printed as x, a and y.

To define a Li, H or zeta with a depth greater than one, you have to pass a GiNaC lst for the indices m and s, and in the case of Li for the argument x as well. The parameter a of G must always be a lst containing the arguments in expanded form. If G is used with a third parameter s, s must have the same length as a. It contains then the signs of the imaginary parts of the arguments. If s is not given, the signs default to +1. Note that Li and zeta are polymorphic in this respect. They can stand in for the classical polylogarithm and Riemann's zeta function (if depth is one), as well as for the multiple polylogarithm and the multiple zeta value, respectively. Note also, that GiNaC doesn't check whether the lsts for two parameters do have the same length. It is up to the user to ensure this, otherwise evaluating will result in undefined behavior.

The functions print in LaTeX format as \mbox{Li}_{m_1,m_2,...,m_k}(x_1,x_2,...,x_k), \mbox{S}_{n,p}(x), \mbox{H}_{m_1,m_2,...,m_k}(x) and \zeta(m_1,m_2,...,m_k) (with the dots replaced by actual parameters). If zeta is an alternating zeta sum, i.e. zeta(m,s), the indices with negative sign are printed with a line above, e.g. \zeta(5,\overline{2}). The order of indices and arguments in the GiNaC lsts and in the output is the same.

Definitions and analytical as well as numerical properties of multiple polylogarithms are too numerous to be covered here. Instead, the user is referred to the publications listed at the end of this section. The implementation in GiNaC adheres to the definitions and conventions therein, except for a few differences which will be explicitly stated in the following.

One difference is about the order of the indices and arguments. For GiNaC we adopt the convention that the indices and arguments are understood to be in the same order as in which they appear in the series representation. This means Li_{m_1,m_2,m_3}(x,1,1) = H_{m_1,m_2,m_3}(x) and Li_{2,1}(1,1) = zeta(2,1) = zeta(3), but zeta(1,2) evaluates to infinity. So in comparison to the older ones of the referenced publications the order of indices and arguments for Li is reversed.

The functions only evaluate if the indices are integers greater than zero, except for the indices s in zeta and G as well as m in H. Since s will be interpreted as the sequence of signs for the corresponding indices m or the sign of the imaginary part for the corresponding arguments a, it must contain 1 or -1, e.g. zeta(lst(3,4), lst(-1,1)) means zeta(\overline{3},4) and G(lst(a,b), lst(-1,1), c) means G(a-0\epsilon,b+0\epsilon;c). The definition of H allows indices to be 0, 1 or -1 (in expanded notation) or equally to be any integer (in compact notation). With GiNaC expanded and compact notation can be mixed, e.g. lst(0,0,-1,0,1,0,0), lst(0,0,-1,2,0,0) and lst(-3,2,0,0) are equivalent as indices. The anonymous evaluator eval() tries to reduce the functions, if possible, to the least-generic multiple polylogarithm. If all arguments are unit, it returns zeta. Arguments equal to zero get considered, too. Riemann's zeta function zeta (with depth one) evaluates also for negative integers and positive even integers. For example:

> Li({3,1},{x,1});
S(2,2,x)
> H({-3,2},1);
-zeta({3,2},{-1,-1})
> S(3,1,1);
1/90*Pi^4

It is easy to tell for a given function into which other function it can be rewritten, may it be a less-generic or a more-generic one, except for harmonic polylogarithms H with negative indices or trailing zeros (the example above gives a hint). Signs can quickly be messed up, for example. Therefore GiNaC offers a C++ function convert_H_to_Li() to deal with the upgrade of a H to a multiple polylogarithm Li (eval() already cares for the possible downgrade):

> convert_H_to_Li({0,-2,-1,3},x);
Li({3,1,3},{-x,1,-1})
> convert_H_to_Li({2,-1,0},x);
-Li({2,1},{x,-1})*log(x)+2*Li({3,1},{x,-1})+Li({2,2},{x,-1})

Every function can be numerically evaluated for arbitrary real or complex arguments. The precision is arbitrary and can be set through the global variable Digits:

> Digits=100;
100
> evalf(zeta({3,1,3,1}));
0.005229569563530960100930652283899231589890420784634635522547448972148869544...

Note that the convention for arguments on the branch cut in GiNaC as stated above is different from the one Remiddi and Vermaseren have chosen for the harmonic polylogarithm.

If a function evaluates to infinity, no exceptions are raised, but the function is returned unevaluated, e.g. zeta(1). In long expressions this helps a lot with debugging, because you can easily spot the divergencies. But on the other hand, you have to make sure for yourself, that no illegal cancellations of divergencies happen.

Useful publications:

Nested Sums, Expansion of Transcendental Functions and Multi-Scale Multi-Loop Integrals, S.Moch, P.Uwer, S.Weinzierl, hep-ph/0110083

Harmonic Polylogarithms, E.Remiddi, J.A.M.Vermaseren, Int.J.Mod.Phys. A15 (2000), pp. 725-754

Special Values of Multiple Polylogarithms, J.Borwein, D.Bradley, D.Broadhurst, P.Lisonek, Trans.Amer.Math.Soc. 353/3 (2001), pp. 907-941

Numerical Evaluation of Multiple Polylogarithms, J.Vollinga, S.Weinzierl, hep-ph/0410259