12.2.2.1 ModularSymbolsAmbient Objects

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( group, weight, sign, base_ring, [character=None])

Initialize a space of modular symbols.

Instances of class ModularSymbolsAmbient have the following methods (in addition to inherited methods and special methods):

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

Further documentation:

boundary_map( )

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

cuspidal_submodule( )

The cuspidal submodule.

dual_star_involution_matrix( )

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

eisenstein_submodule( )

Return the Eisenstein submodule of this space of modular symbols.

element( 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( )

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.

manin_symbols_basis( )

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_symbols_of_sign( 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
Full Modular Symbols space for Gamma_0(11) of weight 2 with sign 0 and
dimension 3 over Rational Field
sage: M.modular_symbols_of_sign(-1)
Full Modular Symbols space for Gamma_0(11) of weight 2 with sign -1 and
dimension 1 over Rational Field
sage: M = ModularSymbols(Gamma1(11),2,sign=0)
sage: M.modular_symbols_of_sign(-1)
Full Modular Symbols space for Gamma_1(11) of weight 2 with sign -1 and
dimension 1 over Rational Field

modular_symbols_of_weight( 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)
Full Modular Symbols space for Gamma_1(6) of weight 3 with sign 0 and
dimension 4 over Rational Field

rank( )

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

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

Instances of class ModularSymbolsAmbient also have the following special methods:

__call__,$  $ __repr__,$  $ _action_on_modular_symbols,$  $ _compute_atkin_lehner_matrix,$  $ _compute_dual_hecke_matrix,$  $ _compute_hecke_matrix_prime,$  $ _compute_sign_subspace,$  $ _degeneracy_lowering_matrix,$  $ _degeneracy_raising_matrix,$  $ _latex_,$  $ _matrix_of_operator_on_modular_symbols,$  $ _ModularSymbolsAmbient__heilbronn_operator

Further documentation:

__call__( 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( 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( 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: from sage.modular.congroup import Gamma1
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_subspace( 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( 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( 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.

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