41.6 Manin symbols

Module: sage.modular.modsym.manin_symbols

Manin symbols

Module-level Functions

apply_to_monomial( i, j, a, b, c, d)

Returns a list of the coefficients of

$\displaystyle (aX + bY)^i (cX + dY)^{j-i},
$

where $ 0 \leq i \leq j$ , and $ a,b,c,d$ are integers.

One should think of $ j$ as being $ k-2$ for the application to modular symbols.

Input:

i, j, a, b, c, d
- all ints

Output: list of ints, which are the coefficients of $ Y^j$ , $ Y^{j-1}*X$ , ..., $ X^j$ , respectively.

We compute that $ (X+Y)^2(X-Y) = X^3 + X^2Y - XY^2 - Y^3$ .

sage: from sage.modular.modsym.manin_symbols import apply_to_monomial
sage: apply_to_monomial(2, 3, 1,1,1,-1)
[-1, -1, 1, 1]
sage: apply_to_monomial(5, 8, 1,2,3,4)
[2048, 9728, 20096, 23584, 17200, 7984, 2304, 378, 27]
sage: apply_to_monomial(6,12, 1,1,1,-1)
[1, 0, -6, 0, 15, 0, -20, 0, 15, 0, -6, 0, 1]

is_ManinSymbol( x)

Class: ManinSymbol

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

Create a Manin symbol $ [X^i*Y^{k-2-i},(u,v)]$ , where $ k$ is the weight.

Input:

parent
- ManinSymbolList
t
- a 3-tuple (i,u,v) of int's.

Functions: apply,$ \,$ copy,$ \,$ endpoints,$ \,$ lift_to_sl2z,$ \,$ modular_symbol_rep,$ \,$ parent,$ \,$ tuple,$ \,$ weight

apply( self, a, b, c, d)

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

Input:

a, b, c, d
- integers

Output: a list of pairs (alpha_i, x_i), where each alpha_i is an integer, x_i is a Manin symbol, and the sum alpha_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 [P(aX+bY,cX+dY),(u,v)*g].

endpoints( self, [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\}$ .

lift_to_sl2z( self, N)

If this Manin symbol is (c,d) viewed modulo N, this function computes and 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).

modular_symbol_rep( self)

Returns a representation of self as a formal sum of modular symbols. (The result is not cached.)

Special Functions: __cmp__,$ \,$ __init__,$ \,$ __mul__,$ \,$ _latex_,$ \,$ _ManinSymbol__get_i,$ \,$ _ManinSymbol__get_u,$ \,$ _ManinSymbol__get_v,$ \,$ _repr_

Class: ManinSymbolList

class ManinSymbolList
All Manin symbols for a given group, weight, and character.
ManinSymbolList( self, weight, list)

Functions: apply,$ \,$ apply_I,$ \,$ apply_S,$ \,$ apply_T,$ \,$ apply_TT,$ \,$ index,$ \,$ manin_symbol,$ \,$ manin_symbol_list,$ \,$ normalize,$ \,$ weight

index( self, x)

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

Input:

x
- 3-tuple of ints. Something equivalent to an element of Manin symbols list, which need not be normalized.
Output:
int
- the index of the Manin symbol equivalent to (i,u,v).

Special Functions: __cmp__,$ \,$ __getitem__,$ \,$ __init__,$ \,$ __len__

Class: ManinSymbolList_character

class ManinSymbolList_character
List of Manin Symbols with character.

ManinSymbolList_character(character, weight): Input:

character
- a dirichlet character
weight
- integer weight >= 2

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)]
ManinSymbolList_character( self, character, weight)

Functions: apply,$ \,$ apply_I,$ \,$ apply_S,$ \,$ apply_T,$ \,$ apply_TT,$ \,$ character,$ \,$ index,$ \,$ level,$ \,$ normalize

apply( self, j, m)

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

j
- integer m = [a, b, c, d] a list of 4 integers.
Output: a list of pairs (j, alpha_i), where each alpha_i is an integer, j is an integer (the j-th Manin symbol), and the sum alpha_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 [P(aX+bY,cX+dY),(u,v)*g].

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)]

index( self, x)

Compute the index into 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, then this function returns -1, 0.

Input:

x
- 3-tuple of ints. Something equivalent to an element of Manin symbols list, which need not be normalized.
Output:
int
- the index of the Manin symbol equivalent to (i,u,v).
scalar
- element of the base field or the int 0.

Special Functions: __init__,$ \,$ __repr__

Class: ManinSymbolList_gamma0

class ManinSymbolList_gamma0

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
ManinSymbolList_gamma0( self, level, weight)

Special Functions: __init__,$ \,$ __repr__

Class: ManinSymbolList_gamma1

class ManinSymbolList_gamma1
ManinSymbolList_gamma1( self, level, weight)

Special Functions: __init__,$ \,$ __repr__

Class: ManinSymbolList_gamma_h

class ManinSymbolList_gamma_h
ManinSymbolList_gamma_h( self, group, weight)

Special Functions: __init__,$ \,$ __repr__

Class: ManinSymbolList_group

class ManinSymbolList_group
Base class for Manin symbol lists for a given group.

ManinSymbolList_group(level, weight, syms):

Input:

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

ManinSymbolList_group( self, level, weight, syms)

Functions: apply,$ \,$ apply_I,$ \,$ apply_S,$ \,$ apply_T,$ \,$ apply_TT,$ \,$ level,$ \,$ normalize

apply( self, j, m)

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

Input:

j
- integer m = [a, b, c, d] a list of 4 integers, which defines a 2x2 matrix.

Output:
list
- a list of pairs (j_i, alpha_i), where each alpha_i is a nonzero integer, j_i is an integer (the j_i-th Manin symbol), and the sum 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].

Special Functions: __init__

Class: x__ManinSymbolList_gamma1

class x__ManinSymbolList_gamma1
List of Manin symbols for Gamma0(N).

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
x__ManinSymbolList_gamma1( self, level, weight)

Functions: apply,$ \,$ apply_I,$ \,$ apply_J,$ \,$ apply_S,$ \,$ apply_T,$ \,$ apply_TT,$ \,$ level,$ \,$ normalize

apply( self, j, m)

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

j
- integer m = [a, b, c, d] a list of 4 integers.
Output: a list of pairs (j, alpha_i), where each alpha_i is an integer, j is an integer (the j-th Manin symbol), and the sum alpha_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 [P(aX+bY,cX+dY),(u,v)*g].

apply_J( self, j)

Apply 2x2 matrix J = [-1,0,0,-1].

Special Functions: __init__,$ \,$ __repr__

See About this document... for information on suggesting changes.