Wolfram Language & System Documentation Center

MultipleZeta

MultipleZeta[{s₁,s₂,…,s_k}]

gives the multiple zeta function $TemplateBox[{TemplateBox[{{{s, _, 1}, ,, {s, _, 2}, ,, ..., ,, {s, _, k}}}, ImplicitList]}, MultipleZeta]$ , defined by the nested sum .

Details

MultipleZeta gives nested sums of reciprocal powers, extending Zeta to multiple strictly ordered indices.
MultipleZeta appears as periods in number theory, as coefficients in -expansions of Feynman integrals and in knot invariants.
MultipleZeta with positive integer indices is also known as "Multiple Zeta Value".
Series definition: .
Integral definition: with the differential -forms and , $TemplateBox[{TemplateBox[{{{s, _, 1}, ,, {s, _, 2}, ,, ..., ,, {s, _, k}}}, ImplicitList]}, MultipleZeta]$ ( are positive integers) is the Chen iterated integral , where denotes consecutive copies of (non-commutative). For example, .
MultipleZeta is a mathematical function, suitable for both symbolic and numerical manipulation.
The function supports numerical evaluation of the following types:
machine precision N Yes

arbitrary precision N Yes

worst-case intervals CenteredInterval No

average-case intervals Around No
The defining series of $TemplateBox[{TemplateBox[{{{s, _, 1}, ,, {s, _, 2}, ,, ..., ,, {s, _, k}}}, ImplicitList]}, MultipleZeta]$ converges whenever the real part of each initial partial sum of the arguments exceeds its length, i.e. for .
In $TemplateBox[{TemplateBox[{{{s, _, 1}, ,, {s, _, 2}, ,, ..., ,, {s, _, k}}}, ImplicitList]}, MultipleZeta]$ , are the weights (also called indices), and is the depth.
MultipleZeta[{s}] is same as Zeta[s].
For certain special arguments, MultipleZeta automatically evaluates to exact values.
When the defining series converges, MultipleZeta[{s₁,s₂,…,s_k}]=MultipleHarmonicNumber[∞,{s₁,s₂,…,s_k}].
Products of MultipleZeta satisfy stuffle relations for nested sums and shuffle relations for iterated integrals.
Sum and Integrate may return results in terms of MultipleZeta.

Examples

open all close all

Basic Examples (2)

Exact values are generated automatically for small weights:

Wolfram Language code: MultipleZeta[{2, 3}]

Evaluate numerically:

Wolfram Language code: N[MultipleZeta[{12, 2}]]

Scope (16)

Numerical Evaluation (3)

Evaluate with large weight:

Wolfram Language code: N[MultipleZeta[{6, 12, 18}]]

Evaluate to arbitrary precision:

Wolfram Language code: N[MultipleZeta[{5, 3}], 50]

Evaluate with rational and complex weights:

Wolfram Language code: N[MultipleZeta[{6, 1 / 3, 2 / 3}]]

Wolfram Language code: N[MultipleZeta[{6, 1 / 3, 2 + I}]]

Specific Values (6)

For total weight , all possible MultipleZeta instances with positive integer indices will autoevaluate in terms of Zeta:

Wolfram Language code: Table[MultipleZeta[{n, 1}], {n, 2, 6}]

For total weight , certain MultipleZeta instances may not be reducible in terms of Zeta:

Wolfram Language code: MultipleZeta[{5, 3}]

Reduction of a MultipleZeta of weight :

Wolfram Language code: MultipleZeta[{9, 1}]

Reduction of a high-weight MultipleZeta with a certain symmetry in the indices:

Wolfram Language code: MultipleZeta[{20, 20, 20, 20}]

Reduction of MultipleZeta with non-positive weights:

Wolfram Language code: MultipleZeta[{5, 0, 0, 1}]

Wolfram Language code: MultipleZeta[{8, -2, 0}]

Examples of divergent MultipleZeta:

Wolfram Language code: MultipleZeta[{2, 0, 3}]

Wolfram Language code: MultipleZeta[{2I, -1 / 2, 3}]

Visualization (5)

Log-scale discrete plot of the diagonal depth-2 values across , highlighting rapid decay with increasing weight:

Wolfram Language code: Plot[MultipleZeta[{n, n}], {n, 2, 10}, ScalingFunctions -> {None, "Log"}]

Side-by-side log-scale traces of and that emphasize order asymmetry under index swap:

Wolfram Language code: Plot[Evaluate@{MultipleZeta[{n, 2}], MultipleZeta[{2, n}]}, {n, 2, 10}, ...]

Three-D plot of Log10[MultipleZeta[{s1,s2}]] over admissible indices, showing how magnitude varies across the grid:

Wolfram Language code: Plot3D[Abs@Log10@MultipleZeta[{s1, s2}], {s1, 5, 10}, {s2, 5, 10}, ...]

Log-scale plot of the diagonal depth-3 values versus , showing depth-driven suppression with weight:

Wolfram Language code: Plot[MultipleZeta[{n, n, n}], {n, 2, 20}, ScalingFunctions -> {None, "Log"}]

Dependence of on the tail index at fixed head :

Wolfram Language code: Plot[MultipleZeta[{4, 4, n}], {n, 1, 10}]

Function Representation (2)

Obtain MultipleZeta from its series representation:

Wolfram Language code: Sum[(1/n1^8n2^2n3^4), {n1, 1, Infinity}, {n2, 1, n1 - 1}, {n3, 1, n2 - 1}]

Obtain the same from its integral representation:

Wolfram Language code:

Subsuperscript[∫, 0, 1]Subsuperscript[∫, 0, x1]Subsuperscript[∫, 0, x2]Subsuperscript[∫, 0, x3]Subsuperscript[∫, 0, x4]Subsuperscript[∫, 0, x5]Subsuperscript[∫, 0, x6]Subsuperscript[∫, 0, x7]Subsuperscript[∫, 0, x8]Subsuperscript[∫, 0, x9]Subsuperscript[∫, 0, x10]Subsuperscript[∫, 0, x11]Subsuperscript[∫, 0, x12]Subsuperscript[∫, 0, x13](1/x1 x2 x3 x4 x5 x6 x7 (1 - x8) x9 (1 - x10) x11 x12 x13 (1 - x14))ⅆx14ⅆx13ⅆx12ⅆx11ⅆx10ⅆx9ⅆx8ⅆx7ⅆx6ⅆx5ⅆx4ⅆx3ⅆx2ⅆx1

Applications (8)

Euler Sums (4)

A high-weight Euler sum collapses to a combination of -powers, products of single zetas, and depth-2 MultipleZeta term:

Wolfram Language code: Underoverscript[∑, n = 1, ∞](HarmonicNumber[n]^6/n^2)

Sum with complex exponents in the pre-factor results in MultipleZeta with complex weights:

Wolfram Language code: Underoverscript[∑, n = 1, ∞](HarmonicNumber[n, (7/2)]^3/n^6 + I)

Mixed Euler sum with harmonic number and generalized harmonic number evaluates to MultipleZeta together with products of single zetas:

Wolfram Language code: Underoverscript[∑, n = 1, ∞](HarmonicNumber[n] HarmonicNumber[n, 2]^2/n^3)

The infinite sum with MultipleHarmonicNumber converts directly into a linear combination of MultipleZeta instances:

Wolfram Language code: Underoverscript[∑, n = 1, ∞](MultipleHarmonicNumber[n, {2, 2, 1}]/n^10)

Mordell–Tornheim Sums (2)

A Mordell–Tornheim sum (also known as Witten zeta) with three variables expressed using MultipleZeta:

Wolfram Language code:

Underoverscript[∑, m1 = 1, ∞]Underoverscript[∑, m2 = 1, ∞]Underoverscript[∑, m3 = 1, ∞](1/m1^2 m2 m3^6 (m1 + m2 + m3)^3)

A Mordell–Tornheim sum with four variables expressed using MultipleZeta:

Wolfram Language code:

Underoverscript[∑, m1 = 1, ∞]Underoverscript[∑, m2 = 1, ∞]Underoverscript[∑, m3 = 1, ∞]Underoverscript[∑, m4 = 1, ∞](1/m1^2 m2 m3^3 m4^2 (m1 + m2 + m3 + m4)^3)

Iterated Integrals (2)

A complex iterated integral returns results in terms of MultipleZeta:

Wolfram Language code:

Integrate[(1/x1 x2 x3 x4 x5 (1 - x6) x7(1 - x8)^2(1 - x9)x10 (1 - x11)), {x1, 0, 1}, {x2, 0, x1}, {x3, 0, x2}, {x4, 0, x3}, {x5, 0, x4}, {x6, 0, x5}, {x7, 0, x6}, {x8, 0, x7}, {x9, 0, x8}, {x10, 0, x9}, {x11, 0, x10}]

An iterated integral returns results in terms of HarmonicPolyLog and MultipleZeta:

Wolfram Language code:

Integrate[(1/x1 x2(1 + x2) (1 - x3) x4(1 - x5)(1 - x6)x7(1 - x8)), {x1, 0, 1}, {x2, 0, x1}, {x3, 0, x2}, {x4, 0, x3}, {x5, 0, x4}, {x6, 0, x5}, {x7, 0, x6}, {x8, 0, x7}]

Properties & Relations (17)

Verify Hoffman’s evaluation, where and denotes a sequence being repeated times:

Wolfram Language code: Block[{n = 10}, MultipleZeta[Table[2, n]] == (π^2n/(2n + 1)!)]

Verify Zagier’s conjecture, :

Wolfram Language code: Block[{n = 10}, MultipleZeta[Flatten[Table[{3, 1}, n]]] == (2π^4n/(4n + 2)!)]

Verify the reduction for :

Wolfram Language code:

Block[{n = 10}, Inactive[MultipleZeta][{n, 1}] == (n / 2) Inactive[Zeta][n + 1] - (1 / 2) Sum[Inactive[Zeta][k] Inactive[Zeta][n + 1 - k], {k, 2, n - 1}]]

Wolfram Language code: Activate[%]//Simplify

Similarly, verify the reduction of for :

Wolfram Language code:

Block[{n = 10}, Inactive[MultipleZeta][{n, 1, 1}] == (n (n + 1) / 6) Inactive[Zeta][n + 2] - ((n - 1) / 2) Inactive[Zeta][2] Inactive[Zeta][n] - (n / 4) Sum[Inactive[Zeta][n - k - 1] Inactive[Zeta][k + 3], {k, 0, n - 4}] + (1 / 6) Sum[Inactive[Zeta][n - k - 2] Sum[Inactive[Zeta][k - j + 2] Inactive[Zeta][j + 2], {j, 0, k}], {k, 0, n - 4}]//Simplify
	]

Wolfram Language code: Activate[%]//Simplify

Verify the classical sum formula where :

Wolfram Language code: Block[{n = 10}, Total[Table[Inactive[MultipleZeta][{k, n - k}], {k, 2, n - 1}]] == Inactive[Zeta][n]]

Wolfram Language code: Activate[%]//Simplify

Verify the weighted sum formula where :

Wolfram Language code: Block[{n = 10}, Sum[2^kInactive[MultipleZeta][{k, n - k}], {k, 2, n - 1}] == (n + 1)Inactive[Zeta][n]]

Wolfram Language code: Activate[%]//Simplify

Implement Hoffman’s duality map by reversing the word (iterated-integral) encoding of the index:

Wolfram Language code:

dualMap[Inactive[MultipleZeta][l_]] := 
	Module[{toAbbreviated, fromAbbreviated, one, zero}, 
	toAbbreviated[w_] := Differences@Prepend[Flatten@Position[w, 1], 0];fromAbbreviated[w_] := Flatten@Map[Join[ConstantArray[0, # - 1], {1}]&, w];
	Inactive[MultipleZeta][toAbbreviated[Reverse[fromAbbreviated[l]] /. {0 -> one, 1 -> zero} /. {zero -> 0, one -> 1}]
	]
	]

Apply the map to an example and display the dual word:

Wolfram Language code: dualMap[e = Inactive[MultipleZeta][{2, 1, 7}]]

Confirm that the duality identity holds:

Wolfram Language code: % == e//Activate

Applying the duality map twice returns the original MultipleZeta:

Wolfram Language code: With[{w = Inactive[MultipleZeta][{2, 1, 7}]}, dualMap[dualMap[w]] === w]

Expand the product of two MultipleZeta instances using shuffle (iterated-integral) algebra without evaluation:

Wolfram Language code: Block[{e = Inactive[MultipleZeta][{2, 3}]Inactive[MultipleZeta][{4}]}, e == ResourceFunction["ShuffleProductExpand"][e]]

Verify that the expansion holds:

Wolfram Language code: Activate[%]//Simplify

Expand the same product using stuffle (series) algebra:

Wolfram Language code: Block[{e = Inactive[MultipleZeta][{2, 3}]Inactive[MultipleZeta][{4}]}, e == ResourceFunction["StuffleProductExpand"][e]]

Verify that the expansion holds:

Wolfram Language code: Activate[%]//Simplify

Verify the double-shuffle relationship:

Wolfram Language code:

Block[{e = Inactive[MultipleZeta][{2, 3}]Inactive[MultipleZeta][{4}]}, Simplify[ResourceFunction["ShuffleProductExpand"][e] == ResourceFunction["StuffleProductExpand"][e]]]

Wolfram Language code: Activate[%]//Simplify

Verify that every term in a shuffle or stuffle expansion preserves total weight (sum of indices):

Wolfram Language code:

With[{p = Inactive[MultipleZeta][{2, 3}] Inactive[MultipleZeta][{4}]}, 
	AllTrue[
	Cases[List@@(ResourceFunction["ShuffleProductExpand"][p] + ResourceFunction["StuffleProductExpand"][p]), Inactive[MultipleZeta][l_List] :> Total[l]], 
	EqualTo[2 + 3 + 4]
	]
	]

Generate ordered compositions (permuted partitions) of into parts:

Wolfram Language code:

compositions[m_Integer ? Positive, r_Integer ? Positive] := DeleteDuplicates@(Join@@(Permutations /@ IntegerPartitions[m, {r}]));

Build Euler’s sum-formula LHS at weight and depth in inactive form:

Wolfram Language code:

sumFormulaLHS[m_Integer ? Positive, r_Integer ? Positive] := 
	Module[{term}, 
	term[alpha_List] := Inactive[MultipleZeta][Join[{alpha[[-1]] + 1}, Reverse@Most@alpha]];
	Total[term /@ compositions[m, r]]
	];

Depth 3, weight 7 () instance:

Wolfram Language code: Block[{m = 6}, sumFormulaLHS[m, 3] == Inactive[Zeta][m + 1]]

Activate to confirm:

Wolfram Language code: Activate[%]//Simplify

Use the basis conjecture with the PSLQ integer-relation detection method to discover identities:

Wolfram Language code:

Clear[MZBasisConjectureRelation];
MZBasisConjectureRelation[mm : {__Integer}, prec_ : 20] := 
	Module[{mzlist, res}, 
	mzlist  = 
	 Map[Inactive[MultipleZeta], Select[Flatten[Tuples[{2, 3}, #]& /@ Range[Ceiling[1 / 2 * Plus@@mm]], 1], Plus@@# == Plus@@mm&]];
	res = 
	FindIntegerNullVector[N[Prepend[Activate@mzlist, MultipleZeta[mm]], prec]];
	Inactive[MultipleZeta][mm] == Apply[Plus, -Rest[res] * mzlist / First[res]] /; FreeQ[res, FindIntegerNullVector] && First[res] =!= 0
	]

Weight MultipleZeta with default digits precision:

Wolfram Language code: MZBasisConjectureRelation[{2, 2, 1, 3}]

Activate and confirm numerically:

Wolfram Language code: Simplify[Activate[%]]

Weight MultipleZeta with digits precision:

Wolfram Language code: MZBasisConjectureRelation[{4, 1, 5}, 30]

The equation contains some irreducible MultipleZeta instances, so verify numerically:

Wolfram Language code: N[Activate[%[[1]]], 10] == N[Activate[%[[2]]], 10]

Depth-1 MultipleZeta reduces to Zeta:

Wolfram Language code: MultipleZeta[{10}] == Zeta[10]

MultipleZeta is related to HarmonicPolyLog at endpoint 1:

Wolfram Language code: MultipleZeta[{10, 10, 10}] == HarmonicPolyLog[{10, 10, 10}, 1]

MultiplePolyLog with a decoration vector as a constant 1s array reduces to MultipleZeta:

Wolfram Language code: MultipleZeta[{6, 4, 2, 8}] == MultiplePolyLog[{6, 4, 2, 8}, {1, 1, 1, 1}]

GeneralizedPolyLog with words over reduces to MultipleZeta:

Wolfram Language code: MultipleZeta[{3, 5, 3, 6}] == GeneralizedPolyLog[{0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1}, 1]

Possible Issues (1)

The argument of MultipleZeta must be a list:

Wolfram Language code: MultipleZeta[2]

Wolfram Language code: MultipleZeta[2, 6, 3]

Neat Examples (3)

Compute a triple Euler sum in terms of MultipleZeta:

Wolfram Language code:

Underoverscript[∑, n1 = 1, ∞]Underoverscript[∑, n2 = 1, n1]Underoverscript[∑, n3 = 1, n2](HarmonicNumber[n1] HarmonicNumber[n2] HarmonicNumber[n3]/n1^2 n2^3 n3^4)

MultipleZeta serves as a bridge between Euler-type nested sums and iterated integrals:

Wolfram Language code:

Underoverscript[∑, n1 = 1, ∞]Underoverscript[∑, n2 = 1, n1 - 1](1/n1^2 n2^3) == MultipleZeta[{2, 3}] == Subsuperscript[∫, 0, 1]Subsuperscript[∫, 0, x1]Subsuperscript[∫, 0, x2]Subsuperscript[∫, 0, x3]Subsuperscript[∫, 0, x4](1/x1 (x2 - 1) x3 x4 (x5 - 1))ⅆx5ⅆx4ⅆx3ⅆx2ⅆx1

A function that finds -functions of a given weight that cannot be reduced to lower-weight -functions:

Wolfram Language code:

findIrreducibleMZ[w_Integer ? Positive] := Module[{inds, d0, disp, val, maxD}, inds = DeleteDuplicates@Flatten[Permutations /@ IntegerPartitions[w], 1];
	d0 = Length /@ inds;
	disp = If[Length[#] == 1, With[{e = First@#}, Defer@Zeta@e], Defer@MultipleZeta[#]]& /@ inds;
	val = (MultipleZeta /@ inds);
	maxD[e_] := Max[0, Sequence@@Cases[e, HoldPattern[MultipleZeta[l_List]] /; Total[l] == w :> Length[l], {0, Infinity}], Sequence@@Cases[e, Zeta[n_Integer] /; n == w :> 1, {0, Infinity}]];
	Pick[disp, MapThread[maxD[#1] >= #2&, {val, d0}]]
	];

A nicely formatted table for the irreducible -functions for weights 1 through 10:

Wolfram Language code:

Grid[Prepend[Cases[Map[{#, findIrreducibleMZ[#]}&, Range[10]], {wt_, val : Except[{}]} :> {wt, Column[val, Spacings -> 0.25]}], {"Weight", Column[{"Irreducible", "ζ-functions"}]}], IconizedObject[«Grid options»]]//TraditionalForm

The number of such irreducible functions increases rapidly after the first 10 total weights:

Wolfram Language code:

Grid[Prepend[Map[{#, Length[findIrreducibleMZ[#1]]}&, Range[11, 16]], {"Weight", "# of irreducible ζ-functions"}]//Transpose, IconizedObject[«Grid options»]]//TraditionalForm

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

MultipleZeta

Details

Examples

Basic Examples (2)

Scope (16)

Numerical Evaluation (3)

Specific Values (6)

Visualization (5)

Function Representation (2)

Applications (8)

Euler Sums (4)

Mordell–Tornheim Sums (2)

Iterated Integrals (2)

Properties & Relations (17)

Possible Issues (1)

Neat Examples (3)

Text

CMS

APA

BibTeX

BibLaTeX

machine precision	N	Yes
arbitrary precision	N	Yes
worst-case intervals	CenteredInterval	No
average-case intervals	Around	No

MultipleZeta

Details

Examples

Basic Examples (2)

Scope (16)

Numerical Evaluation (3)

Specific Values (6)

Visualization (5)

Function Representation (2)

Applications (8)

Euler Sums (4)

Mordell–Tornheim Sums (2)

Iterated Integrals (2)

Properties & Relations (17)

Possible Issues (1)

Neat Examples (3)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX