# Manin symbols¶

This module defines the class ManinSymbol. A Manin Symbol of weight $$k$$, level $$N$$ has the form $$[P(X,Y),(u:v)]$$ where $$P(X,Y)\in\mathbb{Z}[X,Y]$$ is homogeneous of weight $$k-2$$ and $$(u:v)\in\mathbb{P}^1(\mathbb{Z}/N\mathbb{Z}).$$ The ManinSymbol class holds a “monomial Manin Symbol” of the simpler form $$[X^iY^{k-2-i},(u:v)]$$, which is stored as a triple $$(i,u,v)$$; the weight and level are obtained from the parent structure, which is a ManinSymbolList.

Integer matrices $$[a,b;c,d]$$ act on Manin Symbols on the right, sending $$[P(X,Y),(u,v)]$$ to $$[P(aX+bY,cX+dY),(u,v)g]$$. Diagonal matrices (with $$b=c=0$$, such as $$I=[-1,0;0,1]$$ and $$J=[-1,0;0,-1]$$) and anti-diagonal matrices (with $$a=d=0$$, such as $$S=[0,-1;1,0]$$) map monomial Manin Symbols to monomial Manin Symbols, up to a scalar factor. For general matrices (such as $$T=[0,1,-1,-1]$$ and $$T^2=[-1,-1;0,1]$$) the image of a monomial Manin Symbol is expressed as a formal sum of monomial Manin Symbols, with integer coefficients.

There are various different classes holding lists of Manin symbols of different types. The hierarchy is as follows:

class ManinSymbolList(SageObject)

class ManinSymbolList_group(ManinSymbolList)
class ManinSymbolList_gamma0(ManinSymbolList_group)
class ManinSymbolList_gamma1(ManinSymbolList_group)
class ManinSymbolList_gamma_h(ManinSymbolList_group)

class ManinSymbolList_character(ManinSymbolList)
class sage.modular.modsym.manin_symbols.ManinSymbol(parent, t)

A Manin symbol $$[X^i\cdot Y^{k-2-i},(u,v)]$$.

INPUT:

• parent - ManinSymbolList.
• t - a 3-tuple $$(i,u,v)$$ of integers.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,2)
sage: s = ManinSymbol(m,(2,2,3)); s
(2,3)
True

::

sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3)); s
[X^2*Y^4,(2,3)]

apply(a, b, c, d)

Return the image of self under the matrix $$[a,b;c,d]$$.

Not implemented for raw ManinSymbol objects, only for members of ManinSymbolLists.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,2)
sage: m.apply(10,[1,0,0,1]) # not implemented for base class

endpoints(N=None)

Returns cusps $$alpha$$, $$beta$$ such that this Manin symbol, viewed as a symbol for level $$N$$, is $$X^i*Y^{k-2-i} \{alpha, beta\}$$.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3)); s
[X^2*Y^4,(2,3)]
sage: s.endpoints()
(1/3, 1/2)

i

Return the $$i$$ field of this ManinSymbol $$(i,u,v)$$.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s._ManinSymbol__get_i()
2
sage: s.i
2

level()

Return the level of this ManinSymbol.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.level()
5

lift_to_sl2z(N=None)

Returns a lift of this Manin Symbol to $$SL_2(\mathbb{Z})$$.

If this Manin symbol is $$(c,d)$$ and $$N$$ is its level, this function returns a list $$[a,b, c',d']$$ that defines a 2x2 matrix with determinant 1 and integer entries, such that $$c=c'$$ (mod $$N$$) and $$d=d'$$ (mod $$N$$).

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s
[X^2*Y^4,(2,3)]
sage: s.lift_to_sl2z()
[1, 1, 2, 3]

modular_symbol_rep()

Returns a representation of self as a formal sum of modular symbols.

The result is not cached.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.modular_symbol_rep()
144*X^6*{1/3, 1/2} - 384*X^5*Y*{1/3, 1/2} + 424*X^4*Y^2*{1/3, 1/2} - 248*X^3*Y^3*{1/3, 1/2} + 81*X^2*Y^4*{1/3, 1/2} - 14*X*Y^5*{1/3, 1/2} + Y^6*{1/3, 1/2}

parent()

Return the parent of this ManinSymbol.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.parent()
Manin Symbol List of weight 8 for Gamma0(5)

tuple()

Return the 3-tuple $$(i,u,v)$$ of this ManinSymbol.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.tuple()
(2, 2, 3)

u

Return the $$u$$ field of this ManinSymbol $$(i,u,v)$$.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.u # indirect doctest
2

v

Return the $$v$$ field of this ManinSymbol $$(i,u,v)$$.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.v # indirect doctest
3

weight()

Return the weight of this ManinSymbol.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: s = ManinSymbol(m,(2,2,3))
sage: s.weight()
8

class sage.modular.modsym.manin_symbols.ManinSymbolList(weight, list)

Base class for lists of all Manin symbols for a given weight, group or character.

apply(j, X)

Apply the matrix $$X=[a,b;c,d]$$ to the $$j$$-th Manin symbol.

Implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.apply(10, [1,2,0,1])
Traceback (most recent call last):
...
NotImplementedError: Only implemented in derived classes

apply_I(j)

Apply the matrix $$I=[-1,0;0,1]$$ to the $$j$$-th Manin symbol.

Implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.apply_I(10)
Traceback (most recent call last):
...
NotImplementedError: Only implemented in derived classes

apply_S(j)

Apply the matrix $$S=[0,-1;1,0]$$ to the $$j$$-th Manin symbol.

Implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.apply_S(10)
Traceback (most recent call last):
...
NotImplementedError: Only implemented in derived classes

apply_T(j)

Apply the matrix $$T=[0,1;-1,-1]$$ to the $$j$$-th Manin symbol.

Implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.apply_T(10)
Traceback (most recent call last):
...
NotImplementedError: Only implemented in derived classes

apply_TT(j)

Apply the matrix $$TT=T^2=[-1,-1;0,1]$$ to the $$j$$-th Manin symbol.

Implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.apply_TT(10)
Traceback (most recent call last):
...
NotImplementedError: Only implemented in derived classes

index(x)

Return the index of x in the list of Manin symbols, where x is a 3-tuple of ints. If x is not in the list, then return -1.

INPUT:

• x - 3-tuple of integers, $$(i,u,v)$$ defining a valid Manin symbol, which need not be normalized.

OUTPUT:

(int) the index of the normalized Manin symbol equivalent to $$(i,u,v)$$.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.index(m[2])
2
sage: all([i == m.index(m[i]) for i in xrange(len(m))])
True

manin_symbol(i)

Returns the i’th ManinSymbol in this ManinSymbolList.

INPUT:

• i - integer, a valid index of a symbol in this list.

OUTPUT:

ManinSymbol - the $$i$$‘th Manin symbol in the list.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.manin_symbol(3) # not implemented for base class

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(6, 4)
sage: s = m.manin_symbol(3); s
[Y^2,(1,2)]
sage: type(s)
<class 'sage.modular.modsym.manin_symbols.ManinSymbol'>

manin_symbol_list()

Returns all the ManinSymbols in this ManinSymbolList as a list

Cached for subsequent calls.

OUTPUT:

a list of ManinSymbol objects, which is a copy of the complete list of Manin symbols.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.manin_symbol_list() # not implemented for the base class

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(6, 4)
sage: m.manin_symbol_list()
[[Y^2,(0,1)],
[Y^2,(1,0)],
[Y^2,(1,1)],
...
[X^2,(3,1)],
[X^2,(3,2)]]

normalize(x)

Returns a normalized ManinSymbol from x.

To be implemented in derived classes.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
sage: m = ManinSymbolList(6,P1List(11))
sage: m.normalize((0,6,7)) # not implemented in base class

weight()

Returns the weight of the ManinSymbols in this ManinSymbolList.

OUTPUT:

integer - the weight of the Manin symbols in the list.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(6, 4)
sage: m.weight()
4

class sage.modular.modsym.manin_symbols.ManinSymbolList_character(character, weight)

List of Manin Symbols with character.

INPUT:

• character - (DirichletCharacter) the Dirichlet character.
• weight - (integer) the weight.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.manin_symbol_list()
[(0,1), (1,0), (1,1), (1,2), (1,3), (2,1)]
True

apply(j, m)

Apply the integer matrix $$m=[a,b;c,d]$$ to the $$j$$-th Manin symbol.

INPUT:

• j (integer): the index of the symbol to act on.
• m (list of ints): $$[a,b,c,d]$$ where $$m = [a, b; c, d]$$ is the matrix to be applied.

OUTPUT:

A list of pairs $$(j, c_i)$$, where each $$c_i$$ is an integer, $$j$$ is an integer (the $$j$$-th Manin symbol), and the sum $$c_i*x_i$$ is the image of self under the right action of the matrix $$[a,b;c,d]$$. Here the right action of $$g=[a,b;c,d]$$ on a Manin symbol $$[P(X,Y),(u,v)]$$ is by definition $$[P(aX+bY,cX+dY),(u,v)*g]$$.

EXAMPLES:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4)
sage: m[6]
(1, 0, 1)
sage: m.apply(4, [1,0,0,1])
[(4, 1)]
sage: m.apply(1, [-1,0,0,1])
[(1, -1)]

apply_I(j)

Apply the matrix $$I=[-1,0,0,1]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (integer) a symbol index

OUTPUT:

(k, s) where $$k$$ is the index of the symbol obtained by acting on the $$j$$‘th symbol with $$I$$, and $$s$$ is the parity of of the $$j$$‘th symbol.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.apply_I(4)
(2, -1)
sage: [m.apply_I(i) for i in xrange(len(m))]
[(0, 1), (1, -1), (4, -1), (3, -1), (2, -1), (5, 1)]

apply_S(j)

Apply the matrix $$S=[0,1;-1,0]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (integer) a symbol index.

OUTPUT:

(k, s) where $$k$$ is the index of the symbol obtained by acting on the $$j$$‘th symbol with $$S$$, and $$s$$ is the parity of the $$j$$‘th symbol.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.apply_S(4)
(2, -1)
sage: [m.apply_S(i) for i in xrange(len(m))]
[(1, 1), (0, -1), (4, 1), (5, -1), (2, -1), (3, 1)]

apply_T(j)

Apply the matrix $$T=[0,1,-1,-1]$$ to the j-th Manin symbol.

INPUT:

• j - (integer) a symbol index.

OUTPUT:

A list of pairs $$(j, c_i)$$, where each $$c_i$$ is an integer, $$j$$ is an integer (the $$j$$-th Manin symbol), and the sum $$c_i*x_i$$ is the image of self under the right action of the matrix $$T$$.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.apply_T(4)
[(1, -1)]
sage: [m.apply_T(i) for i in xrange(len(m))]
[[(4, 1)], [(0, -1)], [(3, 1)], [(5, 1)], [(1, -1)], [(2, 1)]]

apply_TT(j)

Apply the matrix $$TT=[-1,-1,0,1]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (integer) a symbol index

OUTPUT:

A list of pairs $$(j, c_i)$$, where each $$c_i$$ is an integer, $$j$$ is an integer (the $$j$$-th Manin symbol), and the sum $$c_i*x_i$$ is the image of self under the right action of the matrix $$T^2$$.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.apply_TT(4)
[(0, 1)]
sage: [m.apply_TT(i) for i in xrange(len(m))]
[[(1, -1)], [(4, -1)], [(5, 1)], [(2, 1)], [(0, 1)], [(3, 1)]]

character()

Return the character of this ManinSymbolList_character object.

OUTPUT:

The Dirichlet character of this Manin symbol list.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,2); m
Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
sage: m.character()
Dirichlet character modulo 4 of conductor 4 mapping 3 |--> -1

index(x)

Returns the index in the list of standard Manin symbols of a symbol that is equivalent, modulo a scalar $$s$$, to x. Returns the index and the scalar.

If x is not in the list, return (-1, 0).

INPUT:

• x - 3-tuple of integers $$(i,u,v)$$, defining an element of this list of Manin symbols, which need not be normalized.

OUTPUT:

(i, s) where i (int) is the index of the Manin symbol equivalent to $$(i,u,v)$$ (or -1) and s is the scalar (an element of the base field) or the int 0.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4); m
Manin Symbol List of weight 4 for Gamma1(4) with character [-1]
sage: [m.index(s.tuple()) for s in m.manin_symbol_list()]
[(0, 1),
(1, 1),
(2, 1),
(3, 1),
...
(16, 1),
(17, 1)]

level()

Return the level of this ManinSymbolList.

OUTPUT:

integer - the level of the symbols in this list.

EXAMPLES:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: ManinSymbolList_character(eps,4).level()
4

normalize(x)

Returns the normalization of the Manin Symbol x with respect to this list, together with the normalizing scalar.

INPUT:

• x - 3-tuple of integers (i,u,v), defining an element of this list of Manin symbols, which need not be normalized.

OUTPUT:

((i,u,v),s), where (i,u,v) is the normalized Manin symbol equivalent to x, and s is the normalizing scalar.

EXAMPLE:

sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4); m
Manin Symbol List of weight 4 for Gamma1(4) with character [-1]
sage: [m.normalize(s.tuple()) for s in m.manin_symbol_list()]
[((0, 0, 1), 1),
((0, 1, 0), 1),
((0, 1, 1), 1),
...
((2, 1, 3), 1),
((2, 2, 1), 1)]

class sage.modular.modsym.manin_symbols.ManinSymbolList_gamma0(level, weight)

Class for Manin Symbols for $$\Gamma_0(N)$$.

INPUT:

• level - (integer): the level.
• weight - (integer): the weight.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,2); m
Manin Symbol List of weight 2 for Gamma0(5)
sage: m.manin_symbol_list()
[(0,1), (1,0), (1,1), (1,2), (1,3), (1,4)]
sage: m = ManinSymbolList_gamma0(6,4); m
Manin Symbol List of weight 4 for Gamma0(6)
sage: len(m)
36

class sage.modular.modsym.manin_symbols.ManinSymbolList_gamma1(level, weight)

Class for Manin Symbols for $$\Gamma_1(N)$$.

INPUT:

• level - (integer): the level.
• weight - (integer): the weight.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma1
sage: m = ManinSymbolList_gamma1(5,2); m
Manin Symbol List of weight 2 for Gamma1(5)
sage: m.manin_symbol_list()
[(0,1),
(0,2),
(0,3),
...
(4,3),
(4,4)]
sage: m = ManinSymbolList_gamma1(6,4); m
Manin Symbol List of weight 4 for Gamma1(6)
sage: len(m)
72
True

class sage.modular.modsym.manin_symbols.ManinSymbolList_gamma_h(group, weight)

Class for Manin Symbols for $$\Gamma_H(N)$$.

INPUT:

• group - (integer): the congruence subgroup.
• weight - (integer): the weight.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma_h
sage: G = GammaH(117, [4])
sage: m = ManinSymbolList_gamma_h(G,2); m
Manin Symbol List of weight 2 for Congruence Subgroup Gamma_H(117) with H generated by [4]
sage: m.manin_symbol_list()[100:110]
[(1,88),
(1,89),
(1,90),
(1,91),
(1,92),
(1,93),
(1,94),
(1,95),
(1,96),
(1,97)]
sage: len(m.manin_symbol_list())
2016
True

group()

Return the group associated to self.

EXAMPLES:

sage: ModularSymbols(GammaH(12, [5]), 2).manin_symbols().group()
Congruence Subgroup Gamma_H(12) with H generated by [5]

class sage.modular.modsym.manin_symbols.ManinSymbolList_group(level, weight, syms)

Base class for Manin symbol lists for a given group.

INPUT:

• level - integer level
• weight - integer weight
• syms - something with a normalize and list method, e.g., P1List.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_group
sage: ManinSymbolList_group(11, 2, P1List(11))
<class 'sage.modular.modsym.manin_symbols.ManinSymbolList_group'>

apply(j, m)

Apply the matrix $$m=[a,b;c,d]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (int) a symbol index
• m = [a, b, c, d] a list of 4 integers, which defines a 2x2 matrix.

OUTPUT:

a list of pairs $$(j_i, \alpha_i)$$, where each $$\alpha_i$$ is a nonzero integer, $$j_i$$ is an integer (index of the $$j_i$$-th Manin symbol), and $$\sum_i \alpha_i\*x_{j_i}$$ is the image of the j-th Manin symbol under the right action of the matrix [a,b;c,d]. Here the right action of g=[a,b;c,d] on a Manin symbol $$[P(X,Y),(u,v)]$$ is $$[P(aX+bY,cX+dY),(u,v)\*g]$$.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: m.apply(40,[2,3,1,1])
[(0, 729), (6, 2916), (12, 4860), (18, 4320), (24, 2160), (30, 576), (36, 64)]

apply_I(j)

Apply the matrix $$I=[-1,0,0,1]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (int) a symbol index

OUTPUT:

(k, s) where k is the index of the symbol obtained by acting on the $$j$$‘th symbol with $$I$$, and $$s$$ is the parity of of the $$j$$‘th symbol (a Python int, either 1 or -1)

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: m.apply_I(4)
(3, 1)
sage: [m.apply_I(i) for i in xrange(10)]
[(0, 1),
(1, 1),
(5, 1),
(4, 1),
(3, 1),
(2, 1),
(6, -1),
(7, -1),
(11, -1),
(10, -1)]

apply_S(j)

Apply the matrix $$S=[0,-1,1,0]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (int) a symbol index

OUTPUT:

(k, s) where k is the index of the symbol obtained by acting on the $$j$$‘th symbol with $$S$$, and $$s$$ is the parity of of the $$j$$‘th symbol (a Python int, either 1 or -1).

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: m.apply_S(4)
(40, 1)
sage: [m.apply_S(i) for i in xrange(len(m))]
[(37, 1),
(36, 1),
(41, 1),
(39, 1),
(40, 1),
(38, 1),
(31, -1),
(30, -1),
(35, -1),
(33, -1),
(34, -1),
(32, -1),
...
(4, 1),
(2, 1)]

apply_T(j)

Apply the matrix $$T=[0,1,-1,-1]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (int) a symbol index

OUTPUT: see documentation for apply()

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: m.apply_T(4)
[(3, 1), (9, -6), (15, 15), (21, -20), (27, 15), (33, -6), (39, 1)]
sage: [m.apply_T(i) for i in xrange(10)]
[[(5, 1), (11, -6), (17, 15), (23, -20), (29, 15), (35, -6), (41, 1)],
[(0, 1), (6, -6), (12, 15), (18, -20), (24, 15), (30, -6), (36, 1)],
[(4, 1), (10, -6), (16, 15), (22, -20), (28, 15), (34, -6), (40, 1)],
[(2, 1), (8, -6), (14, 15), (20, -20), (26, 15), (32, -6), (38, 1)],
[(3, 1), (9, -6), (15, 15), (21, -20), (27, 15), (33, -6), (39, 1)],
[(1, 1), (7, -6), (13, 15), (19, -20), (25, 15), (31, -6), (37, 1)],
[(5, 1), (11, -5), (17, 10), (23, -10), (29, 5), (35, -1)],
[(0, 1), (6, -5), (12, 10), (18, -10), (24, 5), (30, -1)],
[(4, 1), (10, -5), (16, 10), (22, -10), (28, 5), (34, -1)],
[(2, 1), (8, -5), (14, 10), (20, -10), (26, 5), (32, -1)]]

apply_TT(j)

Apply the matrix $$TT=[-1,-1,0,1]$$ to the $$j$$-th Manin symbol.

INPUT:

• j - (int) a symbol index

OUTPUT: see documentation for apply()

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: m.apply_TT(4)
[(38, 1)]
sage: [m.apply_TT(i) for i in xrange(10)]
[[(37, 1)],
[(41, 1)],
[(39, 1)],
[(40, 1)],
[(38, 1)],
[(36, 1)],
[(31, -1), (37, 1)],
[(35, -1), (41, 1)],
[(33, -1), (39, 1)],
[(34, -1), (40, 1)]]

level()

Return the level of this ManinSymbolList.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: ManinSymbolList_gamma0(5,2).level()
5

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma1
sage: ManinSymbolList_gamma1(51,2).level()
51

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma_h
sage: ManinSymbolList_gamma_h(GammaH(117, [4]),2).level()
117

normalize(x)

Returns the normalization of the ModSym x with respect to this list.

INPUT:

• x - (3-tuple of ints) a tuple defining a ManinSymbol.

OUTPUT:

(i,u,v) - (3-tuple of ints) another tuple defining the associated normalized ManinSymbol.

EXAMPLE:

sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
sage: m = ManinSymbolList_gamma0(5,8)
sage: [m.normalize(s.tuple()) for s in m.manin_symbol_list()][:10]
[(0, 0, 1),
(0, 1, 0),
(0, 1, 1),
(0, 1, 2),
(0, 1, 3),
(0, 1, 4),
(1, 0, 1),
(1, 1, 0),
(1, 1, 1),
(1, 1, 2)]

sage.modular.modsym.manin_symbols.is_ManinSymbol(x)

Returns True if x is a ManinSymbol.

EXAMPLES:

sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0, is_ManinSymbol
sage: m = ManinSymbolList_gamma0(6, 4)
sage: is_ManinSymbol(m[3])
False
sage: s = ManinSymbol(m,m[3])
sage: s
[Y^2,(1,2)]
sage: is_ManinSymbol(s)
True


#### Previous topic

Modular symbols {alpha, beta}

#### Next topic

Space of boundary modular symbols