Multiple zeta values and multiple polylogarithms
The multiple zeta values
and the multiple polylogarithms
are computed in acb_mzeta from their representations as iterated integrals. For multiple zeta values FLINT uses Akhilesh's double tails [Akh2017], a recursion with values per level and about levels for weight and bits, carried out in fixed-point arithmetic with exactly counted rounding errors; at very high precision, Hölder convolution [BBBL2001] reduces the value to multiple polylogarithms at , which are evaluated by binary splitting in quasi-linear time. General multiple polylogarithms are written as Goncharov's iterated integrals [Gon2001] and summed as power series, directly or after splitting the path at .
Words and iterated integrals#
With the differential forms and , a word in the letters defines the iterated integral
which converges when is admissible: it starts with and ends with . Expanding as a geometric series and integrating term by term gives
so the weight is the length of the word and the depth is the number of letters . The admissible words of weight are for all words of length ; acb_mzeta_mzv_index numbers them by the binary integer , writing and , so that the indices of weight are . The substitution shows that for the dual word , obtained by reversing and exchanging the letters; it is admissible when is.
Double tails#
Akhilesh's double tails of a word (not necessarily admissible) are
with for admissible .
Lemma 1 (Recurrences). For words ,
(for , respectively ), and
Proof. For the first identity, integrate out : ; the second is the same with and , and the third is the beta integral. Writing ,
since and . In the same way, from , . Applying the first relation to and the second to gives the diagonal step.
Every word reduces by these rules to shorter words or to the same word with increased by , so all values are determined by those at a large level . Moreover a subword of appears in the recursion only with , the number of letters in . The algorithm therefore stores, at level , one value per state , at most values, and computes the levels with the values of level replaced by zero; within a level the states are processed by increasing length. Only two levels are kept in memory. At level 0 only the states reachable from the requested words are computed.
Lemma 2 (Size of the tails). For a word with letters and letters , when and . In particular, at level every value is at most .
Proof. On the simplex , so the density of a letter at position is and that of a letter is . The integrand is therefore at most , and the simplex has volume at most 1. At level the exponents and are at least and ; for the empty word, .
So levels suffice for bits, and in the fixed-point format of about fraction bits the values at level have only about significant bits: the precision of each level is tapered accordingly.
Theorem 3 (Truncation). If every value dropped at level is bounded by (for example by Lemma 2), the error of the values at level 0 caused by replacing them by zero is at most .
Proof. Let bound the errors of all values at level , so . In the diagonal step at level , the terms and belong to level and contribute at most , while belongs to level (its offset is one larger) and contributes at most , since . The other rules divide by and do not increase errors. Hence , that is . At level 0 the same count gives , so , for the states with offset , and then for the words themselves (). So .
Arithmetic. All quantities are nonnegative, and the recursion is run in fixed point with fraction bits (one integer limb on top) with truncating divisions by the small integers , , , . Every computed value is then a lower bound for the exact one, and its error is an integer number of ulps that is counted exactly alongside the values (one ulp per truncating operation, propagated through the same linear recurrences). The empty-word values are carried as , whose step ratio is close to 1, and shifted down when used. The cost is dominated by the divisions by one limb: the two divisions of a diagonal step are merged into one by , and several independent divisions (states of the same length, whose children are shorter) are interleaved with precomputed inverses [GraMol2010] to hide the latency of the remainder chain. The total cost is bit operations.
Several words at once#
Different words share subwords, and the recursion can carry the states of several words together. This is used for:
- Star values. is the sum of over the indices obtained from by replacing some commas by plus signs.
- Yamamoto's interpolation [Yam2013] over the same indices: the coefficients are computed together and the polynomial is evaluated at by Horner's rule, so for far from the error is relative to the largest term.
- All values of a weight.
acb_mzeta_mzv_allevaluates all admissible words of weight (or all weights up to ) in batches limited by memory, so that each state is computed once per batch, and forms star values by summing over the merges.
Hölder convolution#
At very high precision the quadratic cost of the double tails is replaced by a quasi-linear algorithm [BBBL2001]. Splitting the integration domain of at (Chen's formula) and substituting in the variables above gives
Every suffix of the admissible words and ends with , so each is a multiple polylogarithm at : for and a suffix starting inside block with first entry ,
With and one accumulator per suffix,
a lower triangular linear recurrence of dimension . The matrices , , have integer entries; their product over is computed by binary splitting, exactly at the lower levels and in ball arithmetic at the working precision above, the products for and in parallel.
Proposition 4 (Truncation). Each omits at most , , when the products stop at .
Proof. , so the tail is at most , and the ratio of consecutive terms is at most .
With terms the cost is for fixed weight. acb_mzeta_mzv switches to this algorithm from 25000 bits (for weight at most 500), the measured crossover.
Multiple polylogarithms#
Goncharov's iterated integrals [Gon2001]
along the segment , give
which follows by expanding each and integrating term by term.
Power series at 0. Write . Then if , and with otherwise. After scaling by , the values for the nonzero letters and the partial sums for all satisfy a lower triangular linear recurrence (with expanded down to the next nonzero letter). Multiplying the rows by , one more than the longest run of zeros, the product of the matrices is computed by binary splitting in complex ball arithmetic (exactly while the entries are exact and short). This gives for all suffixes at once.
Theorem 5 (Truncation). Let be the smallest absolute value of a nonzero letter, the number of nonzero letters, and . Truncating the series after changes each by at most
Proof. The coefficients of are bounded in absolute value by those of , and integration preserves coefficientwise majorization, so , the coefficients of the series with the letters . For , by induction from : a letter 0 does not increase (for a series with nonnegative coefficients vanishing at 0, ), and a nonzero letter multiplies it by at most , since is increasing. Hence and, by Cauchy's inequality, . With , and ; sum the geometric tail and use .
Splitting at . The series at 1 converges geometrically with ratio . If it is used directly; otherwise, if every nonzero letter and every nonzero has absolute value at least , the path is split at (Chen's formula) and is substituted above it:
where both families are suffixes of one word (the second of , the first of the reversed word ), so two binary splitting runs with ratio at most give all the factors. Arguments outside these regions, such as letters close to or points outside the unit disk, are not supported.
Colored multiple zeta values. For with , the partial products are formed exactly from the sums of the exponents. The letters are roots of unity and the letters have absolute value for , so the split applies for (with ratio at most for ).
Use in FLINT#
acb_mzeta_mzv,acb_mzeta_mzv_star,acb_mzeta_mzv_t,acb_mzeta_mzv_all: double tails; Hölder convolution inacb_mzeta_mzvfrom 25000 bits.acb_mzeta_polylog,acb_mzeta_mzv_colored: Goncharov's iterated integrals by binary splitting.
Referenced from#
References#
- [Akh2017] P. Akhilesh, "Double tails of multiple zeta values", Journal of Number Theory 170 (2017), 228-249, https://arxiv.org/abs/2105.12156
- [BBBL2001] J. M. Borwein, D. M. Bradley, D. J. Broadhurst and P. Lisoněk, "Special values of multiple polylogarithms", Transactions of the American Mathematical Society 353 (2001), 907-941, https://arxiv.org/abs/math/9910045
- [Gon2001] A. B. Goncharov, "Multiple polylogarithms and mixed Tate motives", preprint (2001), https://arxiv.org/abs/math/0103059
- [GraMol2010] N. Möller and T. Granlund, "Improved division by invariant integers", IEEE Transactions on Computers 60 (2011), 165–175, https://gmplib.org/~tege/division-paper.pdf
- [Yam2013] S. Yamamoto, "Interpolation of multiple zeta and zeta-star values", Journal of Algebra 385 (2013), 102-114, https://arxiv.org/abs/1203.1118
The FLINT team, “Multiple zeta values and multiple polylogarithms,” FLINT: Fast Library for Number Theory, documentation, version 3.7.0-dev, 2026. https://flintlib.org/doc/algorithms/special-functions/multiple-zeta.html (generated 2026-11-07).
@misc{flint-doc-algorithms-special-functions-multiple-zeta,
author = {{The FLINT team}},
title = {{Multiple zeta values and multiple polylogarithms}},
howpublished = {FLINT: Fast Library for Number Theory, documentation, version 3.7.0-dev},
year = {2026},
url = {https://flintlib.org/doc/algorithms/special-functions/multiple-zeta.html},
note = {Generated 2026-11-07}
}