Wolfram Language & System Documentation Center

GeneralizedPolyLog

GeneralizedPolyLog[{a₁,a₂,…,a_k},x]

gives the Goncharov polylogarithm defined as the iterated integral .

GeneralizedPolyLog[{a₁,a₂,…,a_k},x,p]

gives the Goncharov polylogarithm with base point p.

GeneralizedPolyLog[{a₁,a₂,…,a_k},x,{p₁,p₂,…,p_k}]

gives the Goncharov polylogarithm with a sequence of base points (p₁, p₂, …).

Details

GeneralizedPolyLog gives Chen iterated integrals from the form , unifying logs, classical polylogs and harmonic polylogs.
GeneralizedPolyLog is defined as an iterated integral (when it converges) as follows:
$TemplateBox[{TemplateBox[{{{a, _, {(, 1, )}}, ,, {a, _, {(, 2, )}}, ,, ..., ,, {a, _, {(, k, )}}}}, ImplicitList], x}, GeneralizedPolyLog]$

$TemplateBox[{TemplateBox[{{{a, _, {(, 1, )}}, ,, {a, _, {(, 2, )}}, ,, ..., ,, {a, _, {(, k, )}}}}, ImplicitList], {x, ;, , p}}, GeneralizedPolyLog]$

$TemplateBox[{TemplateBox[{{{a, _, {(, 1, )}}, ,, {a, _, {(, 2, )}}, ,, ..., ,, {a, _, {(, k, )}}}}, ImplicitList], {x, ;, , {{, {{p, _, 1}, ,, , {p, _, 2}, ,, , ..., ,, , {p, _, k}}, }}}}, GeneralizedPolyLog]$
The first argument of GeneralizedPolyLog[{a₁,a₂,…,a_k},x] is the word, and are the letters (or weights). x is the endpoint.
The defining iterated integral of $TemplateBox[{TemplateBox[{{{a, _, 1}, ,, {a, _, 2}, ,, ..., ,, {a, _, k}}}, ImplicitList], x}, GeneralizedPolyLog]$ diverges in the following three conditions:
Lower-endpoint collision

Upper-endpoint collision

Letter crossing (pole on the path) at least one of lies on the open segment
The following measures are taken in the divergent cases:

	Lower-endpoint collision	returns a regularized value using shuffle relations
	Upper-endpoint collision	returns ComplexInfinity
	Letter crossing (pole on the path)	returns values obtained by analytic continuation, using infinitesimal circular detours around the poles

GeneralizedPolyLog 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
. On principal branches, and .
Products at the same endpoint satisfy the shuffle algebra: $TemplateBox[{TemplateBox[{u}, ImplicitList], x}, GeneralizedPolyLog]*TemplateBox[{TemplateBox[{v}, ImplicitList], x}, GeneralizedPolyLog]= sum_(w in u ⧢ v)TemplateBox[{TemplateBox[{w}, ImplicitList], x}, GeneralizedPolyLog]$ , where denotes all interleavings preserving the internal orders of and .
While MultiplePolyLog is the generalization of the series definition of PolyLog, GeneralizedPolyLog represents a generalization of the integral definition of PolyLog.
Sum, GeneratingFunction, ExponentialGeneratingFunction, ZTransform, DirichletTransform, Integrate, DSolve and AsymptoticDSolveValue may return results in terms of GeneralizedPolyLog.

Examples

open all close all

Basic Examples (6)

Evaluate a GeneralizedPolyLog numerically:

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

The defining integral of a GeneralizedPolyLog:

Wolfram Language code: Integrate[(1/(x1 - 1)(x2 - 2)(x3 - 3)(x4 - 4)), {x1, 0, I}, {x2, 0, x1}, {x3, 0, x2}, {x4, 0, x3}]

Plot a GeneralizedPolyLog over a subset of the reals:

Wolfram Language code: Plot[GeneralizedPolyLog[{4, 10}, x], {x, -2, 2}]

Plot over a subset of complexes:

Wolfram Language code: ComplexPlot3D[GeneralizedPolyLog[{4, 10}, x], {x, -1 - I, 1 + I}]

Plot the real and imaginary parts of a family of GeneralizedPolyLog function:

Wolfram Language code:

GraphicsRow[{Plot[Evaluate@Table[Re@GeneralizedPolyLog[{c * I, -c * I}, x], {c, 6}], {x, -2, 2}, PlotStyle -> Automatic], Plot[Evaluate@Table[Im@GeneralizedPolyLog[{c * I, -c * I}, x], {c, 6}], {x, -2, 2}, PlotStyle -> Automatic]}]

Series expansion at the origin:

Wolfram Language code: Series[GeneralizedPolyLog[{I, 3}, x], {x, 0, 10}]

Scope (31)

Numerical Evaluation (2)

Evaluate numerically:

Wolfram Language code: GeneralizedPolyLog[{2, I, -I}, 1.]

Evaluate to high precision:

Wolfram Language code: N[GeneralizedPolyLog[{2, I, -I}, 1], 10]

Specific Values (8)

A single zero letter reproduces the principal logarithm:

Wolfram Language code: GeneralizedPolyLog[{0}, 10]

Compute over integer letters:

Wolfram Language code: GeneralizedPolyLog[{2, 7}, 1]

Compute over rational letters:

Wolfram Language code: GeneralizedPolyLog[{-2 / 3, 10 / 7}, 1]

Compute over algebraic letters:

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

Compute over complex letters:

Wolfram Language code: GeneralizedPolyLog[{-I, I}, 1]

Word composed of three letters:

Wolfram Language code: GeneralizedPolyLog[{2, 10, 20}, 1]

Word composed of five letters:

Wolfram Language code: GeneralizedPolyLog[{0, 2, 2, 2, 2}, 1]

Evaluate at a complex endpoint:

Wolfram Language code: GeneralizedPolyLog[{-2, 0, 2}, 2 - 4I]

Visualization (7)

Plot the real and imaginary parts of a depth-2 GeneralizedPolyLog along the real axis:

Wolfram Language code: ReImPlot[GeneralizedPolyLog[{-I, I}, x], {x, -2, 2}]

Evaluate the same GeneralizedPolyLog along the slanted segment :

Wolfram Language code:

pathPlot = Graphics[{Thick, Arrowheads[.15], Arrow[{{0, 0}, {1, 1}}]}, ...];
ReImPlot[GeneralizedPolyLog[{-I, I}, (1 + I) x], {x, 0, 1}, ...]

Trace the GeneralizedPolyLog along the circle :

Wolfram Language code:

pathCirclePlot = Graphics[{Circle[{0, 0}, 1 / 2, {-Pi / 2, 3 Pi / 2}] }, ...];
ParametricPlot[ReIm@GeneralizedPolyLog[{-I, I}, (1 / 2) Exp[I t]], {t, 0, 2 Pi}, ...]

See the evolution with four different radii:

Wolfram Language code:

With[{rs = {.3, .45, .6, .75}}, ParametricPlot[Evaluate@Table[ReIm@GeneralizedPolyLog[{-I, I}, r Exp[I t]], {r, rs}], {t, 0, 2 Pi}, ...]]

Check the effect of incrementally adding new symmetric letters:

Wolfram Language code:

GraphicsRow[{ParametricPlot[ReIm[GeneralizedPolyLog[{1}, (1 / 2)Exp[I t]]], {t, 0, 2Pi}, Rule[...]], ParametricPlot[ReIm[GeneralizedPolyLog[{-1, 1}, (1 / 2)Exp[I t]]], {t, 0, 2Pi}, Rule[...]], ParametricPlot[ReIm[GeneralizedPolyLog[{-1, -1, 1, 1}, (1 / 2)Exp[I t]]], {t, 0, 2Pi}, Rule[...]], 
	ParametricPlot[ReIm[GeneralizedPolyLog[{-1, -1, -1, 1, 1, 1}, (1 / 2)Exp[I t]]], {t, 0, 2Pi}, Rule[...]]}
	]

Vary the second letter while keeping the argument fixed at :

Wolfram Language code: ReImPlot[GeneralizedPolyLog[{-I, k I}, 1], {k, 1, 10}]

Zero contours of real and imaginary parts of GeneralizedPolyLog[{I,-I},z]:

Wolfram Language code:

Clear[g];g[z_] := GeneralizedPolyLog[{I, -I}, z];
ContourPlot[{Re[g[x + I y]] == 0, Im[g[x + I y]] == 0}, {x, -1 / 2, 1 / 2}, {y, -1 / 2, 1 / 2}, ...]

Differentiation (6)

Take derivative w.r.t. the endpoint:

Wolfram Language code: D[GeneralizedPolyLog[{2, 3, 4}, x], x]

Take higher-order derivative:

Wolfram Language code: D[GeneralizedPolyLog[{1, 2, 3, 4, 5, 6}, x], {x, 3}]

Endpoint is a function of :

Wolfram Language code: D[GeneralizedPolyLog[{-6, 8, 10}, x ^ 2], x]

Take derivative w.r.t. a letter:

Wolfram Language code: D[GeneralizedPolyLog[{a, 3, 4}, x], a]

Take the derivative of a GeneralizedPolyLog having a nonzero basepoint w.r.t. the endpoint:

Wolfram Language code: D[GeneralizedPolyLog[{2, 3, 4}, x, I], x]

Take the derivative of a GeneralizedPolyLog having a sequence of basepoints w.r.t. the endpoint:

Wolfram Language code: D[GeneralizedPolyLog[{2, 3, 4}, x, {I, 2I, 3I}], x]

Integration (1)

Indefinite integration involving GeneralizedPolyLog:

Wolfram Language code: Integrate[GeneralizedPolyLog[{2, 3}, x], x]

Definite integration involving GeneralizedPolyLog:

Wolfram Language code: Integrate[GeneralizedPolyLog[{2, 3}, x], {x, 0, 1}]

Algebraic Relations (7)

Duality relationship: $TemplateBox[{TemplateBox[{{{c, -, {z, _, 1}}, ,, {c, -, {z, _, 2}}, ,, ..., ,, {c, -, {z, _, n}}}}, ImplicitList], c}, GeneralizedPolyLog]=(-1)^nTemplateBox[{TemplateBox[{{{z, _, n}, ,, {z, _, {(, {n, -, 1}, )}}, ,, ..., ,, {z, _, 1}}}, ImplicitList], c}, GeneralizedPolyLog]$ :

Wolfram Language code: PossibleZeroQ@Chop@N[GeneralizedPolyLog[{4, 6, 8, 10}, 2] - GeneralizedPolyLog[{-8, -6, -4, -2}, 2]]

Scaling relationship: for nonzero , $TemplateBox[{TemplateBox[{{{c, , {z, _, 1}}, ,, {c, , {z, _, 2}}, ,, ..., ,, {c, , {z, _, n}}}}, ImplicitList], c}, GeneralizedPolyLog]=TemplateBox[{TemplateBox[{{{z, _, 1}, ,, {z, _, 2}, ,, ..., ,, {z, _, n}}}, ImplicitList], 1}, GeneralizedPolyLog]$ :

Wolfram Language code: PossibleZeroQ@Chop@N[GeneralizedPolyLog[{2I, -2I, 2I, -2I}, 2] - GeneralizedPolyLog[{I, -I, I, -I}, 1]]

Shuffle product identity: for words and with common endpoint , $TemplateBox[{TemplateBox[{u}, ImplicitList], x}, GeneralizedPolyLog]*TemplateBox[{TemplateBox[{v}, ImplicitList], x}, GeneralizedPolyLog]= sum_(w in u ⧢ v)TemplateBox[{TemplateBox[{w}, ImplicitList], x}, GeneralizedPolyLog]$ :

Wolfram Language code: product = Inactive[GeneralizedPolyLog][{1, 2}, 1 / 2] * Inactive[GeneralizedPolyLog][{3, 4}, 1 / 2];

Wolfram Language code: expanded = ResourceFunction["ShuffleProductExpand"][product]

Verification:

Wolfram Language code: PossibleZeroQ@Chop@N@Activate[product - expanded]

GeneralizedPolyLog satisfies the stuffle product identity via the standard map to MultiplePolyLog:

Wolfram Language code: product = Inactive[GeneralizedPolyLog][{2}, 1] * Inactive[GeneralizedPolyLog][{6}, 1];

Wolfram Language code: expanded = ResourceFunction["StuffleProductExpand"][product]

Verification:

Wolfram Language code: PossibleZeroQ@Chop@N@Activate[product - expanded]

Hölder convolution: for letters and split point , $TemplateBox[{TemplateBox[{{{a, _, 1}, ,, {a, _, 2}, ,, ..., ,, {a, _, n}}}, ImplicitList], 1}, GeneralizedPolyLog]=sum_(j=0)^n(-1)^jTemplateBox[{TemplateBox[{{{1, -, {a, _, j}}, ,, {1, -, {a, _, {(, {j, -, 1}, )}}}, ,, ..., ,, {1, -, {a, _, 1}}}}, ImplicitList], {1, -, q}}, GeneralizedPolyLog]TemplateBox[{TemplateBox[{{{a, _, {(, {j, +, 1}, )}}, ,, ..., ,, {a, _, n}}}, ImplicitList], q}, GeneralizedPolyLog]$ :

Wolfram Language code:

HolderRHS[a_List, q_ ? NumericQ] := Module[{n = Length[a]}, Sum[(-1) ^ j * GeneralizedPolyLog[Reverse[1 - Take[a, j]], 1 - q] * GeneralizedPolyLog[Drop[a, j], q], {j, 0, n}]];

Wolfram Language code: PossibleZeroQ@Chop@N[GeneralizedPolyLog[{2, 3, 4}, 1] - HolderRHS[{2, 3, 4}, 1]]

GeneralizedPolyLog is covariant under complex conjugation:

Wolfram Language code:

PossibleZeroQ@Chop@N[Conjugate[GeneralizedPolyLog[{I, 2 + I}, 1 - I]] - GeneralizedPolyLog[Conjugate /@ {I, 2 + I}, Conjugate[1 - I]]]

Antipode identity: $sum_(k=0)^n(-1)^kTemplateBox[{TemplateBox[{{{a, _, k}, ,, ..., ,, {a, _, 1}}}, ImplicitList], x}, GeneralizedPolyLog]TemplateBox[{TemplateBox[{{{a, _, {(, {k, +, 1}, )}}, ,, ..., ,, {a, _, n}}}, ImplicitList], x}, GeneralizedPolyLog]=0$ with the convention $TemplateBox[{TemplateBox[{{{a, _, 0}, ,, ..., ,, {a, _, 1}}}, ImplicitList], x}, GeneralizedPolyLog]=1$ :

Wolfram Language code: x = 1;w = {2, 5, 7};

Wolfram Language code: sum = Sum[(-1) ^ k * GeneralizedPolyLog[Reverse@Take[w, k], x] * GeneralizedPolyLog[Drop[w, k], x], {k, 0, Length[w]}];

Wolfram Language code: PossibleZeroQ@Chop@N[sum]

Generalizations & Extensions (7)

Regularization (3)

Upper-endpoint collision—GeneralizedPolyLog diverges when the endpoint coincides with the first letter:

Wolfram Language code: GeneralizedPolyLog[{1, 2}, 1]

Lower-endpoint collision—trailing zeros in the word cause divergence but can be regularized:

Wolfram Language code: GeneralizedPolyLog[{1, 2, 0, 0}, 1 / 2]

Wolfram Language code: N[%]

With regularization, one can continue to use the iterated integral definition with Log[x]. A regularized GeneralizedPolyLog:

Wolfram Language code: GeneralizedPolyLog[{1 + I, 0, 0}, x]

Evaluate at :

Wolfram Language code: % /. x -> 2.

This is the same as:

Wolfram Language code: NIntegrate[(1 / (x - (1 + I)))Log[x] ^ 2 / Factorial[2], {x, 0, 2}]

Analytic Continuation (2)

The defining integral for GeneralizedPolyLog[{2, I}, 3] diverges, since the pole at lies on the open segment :

Wolfram Language code: Integrate[(1/(x1 - 2)(x2 - I)), {x1, 0, 3}, {x2, 0, x1}]

A finite value is obtained by integrating along an infinitesimal circular detour around the pole:

Wolfram Language code: GeneralizedPolyLog[{2, I}, 3]//N

Visualize the branch-cut discontinuity of GeneralizedPolyLog[{2, I},x]:

Wolfram Language code: ReImPlot[GeneralizedPolyLog[{2, I}, x], {x, 0, 3}]

Nonzero Base Point (2)

A GeneralizedPolyLog with base point I:

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

Obtain the same from its integral representation:

Wolfram Language code: % == Integrate[(1/(x1 - 2)(x2 - 3)), {x1, I, 1}, {x2, I, x1}]

A GeneralizedPolyLog with a sequence of base points {I, 2 I}:

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

Obtain the same from its integral representation:

Wolfram Language code: % == Integrate[(1/(x1 - 2)(x2 - 3)), {x1, I, 1}, {x2, 2I, x1}]

Applications (12)

Euler Sum (2)

An Euler sum involving a three-argument HarmonicNumber is expressed in terms of GeneralizedPolyLog and MultiplePolyLog:

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

An Euler sum involving a MultipleHarmonicNumber:

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

Iterated Integrals (4)

Evaluate an iterated integral in terms of GeneralizedPolyLog:

Wolfram Language code: Integrate[(1/(x1 - 1) (x2 - 4I)(x2 - 6I)(x2 - 8I)(x3 - 11I)), {x1, 0, (1/2)}, {x2, 0, x1}, {x3, 0, x2}]

A rational iterated integral with a polynomial part evaluates in terms of GeneralizedPolyLog, PolyLog and Log:

Wolfram Language code: Integrate[(x1^3/x1^2 - 1)(1/1 + x2)(1/2x3 - 6), {x1, 0, I}, {x2, 0, x1}, {x3, 0, x2}]

A rational iterated integral with nonzero lower limits evaluates in terms of GeneralizedPolyLog:

Wolfram Language code: Integrate[(1/(x1 - 1) (x2 - 4I)(x2 - 8I)(x3 - 11I)), {x1, I, 1 / 2}, {x2, 2I, x1}, {x3, 3I, x2}]//Short

An iterated integral that evaluates in terms of a three-argument GeneralizedPolyLog:

Wolfram Language code: Integrate[(x1/(-(5/2) + x1) x2 (-(11/4) + x3)), {x1, 0, (1/2)}, {x2, 1, x1}, {x3, (4/3), x2}]

Rational ODE System (2)

Solve a linear homogeneous system of ordinary differential equations in terms of GeneralizedPolyLog:

Wolfram Language code:

DSolveValue[{Derivative[1][y1][x] == ((2 - 30 I) + (50 - 3 I) x + 7 x^2/(-I + x) (I + x) (10 + x)) y2[x] + ((3 - 30 I) + (70 - 3 I) x + 10 x^2/(-I + x) (I + x) (10 + x))y3[x], Derivative[1][y2][x] == (2 ((1 + 10 I) + (20 + I) x + 3 x^2)/(-I + x) (I + x) (10 + x)) y3[x], Derivative[1][y3][x] == 0, y1[0] == 1, y2[0] == 2, y3[0] == 3}, {y1[x], y2[x], y3[x]}, x]

A Fuchsian system with two real and two complex poles:

Wolfram Language code:

DSolveValue[{Derivative[1][y1][x] == ((2/-2 + x) + (1/-I + x) + (2/I + x) + (1/2 + x)) y2[x] + ((3/-2 + x) + (3/-I + x) + (4/I + x) + (2/2 + x)) y3[x] + ((4/-2 + x) + (5/-I + x) + (6/I + x) + (3/2 + x)) y4[x], Derivative[1][y2][x] == ((3/-2 + x) + (5/-I + x) + (1/I + x) + (1/2 + x)) y3[x] + ((4/-2 + x) + (6/-I + x) + (2/I + x) + (2/2 + x)) y4[x], Derivative[1][y3][x] == ((2/-2 + x) + (1/-I + x) + (3/I + x) + (1/2 + x)) y4[x], Derivative[1][y4][x] == 0, y1[0] == 1, y2[0] == 1, y3[0] == 1, y4[0] == 1}, {y1[x], y2[x], y3[x], y4[x]}, x]//Short

Rational Perturbative ODE System (2)

Solution of a perturbative Fuchsian ODE system in epsilon form is expressed using GeneralizedPolyLog:

Wolfram Language code:

AsymptoticDSolveValue[{Derivative[1][y1][x] == ϵ ((3 y1[x]/-6 + x) + ((1/-8 + x) + (2/-6 + x)) y2[x] + ((2/-8 + x) + (3/-6 + x)) y3[x]), Derivative[1][y2][x] == ϵ (-(4 y1[x]/-8 + x) + ((3/-8 + x) + (2/-6 + x)) y3[x]), Derivative[1][y3][x] == 0, y1[0] == 1, y2[0] == 2, y3[0] == 3}, {y1[x], y2[x], y3[x]}, x, {ϵ, 0, 3}]

A rational perturbative ODE system:

Wolfram Language code:

AsymptoticDSolveValue[{Derivative[1][y1][x] == (ϵ y1[x]/(-2 + x) ^ 2) - (2 ϵ y2[x]/1 + x), Derivative[1][y2][x] == (ϵ y1[x]/2 + x) + (3 ϵ y2[x]/(I + x) ^ 3), y1[0] == 1, y2[0] == 1}, {y1[x], y2[x]}, x, {ϵ, 0, 3}]//Short[#, 8]&

Rational Perturbative PDE System (2)

Solve a rational perturbative PDE system in -form in terms of GeneralizedPolyLog:

Wolfram Language code:

{aXeps, aYeps} = {{{(ϵ/1 - x), (ϵ/x), 0}, {0, (ϵ/-1 + x), 0}, {0, 0, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, -(2 ϵ/-1 + y)}}};
eqns = Join[Thread[D[{f1[x, y], f2[x, y], f3[x, y]}, x] == aXeps.{f1[x, y], f2[x, y], f3[x, y]}], Thread[D[{f1[x, y], f2[x, y], f3[x, y]}, y] == aYeps.{f1[x, y], f2[x, y], f3[x, y]}]];
AsymptoticDSolveValue[eqns, {f1[x, y], f2[x, y], f3[x, y]}, {x, y}, {ϵ, 0, 2}]

Solve a rational perturbative PDE system that is not in -form in terms of GeneralizedPolyLog:

Wolfram Language code:

{aXeps, aYeps} = {{{1 / x + ϵ / (1 - x), ϵ / x, 0}, {0, 1 / x - ϵ / (1 - x), 0}, {0, 0, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 1 / y + 2 ϵ / (1 - y)}}};
eqns = Join[Thread[D[{f1[x, y], f2[x, y], f3[x, y]}, x] == aXeps.{f1[x, y], f2[x, y], f3[x, y]}], Thread[D[{f1[x, y], f2[x, y], f3[x, y]}, y] == aYeps.{f1[x, y], f2[x, y], f3[x, y]}]];
AsymptoticDSolveValue[eqns, {f1[x, y], f2[x, y], f3[x, y]}, {x, y}, {ϵ, 0, 2}]

Properties & Relations (17)

An empty word produces unity:

Wolfram Language code: GeneralizedPolyLog[{}, x]

Depth-1 GeneralizedPolyLog with letter reproduces the natural logarithm:

Wolfram Language code: GeneralizedPolyLog[{0}, x]

Words composed of repeated zeros give rise to powers of Log:

Wolfram Language code: GeneralizedPolyLog[{0, 0, 0}, x]

With a nonzero letter, it reproduces a logarithm of an affine factor:

Wolfram Language code: GeneralizedPolyLog[{10}, x]

Words composed of repeated nonzero letters give rise to powers of Log with an affine factor:

Wolfram Language code: GeneralizedPolyLog[{10, 10, 10, 10}, x]

A block of zeros followed by a nonzero letter collapses to a classical polylogarithm:

Wolfram Language code: GeneralizedPolyLog[{0, 0, 0, 2I}, x]

A block of zeros followed by a block of identical nonzero letters collapses to a Nielsen polylogarithm:

Wolfram Language code: GeneralizedPolyLog[{0, 0, 0, 0, 1 + I, 1 + I, 1 + I}, x]

Words over evaluated at give MultipleZeta (each run of zeros before a contributes the index ):

Wolfram Language code: GeneralizedPolyLog[{0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1}, 1]

Words over give HarmonicPolyLog:

Wolfram Language code: GeneralizedPolyLog[{-1, 0, -1, -1, 0, 0, 1, 1, 0, 1, 1}, 1 / 2]

Zero blocks separating nonzero letters convert a GeneralizedPolyLog to a MultiplePolyLog:

Wolfram Language code: GeneralizedPolyLog[{0, I, 0, 0, 2I}, 1 / 2]

The antisymmetric combination at letters collapses to ArcTan[x]:

Wolfram Language code: ArcTan[x] == (I / 2) * (GeneralizedPolyLog[{1 / (x I)}, 1] - GeneralizedPolyLog[{-1 / (x I)}, 1])//FullSimplify

The antisymmetric combination at letters collapses to ArcTanh:

Wolfram Language code: ArcTanh[x] == (1 / 2) * (GeneralizedPolyLog[{-1 / x}, 1] - GeneralizedPolyLog[{1 / x}, 1])//FullSimplify

Similarly for ArcCot and ArcCoth:

Wolfram Language code: ArcCot[x] == (I / 2)(GeneralizedPolyLog[{x / I}, 1] - GeneralizedPolyLog[{-x / I}, 1])//FullSimplify

Wolfram Language code: ArcCoth[x] == (1 / 2)(GeneralizedPolyLog[{-x}, 1] - GeneralizedPolyLog[{x}, 1])//FullSimplify

Express Log of polynomial as a rational linear combination of a few GeneralizedPolyLog instances (plus a piecewise constant):

Wolfram Language code: logPolynomial = Log[x ^ 3 - 2x ^ 2 - x + 1];

Wolfram Language code:

logPolyAsGPL = ResourceFunction["LogAffineExpand"][logPolynomial, x] /. Log[1 + k_. * x] :> Inactive[GeneralizedPolyLog][{-1 / k}, x]

Wolfram Language code: PossibleZeroQ[Chop[N@Activate[(logPolynomial - logPolyAsGPL) /. x -> 10]]]

Similarly for Log of a rational function:

Wolfram Language code: logRational = Log[(2 - x) / (x ^ 3 - 2x ^ 2 - x + 1)];

Wolfram Language code:

logRatAsGPL = ResourceFunction["LogAffineExpand"][logRational, x] /. Log[1 + k_. * x] :> Inactive[GeneralizedPolyLog][{-1 / k}, x]

Wolfram Language code: PossibleZeroQ[Chop[N@Activate[(logRational - logRatAsGPL) /. x -> 10]]]

Express PolyLog[s,xⁿ] as a linear combination of GeneralizedPolyLog:

Wolfram Language code: polylog = PolyLog[2, x ^ 3];

Wolfram Language code:

asGPL = polylog /. PolyLog[s_, x ^ n_] :> (n^s - 1Sum[PolyLog[s, Exp[2Pi I k / n]x], {k, 0, n - 1}]) /. PolyLog[p_, k_. * x] :> (-Inactive[GeneralizedPolyLog][Append[ConstantArray[0, p - 1], 1 / k], x])

Wolfram Language code: PossibleZeroQ[Chop[N@Activate[(polylog - asGPL) /. x -> 10]]]

GeneralizedPolyLog appears as the limit of MultipleHarmonicNumber as the index goes to :

Wolfram Language code: MultipleHarmonicNumber[∞, {1, 1, 1, 1}, {1 / 2, 1 / 3, 1 / 4, 1 / 5}]

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

GeneralizedPolyLog

Details

Examples

Basic Examples (6)

Scope (31)

Numerical Evaluation (2)

Specific Values (8)

Visualization (7)

Differentiation (6)

Integration (1)

Algebraic Relations (7)

Generalizations & Extensions (7)

Regularization (3)

Analytic Continuation (2)

Nonzero Base Point (2)

Applications (12)

Euler Sum (2)

Iterated Integrals (4)

Rational ODE System (2)

Rational Perturbative ODE System (2)

Rational Perturbative PDE System (2)

Properties & Relations (17)

Text

CMS

APA

BibTeX

BibLaTeX

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

GeneralizedPolyLog

Details

Examples

Basic Examples (6)

Scope (31)

Numerical Evaluation (2)

Specific Values (8)

Visualization (7)

Differentiation (6)

Integration (1)

Algebraic Relations (7)

Generalizations & Extensions (7)

Regularization (3)

Analytic Continuation (2)

Nonzero Base Point (2)

Applications (12)

Euler Sum (2)

Iterated Integrals (4)

Rational ODE System (2)

Rational Perturbative ODE System (2)

Rational Perturbative PDE System (2)

Properties & Relations (17)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX