8.3.1.1 ModularSymbolsSpace Objects

class ModularSymbolsSpace
ModularSymbolsSpace( group, weight, character, sign, base_field)

Instances of class ModularSymbolsSpace have the following functions (in addition to inherited functions and special functions):

ambient_space,$  $ base_field,$  $ base_ring,$  $ basis,$  $ character,$  $ complement,$  $ degree,$  $ dimension,$  $ dual_eigenvector,$  $ dual_hecke_matrix,$  $ dual_star_involution_matrix,$  $ eigenvalue,$  $ embedded_dual_vector_space,$  $ embedded_vector_space,$  $ factorization,$  $ gen,$  $ group,$  $ hecke_algebra,$  $ hecke_matrix,$  $ hecke_operator,$  $ hecke_polynomial,$  $ is_ambient,$  $ is_anemic_hecke_module,$  $ is_cuspidal,$  $ is_full_hecke_module,$  $ is_new,$  $ is_simple,$  $ level,$  $ minus_subspace,$  $ ngens,$  $ plus_subspace,$  $ projection,$  $ q_expansion,$  $ q_expansion_basis,$  $ sign,$  $ sign_subspace,$  $ star_decomposition,$  $ star_eigenvalue,$  $ star_involution,$  $ sturm_bound,$  $ T,$  $ vector_space,$  $ weight,$  $ zero_subspace

Further documentation:

basis( )

Returns a basis for self.

complement( )

Return the largest Hecke-stable subspace C of the ambient space that contains no simple factor isomorphic to a subspace of self. In many cases, C is a complement to self, in the sense that the direct sum of C and self is the ambient space.

dual_eigenvector( )

Return an eigenvector for the Hecke operators acting on this space via their transposes. This eigenvector will have entries in an extension of the base ring of degree equal to the dimension of this space.

INPUT:
    The input modular symbols space must Hecke equivariant
    and simple.
    
OUTPUT:
    A vector with entries possibly in an extension of the base
    ring.  This vector is an eigenvector for all Hecke
operators
    acting via their transpose.

NOTES: (1) The answer is cached so subsequent calls always return the same vector. However, the algorithm is randomized, so calls during another session may yield a different eigenvector. This function is used mainly for computing systems of Hecke eigenvalues.

(2) One can also view a dual eigenvector as defining (via dot product) a functional phi from the ambient space of modular symbols to a field. This functional phi is an eigenvector for the dual action of Hecke operators on functionals.

dual_hecke_matrix( n)

The matrix of the n-th Hecke operator acting on the embedded_dual_vector_space of self.

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.

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.

ASSUMPTION: self is a module over the anemic Hecke algebra.

gen( n)

The n-th generator of self.

INPUT:
    n -- int, an integer between 0 to the dimension minus 1.
    
OUTPUT:
    -- The n-th basis element (ModularSymbol)

group( )

Returns the group of this modular symbols space.

INPUT:
   ModularSymbols self -- an arbitrary space of modular symbols
   
OUTPUT:
   CongruenceSubgroup -- the congruence subgroup that this is a
space
                      of modular symbols for.

ALGORITHM: The group is recorded when this space is created.

sage: m = ModularSymbols(20)
sage: m.group()
Gamma_0(20)

hecke_matrix( n)

The matrix of the n-th Hecke operator acting on the basis for self.

hecke_operator( n)

Returns the n-th Hecke operator T_n.

INPUT:
   ModularSymbols self -- Hecke equivariant space of
                          modular symbols
   int n -- an integer at least 1.

OUTPUT:
   function.MatrixFunction -- the matrix function that
            represents the n-th Hecke operator on the chosen
            basis for self.

hecke_polynomial( n)

Return the characteristic polynomial of the n-th Hecke operator acting on this space.

INPUT:
    n -- integer
OUTPUT:
    a polynomial

level( )

Returns the level of this modular symbols space.

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

ALGORITHM: The level is recorded when self is created.

sage: m = ModularSymbols(20)
sage: m.level()
20

minus_subspace( [compute_dual=True])

Return the subspace of self on which the star involution acts as -1.

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

ngens( )

The number of generators of self.

INPUT:
   ModularSymbols self -- arbitrary space of modular symbols.
OUTPUT:
   int -- the number of generators, which is the same as the
          dimension of self.
ALGORITHM:
   Call the dimension function.

sage: m = modsym.ModularSymbols(33)
sage: m.ngens()
9
sage: m.dimension()
9
sage: modsym.ModularSymbols(100, weight=2, sign=1).ngens()
18

plus_subspace( [compute_dual=True])

Return the subspace of self on which the star involution acts as +1.

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

projection( )

Return the projection map from the ambient space to self.

OUTPUT: MatrixFunction - The output is a matrix function, which defines projection from the ambient space to self.

ALGORITHM: Let $ B$ be the matrix whose columns are got by concatenating together a basis for the factors of the ambient space. Then the projection matrix onto self is the submatrix of $ B^{-1}$ got from the rows corresponding to self, i.e., if the basis vectors for self appear as columns $ n$ through $ m$ of $ B$ , then the projection matrix is got from rows $ n$ through $ m$ of $ B^{-1}$ . This is because projection with respect to the B basis is just given by an $ m-n+1$ row slice $ P$ of a diagonal matrix D with 1's in the $ n$ through $ m$ positions, so projection with respect to the standard basis is given by $ P\cdot
B^{-1}$ , which is just rows $ n$ through $ m$ of $ B^{-1}$ .

q_expansion( prec)

Returns the q-expansion to precision prec of a newform associated to self, where self must be new, cuspidal, and simple.

q_expansion_basis( prec)

Returns a basis of q-expansions (as power series) to precision prec of the space of modular forms associated to self. The q-expansions are defined over the same base ring as prec.

sign( )

Returns the sign of self.

For efficiency reasons, it is often useful to compute in the (largest) quotient of modular symbols where the * involution acts as +1, or where it acts as -1.

INPUT:
   ModularSymbols self -- arbitrary space of modular symbols.
   
OUTPUT:
   int -- the sign of self, either -1, 0, or 1.
          -1 -- largest quotient where * acts as -1,
          +1 -- largest quotient where * acts as +1, 
           0 -- full space of modular symbols (no quotient).

ALGORITHM: Call the dimension function.

sage: m = ModularSymbols(33)
sage: m.dimension()
6
sage: m.sign()
1
sage: m = ModularSymbols(33, sign=0)
sage: m.sign()
0
sage: m.dimension()
9
sage: m = ModularSymbols(33, sign=-1)
sage: m.sign()
-1
sage: m.dimension()
3

sign_subspace( sign, [compute_dual=True])

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

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

star_decomposition( )

star_eigenvalue( )

If the star involution acts as either the matrix +1 or -1 on self, this function returns +1 or -1, respectively. Otherwise it returns 0.

sage: M = ModularSymbols(11)
sage: D = M.decomposition()
sage: M.star_eigenvalue()
0
sage: D[0].star_eigenvalue()
1
sage: D[1].star_eigenvalue()
0
sage: D[1].plus_subspace().star_eigenvalue()
1
sage: D[1].minus_subspace().star_eigenvalue()
-1

star_involution( )

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

sturm_bound( )

Returns the Sturm bound for this space of modular symbols.

Returns a positive integer $ n$ such that the Hecke operators $ T_1,\ldots, T_n$ acting on cusp forms generate the Hecke algebra as a $ \mathbf{Z}$ -module when the character is trivial or quadratic. Otherwise, $ T_1,\ldots, T_n$ generate the Hecke algebra at least as a $ \mathbf{Z}[\varepsilon ]$ -module, where $ \mathbf{Z}[\varepsilon ]$ is the ring generated by the values of the Dirichlet character $ \varepsilon $ . Alternatively, this is a bound such that if two cusp forms associated to this space of modular symbols are congruent modulo $ (\lambda, q^n)$ , then they are congruent modulo $ \lambda$ .

REFERENCES: See the Agashe-Stein appendix to Lario and Schoof's Some computations with Hecke rings and deformation rings, Experimental Math., 11 (2002), no. 2, 303-311. This result originated in the paper Sturm, On the congruence of modular forms, Springer LNM 1240, 275-280, 1987.

REMARK:

Kevin Buzzard pointed out to me (William Stein) in Fall 2002 that the above bound is fine for $ \Gamma_1(N)$ with character, as one sees by taking a power of $ f$ . More precisely, if $ f\equiv 0\pmod{p}$ for first $ s$ coefficients, then $ f^r \equiv 0
\pmod{p}$ for first $ s r$ coefficents. Since the weight of $ f^r$ is $ r\cdot k(f)$ , it follows that if $ s \geq b$ , where $ b$ is the Sturm bound for $ \Gamma_0(N)$ at weight $ k(f)$ , then $ f^r$ has valuation large enough to be forced to be 0 at $ r*k(f)$ by Sturm bound (which is valid if we choose $ r$ correctly). Thus $ f\equiv 0\pmod{p}$ . Conclusion: For $ \Gamma_1(N)$ with fixed character, the Sturm bound is exactly the same as for $ \Gamma_0(N)$ .

A key point is that we are finding $ \mathbf{Z}[\varepsilon ]$ generators for the Hecke algebra here, not $ \mathbf{Z}$ -generators. So if one wants generators for the Hecke algebra over $ \mathbf{Z}$ , this bound must be suitably modified.

T( n)

Returns the $ n$ -th Hecke operator $ T_n$ . This function is a synonym for hecke_operator.

vector_space( )

Returns the underlying vector space of self. NOTES: This is always an ambient vector space over the base ring of dimension equal to the dimension of self. For the embedded subspace of the ambient space's vector space, use the embedded_subspace function.

INPUT:
   ModularSymbols self -- arbitrary space of modular symbols.
OUTPUT:
   VectorSpace
ALGORITHM:
   Create and return the ambient vector space over the base
   field of dimension equal to the dimension of self.

sage: import modsym
sage: m = modsym.ModularSymbols(23)
sage: m.vector_space()
Full Vector space of degree 5 over Rational Field

sage: a = m[0]
sgae.: a.vector_space()
Full Vector space of degree 1 over Rational Field

weight( )

Returns the weight of this modular symbols space.

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

ALGORITHM: The weight is recorded when self is created.

sage: m = ModularSymbols(20, weight=2)
sage: m.weight()
2

zero_subspace( )

Returns the zero subspace of this space of modular symbols.

Instances of class ModularSymbolsSpace also have the following special functions:

__cmp__,$  $ __contains__

Further documentation:

__cmp__( other)

Compare self and other.

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