Notation

GPLs are complex-valued functions that depend on \(m\) complex parameters \(z_1,...,z_m\) as well as an argument \(y\). We can define a GPL as a nested integral with \(z_m\neq 0\)

(1)\[ G(z_1,...,z_m\ ;y) \equiv \int_0^y \frac{\D t_1}{t_1-z_1} \int_0^{t_1 } \frac{\D t_2}{t_2-z_2} \cdots \int_0^{t_{m-1}} \frac{\D t_m}{t_m-z_m}\,.\]

Alternatively, they can also be defined in recursive form as

\[G(z_1,...,z_m\ ;y)=\int_0^y \frac{\D t_1}{t_1-z_1} G(z_2,...,z_m\ ;t_1)\,,\]

where the base case of \(m=1\) is just a logarithm

\[G(z\ ;y)= \log\Big(1-\frac{y}{z}\Big)\,.\]

To also cover the case of \(z_m=0\) we define

(2)\[ G(\underbrace{0,...,0}_{m}\ ;y)\equiv G(0_m\ ; y) =\frac{(\log y)^m}{m!}\,,\]

where we denote a string of \(m\) zeros as \(0_m\).

We call \(G(z_1,...,z_m;y)\) flat since all parameters are explicit. However, this notation can be cumbersome if many of the \(z_i\) are zero. In this case we introduce the condensed notation which uses partial weights \(m_i\) in order to keep track of the number of zeros in front of the parameter \(z_i\)

(3)\[ G_{m_1,...,m_k}\big(z_1,...,z_k\ ;y\big) \equiv G\big( 0_{m_1-1}, z_1,...,z_{k-1}, 0_{m_k-1},z_k\ ;y\big)\,.\]

Both notations will be used interchangeably. We say that this GPL is of depth \(k\) as it has \(k\) non-zero parameters (not counting \(y\)). Its total weight is \(m=\sum m_i\).

Multiple polylogarithms

Multiple polylogarithms (MPLs) are a related class of functions that also generalise logarithms. They are defined as an infinite nested series

(4)\[ \Li_{m_1,...,m_k}(x_1,...,x_k) \equiv \sum_{i_1 > \cdots > i_k}^\infty \frac{x_1^{i_1}}{i_1^{m_1}} \cdots \frac{x_k^{i_k}}{i_k^{m_k}}\,,\]

where \(m_1,...,m_k\) are integer weights. If there is only one argument present, they reduce to classical polylogarithms \(\Li_m(x)\).

MPLs are closely related to GPLs through

\[\Li_{m_1,...,m_k}(x_1,...,x_k) = (-1)^k G_{m_1,...,m_k} \Big( \frac1{x_1} , \frac1{x_1 x_2} ,..., \frac1{x_1 \cdots x_k}\ ;1 \Big)\,.\]

This can be inverted by performing an iterated substitution

\[u_1 = \frac1{x_1}\,,\quad u_2 = \frac1{x_1 x_2} = \frac{u_1}{x_1}\,, \quad...\qquad u_k = \frac1{x_1 ... x_k} = \frac{u_{k-1}}{x_k}\,,\]

allowing us to write the GPLs in terms of MPLs

(5)\[ G_{m_1,...,m_k}(u_1,...,u_k\ ;1) = (-1)^k \Li_{m_1,...,m_k} \Big( \frac1{u_1},\frac{u_1}{u_2} , ... , \frac{u_{k-1}}{u_k} \Big)\,.\]

In (5), the left-hand side is an integral representation whereas the right-hand side is a series representation.

GPLs with arbitrary parameters satisfy the scaling relation

(6)\[ G(z_1,...,z_m\ ;y) = G(\kappa z_1,...,\kappa z_m\ ;\kappa y)\]

for any complex number \(\kappa \ne 0\). (5) assumes the argument of \(G\) is equal to one. Using the scaling relation we can normalise \(G(z_1,...,z_m;y)\) with \(\kappa=1/y\) to guarantee that the argument is indeed one.

For the numerical evaluation the main idea will be to compute \(G\)-functions by reducing them to their corresponding series representation (5).

Convergence properties

If we want to use an infinite series for numerical evaluation of GPLs, the series needs to be convergent. It can be shown [7] that an MPL \(\Li_{m_1,...,m_k}(x_1,...,x_k)\) is convergent if the conditions

\[|x_1 \cdots x_k| < 1 \qquad \text{and} \qquad (m_1,x_1) \ne (1,1)\]

are satisfied. Using the relation (5), this translates to a sufficient convergence criterion for the integral representation. We find that if

(7)\[|y| < |z_i|\quad \forall i=1,...,k\quad \text{and} \quad (m_1,y/z_1) \ne (1,1)\,,\]

\(G_{m_1,...,m_k}(z_1,...,z_k\ ;y)\) is convergent.

In Section The algorithm we will review the algorithm developed by [7] to transform any GPL into this form.

Shuffle algebra and trailing zeros

If the last parameter \(z_k\) of a GPL \(G_{m_1,...,m_k}(z_1,...,z_k\ ;y)\) vanishes, the convergence criterion (7) is not fulfilled. Hence, any algorithm that intents to exploit (4) for numerical evaluation needs to remove trailing zeros.

We can exploit the fact that GPLs satisfy two Hopf algebras: a shuffle algebra and a stuffle algebra [3, 5, 7]. Here, we will only be needing the former. It allows us to write the product of two GPLs with parameters \(\vec a\) and \(\vec b\) as

(8)\[G(\vec a\ ;y) \cdot G(\vec b\ ;y) = \sum_{\vec c = \vec a\,\shuffle\,\vec b} G(\vec c\ ;y)\,.\]

The sum in the right-hand side of (8) runs over all elements of the shuffle product of the list \(\vec a\) with \(\vec b\). This shuffle product gives the set of all permutations of the elements in \(\vec a\) and \(\vec b\) that preserve the respective orderings of \(\vec a\) and \(\vec b\). For practical implementations, a recursive algorithm exists [4].