Up One Level SAGE Reference Manual Contents Module Index Index
Previous: Up: 39. Modular Forms: General Next:

39.6 Hecke modules

Module: sage.modular.hecke.module

Hecke modules

Module-level Functions

dict_set( v, n, key, val)

is_HeckeModule( x)

Class: HeckeModule_free_module

class HeckeModule_free_module
A Hecke module modeled on a free module over a ring.
HeckeModule_free_module( self, base_ring, level, weight)

Functions: ambient,$ $ ambient_module,$ $ atkin_lehner_operator,$ $ basis,$ $ decomposition,$ $ degree,$ $ dual_eigenvector,$ $ dual_hecke_matrix,$ $ eigenvalue,$ $ factor_number,$ $ gen,$ $ hecke_matrix,$ $ hecke_operator,$ $ hecke_polynomial,$ $ is_simple,$ $ is_splittable,$ $ is_splittable_anemic,$ $ is_submodule,$ $ ngens,$ $ projection,$ $ system_of_eigenvalues,$ $ T,$ $ weight,$ $ zero_submodule

atkin_lehner_operator( self, [d=None])
Return the Atkin-Lehner operator $ W_d$ on this space, if defined, where $ d$ is a divisor of the level $ N$ such that $ N/d$ and $ d$ are coprime. 

sage: M = ModularSymbols(11)
sage: w = M.atkin_lehner_operator()
sage: w
Hecke module morphism Atkin-Lehner operator W_11 defined by the matrix
[-1  0  0]
[ 0 -1  0]
[ 0  0 -1]
Domain: Modular Symbols space of dimension 3 for Gamma_0(11) of weight ...
Codomain: Modular Symbols space of dimension 3 for Gamma_0(11) of weight
...
sage: M = ModularSymbols(Gamma1(13))
sage: w = M.atkin_lehner_operator()
sage: w.fcp('x')
(x - 1)^7 * (x + 1)^8


sage: M = ModularSymbols(33)
sage: S = M.cuspidal_submodule()
sage: S.atkin_lehner_operator()
Hecke module morphism Atkin-Lehner operator W_33 defined by the matrix
(not printing 6 x 6 matrix)
Domain: Modular Symbols subspace of dimension 6 of Modular Symbols space
...
Codomain: Modular Symbols subspace of dimension 6 of Modular Symbols space
...


sage: S.atkin_lehner_operator(3)
Hecke module morphism Atkin-Lehner operator W_3 defined by the matrix
(not printing 6 x 6 matrix)
Domain: Modular Symbols subspace of dimension 6 of Modular Symbols space
...
Codomain: Modular Symbols subspace of dimension 6 of Modular Symbols space
...


sage: N = M.new_submodule()
sage: N.atkin_lehner_operator()
Hecke module morphism Atkin-Lehner operator W_33 defined by the matrix
[  1 2/5 4/5]
[  0  -1   0]
[  0   0  -1]
Domain: Modular Symbols subspace of dimension 3 of Modular Symbols space
...
Codomain: Modular Symbols subspace of dimension 3 of Modular Symbols space
...

basis( self)
Returns a basis for self. 

sage: m = ModularSymbols(43)
sage: m.basis()
((1,0), (1,31), (1,32), (1,38), (1,39), (1,40), (1,41))

decomposition( self, [bound=None], [anemic=True], [compute_dual=False], [height_guess=1], [proof=None])
Returns the maximal decomposition of this Hecke module under the action of Hecke operators of index coprime to the level. This is the finest decomposition of self that we can obtain using factors obtained by taking kernels of Hecke operators.

Each factor in the decomposition is a Hecke submodule obtained as the kernel of $ f(T_n)^r$ acting on self, where n is coprime to the level and $ r=1$. If anemic if False, instead choose $ r$ so that $ f(X)^r$ exactly divides the characteristic polynomial. 

INPUT:
    anemic -- bool (default: True),  if True, use only Hecke operators
              of index coprime to the level.  
              
    compute_dual -- bool (default: False) also compute dual subspaces
               along the way.  These are useful for many algorithms.
               This is only allowed for ambient Hecke modules.

    bound -- int or None, (default: None).  If None, use all Hecke
operators
             up to the Sturm bound, and hence obtain the same result as
             one would obtain by using every element of the Hecke ring.
             If a fixed integer, decompose using only Hecke operators
             T_p, with p prime, up to bound.

OUTPUT:
    list -- a list of subspaces of self.

dual_eigenvector( self, [name=alpha])
Return an eigenvector for the Hecke operators acting on the linear dual of this space. This eigenvector will have entries in an extension of the base ring of degree equal to the dimension of this space. 

INPUT:
    The input space must be simple.
    name -- print name of generator for eigenvalue field. 
    
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( self, n)
The matrix of the $ n$-th Hecke operator acting on the dual embedded representation of self.

eigenvalue( self, n, [name=alpha])
Assuming that self is a simple space, return the eigenvalue of the $ n$th Hecke operator on self. 

INPUT:
    n -- index of Hecke operator
    name -- print representation of generator of eigenvalue field


sage: A = ModularSymbols(125,sign=1).new_subspace()[0]
sage: A.eigenvalue(7)
-3
sage: A.eigenvalue(3)
-alpha - 2
sage: A.eigenvalue(3,'w')
-w - 2
sage: A.eigenvalue(3,'z').charpoly('x')
x^2 + 3*x + 1
sage: A.hecke_polynomial(3)
x^2 + 3*x + 1

NOTES: (1) In fact there are $ d$ systems of eigenvalues associated to self, where $ d$ is the rank of self. Each of the systems of eigenvalues is conjugate over the base field. This function chooses one of the systems and consistently returns eigenvalues from that system. Thus these are the coefficients $ a_n$ for $ n \geq 1$ of a modular eigenform attached to self.

(2) This function works even for Eisenstein subspaces, though it will not give the constant coefficient of one of the corresponding Eisenstein series (i.e., the generalized Bernoulli number).

factor_number( self)
If this Hecke module was computed via a decomposition of another Hecke module, this is the corresponding number. Otherwise return -1.

hecke_matrix( self, n)
The matrix of the $ n$-th Hecke operator acting on given basis.

hecke_operator( self, 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.

hecke_polynomial( self, n, [var=x])
Return the characteristic polynomial of the n-th Hecke operator acting on this space. 

INPUT:
    n -- integer
OUTPUT:
    a polynomial

is_splittable( self)
Returns True if and only if only it is possible to split off a nontrivial generalized eigenspace of self as the kernel of some Hecke operator.

is_splittable_anemic( self)
Returns true if and only if only it is possible to split off a nontrivial generalized eigenspace of self as the kernel of some Hecke operator of index coprime to the level.

projection( self)
Return the projection map from the ambient space to self.

ALGORITHM: Let $ B$ be the matrix whose columns are obtained by concatenating together a basis for the factors of the ambient space. Then the projection matrix onto self is the submatrix of $ B^{-1}$ obtained 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}$. 

sage: e = EllipticCurve('34a')
sage: m = ModularSymbols(34); s = m.cuspidal_submodule()
sage: d = s.decomposition(7)
sage: d
[
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 9 for Gamma_0(34) of weight 2 with sign 0 over Rational Field,
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 9 for Gamma_0(34) of weight 2 with sign 0 over Rational Field
]
sage: a = d[0]; a
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 9 for Gamma_0(34) of weight 2 with sign 0 over Rational Field
sage: pi = a.projection()
sage: pi(m([0,oo]))
-1/6*(2,7) + 1/6*(2,13) - 1/6*(2,31) + 1/6*(2,33)
sage: M = ModularSymbols(53,sign=1)
sage: S = M.cuspidal_subspace()[1] ; S
Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 5 for Gamma_0(53) of weight 2 with sign 1 over Rational Field
sage: p = S.projection()
sage: S.basis()
((1,33) - (1,37), (1,35), (1,49))
sage: [ p(x) for x in S.basis() ]
[(1,33) - (1,37), (1,35), (1,49)]

system_of_eigenvalues( self, n, [name=alpha])
Assuming that self is a simple space of modular symbols, return the eigenvalues $ [a_1, \ldots, a_nmax]$ of the Hecke operators on self. See self.eigenvalue(n) for more details. 

INPUT:
     n -- number of eigenvalues
     alpha -- name of generate for eigenvalue field

We compute eigenvalues for newforms of level 62. 

sage: M = ModularSymbols(62,2,sign=-1)
sage: S = M.cuspidal_submodule().new_submodule()
sage: [A.system_of_eigenvalues(3) for A in S.decomposition()]  # random output

[[1, 1, 0], [1, -1, -alpha - 1]]

Next we define a function that does the above: 

sage: def b(N,k=2):
...    t=cputime()
...    S = ModularSymbols(N,k,sign=-1).cuspidal_submodule().new_submodule()
...    for A in S.decomposition():
...        print N, A.system_of_eigenvalues(5)


sage: b(63)
63 [1, 1, 0, -1, 2]
63 [1, alpha, 0, 1, -2*alpha]

This example illustrates finding field over which the eigenvalues are defined: 

sage: M = ModularSymbols(23,2,sign=1).cuspidal_submodule().new_submodule()
sage: v = M.system_of_eigenvalues(10); v
[1, alpha, -2*alpha - 1, -alpha - 1, 2*alpha, alpha - 2, 2*alpha + 2,
-2*alpha - 1, 2, -2*alpha + 2]
sage: v[0].parent()
Univariate Quotient Polynomial Ring in alpha over Rational Field with
modulus x^2 + x - 1

This example illustrates setting the print name of the eigenvalue field. 

sage: A = ModularSymbols(125,sign=1).new_subspace()[0]
sage: A.system_of_eigenvalues(10)
[1, alpha, -alpha - 2, -alpha - 1, 0, -alpha - 1, -3, -2*alpha - 1, 3*alpha
+ 2, 0]
sage: A.system_of_eigenvalues(10,'x')
[1, x, -x - 2, -x - 1, 0, -x - 1, -3, -2*x - 1, 3*x + 2, 0]

T( self, n)
Returns the $ n$-th Hecke operator $ T_n$. This function is a synonym for hecke_operator.

weight( self)
Returns the weight of this Hecke module. 

INPUT:
   self -- an arbitrary Hecke module
   
OUTPUT:
   int -- the weight


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

zero_submodule( self)
Return the zero submodule of self. 

sage: ModularSymbols(11,4).zero_submodule()
Modular Symbols subspace of dimension 0 of Modular Symbols space of
dimension 6 for Gamma_0(11) of weight 4 with sign 0 over Rational Field
sage: CuspForms(11,4).zero_submodule()
Modular Forms subspace of dimension 0 of Modular Forms space of dimension 4
for Congruence Subgroup Gamma0(11) of weight 4 over Rational Field

Special Functions: __cmp__,$ $ __contains__,$ $ __getitem__,$ $ __len__,$ $ _eigen_nonzero,$ $ _eigen_nonzero_element,$ $ _element_eigenvalue,$ $ _hecke_image_of_ith_basis_vector,$ $ _is_hecke_equivariant_free_module,$ $ _set_factor_number

_eigen_nonzero_element( self, [n=1])
Return $ T_n(x)$ where $ x$ is a sparse modular symbol such that the image of $ x$ is nonzero under the dual projection map associated to this space, and $ T_n$ is the $ n$-th Hecke operator.

_hecke_image_of_ith_basis_vector( self, n, i)
Return $ T_n(e_i)$, where $ e_i$ is the $ i$th basis vector of the ambient space.

_is_hecke_equivariant_free_module( self, submodule)
Returns True if the given free submodule of the ambient free module is invariant under all Hecke operators. 

sage: M = ModularSymbols(11); V = M.free_module()
sage: M._is_hecke_equivariant_free_module(V.span([V.0]))
False
sage: M._is_hecke_equivariant_free_module(V)
True
sage: M._is_hecke_equivariant_free_module(M.cuspidal_submodule().free_module())
True

We do the same as above, but with a modular forms space: 

sage: M = ModularForms(11); V = M.free_module()
sage: M._is_hecke_equivariant_free_module(V.span([V.0 + V.1]))
False
sage: M._is_hecke_equivariant_free_module(V)
True
sage: M._is_hecke_equivariant_free_module(M.cuspidal_submodule().free_module())
True

Class: HeckeModule_generic

class HeckeModule_generic
A very general Hecke module.

All Hecke module classes derive from this class--spaces of modular symbols (free modules), modular forms (finite-rank free modules), modular abelian varieties (infinitely divisible groups), torsion submodules of abelian varieties (finite groups), etc.

HeckeModule_generic( self, base_ring, level)

Functions: anemic_hecke_algebra,$ $ basis_matrix,$ $ category,$ $ character,$ $ dimension,$ $ hecke_algebra,$ $ is_full_hecke_module,$ $ is_hecke_invariant,$ $ is_zero,$ $ level,$ $ submodule

anemic_hecke_algebra( self)
Return the Hecke algebra associated to this Hecke module. 

sage: T = ModularSymbols(1,12).hecke_algebra()
sage: A = ModularSymbols(1,12).anemic_hecke_algebra()
sage: T == A
False
sage: A
Anemic Hecke algebra acting on Modular Symbols space of dimension 3 for
Gamma_0(1) of weight 12 with sign 0 over Rational Field


sage: A.is_anemic()
True

hecke_algebra( self)
Return the Hecke algebra associated to this Hecke module. 

sage: T = ModularSymbols(Gamma1(5),3).hecke_algebra()
sage: T
Full Hecke algebra acting on Modular Symbols space of dimension 4 for
Gamma_1(5) of weight 3 with sign 0 and over Rational Field
sage: T.is_anemic()
False


sage: M = ModularSymbols(37,sign=1)
sage: E, A, B = M.decomposition()
sage: A.hecke_algebra() == B.hecke_algebra()
False

is_full_hecke_module( self)
Return True if this space is invariant under all Hecke operators.

Since self is guaranteed to be an anemic Hecke module, the significance of this function is that it also ensures invariance under Hecke operators of index that divide the level.

is_hecke_invariant( self, n)
Return True if self is invariant under the Hecke operator $ T_n$.

Since self is guaranteed to be an anemic Hecke module it is only interesting to call this function when $ n$ is not coprime to the level. 

sage: M = ModularSymbols(22).cuspidal_subspace()
sage: M.is_hecke_invariant(2)
True

We use check=False to create a nasty ``module'' that is not invariant under $ T_2$: 

sage: S = M.submodule(M.free_module().span([M.0.list()]), check=False); S
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field
sage: S.is_hecke_invariant(2)
False
sage: [n for n in range(1,12) if S.is_hecke_invariant(n)]
[1, 3, 5, 7, 9, 11]

is_zero( self)
Return True if this Hecke module has dimension 0. 

sage: ModularSymbols(11).is_zero()
False
sage: ModularSymbols(11).old_submodule().is_zero()
True
sage: CuspForms(10).is_zero()
True
sage: CuspForms(1,12).is_zero()
False

level( self)
Returns the level of this modular symbols space. 

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


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

Special Functions: __cmp__,$ $ _compute_dual_hecke_matrix,$ $ _compute_hecke_matrix,$ $ _compute_hecke_matrix_general_product,$ $ _compute_hecke_matrix_prime,$ $ _compute_hecke_matrix_prime_power

_compute_hecke_matrix_prime( self, p)
Compute and return the matrix of the p-th Hecke operator.

Up One Level SAGE Reference Manual Contents Module Index Index
Previous: Up: 39. Modular Forms: General Next:
Release 2007.10.28, documentation updated on October 28, 2007.
See About this document... for information on suggesting changes.