Algebra of motivic multiple zeta values¶

This file contains an implementation of the algebra of motivic multiple zeta values.

The elements of this algebra are not the usual multiple zeta values as real numbers defined by concrete iterated integrals, but abstract symbols that satisfy all the linear relations between formal iterated integrals that come from algebraic geometry (motivic relations). Although this set of relations is not explicit, one can test the equality as explained in the article [Brown2012]. One can map these motivic multiple zeta values to the associated real numbers. Conjecturally, this period map should be injective.

The implementation follows closely all the conventions from [Brown2012].

As a convenient abbreviation, the elements will be called multizetas.

EXAMPLES:

One can input multizetas using compositions as arguments:

Sage

sage: Multizeta(3)
ζ(3)
sage: Multizeta(2,3,2)
ζ(2,3,2)

Python

>>> from sage.all import *
>>> Multizeta(Integer(3))
ζ(3)
>>> Multizeta(Integer(2),Integer(3),Integer(2))
ζ(2,3,2)

Sage Live

Multizeta(3)
Multizeta(2,3,2)

as well as linear combinations of them:

Sage

sage: Multizeta(5)+6*Multizeta(2,3)
6*ζ(2,3) + ζ(5)

Python

>>> from sage.all import *
>>> Multizeta(Integer(5))+Integer(6)*Multizeta(Integer(2),Integer(3))
6*ζ(2,3) + ζ(5)

Sage Live

Multizeta(5)+6*Multizeta(2,3)

This creates elements of the class Multizetas.

One can multiply such elements:

Sage

sage: Multizeta(2)*Multizeta(3)
6*ζ(1,4) + 3*ζ(2,3) + ζ(3,2)

Python

>>> from sage.all import *
>>> Multizeta(Integer(2))*Multizeta(Integer(3))
6*ζ(1,4) + 3*ζ(2,3) + ζ(3,2)

Sage Live

Multizeta(2)*Multizeta(3)

and their linear combinations:

Sage

sage: (Multizeta(2)+Multizeta(1,2))*Multizeta(3)
9*ζ(1,1,4) + 5*ζ(1,2,3) + 2*ζ(1,3,2) + 6*ζ(1,4) + 2*ζ(2,1,3) + ζ(2,2,2)
+ 3*ζ(2,3) + ζ(3,1,2) + ζ(3,2)

Python

>>> from sage.all import *
>>> (Multizeta(Integer(2))+Multizeta(Integer(1),Integer(2)))*Multizeta(Integer(3))
9*ζ(1,1,4) + 5*ζ(1,2,3) + 2*ζ(1,3,2) + 6*ζ(1,4) + 2*ζ(2,1,3) + ζ(2,2,2)
+ 3*ζ(2,3) + ζ(3,1,2) + ζ(3,2)

Sage Live

(Multizeta(2)+Multizeta(1,2))*Multizeta(3)

The algebra is graded by the weight, which is the sum of the arguments. One can extract homogeneous components:

Sage

sage: z = Multizeta(6)+6*Multizeta(2,3)
sage: z.homogeneous_component(5)
6*ζ(2,3)

Python

>>> from sage.all import *
>>> z = Multizeta(Integer(6))+Integer(6)*Multizeta(Integer(2),Integer(3))
>>> z.homogeneous_component(Integer(5))
6*ζ(2,3)

Sage Live

z = Multizeta(6)+6*Multizeta(2,3)
z.homogeneous_component(5)

One can also use the ring of multiple zeta values as a base ring for other constructions:

Sage

sage: Z = Multizeta
sage: M = matrix(2,2,[Z(2),Z(3),Z(4),Z(5)])
sage: M.det()
-10*ζ(1,6) - 5*ζ(2,5) - ζ(3,4) + ζ(4,3) + ζ(5,2)

Python

>>> from sage.all import *
>>> Z = Multizeta
>>> M = matrix(Integer(2),Integer(2),[Z(Integer(2)),Z(Integer(3)),Z(Integer(4)),Z(Integer(5))])
>>> M.det()
-10*ζ(1,6) - 5*ζ(2,5) - ζ(3,4) + ζ(4,3) + ζ(5,2)

Sage Live

Z = Multizeta
M = matrix(2,2,[Z(2),Z(3),Z(4),Z(5)])
M.det()

Auxiliary class for alternative notation

One can also use sequences of 0 and 1 as arguments:

Sage

sage: Multizeta(1,1,0)+3*Multizeta(1,0,0)
I(110) + 3*I(100)

Python

>>> from sage.all import *
>>> Multizeta(Integer(1),Integer(1),Integer(0))+Integer(3)*Multizeta(Integer(1),Integer(0),Integer(0))
I(110) + 3*I(100)

Sage Live

Multizeta(1,1,0)+3*Multizeta(1,0,0)

This creates an element of the auxiliary class Multizetas_iterated. This class is used to represent multiple zeta values as iterated integrals.

One can also multiply such elements:

Sage

sage: Multizeta(1,0)*Multizeta(1,0)
4*I(1100) + 2*I(1010)

Python

>>> from sage.all import *
>>> Multizeta(Integer(1),Integer(0))*Multizeta(Integer(1),Integer(0))
4*I(1100) + 2*I(1010)

Sage Live

Multizeta(1,0)*Multizeta(1,0)

Back-and-forth conversion between the two classes can be done using the methods “composition” and “iterated”:

Sage

sage: (Multizeta(2)*Multizeta(3)).iterated()
6*I(11000) + 3*I(10100) + I(10010)

sage: (Multizeta(1,0)*Multizeta(1,0)).composition()
4*ζ(1,3) + 2*ζ(2,2)

Python

>>> from sage.all import *
>>> (Multizeta(Integer(2))*Multizeta(Integer(3))).iterated()
6*I(11000) + 3*I(10100) + I(10010)

>>> (Multizeta(Integer(1),Integer(0))*Multizeta(Integer(1),Integer(0))).composition()
4*ζ(1,3) + 2*ζ(2,2)

Sage Live

(Multizeta(2)*Multizeta(3)).iterated()
(Multizeta(1,0)*Multizeta(1,0)).composition()

Beware that the conversion between these two classes, besides exchanging the indexing by words in 0 and 1 and the indexing by compositions, also involves the sign \((-1)^w\) where \(w\) is the length of the composition and the number of \(1\) in the associated word in 0 and 1. For example, one has the equality

\[\zeta(2,3,4) = (-1)^3 I(1,0,1,0,0,1,0,0,0).\]

Approximate period map

The period map, or rather an approximation, is also available under the generic numerical approximation method:

Sage

sage: z = Multizeta(5)+6*Multizeta(2,3)
sage: z.n()
2.40979014076349
sage: z.n(prec=100)
2.4097901407634924849438423801

Python

>>> from sage.all import *
>>> z = Multizeta(Integer(5))+Integer(6)*Multizeta(Integer(2),Integer(3))
>>> z.n()
2.40979014076349
>>> z.n(prec=Integer(100))
2.4097901407634924849438423801

Sage Live

z = Multizeta(5)+6*Multizeta(2,3)
z.n()
z.n(prec=100)

Behind the scene, all the numerical work is done by the PARI implementation of numerical multiple zeta values.

Searching for linear relations

All this can be used to find linear dependencies between any set of multiple zeta values. Let us illustrate this by an example.

Let us first build our sample set:

Sage

sage: Z = Multizeta
sage: L = [Z(*c) for c in [(1, 1, 4), (1, 2, 3), (1, 5), (6,)]]

Python

>>> from sage.all import *
>>> Z = Multizeta
>>> L = [Z(*c) for c in [(Integer(1), Integer(1), Integer(4)), (Integer(1), Integer(2), Integer(3)), (Integer(1), Integer(5)), (Integer(6),)]]

Sage Live

Z = Multizeta
L = [Z(*c) for c in [(1, 1, 4), (1, 2, 3), (1, 5), (6,)]]

Then one can compute the space of relations:

Sage

sage: M = matrix([Zc.phi_as_vector() for Zc in L])
sage: K = M.kernel(); K
Vector space of degree 4 and dimension 2 over Rational Field
Basis matrix:
[     1      0     -2   1/16]
[     0      1      6 -13/48]

Python

>>> from sage.all import *
>>> M = matrix([Zc.phi_as_vector() for Zc in L])
>>> K = M.kernel(); K
Vector space of degree 4 and dimension 2 over Rational Field
Basis matrix:
[     1      0     -2   1/16]
[     0      1      6 -13/48]

Sage Live

M = matrix([Zc.phi_as_vector() for Zc in L])
K = M.kernel(); K

and check that the first relation holds:

Sage

sage: relation = L[0]-2*L[2]+1/16*L[3]; relation
ζ(1,1,4) - 2*ζ(1,5) + 1/16*ζ(6)
sage: relation.phi()
0
sage: relation.is_zero()
True

Python

>>> from sage.all import *
>>> relation = L[Integer(0)]-Integer(2)*L[Integer(2)]+Integer(1)/Integer(16)*L[Integer(3)]; relation
ζ(1,1,4) - 2*ζ(1,5) + 1/16*ζ(6)
>>> relation.phi()
0
>>> relation.is_zero()
True

Sage Live

relation = L[0]-2*L[2]+1/16*L[3]; relation
relation.phi()
relation.is_zero()

Warning

Because this code uses an hardcoded multiplicative basis that is available up to weight 17 included, some parts will not work in larger weights, in particular the test of equality.

REFERENCES:

[Brown2012] (1,2,3,4,5,6,7,8,9)

Francis C. S. Brown, On the decomposition of motivic multiple zeta values, Advanced Studies in Pure Mathematics 63, 2012. Galois-Teichmuller Theory and Arithmetic Geometry.

[Brown2019]

Francis C. S. Brown, From the Deligne-Ihara conjecture to multiple modular values, arXiv 1904.00179

[Deli2012]

Pierre Deligne, Multizêtas, d’après Francis Brown, Séminaire Bourbaki, janvier 2012. http://www.bourbaki.ens.fr/TEXTES/1048.pdf

[Stie2020]

S. Stieberger, Periods and Superstring Amplitudes, Periods in Quantum Field Theory and Arithmetic, Springer Proceedings in Mathematics and Statistics 314, 2020

class sage.modular.multiple_zeta.All_iterated(R)[source]¶

Bases: CombinatorialFreeModule

Auxiliary class for multiple zeta value as generalized iterated integrals.

This is used to represent multiple zeta values as possibly divergent iterated integrals of the differential forms \(\omega_0 = dt/t\) and \(\omega_1 = dt/(t-1)\).

This means that the elements are symbols \(I(a_0 ; a_1,a_2,...a_n ; a_{n+1})\) where all arguments, including the starting and ending points can be 0 or 1.

This comes with a “regularise” method mapping to Multizetas_iterated.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ); M
Space of motivic multiple zeta values as general iterated integrals
over Rational Field
sage: M((0,1,0,1))
I(0;10;1)
sage: x = M((1,1,0,0)); x
I(1;10;0)
sage: x.regularise()
-I(10)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ); M
Space of motivic multiple zeta values as general iterated integrals
over Rational Field
>>> M((Integer(0),Integer(1),Integer(0),Integer(1)))
I(0;10;1)
>>> x = M((Integer(1),Integer(1),Integer(0),Integer(0))); x
I(1;10;0)
>>> x.regularise()
-I(10)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ); M
M((0,1,0,1))
x = M((1,1,0,0)); x
x.regularise()

class Element[source]¶

Bases: IndexedFreeModuleElement

conversion()[source]¶

Conversion to the Multizetas_iterated.

This assumed that the element has been prepared.

Not to be used directly.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,1,0,0,1))
sage: y = M(x).conversion(); y
I(100)
sage: y.parent()
Algebra of motivic multiple zeta values as convergent iterated
integrals over Rational Field

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(1),Integer(0),Integer(0),Integer(1)))
>>> y = M(x).conversion(); y
I(100)
>>> y.parent()
Algebra of motivic multiple zeta values as convergent iterated
integrals over Rational Field

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,1,0,0,1))
y = M(x).conversion(); y
y.parent()

regularise()[source]¶

Conversion to the Multizetas_iterated.

This is the regularisation procedure, done in several steps.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,0,1,0,1))
sage: M(x).regularise()
-2*I(100)
sage: x = Word((0,1,1,0,1))
sage: M(x).regularise()
I(110)

sage: x = Word((1,0,1,0,0))
sage: M(x).regularise()
2*I(100)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(0),Integer(1)))
>>> M(x).regularise()
-2*I(100)
>>> x = Word((Integer(0),Integer(1),Integer(1),Integer(0),Integer(1)))
>>> M(x).regularise()
I(110)

>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M(x).regularise()
2*I(100)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,0,1,0,1))
M(x).regularise()
x = Word((0,1,1,0,1))
M(x).regularise()
x = Word((1,0,1,0,0))
M(x).regularise()

dual()[source]¶

Reverse words and exchange the letters 0 and 1.

This is the operation R4 in [Brown2012].

This should be used only when \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,0,1,1,1))
sage: y = Word((0,0,1,0,1))
sage: M.dual(M(x)+5*M(y))
5*I(0;010;1) - I(0;001;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(1),Integer(1)))
>>> y = Word((Integer(0),Integer(0),Integer(1),Integer(0),Integer(1)))
>>> M.dual(M(x)+Integer(5)*M(y))
5*I(0;010;1) - I(0;001;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,0,1,1,1))
y = Word((0,0,1,0,1))
M.dual(M(x)+5*M(y))

dual_on_basis(w)[source]¶

Reverse the word and exchange the letters 0 and 1.

This is the operation R4 in [Brown2012].

This should be used only when \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,0,1,0,1))
sage: M.dual_on_basis(x)
I(0;010;1)
sage: x = Word((0,1,0,1,1))
sage: M.dual_on_basis(x)
-I(0;010;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(0),Integer(1)))
>>> M.dual_on_basis(x)
I(0;010;1)
>>> x = Word((Integer(0),Integer(1),Integer(0),Integer(1),Integer(1)))
>>> M.dual_on_basis(x)
-I(0;010;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,0,1,0,1))
M.dual_on_basis(x)
x = Word((0,1,0,1,1))
M.dual_on_basis(x)

expand()[source]¶

Perform an expansion as a linear combination.

This is the operation R2 in [Brown2012].

This should be used only when \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,0,1,0,1))
sage: y = Word((0,0,1,1,1))
sage: M.expand(M(x)+2*M(y))
-2*I(0;110;1) - 2*I(0;101;1) - 2*I(0;100;1)
sage: M.expand(M([0,1,1,0,1]))
I(0;110;1)
sage: M.expand(M([0,1,0,0,1]))
I(0;100;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(0),Integer(1)))
>>> y = Word((Integer(0),Integer(0),Integer(1),Integer(1),Integer(1)))
>>> M.expand(M(x)+Integer(2)*M(y))
-2*I(0;110;1) - 2*I(0;101;1) - 2*I(0;100;1)
>>> M.expand(M([Integer(0),Integer(1),Integer(1),Integer(0),Integer(1)]))
I(0;110;1)
>>> M.expand(M([Integer(0),Integer(1),Integer(0),Integer(0),Integer(1)]))
I(0;100;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,0,1,0,1))
y = Word((0,0,1,1,1))
M.expand(M(x)+2*M(y))
M.expand(M([0,1,1,0,1]))
M.expand(M([0,1,0,0,1]))

expand_on_basis(w)[source]¶

Perform an expansion as a linear combination.

This is the operation R2 in [Brown2012].

This should be used only when \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((0,0,1,0,1))
sage: M.expand_on_basis(x)
-2*I(0;100;1)

sage: x = Word((0,0,0,1,0,1,0,0,1))
sage: M.expand_on_basis(x)
6*I(0;1010000;1) + 6*I(0;1001000;1) + 3*I(0;1000100;1)

sage: x = Word((0,1,1,0,1))
sage: M.expand_on_basis(x)
I(0;110;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(0),Integer(1)))
>>> M.expand_on_basis(x)
-2*I(0;100;1)

>>> x = Word((Integer(0),Integer(0),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1)))
>>> M.expand_on_basis(x)
6*I(0;1010000;1) + 6*I(0;1001000;1) + 3*I(0;1000100;1)

>>> x = Word((Integer(0),Integer(1),Integer(1),Integer(0),Integer(1)))
>>> M.expand_on_basis(x)
I(0;110;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((0,0,1,0,1))
M.expand_on_basis(x)
x = Word((0,0,0,1,0,1,0,0,1))
M.expand_on_basis(x)
x = Word((0,1,1,0,1))
M.expand_on_basis(x)

reversal()[source]¶

Reverse words if necessary.

This is the operation R3 in [Brown2012].

This reverses the word only if \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((1,0,1,0,0))
sage: y = Word((0,0,1,1,1))
sage: M.reversal(M(x)+2*M(y))
2*I(0;011;1) - I(0;010;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> y = Word((Integer(0),Integer(0),Integer(1),Integer(1),Integer(1)))
>>> M.reversal(M(x)+Integer(2)*M(y))
2*I(0;011;1) - I(0;010;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((1,0,1,0,0))
y = Word((0,0,1,1,1))
M.reversal(M(x)+2*M(y))

reversal_on_basis(w)[source]¶

Reverse the word if necessary.

This is the operation R3 in [Brown2012].

This reverses the word only if \(a_0 = 0\) and \(a_{n+1} = 1\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import All_iterated
sage: M = All_iterated(QQ)
sage: x = Word((1,0,1,0,0))
sage: M.reversal_on_basis(x)
-I(0;010;1)
sage: x = Word((0,0,1,1,1))
sage: M.reversal_on_basis(x)
I(0;011;1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import All_iterated
>>> M = All_iterated(QQ)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M.reversal_on_basis(x)
-I(0;010;1)
>>> x = Word((Integer(0),Integer(0),Integer(1),Integer(1),Integer(1)))
>>> M.reversal_on_basis(x)
I(0;011;1)

Sage Live

from sage.modular.multiple_zeta import All_iterated
M = All_iterated(QQ)
x = Word((1,0,1,0,0))
M.reversal_on_basis(x)
x = Word((0,0,1,1,1))
M.reversal_on_basis(x)

sage.modular.multiple_zeta.D_on_compo(k, compo)[source]¶

Return the value of the operator \(D_k\) on a multiple zeta value.

This is now only used as a place to keep many doctests.

INPUT:

k – an odd integer
compo – a composition

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import D_on_compo
sage: D_on_compo(3,(2,3))
3*I(100) # I(10)

sage: D_on_compo(3,(4,3))
I(100) # I(1000)
sage: D_on_compo(5,(4,3))
10*I(10000) # I(10)

sage: [D_on_compo(k, [3,5]) for k in (3,5,7)]
[0, -5*I(10000) # I(100), 0]

sage: [D_on_compo(k, [3,7]) for k in (3,5,7,9)]
[0, -6*I(10000) # I(10000), -14*I(1000000) # I(100), 0]

sage: D_on_compo(3,(4,3,3))
-I(100) # I(1000100)
sage: D_on_compo(5,(4,3,3))
-10*I(10000) # I(10100)
sage: D_on_compo(7,(4,3,3))
4*I(1001000) # I(100) + 2*I(1000100) # I(100)

sage: [D_on_compo(k,(1,3,1,3,1,3)) for k in range(3,10,2)]
[0, 0, 0, 0]

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import D_on_compo
>>> D_on_compo(Integer(3),(Integer(2),Integer(3)))
3*I(100) # I(10)

>>> D_on_compo(Integer(3),(Integer(4),Integer(3)))
I(100) # I(1000)
>>> D_on_compo(Integer(5),(Integer(4),Integer(3)))
10*I(10000) # I(10)

>>> [D_on_compo(k, [Integer(3),Integer(5)]) for k in (Integer(3),Integer(5),Integer(7))]
[0, -5*I(10000) # I(100), 0]

>>> [D_on_compo(k, [Integer(3),Integer(7)]) for k in (Integer(3),Integer(5),Integer(7),Integer(9))]
[0, -6*I(10000) # I(10000), -14*I(1000000) # I(100), 0]

>>> D_on_compo(Integer(3),(Integer(4),Integer(3),Integer(3)))
-I(100) # I(1000100)
>>> D_on_compo(Integer(5),(Integer(4),Integer(3),Integer(3)))
-10*I(10000) # I(10100)
>>> D_on_compo(Integer(7),(Integer(4),Integer(3),Integer(3)))
4*I(1001000) # I(100) + 2*I(1000100) # I(100)

>>> [D_on_compo(k,(Integer(1),Integer(3),Integer(1),Integer(3),Integer(1),Integer(3))) for k in range(Integer(3),Integer(10),Integer(2))]
[0, 0, 0, 0]

Sage Live

from sage.modular.multiple_zeta import D_on_compo
D_on_compo(3,(2,3))
D_on_compo(3,(4,3))
D_on_compo(5,(4,3))
[D_on_compo(k, [3,5]) for k in (3,5,7)]
[D_on_compo(k, [3,7]) for k in (3,5,7,9)]
D_on_compo(3,(4,3,3))
D_on_compo(5,(4,3,3))
D_on_compo(7,(4,3,3))
[D_on_compo(k,(1,3,1,3,1,3)) for k in range(3,10,2)]

sage.modular.multiple_zeta.Multizeta(*args)[source]¶

Common entry point for multiple zeta values.

If the argument is a sequence of 0 and 1, an element of Multizetas_iterated will be returned.

Otherwise, an element of Multizetas will be returned.

The base ring is \(\QQ\).

EXAMPLES:

Sage

sage: Z = Multizeta
sage: Z(1,0,1,0)
I(1010)
sage: Z(3,2,2)
ζ(3,2,2)

Python

>>> from sage.all import *
>>> Z = Multizeta
>>> Z(Integer(1),Integer(0),Integer(1),Integer(0))
I(1010)
>>> Z(Integer(3),Integer(2),Integer(2))
ζ(3,2,2)

Sage Live

Z = Multizeta
Z(1,0,1,0)
Z(3,2,2)

class sage.modular.multiple_zeta.MultizetaValues[source]¶

Bases: Singleton

Custom cache for numerical values of multiple zetas.

Computations are performed using the PARI/GP pari:zetamultall (for the cache) and pari:zetamult (for indices/precision outside of the cache).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import MultizetaValues
sage: M = MultizetaValues()

sage: M((1,2))
1.202056903159594285399738161511449990764986292340...
sage: parent(M((2,3)))
Real Field with 1024 bits of precision

sage: M((2,3), prec=53)
0.228810397603354
sage: parent(M((2,3), prec=53))
Real Field with 53 bits of precision

sage: M((2,3), reverse=False) == M((3,2))
True

sage: M((2,3,4,5))
2.9182061974731261426525583710934944310404272413...e-6
sage: M((2,3,4,5), reverse=False)
0.0011829360522243605614404196778185433287651...

sage: parent(M((2,3,4,5)))
Real Field with 1024 bits of precision
sage: parent(M((2,3,4,5), prec=128))
Real Field with 128 bits of precision

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import MultizetaValues
>>> M = MultizetaValues()

>>> M((Integer(1),Integer(2)))
1.202056903159594285399738161511449990764986292340...
>>> parent(M((Integer(2),Integer(3))))
Real Field with 1024 bits of precision

>>> M((Integer(2),Integer(3)), prec=Integer(53))
0.228810397603354
>>> parent(M((Integer(2),Integer(3)), prec=Integer(53)))
Real Field with 53 bits of precision

>>> M((Integer(2),Integer(3)), reverse=False) == M((Integer(3),Integer(2)))
True

>>> M((Integer(2),Integer(3),Integer(4),Integer(5)))
2.9182061974731261426525583710934944310404272413...e-6
>>> M((Integer(2),Integer(3),Integer(4),Integer(5)), reverse=False)
0.0011829360522243605614404196778185433287651...

>>> parent(M((Integer(2),Integer(3),Integer(4),Integer(5))))
Real Field with 1024 bits of precision
>>> parent(M((Integer(2),Integer(3),Integer(4),Integer(5)), prec=Integer(128)))
Real Field with 128 bits of precision

Sage Live

from sage.modular.multiple_zeta import MultizetaValues
M = MultizetaValues()
M((1,2))
parent(M((2,3)))
M((2,3), prec=53)
parent(M((2,3), prec=53))
M((2,3), reverse=False) == M((3,2))
M((2,3,4,5))
M((2,3,4,5), reverse=False)
parent(M((2,3,4,5)))
parent(M((2,3,4,5), prec=128))

pari_eval(index)[source]¶

reset(max_weight=8, prec=1024)[source]¶: Reset the cache to its default values or to given arguments.

update(max_weight, prec)[source]¶: Compute and store more values if needed.

class sage.modular.multiple_zeta.Multizetas(R)[source]¶

Bases: CombinatorialFreeModule

Main class for the algebra of multiple zeta values.

The convention is chosen so that \(\zeta(1,2)\) is convergent.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = M((2,))
sage: y = M((4,3))
sage: x+5*y
ζ(2) + 5*ζ(4,3)
sage: x*y
6*ζ(1,4,4) + 8*ζ(1,5,3) + 3*ζ(2,3,4) + 4*ζ(2,4,3) + 3*ζ(3,2,4)
+ 2*ζ(3,3,3) + 6*ζ(4,1,4) + 3*ζ(4,2,3) + ζ(4,3,2)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = M((Integer(2),))
>>> y = M((Integer(4),Integer(3)))
>>> x+Integer(5)*y
ζ(2) + 5*ζ(4,3)
>>> x*y
6*ζ(1,4,4) + 8*ζ(1,5,3) + 3*ζ(2,3,4) + 4*ζ(2,4,3) + 3*ζ(3,2,4)
+ 2*ζ(3,3,3) + 6*ζ(4,1,4) + 3*ζ(4,2,3) + ζ(4,3,2)

Sage Live

M = Multizetas(QQ)
x = M((2,))
y = M((4,3))
x+5*y
x*y

class Element[source]¶

Bases: IndexedFreeModuleElement

is_zero()[source]¶

Return whether this element is zero.

EXAMPLES:

Sage

sage: M = Multizeta

sage: (4*M(2,3) + 6*M(3,2) - 5*M(5)).is_zero()
True
sage: (3*M(4) - 4*M(2,2)).is_zero()
True
sage: (4*M(2,3) + 6*M(3,2) + 3*M(4) - 5*M(5) - 4*M(2,2)).is_zero()
True

sage: (4*M(2,3) + 6*M(3,2) - 4*M(5)).is_zero()
False
sage: (M(4) - M(2,2)).is_zero()
False
sage: (4*M(2,3) + 6*M(3,2) + 3*M(4) - 4*M(5) - 4*M(2,2)).is_zero()
False

Python

>>> from sage.all import *
>>> M = Multizeta

>>> (Integer(4)*M(Integer(2),Integer(3)) + Integer(6)*M(Integer(3),Integer(2)) - Integer(5)*M(Integer(5))).is_zero()
True
>>> (Integer(3)*M(Integer(4)) - Integer(4)*M(Integer(2),Integer(2))).is_zero()
True
>>> (Integer(4)*M(Integer(2),Integer(3)) + Integer(6)*M(Integer(3),Integer(2)) + Integer(3)*M(Integer(4)) - Integer(5)*M(Integer(5)) - Integer(4)*M(Integer(2),Integer(2))).is_zero()
True

>>> (Integer(4)*M(Integer(2),Integer(3)) + Integer(6)*M(Integer(3),Integer(2)) - Integer(4)*M(Integer(5))).is_zero()
False
>>> (M(Integer(4)) - M(Integer(2),Integer(2))).is_zero()
False
>>> (Integer(4)*M(Integer(2),Integer(3)) + Integer(6)*M(Integer(3),Integer(2)) + Integer(3)*M(Integer(4)) - Integer(4)*M(Integer(5)) - Integer(4)*M(Integer(2),Integer(2))).is_zero()
False

Sage Live

M = Multizeta
(4*M(2,3) + 6*M(3,2) - 5*M(5)).is_zero()
(3*M(4) - 4*M(2,2)).is_zero()
(4*M(2,3) + 6*M(3,2) + 3*M(4) - 5*M(5) - 4*M(2,2)).is_zero()
(4*M(2,3) + 6*M(3,2) - 4*M(5)).is_zero()
(M(4) - M(2,2)).is_zero()
(4*M(2,3) + 6*M(3,2) + 3*M(4) - 4*M(5) - 4*M(2,2)).is_zero()

iterated()[source]¶

Convert to the algebra of iterated integrals.

Beware that this conversion involves signs.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = M((2,3,4))
sage: x.iterated()
-I(101001000)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = M((Integer(2),Integer(3),Integer(4)))
>>> x.iterated()
-I(101001000)

Sage Live

M = Multizetas(QQ)
x = M((2,3,4))
x.iterated()

numerical_approx(prec=None, digits=None, algorithm=None)[source]¶

Return a numerical value for this element.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M(Word((3,2))).n()  # indirect doctest
0.711566197550572
sage: parent(M(Word((3,2))).n())
Real Field with 53 bits of precision

sage: (M((3,)) * M((2,))).n(prec=80)
1.9773043502972961181971
sage: M((1,2)).n(70)
1.2020569031595942854

sage: M((3,)).n(digits=10)
1.202056903

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M(Word((Integer(3),Integer(2)))).n()  # indirect doctest
0.711566197550572
>>> parent(M(Word((Integer(3),Integer(2)))).n())
Real Field with 53 bits of precision

>>> (M((Integer(3),)) * M((Integer(2),))).n(prec=Integer(80))
1.9773043502972961181971
>>> M((Integer(1),Integer(2))).n(Integer(70))
1.2020569031595942854

>>> M((Integer(3),)).n(digits=Integer(10))
1.202056903

Sage Live

M = Multizetas(QQ)
M(Word((3,2))).n()  # indirect doctest
parent(M(Word((3,2))).n())
(M((3,)) * M((2,))).n(prec=80)
M((1,2)).n(70)
M((3,)).n(digits=10)

If you plan to use intensively numerical approximation at high precision, you might want to add more values and/or accuracy to the cache:

Sage

sage: from sage.modular.multiple_zeta import MultizetaValues
sage: M = MultizetaValues()
sage: M.update(max_weight=9, prec=2048)
sage: M
Cached multiple zeta values at precision 2048 up to weight 9
sage: M.reset()  # restore precision for the other doctests

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import MultizetaValues
>>> M = MultizetaValues()
>>> M.update(max_weight=Integer(9), prec=Integer(2048))
>>> M
Cached multiple zeta values at precision 2048 up to weight 9
>>> M.reset()  # restore precision for the other doctests

Sage Live

from sage.modular.multiple_zeta import MultizetaValues
M = MultizetaValues()
M.update(max_weight=9, prec=2048)
M
M.reset()  # restore precision for the other doctests

phi()[source]¶

Return the image of self by the morphism phi.

This sends multiple zeta values to the auxiliary F-algebra.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M((1,2)).phi()
f3

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M((Integer(1),Integer(2))).phi()
f3

Sage Live

M = Multizetas(QQ)
M((1,2)).phi()

phi_as_vector()[source]¶

Return the image of self by the morphism phi as a vector.

The morphism phi sends multiple zeta values to the algebra F_ring(). Then the image is expressed as a vector in a fixed basis of one graded component of this algebra.

This is only defined for homogeneous elements.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M((3,2)).phi_as_vector()
(9/2, -2)
sage: M(0).phi_as_vector()
()

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M((Integer(3),Integer(2))).phi_as_vector()
(9/2, -2)
>>> M(Integer(0)).phi_as_vector()
()

Sage Live

M = Multizetas(QQ)
M((3,2)).phi_as_vector()
M(0).phi_as_vector()

simplify()[source]¶

Gather terms using the duality relations.

This can help to lower the number of monomials.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: z = 3*M((3,)) + 5*M((1,2))
sage: z.simplify()
8*ζ(3)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> z = Integer(3)*M((Integer(3),)) + Integer(5)*M((Integer(1),Integer(2)))
>>> z.simplify()
8*ζ(3)

Sage Live

M = Multizetas(QQ)
z = 3*M((3,)) + 5*M((1,2))
z.simplify()

simplify_full(basis=None)[source]¶

Rewrite the term in a given basis.

INPUT:

basis – either None (default) or a function such that basis(d) is a basis of the weight d multiple zeta values. If None, the Hoffman basis is used.

EXAMPLES:

Sage

sage: z = Multizeta(5) + Multizeta(1,4) + Multizeta(3,2) - 5 * Multizeta(2,3)
sage: z.simplify_full()
-22/5*ζ(2,3) + 12/5*ζ(3,2)
sage: z.simplify_full(basis=z.parent().basis_filtration)
18*ζ(1,4) - ζ(5)

sage: z == z.simplify_full() == z.simplify_full(basis=z.parent().basis_filtration)
True

Python

>>> from sage.all import *
>>> z = Multizeta(Integer(5)) + Multizeta(Integer(1),Integer(4)) + Multizeta(Integer(3),Integer(2)) - Integer(5) * Multizeta(Integer(2),Integer(3))
>>> z.simplify_full()
-22/5*ζ(2,3) + 12/5*ζ(3,2)
>>> z.simplify_full(basis=z.parent().basis_filtration)
18*ζ(1,4) - ζ(5)

>>> z == z.simplify_full() == z.simplify_full(basis=z.parent().basis_filtration)
True

Sage Live

z = Multizeta(5) + Multizeta(1,4) + Multizeta(3,2) - 5 * Multizeta(2,3)
z.simplify_full()
z.simplify_full(basis=z.parent().basis_filtration)
z == z.simplify_full() == z.simplify_full(basis=z.parent().basis_filtration)

Be careful, that this does not optimize the number of terms:

Sage

sage: Multizeta(7).simplify_full()
352/151*ζ(2,2,3) + 672/151*ζ(2,3,2) + 528/151*ζ(3,2,2)

Python

>>> from sage.all import *
>>> Multizeta(Integer(7)).simplify_full()
352/151*ζ(2,2,3) + 672/151*ζ(2,3,2) + 528/151*ζ(3,2,2)

Sage Live

Multizeta(7).simplify_full()

single_valued()[source]¶

Return the single-valued version of self.

This is the projection map onto the sub-algebra of single-valued motivic multiple zeta values, as defined by F. Brown in [Bro2013].

This morphism of algebras sends in particular \(\zeta(2)\) to \(0\).

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = M((2,))
sage: x.single_valued()
0
sage: x = M((3,))
sage: x.single_valued()
2*ζ(3)
sage: x = M((5,))
sage: x.single_valued()
2*ζ(5)
sage: x = M((2,3))
sage: x.single_valued()
-11*ζ(5)

sage: Z = Multizeta
sage: Z(3,5).single_valued() == -10*Z(3)*Z(5)
True
sage: Z(5,3).single_valued() == 14*Z(3)*Z(5)
True

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = M((Integer(2),))
>>> x.single_valued()
0
>>> x = M((Integer(3),))
>>> x.single_valued()
2*ζ(3)
>>> x = M((Integer(5),))
>>> x.single_valued()
2*ζ(5)
>>> x = M((Integer(2),Integer(3)))
>>> x.single_valued()
-11*ζ(5)

>>> Z = Multizeta
>>> Z(Integer(3),Integer(5)).single_valued() == -Integer(10)*Z(Integer(3))*Z(Integer(5))
True
>>> Z(Integer(5),Integer(3)).single_valued() == Integer(14)*Z(Integer(3))*Z(Integer(5))
True

Sage Live

M = Multizetas(QQ)
x = M((2,))
x.single_valued()
x = M((3,))
x.single_valued()
x = M((5,))
x.single_valued()
x = M((2,3))
x.single_valued()
Z = Multizeta
Z(3,5).single_valued() == -10*Z(3)*Z(5)
Z(5,3).single_valued() == 14*Z(3)*Z(5)

algebra_generators(n)[source]¶

Return a set of multiplicative generators in weight n.

This is obtained from hardcoded data, available only up to weight 17.

INPUT:

n – integer

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.algebra_generators(5)
[ζ(5)]
sage: M.algebra_generators(8)
[ζ(3,5)]

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.algebra_generators(Integer(5))
[ζ(5)]
>>> M.algebra_generators(Integer(8))
[ζ(3,5)]

Sage Live

M = Multizetas(QQ)
M.algebra_generators(5)
M.algebra_generators(8)

an_element()[source]¶

Return an element of the algebra.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.an_element()
ζ() + ζ(1,2) + 1/2*ζ(5)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.an_element()
ζ() + ζ(1,2) + 1/2*ζ(5)

Sage Live

M = Multizetas(QQ)
M.an_element()

basis_brown(n)[source]¶

Return a basis of the algebra of multiple zeta values in weight n.

It was proved by Francis Brown that this is a basis of motivic multiple zeta values.

This is made of all \(\zeta(n_1, ..., n_r)\) with parts in {2,3}.

INPUT:

n – integer

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.basis_brown(3)
[ζ(3)]
sage: M.basis_brown(4)
[ζ(2,2)]
sage: M.basis_brown(5)
[ζ(3,2), ζ(2,3)]
sage: M.basis_brown(6)
[ζ(3,3), ζ(2,2,2)]

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.basis_brown(Integer(3))
[ζ(3)]
>>> M.basis_brown(Integer(4))
[ζ(2,2)]
>>> M.basis_brown(Integer(5))
[ζ(3,2), ζ(2,3)]
>>> M.basis_brown(Integer(6))
[ζ(3,3), ζ(2,2,2)]

Sage Live

M = Multizetas(QQ)
M.basis_brown(3)
M.basis_brown(4)
M.basis_brown(5)
M.basis_brown(6)

basis_data(basering, n)[source]¶

Return an iterator for a basis in weight n.

This is obtained from hardcoded data, available only up to weight 17.

INPUT:

n – integer

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: list(M.basis_data(QQ, 4))
[4*ζ(1,3) + 2*ζ(2,2)]

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> list(M.basis_data(QQ, Integer(4)))
[4*ζ(1,3) + 2*ζ(2,2)]

Sage Live

M = Multizetas(QQ)
list(M.basis_data(QQ, 4))

basis_filtration(d, reverse=False)[source]¶

Return a module basis of the homogeneous components of weight d compatible with the length filtration.

INPUT:

d – nonnegative integer; the weight
reverse – boolean (default: False); change the ordering of compositions

EXAMPLES:

Sage

sage: M = Multizetas(QQ)

sage: M.basis_filtration(5)
[ζ(5), ζ(1,4)]
sage: M.basis_filtration(6)
[ζ(6), ζ(1,5)]
sage: M.basis_filtration(8)
[ζ(8), ζ(1,7), ζ(2,6), ζ(1,1,6)]
sage: M.basis_filtration(8, reverse=True)
[ζ(8), ζ(6,2), ζ(5,3), ζ(5,1,2)]

sage: M.basis_filtration(0)
[ζ()]
sage: M.basis_filtration(1)
[]

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)

>>> M.basis_filtration(Integer(5))
[ζ(5), ζ(1,4)]
>>> M.basis_filtration(Integer(6))
[ζ(6), ζ(1,5)]
>>> M.basis_filtration(Integer(8))
[ζ(8), ζ(1,7), ζ(2,6), ζ(1,1,6)]
>>> M.basis_filtration(Integer(8), reverse=True)
[ζ(8), ζ(6,2), ζ(5,3), ζ(5,1,2)]

>>> M.basis_filtration(Integer(0))
[ζ()]
>>> M.basis_filtration(Integer(1))
[]

Sage Live

M = Multizetas(QQ)
M.basis_filtration(5)
M.basis_filtration(6)
M.basis_filtration(8)
M.basis_filtration(8, reverse=True)
M.basis_filtration(0)
M.basis_filtration(1)

degree_on_basis(w)[source]¶

Return the degree of the monomial w.

This is the sum of terms in w.

INPUT:

w – a composition

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = (2,3)
sage: M.degree_on_basis(x)  # indirect doctest
5

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = (Integer(2),Integer(3))
>>> M.degree_on_basis(x)  # indirect doctest
5

Sage Live

M = Multizetas(QQ)
x = (2,3)
M.degree_on_basis(x)  # indirect doctest

half_product(w1, w2)[source]¶

Compute half of the product of two elements.

This comes from half of the shuffle product.

Warning

This is not a motivic operation.

INPUT:

w1, w2 – elements

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.half_product(M([2]),M([2]))
2*ζ(1,3) + ζ(2,2)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.half_product(M([Integer(2)]),M([Integer(2)]))
2*ζ(1,3) + ζ(2,2)

Sage Live

M = Multizetas(QQ)
M.half_product(M([2]),M([2]))

iterated()[source]¶

Convert to the algebra of iterated integrals.

This is also available as a method of elements.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = M((3,2))
sage: M.iterated(3*x)
3*I(10010)
sage: x = M((2,3,2))
sage: M.iterated(4*x)
-4*I(1010010)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = M((Integer(3),Integer(2)))
>>> M.iterated(Integer(3)*x)
3*I(10010)
>>> x = M((Integer(2),Integer(3),Integer(2)))
>>> M.iterated(Integer(4)*x)
-4*I(1010010)

Sage Live

M = Multizetas(QQ)
x = M((3,2))
M.iterated(3*x)
x = M((2,3,2))
M.iterated(4*x)

iterated_on_basis(w)[source]¶

Convert to the algebra of iterated integrals.

Beware that this conversion involves signs in our chosen convention.

INPUT:

w – a word

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: x = M.basis().keys()((3,2))
sage: M.iterated_on_basis(x)
I(10010)
sage: x = M.basis().keys()((2,3,2))
sage: M.iterated_on_basis(x)
-I(1010010)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> x = M.basis().keys()((Integer(3),Integer(2)))
>>> M.iterated_on_basis(x)
I(10010)
>>> x = M.basis().keys()((Integer(2),Integer(3),Integer(2)))
>>> M.iterated_on_basis(x)
-I(1010010)

Sage Live

M = Multizetas(QQ)
x = M.basis().keys()((3,2))
M.iterated_on_basis(x)
x = M.basis().keys()((2,3,2))
M.iterated_on_basis(x)

one_basis()[source]¶

Return the index of the unit for the algebra.

This is the empty word.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.one_basis()
word:

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.one_basis()
word:

Sage Live

M = Multizetas(QQ)
M.one_basis()

phi()[source]¶

Return the morphism phi.

This sends multiple zeta values to the auxiliary F-algebra, which is a shuffle algebra in odd generators \(f_3,f_5,f_7,\dots\) over the polynomial ring in one variable \(f_2\).

This is a ring isomorphism, that depends on the choice of a multiplicative basis for the ring of motivic multiple zeta values. Here we use one specific hardcoded basis.

For the precise definition of phi by induction, see [Brown2012].

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: m = Multizeta(2,2) + 2*Multizeta(1,3); m
2*ζ(1,3) + ζ(2,2)
sage: M.phi(m)
1/2*f2^2

sage: Z = Multizeta
sage: B5 = [3*Z(1,4) + 2*Z(2,3) + Z(3,2), 3*Z(1,4) + Z(2,3)]
sage: [M.phi(b) for b in B5]
[-1/2*f5 + f2*f3, 1/2*f5]

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> m = Multizeta(Integer(2),Integer(2)) + Integer(2)*Multizeta(Integer(1),Integer(3)); m
2*ζ(1,3) + ζ(2,2)
>>> M.phi(m)
1/2*f2^2

>>> Z = Multizeta
>>> B5 = [Integer(3)*Z(Integer(1),Integer(4)) + Integer(2)*Z(Integer(2),Integer(3)) + Z(Integer(3),Integer(2)), Integer(3)*Z(Integer(1),Integer(4)) + Z(Integer(2),Integer(3))]
>>> [M.phi(b) for b in B5]
[-1/2*f5 + f2*f3, 1/2*f5]

Sage Live

M = Multizetas(QQ)
m = Multizeta(2,2) + 2*Multizeta(1,3); m
M.phi(m)
Z = Multizeta
B5 = [3*Z(1,4) + 2*Z(2,3) + Z(3,2), 3*Z(1,4) + Z(2,3)]
[M.phi(b) for b in B5]

product_on_basis(w1, w2)[source]¶

Compute the product of two monomials.

This is done by converting to iterated integrals and using the shuffle product.

INPUT:

w1, w2 – compositions as words

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: W = M.basis().keys()
sage: M.product_on_basis(W([2]),W([2]))
4*ζ(1,3) + 2*ζ(2,2)
sage: x = M((2,))
sage: x*x
4*ζ(1,3) + 2*ζ(2,2)

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> W = M.basis().keys()
>>> M.product_on_basis(W([Integer(2)]),W([Integer(2)]))
4*ζ(1,3) + 2*ζ(2,2)
>>> x = M((Integer(2),))
>>> x*x
4*ζ(1,3) + 2*ζ(2,2)

Sage Live

M = Multizetas(QQ)
W = M.basis().keys()
M.product_on_basis(W([2]),W([2]))
x = M((2,))
x*x

some_elements()[source]¶

Return some elements of the algebra.

EXAMPLES:

Sage

sage: M = Multizetas(QQ)
sage: M.some_elements()
(ζ(), ζ(2), ζ(3), ζ(4), ζ(1,2))

Python

>>> from sage.all import *
>>> M = Multizetas(QQ)
>>> M.some_elements()
(ζ(), ζ(2), ζ(3), ζ(4), ζ(1,2))

Sage Live

M = Multizetas(QQ)
M.some_elements()

class sage.modular.multiple_zeta.Multizetas_iterated(R)[source]¶

Bases: CombinatorialFreeModule

Secondary class for the algebra of multiple zeta values.

This is used to represent multiple zeta values as iterated integrals of the differential forms \(\omega_0 = dt/t\) and \(\omega_1 = dt/(t-1)\).

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ); M
Algebra of motivic multiple zeta values as convergent iterated
integrals over Rational Field
sage: M((1,0))
I(10)
sage: M((1,0))**2
4*I(1100) + 2*I(1010)
sage: M((1,0))*M((1,0,0))
6*I(11000) + 3*I(10100) + I(10010)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ); M
Algebra of motivic multiple zeta values as convergent iterated
integrals over Rational Field
>>> M((Integer(1),Integer(0)))
I(10)
>>> M((Integer(1),Integer(0)))**Integer(2)
4*I(1100) + 2*I(1010)
>>> M((Integer(1),Integer(0)))*M((Integer(1),Integer(0),Integer(0)))
6*I(11000) + 3*I(10100) + I(10010)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ); M
M((1,0))
M((1,0))**2
M((1,0))*M((1,0,0))

D(k)[source]¶

Return the operator \(D_k\).

INPUT:

k – an odd integer, at least 3

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: D3 = M.D(3)
sage: elt = M((1,0,1,0,0)) + 2 * M((1,1,0,0,1,0))
sage: D3(elt)
-6*I(100) # I(110) + 3*I(100) # I(10)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> D3 = M.D(Integer(3))
>>> elt = M((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0))) + Integer(2) * M((Integer(1),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)))
>>> D3(elt)
-6*I(100) # I(110) + 3*I(100) # I(10)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
D3 = M.D(3)
elt = M((1,0,1,0,0)) + 2 * M((1,1,0,0,1,0))
D3(elt)

D_on_basis(k, w)[source]¶

Return the action of the operator \(D_k\) on the monomial w.

This is one main tool in the procedure that allows to map the algebra of multiple zeta values to the F Ring.

INPUT:

k – an odd integer, at least 3
w – a word in 0 and 1

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M.D_on_basis(3,(1,1,1,0,0))
I(110) # I(10) + 2*I(100) # I(10)

sage: M.D_on_basis(3,(1,0,1,0,0))
3*I(100) # I(10)
sage: M.D_on_basis(5,(1,0,0,0,1,0,0,1,0,0))
10*I(10000) # I(10100)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M.D_on_basis(Integer(3),(Integer(1),Integer(1),Integer(1),Integer(0),Integer(0)))
I(110) # I(10) + 2*I(100) # I(10)

>>> M.D_on_basis(Integer(3),(Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
3*I(100) # I(10)
>>> M.D_on_basis(Integer(5),(Integer(1),Integer(0),Integer(0),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0),Integer(0)))
10*I(10000) # I(10100)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M.D_on_basis(3,(1,1,1,0,0))
M.D_on_basis(3,(1,0,1,0,0))
M.D_on_basis(5,(1,0,0,0,1,0,0,1,0,0))

class Element[source]¶

Bases: IndexedFreeModuleElement

composition()[source]¶

Convert to the algebra of multiple zeta values of composition style.

This means the algebra Multizetas.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = M((1,0,1,0))
sage: x.composition()
ζ(2,2)
sage: x = M((1,0,1,0,0))
sage: x.composition()
ζ(2,3)
sage: x = M((1,0,1,0,0,1,0))
sage: x.composition()
-ζ(2,3,2)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = M((Integer(1),Integer(0),Integer(1),Integer(0)))
>>> x.composition()
ζ(2,2)
>>> x = M((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> x.composition()
ζ(2,3)
>>> x = M((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)))
>>> x.composition()
-ζ(2,3,2)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = M((1,0,1,0))
x.composition()
x = M((1,0,1,0,0))
x.composition()
x = M((1,0,1,0,0,1,0))
x.composition()

coproduct()[source]¶

Return the coproduct of self.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: a = 3*Multizeta(1,3) + Multizeta(2,3)
sage: a.iterated().coproduct()
3*I() # I(1100) + I() # I(10100) + I(10100) # I() + 3*I(100) # I(10)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> a = Integer(3)*Multizeta(Integer(1),Integer(3)) + Multizeta(Integer(2),Integer(3))
>>> a.iterated().coproduct()
3*I() # I(1100) + I() # I(10100) + I(10100) # I() + 3*I(100) # I(10)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
a = 3*Multizeta(1,3) + Multizeta(2,3)
a.iterated().coproduct()

is_zero()[source]¶

Return whether this element is zero.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M(0).is_zero()
True
sage: M(1).is_zero()
False
sage: (M((1,1,0)) - -M((1,0,0))).is_zero()
True

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M(Integer(0)).is_zero()
True
>>> M(Integer(1)).is_zero()
False
>>> (M((Integer(1),Integer(1),Integer(0))) - -M((Integer(1),Integer(0),Integer(0)))).is_zero()
True

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M(0).is_zero()
M(1).is_zero()
(M((1,1,0)) - -M((1,0,0))).is_zero()

numerical_approx(prec=None, digits=None, algorithm=None)[source]¶

Return a numerical approximation as a sage real.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = M((1,0,1,0))
sage: y = M((1, 0, 0))
sage: (3*x+y).n()  # indirect doctest
1.23317037269047

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = M((Integer(1),Integer(0),Integer(1),Integer(0)))
>>> y = M((Integer(1), Integer(0), Integer(0)))
>>> (Integer(3)*x+y).n()  # indirect doctest
1.23317037269047

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = M((1,0,1,0))
y = M((1, 0, 0))
(3*x+y).n()  # indirect doctest

phi()[source]¶

Return the image of self by the morphism phi.

This sends multiple zeta values to the auxiliary F-algebra.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M((1,1,0)).phi()
f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M((Integer(1),Integer(1),Integer(0))).phi()
f3

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M((1,1,0)).phi()

simplify()[source]¶

Gather terms using the duality relations.

This can help to lower the number of monomials.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: z = 4*M((1,0,0)) + 3*M((1,1,0))
sage: z.simplify()
I(100)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> z = Integer(4)*M((Integer(1),Integer(0),Integer(0))) + Integer(3)*M((Integer(1),Integer(1),Integer(0)))
>>> z.simplify()
I(100)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
z = 4*M((1,0,0)) + 3*M((1,1,0))
z.simplify()

composition()[source]¶

Convert to the algebra of multiple zeta values of composition style.

This means the algebra Multizetas.

This is also available as a method of elements.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = M((1,0))
sage: M.composition(2*x)
-2*ζ(2)
sage: x = M((1,0,1,0,0))
sage: M.composition(x)
ζ(2,3)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = M((Integer(1),Integer(0)))
>>> M.composition(Integer(2)*x)
-2*ζ(2)
>>> x = M((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M.composition(x)
ζ(2,3)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = M((1,0))
M.composition(2*x)
x = M((1,0,1,0,0))
M.composition(x)

composition_on_basis(w, basering=None)[source]¶

Convert to the algebra of multiple zeta values of composition style.

INPUT:

basering – (optional) choice of the coefficient ring

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = Word((1,0,1,0,0))
sage: M.composition_on_basis(x)
ζ(2,3)
sage: x = Word((1,0,1,0,0,1,0))
sage: M.composition_on_basis(x)
-ζ(2,3,2)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M.composition_on_basis(x)
ζ(2,3)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)))
>>> M.composition_on_basis(x)
-ζ(2,3,2)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = Word((1,0,1,0,0))
M.composition_on_basis(x)
x = Word((1,0,1,0,0,1,0))
M.composition_on_basis(x)

coproduct()[source]¶

Return the motivic coproduct of an element.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: a = 3*Multizeta(1,4) + Multizeta(2,3)
sage: M.coproduct(a.iterated())
3*I() # I(11000) + I() # I(10100) + 3*I(11000) # I()
+ I(10100) # I()

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> a = Integer(3)*Multizeta(Integer(1),Integer(4)) + Multizeta(Integer(2),Integer(3))
>>> M.coproduct(a.iterated())
3*I() # I(11000) + I() # I(10100) + 3*I(11000) # I()
+ I(10100) # I()

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
a = 3*Multizeta(1,4) + Multizeta(2,3)
M.coproduct(a.iterated())

coproduct_on_basis(w)[source]¶

Return the motivic coproduct of a monomial.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M.coproduct_on_basis([1,0])
I() # I(10)

sage: M.coproduct_on_basis((1,0,1,0))
I() # I(1010)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M.coproduct_on_basis([Integer(1),Integer(0)])
I() # I(10)

>>> M.coproduct_on_basis((Integer(1),Integer(0),Integer(1),Integer(0)))
I() # I(1010)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M.coproduct_on_basis([1,0])
M.coproduct_on_basis((1,0,1,0))

degree_on_basis(w)[source]¶

Return the degree of the monomial w.

This is the length of the word.

INPUT:

w – a word in 0 and 1

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = Word((1,0,1,0,0))
sage: M.degree_on_basis(x)
5

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M.degree_on_basis(x)
5

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = Word((1,0,1,0,0))
M.degree_on_basis(x)

dual_on_basis(w)[source]¶

Return the order of the word and exchange letters 0 and 1.

This is an involution.

INPUT:

w – a word in 0 and 1

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = Word((1,0,1,0,0))
sage: M.dual_on_basis(x)
-I(11010)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = Word((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
>>> M.dual_on_basis(x)
-I(11010)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = Word((1,0,1,0,0))
M.dual_on_basis(x)

half_product()[source]¶

Compute half of the product of two elements.

This is half of the shuffle product.

Warning

This is not a motivic operation.

INPUT:

w1, w2 – elements

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = M(Word([1,0]))
sage: M.half_product(x,x)
2*I(1100) + I(1010)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = M(Word([Integer(1),Integer(0)]))
>>> M.half_product(x,x)
2*I(1100) + I(1010)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = M(Word([1,0]))
M.half_product(x,x)

half_product_on_basis(w1, w2)[source]¶

Compute half of the product of two monomials.

This is half of the shuffle product.

Warning

This is not a motivic operation.

INPUT:

w1, w2 – monomials

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = Word([1,0])
sage: M.half_product_on_basis(x,x)
2*I(1100) + I(1010)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = Word([Integer(1),Integer(0)])
>>> M.half_product_on_basis(x,x)
2*I(1100) + I(1010)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = Word([1,0])
M.half_product_on_basis(x,x)

one_basis()[source]¶

Return the index of the unit for the algebra.

This is the empty word.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M.one_basis()
word:

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M.one_basis()
word:

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M.one_basis()

phi()[source]¶

Return the morphism phi.

This sends multiple zeta values to the auxiliary F-algebra.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: m = Multizeta(1,0,1,0) + 2*Multizeta(1,1,0,0); m
2*I(1100) + I(1010)
sage: M.phi(m)
1/2*f2^2

sage: Z = Multizeta
sage: B5 = [3*Z(1,4) + 2*Z(2,3) + Z(3,2), 3*Z(1,4) + Z(2,3)]
sage: [M.phi(b.iterated()) for b in B5]
[-1/2*f5 + f2*f3, 1/2*f5]

sage: B6 = [6*Z(1,5) + 3*Z(2,4) + Z(3,3),
....:  6*Z(1,1,4) + 4*Z(1,2,3) + 2*Z(1,3,2) + 2*Z(2,1,3) + Z(2,2,2)]
sage: [M.phi(b.iterated()) for b in B6]
[f3f3, 1/6*f2^3]

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> m = Multizeta(Integer(1),Integer(0),Integer(1),Integer(0)) + Integer(2)*Multizeta(Integer(1),Integer(1),Integer(0),Integer(0)); m
2*I(1100) + I(1010)
>>> M.phi(m)
1/2*f2^2

>>> Z = Multizeta
>>> B5 = [Integer(3)*Z(Integer(1),Integer(4)) + Integer(2)*Z(Integer(2),Integer(3)) + Z(Integer(3),Integer(2)), Integer(3)*Z(Integer(1),Integer(4)) + Z(Integer(2),Integer(3))]
>>> [M.phi(b.iterated()) for b in B5]
[-1/2*f5 + f2*f3, 1/2*f5]

>>> B6 = [Integer(6)*Z(Integer(1),Integer(5)) + Integer(3)*Z(Integer(2),Integer(4)) + Z(Integer(3),Integer(3)),
...  Integer(6)*Z(Integer(1),Integer(1),Integer(4)) + Integer(4)*Z(Integer(1),Integer(2),Integer(3)) + Integer(2)*Z(Integer(1),Integer(3),Integer(2)) + Integer(2)*Z(Integer(2),Integer(1),Integer(3)) + Z(Integer(2),Integer(2),Integer(2))]
>>> [M.phi(b.iterated()) for b in B6]
[f3f3, 1/6*f2^3]

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
m = Multizeta(1,0,1,0) + 2*Multizeta(1,1,0,0); m
M.phi(m)
Z = Multizeta
B5 = [3*Z(1,4) + 2*Z(2,3) + Z(3,2), 3*Z(1,4) + Z(2,3)]
[M.phi(b.iterated()) for b in B5]
B6 = [6*Z(1,5) + 3*Z(2,4) + Z(3,3),
 6*Z(1,1,4) + 4*Z(1,2,3) + 2*Z(1,3,2) + 2*Z(2,1,3) + Z(2,2,2)]
[M.phi(b.iterated()) for b in B6]

phi_extended(w)[source]¶

Return the image of the monomial w by the morphism phi.

INPUT:

w – a word in 0 and 1

OUTPUT: an element in the auxiliary F-algebra

The coefficients are in the base ring.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: M.phi_extended((1,0))
-f2
sage: M.phi_extended((1,0,0))
-f3
sage: M.phi_extended((1,1,0))
f3
sage: M.phi_extended((1,0,1,0,0))
-11/2*f5 + 3*f2*f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> M.phi_extended((Integer(1),Integer(0)))
-f2
>>> M.phi_extended((Integer(1),Integer(0),Integer(0)))
-f3
>>> M.phi_extended((Integer(1),Integer(1),Integer(0)))
f3
>>> M.phi_extended((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)))
-11/2*f5 + 3*f2*f3

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
M.phi_extended((1,0))
M.phi_extended((1,0,0))
M.phi_extended((1,1,0))
M.phi_extended((1,0,1,0,0))

More complicated examples:

Sage

sage: from sage.modular.multiple_zeta import composition_to_iterated
sage: M.phi_extended(composition_to_iterated((4,3)))
-18*f7 + 10*f2*f5 + 2/5*f2^2*f3

sage: M.phi_extended(composition_to_iterated((3,4)))
17*f7 - 10*f2*f5

sage: M.phi_extended(composition_to_iterated((4,2)))
-2*f3f3 + 10/21*f2^3
sage: M.phi_extended(composition_to_iterated((3,5)))
-5*f5f3
sage: M.phi_extended(composition_to_iterated((3,7)))
-6*f5f5 - 14*f7f3

sage: M.phi_extended(composition_to_iterated((3,3,2)))
9*f3f5 - 9/2*f5f3 - 4*f2*f3f3 - 793/875*f2^4

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import composition_to_iterated
>>> M.phi_extended(composition_to_iterated((Integer(4),Integer(3))))
-18*f7 + 10*f2*f5 + 2/5*f2^2*f3

>>> M.phi_extended(composition_to_iterated((Integer(3),Integer(4))))
17*f7 - 10*f2*f5

>>> M.phi_extended(composition_to_iterated((Integer(4),Integer(2))))
-2*f3f3 + 10/21*f2^3
>>> M.phi_extended(composition_to_iterated((Integer(3),Integer(5))))
-5*f5f3
>>> M.phi_extended(composition_to_iterated((Integer(3),Integer(7))))
-6*f5f5 - 14*f7f3

>>> M.phi_extended(composition_to_iterated((Integer(3),Integer(3),Integer(2))))
9*f3f5 - 9/2*f5f3 - 4*f2*f3f3 - 793/875*f2^4

Sage Live

from sage.modular.multiple_zeta import composition_to_iterated
M.phi_extended(composition_to_iterated((4,3)))
M.phi_extended(composition_to_iterated((3,4)))
M.phi_extended(composition_to_iterated((4,2)))
M.phi_extended(composition_to_iterated((3,5)))
M.phi_extended(composition_to_iterated((3,7)))
M.phi_extended(composition_to_iterated((3,3,2)))

product_on_basis(w1, w2)[source]¶

Compute the product of two monomials.

This is the shuffle product.

INPUT:

w1, w2 – words in 0 and 1

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import Multizetas_iterated
sage: M = Multizetas_iterated(QQ)
sage: x = Word([1,0])
sage: M.product_on_basis(x,x)
4*I(1100) + 2*I(1010)
sage: y = Word([1,1,0])
sage: M.product_on_basis(y,x)
I(10110) + 3*I(11010) + 6*I(11100)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import Multizetas_iterated
>>> M = Multizetas_iterated(QQ)
>>> x = Word([Integer(1),Integer(0)])
>>> M.product_on_basis(x,x)
4*I(1100) + 2*I(1010)
>>> y = Word([Integer(1),Integer(1),Integer(0)])
>>> M.product_on_basis(y,x)
I(10110) + 3*I(11010) + 6*I(11100)

Sage Live

from sage.modular.multiple_zeta import Multizetas_iterated
M = Multizetas_iterated(QQ)
x = Word([1,0])
M.product_on_basis(x,x)
y = Word([1,1,0])
M.product_on_basis(y,x)

sage.modular.multiple_zeta.coeff_phi(w)[source]¶

Return the coefficient of \(f_k\) in the image by phi.

INPUT:

w – a word in 0 and 1 with \(k\) letters (where \(k\) is odd)

OUTPUT: a rational number

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import coeff_phi
sage: coeff_phi(Word([1,0,0]))
-1
sage: coeff_phi(Word([1,1,0]))
1
sage: coeff_phi(Word([1,1,0,1,0]))
11/2
sage: coeff_phi(Word([1,1,0,0,0,1,0]))
109/16

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import coeff_phi
>>> coeff_phi(Word([Integer(1),Integer(0),Integer(0)]))
-1
>>> coeff_phi(Word([Integer(1),Integer(1),Integer(0)]))
1
>>> coeff_phi(Word([Integer(1),Integer(1),Integer(0),Integer(1),Integer(0)]))
11/2
>>> coeff_phi(Word([Integer(1),Integer(1),Integer(0),Integer(0),Integer(0),Integer(1),Integer(0)]))
109/16

Sage Live

from sage.modular.multiple_zeta import coeff_phi
coeff_phi(Word([1,0,0]))
coeff_phi(Word([1,1,0]))
coeff_phi(Word([1,1,0,1,0]))
coeff_phi(Word([1,1,0,0,0,1,0]))

sage.modular.multiple_zeta.composition_to_iterated(w, reverse=False)[source]¶

Convert a composition to a word in 0 and 1.

By default, the chosen convention maps (2,3) to (1,0,1,0,0), respecting the reading order from left to right.

The inverse map is given by iterated_to_composition().

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import composition_to_iterated
sage: composition_to_iterated((1,2))
(1, 1, 0)
sage: composition_to_iterated((3,1,2))
(1, 0, 0, 1, 1, 0)
sage: composition_to_iterated((3,1,2,4))
(1, 0, 0, 1, 1, 0, 1, 0, 0, 0)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import composition_to_iterated
>>> composition_to_iterated((Integer(1),Integer(2)))
(1, 1, 0)
>>> composition_to_iterated((Integer(3),Integer(1),Integer(2)))
(1, 0, 0, 1, 1, 0)
>>> composition_to_iterated((Integer(3),Integer(1),Integer(2),Integer(4)))
(1, 0, 0, 1, 1, 0, 1, 0, 0, 0)

Sage Live

from sage.modular.multiple_zeta import composition_to_iterated
composition_to_iterated((1,2))
composition_to_iterated((3,1,2))
composition_to_iterated((3,1,2,4))

sage.modular.multiple_zeta.compute_u_on_basis(w)[source]¶

Compute the value of u on a multiple zeta value.

INPUT:

w – a word in 0,1

OUTPUT: an element of F_ring() over \(\QQ\)

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import compute_u_on_basis
sage: compute_u_on_basis((1,0,0,0,1,0))
-2*f3f3

sage: compute_u_on_basis((1,1,1,0,0))
f2*f3

sage: compute_u_on_basis((1,0,0,1,0,0,0,0))
-5*f5f3

sage: compute_u_on_basis((1,0,1,0,0,1,0))
11/2*f2*f5

sage: compute_u_on_basis((1,0,0,1,0,1,0,0,1,0))
-75/4*f3f7 + 81/4*f5f5 + 75/8*f7f3 + 11*f2*f3f5 - 9*f2*f5f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import compute_u_on_basis
>>> compute_u_on_basis((Integer(1),Integer(0),Integer(0),Integer(0),Integer(1),Integer(0)))
-2*f3f3

>>> compute_u_on_basis((Integer(1),Integer(1),Integer(1),Integer(0),Integer(0)))
f2*f3

>>> compute_u_on_basis((Integer(1),Integer(0),Integer(0),Integer(1),Integer(0),Integer(0),Integer(0),Integer(0)))
-5*f5f3

>>> compute_u_on_basis((Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)))
11/2*f2*f5

>>> compute_u_on_basis((Integer(1),Integer(0),Integer(0),Integer(1),Integer(0),Integer(1),Integer(0),Integer(0),Integer(1),Integer(0)))
-75/4*f3f7 + 81/4*f5f5 + 75/8*f7f3 + 11*f2*f3f5 - 9*f2*f5f3

Sage Live

from sage.modular.multiple_zeta import compute_u_on_basis
compute_u_on_basis((1,0,0,0,1,0))
compute_u_on_basis((1,1,1,0,0))
compute_u_on_basis((1,0,0,1,0,0,0,0))
compute_u_on_basis((1,0,1,0,0,1,0))
compute_u_on_basis((1,0,0,1,0,1,0,0,1,0))

sage.modular.multiple_zeta.compute_u_on_compo(compo)[source]¶

Compute the value of the map u on a multiple zeta value.

INPUT:

compo – a composition

OUTPUT: an element of F_ring() over \(\QQ\)

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import compute_u_on_compo
sage: compute_u_on_compo((2,4))
2*f3f3
sage: compute_u_on_compo((2,3,2))
-11/2*f2*f5
sage: compute_u_on_compo((3,2,3,2))
-75/4*f3f7 + 81/4*f5f5 + 75/8*f7f3 + 11*f2*f3f5 - 9*f2*f5f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import compute_u_on_compo
>>> compute_u_on_compo((Integer(2),Integer(4)))
2*f3f3
>>> compute_u_on_compo((Integer(2),Integer(3),Integer(2)))
-11/2*f2*f5
>>> compute_u_on_compo((Integer(3),Integer(2),Integer(3),Integer(2)))
-75/4*f3f7 + 81/4*f5f5 + 75/8*f7f3 + 11*f2*f3f5 - 9*f2*f5f3

Sage Live

from sage.modular.multiple_zeta import compute_u_on_compo
compute_u_on_compo((2,4))
compute_u_on_compo((2,3,2))
compute_u_on_compo((3,2,3,2))

sage.modular.multiple_zeta.coproduct_iterator(paire)[source]¶

Return an iterator for terms in the coproduct.

This is an auxiliary function.

INPUT:

paire – a pair (list of indices, end of word)

OUTPUT: iterator for terms in the motivic coproduct

Each term is seen as a list of positions.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import coproduct_iterator
sage: list(coproduct_iterator(([0],[0,1,0,1])))
[[0, 1, 2, 3]]
sage: list(coproduct_iterator(([0],[0,1,0,1,1,0,1])))
[[0, 1, 2, 3, 4, 5, 6], [0, 1, 2, 6], [0, 1, 5, 6], [0, 4, 5, 6], [0, 6]]

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import coproduct_iterator
>>> list(coproduct_iterator(([Integer(0)],[Integer(0),Integer(1),Integer(0),Integer(1)])))
[[0, 1, 2, 3]]
>>> list(coproduct_iterator(([Integer(0)],[Integer(0),Integer(1),Integer(0),Integer(1),Integer(1),Integer(0),Integer(1)])))
[[0, 1, 2, 3, 4, 5, 6], [0, 1, 2, 6], [0, 1, 5, 6], [0, 4, 5, 6], [0, 6]]

Sage Live

from sage.modular.multiple_zeta import coproduct_iterator
list(coproduct_iterator(([0],[0,1,0,1])))
list(coproduct_iterator(([0],[0,1,0,1,1,0,1])))

sage.modular.multiple_zeta.dual_composition(c)[source]¶

Return the dual composition of c.

This is an involution on compositions such that associated multizetas are equal.

INPUT:

c – a composition

OUTPUT: a composition

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import dual_composition
sage: dual_composition([3])
(1, 2)
sage: dual_composition(dual_composition([3,4,5])) == (3,4,5)
True

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import dual_composition
>>> dual_composition([Integer(3)])
(1, 2)
>>> dual_composition(dual_composition([Integer(3),Integer(4),Integer(5)])) == (Integer(3),Integer(4),Integer(5))
True

Sage Live

from sage.modular.multiple_zeta import dual_composition
dual_composition([3])
dual_composition(dual_composition([3,4,5])) == (3,4,5)

sage.modular.multiple_zeta.extend_multiplicative_basis(B, n)[source]¶

Extend a multiplicative basis into a basis.

This is an iterator.

INPUT:

B – function mapping integer to list of tuples of compositions
n – integer

OUTPUT: each term is a tuple of tuples of compositions

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import extend_multiplicative_basis
sage: from sage.modular.multiple_zeta import B_data
sage: list(extend_multiplicative_basis(B_data,5))
[((5,),), ((3,), (2,))]
sage: list(extend_multiplicative_basis(B_data,6))
[((3,), (3,)), ((2,), (2,), (2,))]
sage: list(extend_multiplicative_basis(B_data,7))
[((7,),), ((5,), (2,)), ((3,), (2,), (2,))]

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import extend_multiplicative_basis
>>> from sage.modular.multiple_zeta import B_data
>>> list(extend_multiplicative_basis(B_data,Integer(5)))
[((5,),), ((3,), (2,))]
>>> list(extend_multiplicative_basis(B_data,Integer(6)))
[((3,), (3,)), ((2,), (2,), (2,))]
>>> list(extend_multiplicative_basis(B_data,Integer(7)))
[((7,),), ((5,), (2,)), ((3,), (2,), (2,))]

Sage Live

from sage.modular.multiple_zeta import extend_multiplicative_basis
from sage.modular.multiple_zeta import B_data
list(extend_multiplicative_basis(B_data,5))
list(extend_multiplicative_basis(B_data,6))
list(extend_multiplicative_basis(B_data,7))

sage.modular.multiple_zeta.iterated_to_composition(w, reverse=False)[source]¶

Convert a word in 0 and 1 to a composition.

By default, the chosen convention maps (1,0,1,0,0) to (2,3).

The inverse map is given by composition_to_iterated().

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import iterated_to_composition
sage: iterated_to_composition([1,0,1,0,0])
(2, 3)
sage: iterated_to_composition(Word([1,1,0]))
(1, 2)
sage: iterated_to_composition(Word([1,1,0,1,1,0,0]))
(1, 2, 1, 3)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import iterated_to_composition
>>> iterated_to_composition([Integer(1),Integer(0),Integer(1),Integer(0),Integer(0)])
(2, 3)
>>> iterated_to_composition(Word([Integer(1),Integer(1),Integer(0)]))
(1, 2)
>>> iterated_to_composition(Word([Integer(1),Integer(1),Integer(0),Integer(1),Integer(1),Integer(0),Integer(0)]))
(1, 2, 1, 3)

Sage Live

from sage.modular.multiple_zeta import iterated_to_composition
iterated_to_composition([1,0,1,0,0])
iterated_to_composition(Word([1,1,0]))
iterated_to_composition(Word([1,1,0,1,1,0,0]))

sage.modular.multiple_zeta.minimize_term(w, cf)[source]¶

Return the largest among w and the dual word of w.

INPUT:

w – a word in the letters 0 and 1
cf – a coefficient

OUTPUT:

(word, coefficient)

The chosen order is lexicographic with 1 < 0.

If the dual word is chosen, the sign of the coefficient is changed, otherwise the coefficient is returned unchanged.

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import minimize_term, Words10
sage: minimize_term(Words10((1,1,0)), 1)
(word: 100, -1)
sage: minimize_term(Words10((1,0,0)), 1)
(word: 100, 1)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import minimize_term, Words10
>>> minimize_term(Words10((Integer(1),Integer(1),Integer(0))), Integer(1))
(word: 100, -1)
>>> minimize_term(Words10((Integer(1),Integer(0),Integer(0))), Integer(1))
(word: 100, 1)

Sage Live

from sage.modular.multiple_zeta import minimize_term, Words10
minimize_term(Words10((1,1,0)), 1)
minimize_term(Words10((1,0,0)), 1)

sage.modular.multiple_zeta.phi_on_basis(L)[source]¶

Compute the value of phi on the hardcoded basis.

INPUT:

L – list of compositions; each composition in the hardcoded basis

This encodes a product of multiple zeta values.

OUTPUT: an element in F_ring()

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import phi_on_basis
sage: phi_on_basis([(3,),(3,)])
2*f3f3
sage: phi_on_basis([(2,),(2,)])
f2^2
sage: phi_on_basis([(2,),(3,),(3,)])
2*f2*f3f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import phi_on_basis
>>> phi_on_basis([(Integer(3),),(Integer(3),)])
2*f3f3
>>> phi_on_basis([(Integer(2),),(Integer(2),)])
f2^2
>>> phi_on_basis([(Integer(2),),(Integer(3),),(Integer(3),)])
2*f2*f3f3

Sage Live

from sage.modular.multiple_zeta import phi_on_basis
phi_on_basis([(3,),(3,)])
phi_on_basis([(2,),(2,)])
phi_on_basis([(2,),(3,),(3,)])

sage.modular.multiple_zeta.phi_on_multiplicative_basis(compo)[source]¶

Compute phi on one single multiple zeta value.

INPUT:

compo – a composition (in the hardcoded multiplicative base)

OUTPUT: an element in F_ring() with rational coefficients

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import phi_on_multiplicative_basis
sage: phi_on_multiplicative_basis((2,))
f2
sage: phi_on_multiplicative_basis((3,))
f3

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import phi_on_multiplicative_basis
>>> phi_on_multiplicative_basis((Integer(2),))
f2
>>> phi_on_multiplicative_basis((Integer(3),))
f3

Sage Live

from sage.modular.multiple_zeta import phi_on_multiplicative_basis
phi_on_multiplicative_basis((2,))
phi_on_multiplicative_basis((3,))

sage.modular.multiple_zeta.rho_inverse(elt)[source]¶

Return the image by the inverse of rho.

INPUT:

elt – an homogeneous element of the F ring

OUTPUT: a linear combination of multiple zeta values

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import rho_inverse
sage: from sage.modular.multiple_zeta_F_algebra import F_algebra
sage: A = F_algebra(QQ)
sage: f = A.gen
sage: rho_inverse(f(3))
ζ(3)
sage: rho_inverse(f(9))
ζ(9)
sage: rho_inverse(A("53"))
-1/5*ζ(3,5)

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import rho_inverse
>>> from sage.modular.multiple_zeta_F_algebra import F_algebra
>>> A = F_algebra(QQ)
>>> f = A.gen
>>> rho_inverse(f(Integer(3)))
ζ(3)
>>> rho_inverse(f(Integer(9)))
ζ(9)
>>> rho_inverse(A("53"))
-1/5*ζ(3,5)

Sage Live

from sage.modular.multiple_zeta import rho_inverse
from sage.modular.multiple_zeta_F_algebra import F_algebra
A = F_algebra(QQ)
f = A.gen
rho_inverse(f(3))
rho_inverse(f(9))
rho_inverse(A("53"))

sage.modular.multiple_zeta.rho_matrix_inverse()[source]¶

Return the matrix of the inverse of rho.

This is the matrix in the chosen bases, namely the hardcoded basis of multiple zeta values and the natural basis of the F ring.

INPUT:

n – integer

EXAMPLES:

Sage

sage: from sage.modular.multiple_zeta import rho_matrix_inverse
sage: rho_matrix_inverse(3)
[1]
sage: rho_matrix_inverse(8)
[-1/5    0    0    0]
[ 1/5    1    0    0]
[   0    0  1/2    0]
[   0    0    0    1]

Python

>>> from sage.all import *
>>> from sage.modular.multiple_zeta import rho_matrix_inverse
>>> rho_matrix_inverse(Integer(3))
[1]
>>> rho_matrix_inverse(Integer(8))
[-1/5    0    0    0]
[ 1/5    1    0    0]
[   0    0  1/2    0]
[   0    0    0    1]

Sage Live

from sage.modular.multiple_zeta import rho_matrix_inverse
rho_matrix_inverse(3)
rho_matrix_inverse(8)