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)

Bases: sage.structure.sage_object.SageObject

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)
sage: s == loads(dumps(s))
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)

Bases: sage.structure.sage_object.SageObject

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)

Bases: sage.modular.modsym.manin_symbols.ManinSymbolList

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)]
sage: m == loads(dumps(m))
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)

Bases: sage.modular.modsym.manin_symbols.ManinSymbolList_group

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)

Bases: sage.modular.modsym.manin_symbols.ManinSymbolList_group

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
sage: m == loads(dumps(m))
True
class sage.modular.modsym.manin_symbols.ManinSymbolList_gamma_h(group, weight)

Bases: sage.modular.modsym.manin_symbols.ManinSymbolList_group

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
sage: m == loads(dumps(m))
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)

Bases: sage.modular.modsym.manin_symbols.ManinSymbolList

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

This Page