27.6 Manin symbols

Module: sage.modular.modsym.manin_symbols

Module-level Functions

_print_polypart( i, j)

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,$  $ i,$  $ lift_to_sl2z,$  $ modular_symbol_rep,$  $ parent,$  $ tuple,$  $ u,$  $ v,$  $ 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__,$  $ __mul__,$  $ __repr__,$  $ _ManinSymbol__get_i,$  $ _ManinSymbol__get_u,$  $ _ManinSymbol__get_v

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: __getitem__,$  $ __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: __repr__

Class: ManinSymbolList_gamma0

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

ManinSymbolList_gamma0(level, weight): INPUT: level - integer level weight - integer weight >= 2

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)

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: __repr__

Class: ManinSymbolList_gamma1

class 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
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: __repr__

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