27.3 Ambient spaces of modular symbols.

Module: sage.modular.modsym.ambient

Class: ModularSymbolsAmbient

class ModularSymbolsAmbient
An ambient space of modular symbols for a congruence subgroup of SL_2(Z).

This class is an abstract base class, so only derived classes should be instantiated. INPUT: weight - an integer >= 2 group - a congruence subgroup. sign - an integer, either -1, 0, or 1 base_ring - a commutative ring

ModularSymbolsAmbient( self, group, weight, sign, base_ring, [character=None])

Initialize a space of modular symbols.

Functions: boundary_map,$  $ boundary_space,$  $ compute_presentation,$  $ cuspidal_submodule,$  $ dual_star_involution_matrix,$  $ eisenstein_submodule,$  $ element,$  $ factorization,$  $ hecke_bound,$  $ integral_structure,$  $ is_cuspidal,$  $ is_eisenstein,$  $ manin_basis,$  $ manin_generators,$  $ manin_gens_to_basis,$  $ manin_symbol,$  $ manin_symbols,$  $ manin_symbols_basis,$  $ modular_symbol,$  $ modular_symbols_of_sign,$  $ modular_symbols_of_weight,$  $ p1list,$  $ rank,$  $ relation_matrix,$  $ star_involution,$  $ submodule

boundary_map( self)

The boundary map to the corresponding space of boundary modular symbols.

cuspidal_submodule( self)

The cuspidal submodule.

dual_star_involution_matrix( self)

Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.

eisenstein_submodule( self)

Return the Eisenstein submodule of this space of modular symbols.

element( self, x)

Creates and returns an element of self from a modular symbol, if possible.

INPUT:
   x -- an object of one of the following types:
        ModularSymbol, ManinSymbol.

OUTPUT:

ModularSymbol - a modular symbol with parent self.

factorization( self)

Returns a list of pairs $ (S,e)$ where $ S$ is simple spaces of modular symbols and self is isomorphic to the direct sum of the $ S^e$ as a module over the anemic Hecke algebra adjoin the star involution.

integral_structure( self)

Return the $ \mathbf{Z}$ -structure of this modular symbols spaces generated by all integral modular symbols.

ALGORITHM: It suffices to consider lattice generated by the free generating symbols $ X^iY^{k-2-i}.(u,v)$ after quotienting out by the $ S$ (and $ I$ ) relations, since the quotient by these relations is the same over any ring.

In weight 2 the rational basis is often integral.

sage: M = ModularSymbols(11,2)
sage: M.integral_structure()
Free module of degree 3 and rank 3 over Integer Ring
Echelon basis matrix:
[1 0 0]
[0 1 0]
[0 0 1]

This is rarely the case in higher weight:

sage: M = ModularSymbols(6,4)
sage: M.integral_structure()
Free module of degree 6 and rank 6 over Integer Ring
Echelon basis matrix:
[  1   0   0   0   0   0]
[  0   1   0   0   0   0]
[  0   0 1/2 1/2 1/2 1/2]
[  0   0   0   1   0   0]
[  0   0   0   0   1   0]
[  0   0   0   0   0   1]

Here is an example involving $ \Gamma_1(N)$ .

sage: M = ModularSymbols(Gamma1(5),6)
sage: M.integral_structure()
Free module of degree 10 and rank 10 over Integer Ring
Echelon basis matrix:
[     1      0      0      0      0      0      0      0      0      0]
[     0      1      0      0      0      0      0      0      0      0]
[     0      0  1/102      0  5/204  1/136  23/24   3/17 43/136 69/136]
[     0      0      0   1/48      0   1/48  23/24    1/6    1/8  17/24]
[     0      0      0      0   1/24      0  23/24    1/3    1/6    1/2]
[     0      0      0      0      0   1/24  23/24    1/3  11/24   5/24]
[     0      0      0      0      0      0      1      0      0      0]
[     0      0      0      0      0      0      0    1/2      0    1/2]
[     0      0      0      0      0      0      0      0    1/2    1/2]
[     0      0      0      0      0      0      0      0      0      1]

manin_basis( self)

Return a list of indices into the list of Manin generators (see self.manin_generators()) such that those symbols form a basis for the quotient of the $ \mathbf{Q}$ -vector space spanned by Manin symbols modulo the relations.

sage: M = ModularSymbols(2,2)
sage: M.manin_basis()
[1]
sage: [M.manin_generators()[i] for i in M.manin_basis()]
[(1,0)]
sage: M = ModularSymbols(6,2)
sage: M.manin_basis()
[1, 10, 11]
sage: [M.manin_generators()[i] for i in M.manin_basis()]
[(1,0), (3,1), (3,2)]

manin_generators( self)

Return list of all Manin symbols for this space. These are the generators in the presentation of this space by Manin symbols.

sage: M = ModularSymbols(2,2)
sage: M.manin_generators()
[(0,1), (1,0), (1,1)]

sage: M = ModularSymbols(1,6)
sage: M.manin_generators()
[[Y^4,(0,0)], [X*Y^3,(0,0)], [X^2*Y^2,(0,0)], [X^3*Y,(0,0)], [X^4,(0,0)]]

manin_symbols_basis( self)

A list of Manin symbols that form a basis for the ambient space self.

INPUT:
   ModularSymbols self -- an ambient space of modular symbols
OUTPUT:
   list -- a list of 2-tuples (if the weight is 2) or 3-tuples, 
           which represent the Manin symbols basis for self.

sage: m = ModularSymbols(23)
sage: m.manin_symbols_basis()
[(1,0), (1,17), (1,19), (1,20), (1,21)]
sage: m = ModularSymbols(6, weight=4, sign=-1)
sage: m.manin_symbols_basis()
[[X^2,(2,1)]]

modular_symbol( self, x, [check=True])

Create a modular symbol in this space.

INPUT:
    x -- a list of either 2 or 3 entries
    2 entries:   [alpha, beta] -- creates the modular
                 symbol {alpha, beta}, or, if the weight
                 is > 2 the symbol Y^(k-2-i){alpha,beta}.
    3 entries:   [i, alpha, beta] -- create the modular
                 symbol X^i*Y^(k-2-i){alpha,beta}.

sage: set_modsym_print_mode('modular')
sage: M = ModularSymbols(11)
sage: M.modular_symbol([2/11, oo])
-{-1/9,0}
sage: M.1
{-1/8,0}
sage: M.modular_symbol([-1/8, 0])
{-1/8,0}
sage: M.modular_symbol([0, -1/8, 0])
{-1/8,0}
sage: M.modular_symbol([10, -1/8, 0])
Traceback (most recent call last):
...
ValueError: The first entry of the tuple (=[10, -1/8, 0]) must be an
integer between 0 and k-2 (=0).

Use check=False for efficiency if the input x is a list of length 3 whose first entry is an Integer, and whose second and third entries are cusps:

sage: M.modular_symbol([0, Cusp(2/11), Cusp(oo)], check=False)
-{-1/9,0}

sage: set_modsym_print_mode()   # return to default.

modular_symbols_of_sign( self, sign)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with given sign.

sage: M = ModularSymbols(Gamma0(11),2,sign=0)
sage: M
Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign
0 over Rational Field
sage: M.modular_symbols_of_sign(-1)
Modular Symbols space of dimension 1 for Gamma_0(11) of weight 2 with sign
-1 over Rational Field
sage: M = ModularSymbols(Gamma1(11),2,sign=0)
sage: M.modular_symbols_of_sign(-1)
Modular Symbols space of dimension 1 for Gamma_1(11) of weight 2 with sign
-1 and over Rational Field

modular_symbols_of_weight( self, k)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight k.

sage: M = ModularSymbols(Gamma1(6),2,sign=0)
sage: M.modular_symbols_of_weight(3)
Modular Symbols space of dimension 4 for Gamma_1(6) of weight 3 with sign 0
and over Rational Field

rank( self)

Returns the rank of self.

INPUT:
   ModularSymbols self -- arbitrary space of modular symbols
   
OUTPUT:
   int -- the rank

sage: M = ModularSymbols(389)
sage: M.rank()
65

sage: ModularSymbols(11,sign=0).rank()
3
sage: ModularSymbols(100,sign=0).rank()
31
sage: ModularSymbols(22,sign=1).rank()
5
sage: ModularSymbols(1,12).rank()
3
sage: ModularSymbols(3,4).rank()
2
sage: ModularSymbols(8,6,sign=-1).rank()
3

star_involution( self)

Return the star involution on self, which is induced by complex conjugation on modular symbols.

Special Functions: __call__,$  $ __cmp__,$  $ _action_on_modular_symbols,$  $ _compute_atkin_lehner_matrix,$  $ _compute_dual_hecke_matrix,$  $ _compute_hecke_matrix_prime,$  $ _compute_sign_submodule,$  $ _degeneracy_lowering_matrix,$  $ _degeneracy_raising_matrix,$  $ _latex_,$  $ _matrix_of_operator_on_modular_symbols,$  $ _modular_symbol_0_to_alpha,$  $ _ModularSymbolsAmbient__heilbronn_operator,$  $ _repr_

__call__( self, x, [computed_with_hecke=False])

Coerce x into this modular symbols space (self). The result is either an element of self or a subspace of self.

The allowed inputs for x are as follows:

_action_on_modular_symbols( self, g)

Compute the matrix of the action of the 2x2 integer matrix g=[a,b,c,d] (which must be specified as an integer list) on self with respect to the standard basis.

Use _matrix_of_operator_on_modular_symbols for more general operators.

_compute_hecke_matrix_prime( self, p)

Compute and return the matrix of the p-th Hecke operator.

We first compute some examples for Gamma0(N):

sage: m = ModularSymbols(2, weight=4)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^2 - 9*x + 8

sage: m = ModularSymbols(1,weight=12)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^3 - 2001*x^2 - 97776*x - 1180224
sage: m._compute_hecke_matrix_prime(13).charpoly()
x^3 - 1792159238562*x^2 - 2070797989680255444*x - 598189440899986203208472

sage: m = ModularSymbols(1,weight=12, sign=-1)
sage: m._compute_hecke_matrix_prime(5)
[4830]
sage: m._compute_hecke_matrix_prime(23)
[18643272]

sage: m = ModularSymbols(3,4)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^2 - 18*x + 81

sage: m = ModularSymbols(6,4)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^6 - 14*x^5 + 29*x^4 + 172*x^3 - 124*x^2 - 320*x + 256
sage: m._compute_hecke_matrix_prime(3).charpoly()
x^6 - 50*x^5 + 511*x^4 + 3012*x^3 - 801*x^2 - 9234*x + 6561

sage: m = ModularSymbols(15,4, sign=-1)
sage: m._compute_hecke_matrix_prime(3).charpoly()
x^4 - 2*x^3 + 18*x^2 + 18*x - 243

sage: m = ModularSymbols(6,4)
sage: m._compute_hecke_matrix_prime(7).charpoly()
x^6 - 1344*x^5 + 666240*x^4 - 140462080*x^3 + 8974602240*x^2 +
406424518656*x + 3584872677376

sage: m = ModularSymbols(4,4)
sage: m._compute_hecke_matrix_prime(3).charpoly()
x^3 - 84*x^2 + 2352*x - 21952

We now compute some examples for modular symbols on Gamma1(N):

sage: m = ModularSymbols(Gamma1(13),2, sign=-1)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^2 + 3*x + 3

The following is an example with odd weight:

sage: m = ModularSymbols(Gamma1(5),3)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^4 - 10*x^3 + 50*x^2 - 170*x + 289

This example has composite conductor and weight>2 dividing the conductor and nontrivial sign:

sage: m = ModularSymbols(Gamma1(9),3, sign=1)
sage: m._compute_hecke_matrix_prime(3).charpoly()
x^6 + 3*x^4 - 19*x^3 + 24*x^2 - 9*x

_compute_sign_submodule( self, sign, [compute_dual=True])

Return the subspace of self that is fixed under the star involution.

INPUT:
    sign -- int (either -1 or +1)
    compute_dual -- bool (default: True) also compute dual subspace.
                    This are useful for many algorithms.
OUTPUT:
    subspace of modular symbols

_matrix_of_operator_on_modular_symbols( self, codomain, R)

INPUT:
    self -- this space of modular symbols
    codomain -- space of modular symbols
    R -- list of lists [a,b,c,d] of length 4, which we view as elements of
GL_2(Q).
    
OUTPUT:
    a matrix, which represents the operator
    $$
       x \mapsto \sum_{g in R} g.x
    $$
    where g.x is the formal linear fractional transformation on modular
symbols.

_ModularSymbolsAmbient__heilbronn_operator( self, M, H, [t=1])

Returns the matrix function from self to M defined by the pair (H, t), where H is a list of matrices and t is an integer.

INPUT:
   self -- ModularSymbols , domain (an ambient space of modular symbols),
                           
   M -- ModularSymbols, codomain (a space of modular symbols),

   H -- list, a list of matrices in M_2(Z),
   
   t  -- int, an integer.
   
OUTPUT:
   free module morphism -- A function from self to M defined
                           by t and the matrices in H.

Class: ModularSymbolsAmbient_wt2_g0_Q

class ModularSymbolsAmbient_wt2_g0_Q
Modular symbols for Gamma_0(N) of integer weight 2 over the field Q.
ModularSymbolsAmbient_wt2_g0_Q( self, N, [sign=0])

Initialize a space of modular symbols.

INPUT:
    N -- int, the level
    sign -- int, either -1, 0, or 1
OUTPUT:
    The space of modular symbols of weight 2, trivial character,
    level N and given sign.

sage: M = ModularSymbols(Gamma0(12),2)

Functions: boundary_space

Special Functions: _compute_hecke_matrix_prime,$  $ _cuspidal_new_submodule_dimension_formula,$  $ _cuspidal_submodule_dimension_formula,$  $ _dimension_formula

_compute_hecke_matrix_prime( self, p)

Compute and return the matrix of the p-th Hecke operator.

sage: m = ModularSymbols(37,2)
sage: m._compute_hecke_matrix_prime(2).charpoly()
x^5 + x^4 - 8*x^3 - 12*x^2

Class: ModularSymbolsAmbient_wtk_eps

class ModularSymbolsAmbient_wtk_eps
ModularSymbolsAmbient_wtk_eps( self, eps, weight, [sign=0])

Space of modular symbols with given weight, character, and sign.

INPUT:
    eps -- dirichlet.DirichletCharacter, the "Nebentypus" character.
    weight -- int, the weight >= 2
    sign -- int, either -1, 0, or 1

sage: eps = DirichletGroup(4).gen(0)
sage: eps.order()
2
sage: ModularSymbols(eps, 2)
Modular Symbols space of dimension 0 and level 4, weight 2, character [-1],
sign 0, over Rational Field
sage: ModularSymbols(eps, 3)
Modular Symbols space of dimension 2 and level 4, weight 3, character [-1],
sign 0, over Rational Field

We next create a space with character of order bigger than 2.

sage: eps = DirichletGroup(5).gen(0)
sage: eps     # has order 4
[zeta4]
sage: ModularSymbols(eps, 2).dimension()
0
sage: ModularSymbols(eps, 3).dimension()
2

Here is another example:

sage: G, e = DirichletGroup(5).objgen()
sage: M = ModularSymbols(e,3)
sage: loads(M.dumps()) == M
True

Functions: boundary_space,$  $ manin_symbols,$  $ modular_symbols_of_level,$  $ modular_symbols_of_sign,$  $ modular_symbols_of_weight

modular_symbols_of_level( self, N)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.

For example, if self is the space of modular symbols of weight 2 for Gamma_0(22), and level is 11, then this function returns modular symbols of weight 2 for Gamma_0(11).

modular_symbols_of_sign( self, sign)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with given sign.

modular_symbols_of_weight( self, k)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight k.

Special Functions: _cuspidal_new_submodule_dimension_formula,$  $ _cuspidal_submodule_dimension_formula,$  $ _degeneracy_raising_matrix,$  $ _dimension_formula,$  $ _matrix_of_operator_on_modular_symbols,$  $ _repr_

_matrix_of_operator_on_modular_symbols( self, codomain, R, [character_twist=False])

INPUT:
    self -- this space of modular symbols
    codomain -- space of modular symbols
    R -- list of lists [a,b,c,d] of length 4, which we view as elements of
GL_2(Q).
    
OUTPUT:
    a matrix, which represents the operator
    $$
       x \mapsto \sum_{g in R} g.x
    $$
    where g.x is the formal linear fractional transformation on modular
symbols.

Class: ModularSymbolsAmbient_wtk_g0_Q

class ModularSymbolsAmbient_wtk_g0_Q
Modular symbols for $ \Gamma_0(N)$ of integer weight $ k > 2$ over the field $ \mathbf{Q}$ .
ModularSymbolsAmbient_wtk_g0_Q( self, N, k, [sign=0])

Initialize a space of modular symbols of weight $ k$ for $ \Gamma_0(N)$ , over $ \mathbf{Q}$ .

For weight $ 2$ , it is faster to use ModularSymbols_wt2_g0_Q.

INPUT:
    N -- int, the level
    k -- integer weight >= 2.
    sign -- int, either -1, 0, or 1

sage: ModularSymbols(1,12)
Modular Symbols space of dimension 3 for Gamma_0(1) of weight 12 with sign
0 over Rational Field
sage: ModularSymbols(1,12, sign=1).dimension()
2
sage: ModularSymbols(15,4, sign=-1).dimension()
4
sage: ModularSymbols(6,6).dimension()
10
sage: ModularSymbols(36,4).dimension()
36

Functions: boundary_space,$  $ manin_symbols,$  $ modular_symbols_of_level

modular_symbols_of_level( self, N)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.

For example, if self is the space of modular symbols of weight 2 for Gamma_0(22), and level is 11, then this function returns modular symbols of weight 2 for Gamma_0(11).

sage: M = ModularSymbols(11)
sage: M.modular_symbols_of_level(22)
Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign
0 over Rational Field
sage: M = ModularSymbols(Gamma1(6))
sage: M.modular_symbols_of_level(12)
Modular Symbols space of dimension 9 for Gamma_1(12) of weight 2 with sign
0 and over Rational Field

Special Functions: _cuspidal_new_submodule_dimension_formula,$  $ _cuspidal_submodule_dimension_formula,$  $ _degeneracy_raising_matrix,$  $ _dimension_formula,$  $ _repr_

Class: ModularSymbolsAmbient_wtk_g1_Q

class ModularSymbolsAmbient_wtk_g1_Q
ModularSymbolsAmbient_wtk_g1_Q( self, level, weight, [sign=0])

Initialize a space of modular symbols for Gamma1(N).

INPUT:
    level -- int, the level
    weight -- int, the weight >= 2
    sign -- int, either -1, 0, or 1

sage: ModularSymbols(Gamma1(17),2)
Modular Symbols space of dimension 25 for Gamma_1(17) of weight 2 with sign
0 and over Rational Field
sage: [ModularSymbols(Gamma1(7),k).dimension() for k in [2,3,4,5]]
[5, 8, 12, 16]

sage: M = ModularSymbols(Gamma1(7),3)

Functions: boundary_space,$  $ manin_symbols,$  $ modular_symbols_of_level

modular_symbols_of_level( self, N)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.

Special Functions: _compute_hecke_matrix_prime_power,$  $ _cuspidal_new_submodule_dimension_formula,$  $ _cuspidal_submodule_dimension_formula,$  $ _degeneracy_raising_matrix,$  $ _dimension_formula,$  $ _repr_

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