41.2 Space of modular symbols (base class)

Module: sage.modular.modsym.space

Space of modular symbols (base class)

All the spaces of modular symbols derive from this class. This class is an abstract base class.

Module-level Functions

is_ModularSymbolsSpace( x)

Class: IntegralPeriodMapping

class IntegralPeriodMapping

Special Functions: _repr_

_repr_( self)

Return the string representation of self.

sage: ModularSymbols(40,2).cuspidal_submodule().integral_period_mapping()._repr_()
'Integral period mapping associated to Modular Symbols subspace of
dimension 6 of Modular Symbols space of dimension 13 for Gamma_0(40) of
weight 2 with sign 0 over Rational Field'

Class: ModularSymbolsSpace

class ModularSymbolsSpace
ModularSymbolsSpace( self, group, weight, character, sign, base_ring)

Create a space of modular symbols.

sage: M = ModularSymbols(22,6) ; M
Modular Symbols space of dimension 30 for Gamma_0(22) of weight 6 with sign
0 over Rational Field
sage: M == loads(dumps(M))
True

Functions: abelian_variety,$ \,$ character,$ \,$ congruence_number,$ \,$ cuspidal_submodule,$ \,$ cuspidal_subspace,$ \,$ default_prec,$ \,$ dimension_of_associated_cuspform_space,$ \,$ dual_star_involution_matrix,$ \,$ eisenstein_subspace,$ \,$ factorization,$ \,$ group,$ \,$ hecke_module_of_level,$ \,$ integral_basis,$ \,$ integral_hecke_matrix,$ \,$ integral_period_mapping,$ \,$ integral_structure,$ \,$ intersection_number,$ \,$ is_ambient,$ \,$ is_cuspidal,$ \,$ is_simple,$ \,$ minus_submodule,$ \,$ modular_symbols_of_sign,$ \,$ multiplicity,$ \,$ new_subspace,$ \,$ ngens,$ \,$ old_subspace,$ \,$ plus_submodule,$ \,$ q_eigenform,$ \,$ q_expansion_basis,$ \,$ q_expansion_cuspforms,$ \,$ q_expansion_module,$ \,$ rational_period_mapping,$ \,$ set_default_prec,$ \,$ set_precision,$ \,$ sign,$ \,$ sign_submodule,$ \,$ simple_factors,$ \,$ star_decomposition,$ \,$ star_eigenvalues,$ \,$ star_involution,$ \,$ sturm_bound

abelian_variety( self)

Return the corresponding abelian variety.

Input:

self
- modular symbols space of weight 2 for a congruence subgroup such as Gamma0, Gamma1 or GammaH.

sage: ModularSymbols(Gamma0(11)).cuspidal_submodule().abelian_variety()
Abelian variety J0(11) of dimension 1
sage: ModularSymbols(Gamma1(11)).cuspidal_submodule().abelian_variety()
Abelian variety J1(11) of dimension 1
sage: ModularSymbols(GammaH(11,[3])).cuspidal_submodule().abelian_variety()
Abelian variety JH(11,[3]) of dimension 1

The abelian variety command only works on cuspidal modular symbols spaces:

sage: M = ModularSymbols(37)
sage: M[0].abelian_variety()
Traceback (most recent call last):
...
ValueError: self must be cuspidal
sage: M[1].abelian_variety()
Abelian subvariety of dimension 1 of J0(37)
sage: M[2].abelian_variety()
Abelian subvariety of dimension 1 of J0(37)

character( self)

Return the character associated to self.

sage: ModularSymbols(12,8).character()
[1, 1]
sage: ModularSymbols(DirichletGroup(25).0, 4).character()
[zeta20]

congruence_number( self, other, [prec=None])

Given two cuspidal spaces of modular symbols, compute the congruence number, using prec terms of the $ q$ -expansions.

The congruence number is defined as follows. If $ V$ is the submodule of integral cusp forms corresponding to self (satured in $ \mathbf{Z}[[q]]$ , by definition) and $ W$ is the submodule corresponding to other, each computed to precision prec, the congruence number is the index of $ V+W$ in its saturation in $ \mathbf{Z}[[q]]$ .

If prec is not given it is set equal to the max of the hecke_bound function called on each space.

cuspidal_submodule( self)

Return the cuspidal submodule of self.

NOTE: This should be overridden by all derived classes.

sage: sage.modular.modsym.space.ModularSymbolsSpace(Gamma0(11),2,DirichletGroup(11).gens()[0]**10,0,QQ).cuspidal_submodule()
Traceback (most recent call last):
...
NotImplementedError: computation of cuspidal submodule not yet implemented
for this class
sage: ModularSymbols(Gamma0(11),2).cuspidal_submodule()
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field

cuspidal_subspace( self)

Synonym for cuspidal_submodule.

sage: m = ModularSymbols(Gamma1(3),12); m.dimension()
8
sage: m.cuspidal_subspace().new_subspace().dimension()
2

default_prec( self)

Get the default precision for computation of $ q$ -expansion associated to the ambient space of this space of modular symbols (and all subspaces). Use set_default_prec to change the default precision.

sage: M = ModularSymbols(15)
sage: M.cuspidal_submodule().q_expansion_basis()
[
q - q^2 - q^3 - q^4 + q^5 + q^6 + O(q^8)
]
sage: M.set_default_prec(20)

Notice that setting the default precision of the ambient space affects the subspaces.

sage: M.cuspidal_submodule().q_expansion_basis()
[
q - q^2 - q^3 - q^4 + q^5 + q^6 + 3*q^8 + q^9 - q^10 - 4*q^11 + q^12 -
2*q^13 - q^15 - q^16 + 2*q^17 - q^18 + 4*q^19 + O(q^20)
]
sage: M.cuspidal_submodule().default_prec()
20

dimension_of_associated_cuspform_space( self)

Return the dimension of the corresponding space of cusp forms.

The input space must be cuspidal, otherwise there is no corresponding space of cusp forms.

sage: m = ModularSymbols(Gamma0(389),2).cuspidal_subspace(); m.dimension()
64
sage: m.dimension_of_associated_cuspform_space()
32
sage: m = ModularSymbols(Gamma0(389),2,sign=1).cuspidal_subspace(); m.dimension()
32
sage: m.dimension_of_associated_cuspform_space()
32

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.

NOTE: This should be overridden in all derived classes.

sage: sage.modular.modsym.space.ModularSymbolsSpace(Gamma0(11),2,DirichletGroup(11).gens()[0]**10,0,QQ).dual_star_involution_matrix()
Traceback (most recent call last):
...
NotImplementedError: computation of dual star involution matrix not yet
implemented for this class
sage: ModularSymbols(Gamma0(11),2).dual_star_involution_matrix()
[ 1  0  0]
[ 0 -1  0]
[ 0  1  1]

eisenstein_subspace( self)

Synonym for eisenstein_submodule.

sage: m = ModularSymbols(Gamma1(3),12); m.dimension()
8
sage: m.eisenstein_subspace().dimension()
2
sage: m.cuspidal_subspace().dimension()
6

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.

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

group( self)

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()
Congruence Subgroup Gamma0(20)

hecke_module_of_level( self, level)

See the documentation for self.modular_symbols_of_level(level).

integral_basis( self)

Return a basis for the $ \mathbf{Z}$ -submodule of this modular symbols space spanned by the generators.

Modular symbols spaces for congruence subgroups have a $ \mathbf{Z}$ -structure. Computing this $ \mathbf{Z}$ -structure is expensive, so by default modular symbols spaces for congruence subgroups in Sage are defined over $ \mathbf{Q}$ . This function returns a tuple of independent elements in this modular symbols space whose $ \mathbf{Z}$ -span is the corresponding space of modular symbols over $ \mathbf{Z}$ .

sage: M = ModularSymbols(11)
sage: M.basis()
((1,0), (1,8), (1,9))
sage: M.integral_basis()
((1,0), (1,8), (1,9))
sage: S = M.cuspidal_submodule()
sage: S.basis()
((1,8), (1,9))
sage: S.integral_basis()
((1,8), (1,9))

sage: M = ModularSymbols(13,4)
sage: M.basis()
([X^2,(0,1)], [X^2,(1,4)], [X^2,(1,5)], [X^2,(1,7)], [X^2,(1,9)],
[X^2,(1,10)], [X^2,(1,11)], [X^2,(1,12)])
sage: M.integral_basis()
([X^2,(0,1)], 1/28*[X^2,(1,4)] + 2/7*[X^2,(1,5)] + 3/28*[X^2,(1,7)] +
11/14*[X^2,(1,9)] + 2/7*[X^2,(1,10)] + 11/28*[X^2,(1,11)] +
3/28*[X^2,(1,12)], [X^2,(1,5)], 1/2*[X^2,(1,7)] + 1/2*[X^2,(1,9)],
[X^2,(1,9)], [X^2,(1,10)], [X^2,(1,11)], [X^2,(1,12)])
sage: S = M.cuspidal_submodule()
sage: S.basis()
([X^2,(1,4)] - [X^2,(1,12)], [X^2,(1,5)] - [X^2,(1,12)], [X^2,(1,7)] -
[X^2,(1,12)], [X^2,(1,9)] - [X^2,(1,12)], [X^2,(1,10)] - [X^2,(1,12)],
[X^2,(1,11)] - [X^2,(1,12)])
sage: S.integral_basis()
(1/28*[X^2,(1,4)] + 2/7*[X^2,(1,5)] + 3/28*[X^2,(1,7)] + 11/14*[X^2,(1,9)]
+ 2/7*[X^2,(1,10)] + 11/28*[X^2,(1,11)] - 53/28*[X^2,(1,12)], [X^2,(1,5)] -
[X^2,(1,12)], 1/2*[X^2,(1,7)] + 1/2*[X^2,(1,9)] - [X^2,(1,12)], [X^2,(1,9)]
- [X^2,(1,12)], [X^2,(1,10)] - [X^2,(1,12)], [X^2,(1,11)] - [X^2,(1,12)])

This function currently raises a NotImplementedError on modular symbols spaces with character of order bigger than $ 2$ :

sage: M = ModularSymbols(DirichletGroup(13).0^2, 2); M
Modular Symbols space of dimension 4 and level 13, weight 2, character
[zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2
sage: M.basis()
((1,0), (1,5), (1,10), (1,11))
sage: M.integral_basis()
Traceback (most recent call last):
...
NotImplementedError

integral_hecke_matrix( self, n)

Return the matrix of the $ n$ th Hecke operator acting on the integral structure on self (as returned by self.integral_structure().

integral_period_mapping( self)

Return the integral period mapping associated to self.

This is a homomorphism to a vector space whose kernel is the same as the kernel of the period mapping associated to self, normalized so the image of integral modular symbols is exactly $ \mathbf{Z}^n$ .

sage: m = ModularSymbols(23).cuspidal_submodule()
sage: i = m.integral_period_mapping()
sage: i
Integral period mapping associated to Modular Symbols subspace of dimension
4 of Modular Symbols space of dimension 5 for Gamma_0(23) of weight 2 with
sign 0 over Rational Field
sage: i.matrix()
[-1/11  1/11     0  3/11]
[    1     0     0     0]
[    0     1     0     0]
[    0     0     1     0]
[    0     0     0     1]
sage: [i(b) for b in m.integral_structure().basis()]
[(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]
sage: [i(b) for b in m.ambient_module().basis()]
[(-1/11, 1/11, 0, 3/11),
 (1, 0, 0, 0),
 (0, 1, 0, 0),
 (0, 0, 1, 0),
 (0, 0, 0, 1)]

We compute the image of the winding element:

sage: m = ModularSymbols(37,sign=1)
sage: a = m[1]
sage: f = a.integral_period_mapping()
sage: e = m([0,oo])
sage: f(e)
(-2/3)

The input space must be cuspidal:

sage: m = ModularSymbols(37,2,sign=1)
sage: m.integral_period_mapping()
Traceback (most recent call last):
...
ValueError: integral mapping only defined for cuspidal spaces

integral_structure( self)

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

sage: M = ModularSymbols(11,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/14   1/7  5/14   1/2 13/14]
[    0     0   1/2     0     0   1/2]
[    0     0     0     1     0     0]
[    0     0     0     0     1     0]
[    0     0     0     0     0     1]
sage: M.cuspidal_submodule().integral_structure()
Free module of degree 6 and rank 4 over Integer Ring
Echelon basis matrix:
[     0   1/14    1/7   5/14    1/2 -15/14]
[     0      0    1/2      0      0   -1/2]
[     0      0      0      1      0     -1]
[     0      0      0      0      1     -1]

intersection_number( self, M)

Given modular symbols spaces self and M in some common ambient space, returns the intersection number of these two spaces. This is the index in their saturation of the sum of their underlying integral structures.

If self and M are of weight two and defined over QQ, and correspond to newforms f and g, then this number equals the order of the intersection of the modular abelian varieties attached to f and g.

sage: m = ModularSymbols(389,2)
sage: d = m.decomposition(2)
sage: eis = d[0]
sage: ell = d[1]
sage: af = d[-1]
sage: af.intersection_number(eis)
97
sage: af.intersection_number(ell)
400

is_ambient( self)

Return True if self is an ambient space of modular symbols.

sage: ModularSymbols(21,4).is_ambient()
True
sage: ModularSymbols(21,4).cuspidal_submodule().is_ambient()
False

is_cuspidal( self)

Return True if self is a cuspidal space of modular symbols.

NOTE: This should be overridden in all derived classes.

sage: sage.modular.modsym.space.ModularSymbolsSpace(Gamma0(11),2,DirichletGroup(11).gens()[0]**10,0,QQ).is_cuspidal()
Traceback (most recent call last):
...
NotImplementedError: computation of cuspidal subspace not yet implemented
for this class
sage: ModularSymbols(Gamma0(11),2).is_cuspidal()
False

is_simple( self)

Return whether not this modular symbols space is simple as a module over the anemic Hecke algebra adjoin *.

sage: m = ModularSymbols(Gamma0(33),2,sign=1)
sage: m.is_simple()
False
sage: o = m.old_subspace()
sage: o.decomposition()
[
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 6 for Gamma_0(33) of weight 2 with sign 1 over Rational Field,
Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 6 for Gamma_0(33) of weight 2 with sign 1 over Rational Field
]
sage: C=ModularSymbols(1,14,0,GF(5)).cuspidal_submodule()
sage: C
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 for Gamma_0(1) of weight 14 with sign 0 over Finite Field of
size 5
sage: C.is_simple()
True

minus_submodule( self, [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

sage: ModularSymbols(14,4)
Modular Symbols space of dimension 12 for Gamma_0(14) of weight 4 with sign
0 over Rational Field
sage: ModularSymbols(14,4).minus_submodule()
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 12 for Gamma_0(14) of weight 4 with sign 0 over Rational Field

modular_symbols_of_sign( self, sign, [bound=None])

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

Input:

self
- a cuspidal space of modular symbols
sign
- an integer, one of -1, 0, or 1
bound
- integer (default: None); if specified only use Hecke operators up to the given bound.

sage: S = ModularSymbols(Gamma0(11),2,sign=0).cuspidal_subspace()
sage: S
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field
sage: S.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: S = ModularSymbols(43,2,sign=1)[2]; S
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field
sage: S.modular_symbols_of_sign(-1)
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 3 for Gamma_0(43) of weight 2 with sign -1 over Rational Field

sage: S.modular_symbols_of_sign(0)
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 7 for Gamma_0(43) of weight 2 with sign 0 over Rational Field

sage: S = ModularSymbols(389,sign=1)[3]; S
Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 33 for Gamma_0(389) of weight 2 with sign 1 over Rational Field
sage: S.modular_symbols_of_sign(-1)
Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 32 for Gamma_0(389) of weight 2 with sign -1 over Rational Field
sage: S.modular_symbols_of_sign(0)
Modular Symbols subspace of dimension 6 of Modular Symbols space of
dimension 65 for Gamma_0(389) of weight 2 with sign 0 over Rational Field

sage: S = ModularSymbols(23,sign=1,weight=4)[2]; S
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 7 for Gamma_0(23) of weight 4 with sign 1 over Rational Field
sage: S.modular_symbols_of_sign(1) is S
True
sage: S.modular_symbols_of_sign(0)
Modular Symbols subspace of dimension 8 of Modular Symbols space of
dimension 12 for Gamma_0(23) of weight 4 with sign 0 over Rational Field
sage: S.modular_symbols_of_sign(-1)
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 5 for Gamma_0(23) of weight 4 with sign -1 over Rational Field

multiplicity( self, S, [check_simple=True])

Return the multiplicity of the simple modular symbols space S in self. S must be a simple anemic Hecke module.

ASSUMPTION: self is an anemic Hecke module with the same weight and group as S, and S is simple.

sage: M = ModularSymbols(11,2,sign=1)
sage: N1, N2 = M.decomposition()
sage: N1.multiplicity(N2)
0
sage: M.multiplicity(N1)
1
sage: M.multiplicity(ModularSymbols(14,2))
0

new_subspace( self, [p=None])

Synonym for new_submodule.

sage: m = ModularSymbols(Gamma0(5),12); m.dimension()
12
sage: m.new_subspace().dimension()
6
sage: m = ModularSymbols(Gamma1(3),12); m.dimension()
8
sage: m.new_subspace().dimension()
2

ngens( self)

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 = ModularSymbols(33)
sage: m.ngens()
9
sage: m.rank()
9
sage: ModularSymbols(100, weight=2, sign=1).ngens()
18

old_subspace( self, [p=None])

Synonym for old_submodule.

sage: m = ModularSymbols(Gamma1(3),12); m.dimension()
8
sage: m.old_subspace().dimension()
6

plus_submodule( self, [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

sage: ModularSymbols(17,2)
Modular Symbols space of dimension 3 for Gamma_0(17) of weight 2 with sign
0 over Rational Field
sage: ModularSymbols(17,2).plus_submodule()
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 3 for Gamma_0(17) of weight 2 with sign 0 over Rational Field

q_eigenform( self, prec, [names=None])

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

q_expansion_basis( self, [prec=None], [algorithm=default])

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 self, and a put in echelon form.

Input:

self
- a space of CUSPIDAL modular symbols
prec
- an integer
algorithm
- string:
'default' (default)
- decide which algorithm to use based on heuristics
'hecke'
- compute basis by computing homomorphisms T -> K, where T is the Hecke algebra
'eigen'
- compute basis using eigenvectors for the Hecke action and Atkin-Lehner-Li theory to patch them together
'all'
- compute using hecke_dual and eigen algorithms and verify that the results are the same.

The computed basis is not cached, though of course Hecke operators used in computing the basis are cached.

sage: M = ModularSymbols(1, 12).cuspidal_submodule()
sage: M.q_expansion_basis(8)
[
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + O(q^8)
]

sage: M.q_expansion_basis(8, algorithm='eigen')
[
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + O(q^8)
]

sage: M = ModularSymbols(1, 24).cuspidal_submodule()
sage: M.q_expansion_basis(8, algorithm='eigen')
[
q + 195660*q^3 + 12080128*q^4 + 44656110*q^5 - 982499328*q^6 -
147247240*q^7 + O(q^8),
q^2 - 48*q^3 + 1080*q^4 - 15040*q^5 + 143820*q^6 - 985824*q^7 + O(q^8)
]

sage: M = ModularSymbols(11, 2, sign=-1).cuspidal_submodule()
sage: M.q_expansion_basis(8, algorithm='eigen')
[
q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 + O(q^8)
]

sage: M = ModularSymbols(Gamma1(13), 2, sign=1).cuspidal_submodule()
sage: M.q_expansion_basis(8, algorithm='eigen')
[
q - 4*q^3 - q^4 + 3*q^5 + 6*q^6 + O(q^8),
q^2 - 2*q^3 - q^4 + 2*q^5 + 2*q^6 + O(q^8)
]

sage: M = ModularSymbols(Gamma1(5), 3, sign=-1).cuspidal_submodule()
sage: M.q_expansion_basis(8, algorithm='eigen')   # dimension is 0
[]

sage: M = ModularSymbols(Gamma1(7), 3, sign=-1).cuspidal_submodule()
sage: M.q_expansion_basis(8)
[
q - 3*q^2 + 5*q^4 - 7*q^7 + O(q^8)
]

sage: M = ModularSymbols(43, 2, sign=0).cuspidal_submodule()
sage: M[0]
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 7 for Gamma_0(43) of weight 2 with sign 0 over Rational Field
sage: M[0].q_expansion_basis()
[
q - 2*q^2 - 2*q^3 + 2*q^4 - 4*q^5 + 4*q^6 + O(q^8)
]
sage: M[1]
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 7 for Gamma_0(43) of weight 2 with sign 0 over Rational Field
sage: M[1].q_expansion_basis()
[
q + 2*q^5 - 2*q^6 - 2*q^7 + O(q^8),
q^2 - q^3 - q^5 + q^7 + O(q^8)
]

q_expansion_cuspforms( self, [prec=None])

Returns a function f(i,j) such that each value f(i,j) is the q-expansion, to the given precision, of an element of the corresponding space $ S$ of cusp forms. Together these functions span $ S$ . Here $ i,j$ are integers with $ 0\leq i,j < d$ , where $ d$ is the dimension of self.

For a reduced echelon basis, use the function q_expansion_basis instead.

More precisely, this function returns the $ q$ -expansions obtained by taking the $ ij$ entry of the matrices of the Hecke operators $ T_n$ acting on the subspace of the linear dual of modular symbols corresponding to self.

sage: S = ModularSymbols(11,2, sign=1).cuspidal_submodule()
sage: f = S.q_expansion_cuspforms(8)
sage: f(0,0)
q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 + O(q^8)

sage: S = ModularSymbols(37,2).cuspidal_submodule()
sage: f = S.q_expansion_cuspforms(8)
sage: f(0,0)
q + q^3 - 2*q^4 - q^7 + O(q^8)
sage: f(3,3)
q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + 6*q^6 - q^7 + O(q^8)
sage: f(1,2)
q^2 + 2*q^3 - 2*q^4 + q^5 - 3*q^6 + O(q^8)

sage: S = ModularSymbols(Gamma1(13),2,sign=-1).cuspidal_submodule()
sage: f = S.q_expansion_cuspforms(8)
sage: f(0,0)
q - 2*q^2 + q^4 - q^5 + 2*q^6 + O(q^8)
sage: f(0,1)
q^2 - 2*q^3 - q^4 + 2*q^5 + 2*q^6 + O(q^8)

sage: S = ModularSymbols(1,12,sign=-1).cuspidal_submodule()
sage: f = S.q_expansion_cuspforms(8)
sage: f(0,0)
q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + O(q^8)

q_expansion_module( self, [prec=None], [R=None])

Return a basis over R for the space spanned by the coefficient vectors of the $ q$ -expansions corresponding to self. If R is not the base ring of self, returns the restriction of scalars down to R (for this, self must have base ring $ \mathbf{Q}$ or a number field).

Input:

self
- must be cuspidal
prec
- an integer (default: self.default_prec())
R
- either ZZ, QQ, or the base_ring of self (which is the default)

Output: A free module over R.

TODO - extend to more general R (though that is fairly easy for the user to get by just doing base_extend or change_ring on the output of this function).

Note that the prec needed to distinguish elements of the restricted-down-to-R basis may be bigger than self.hecke_bound(), since one must use the Sturm bound for modular forms on $ \Gamma_H(N)$ .

Input:

prec
- integer

Output: A QQ-vector space

EXAMPLES WITH SIGN 1 and R=QQ:

Basic example with sign 1:

sage: M = ModularSymbols(11, sign=1).cuspidal_submodule()
sage: M.q_expansion_module(5, QQ)
Vector space of degree 5 and dimension 1 over Rational Field
Basis matrix:
[ 0  1 -2 -1  2]

Same example with sign -1:

sage: M = ModularSymbols(11, sign=-1).cuspidal_submodule()
sage: M.q_expansion_module(5, QQ)
Vector space of degree 5 and dimension 1 over Rational Field
Basis matrix:
[ 0  1 -2 -1  2]

An example involving old forms:

sage: M = ModularSymbols(22, sign=1).cuspidal_submodule()
sage: M.q_expansion_module(5, QQ)
Vector space of degree 5 and dimension 2 over Rational Field
Basis matrix:
[ 0  1  0 -1 -2]
[ 0  0  1  0 -2]

An example that (somewhat spuriously) is over a number field:

sage: x = polygen(QQ)
sage: k = NumberField(x^2+1, 'a')
sage: M = ModularSymbols(11, base_ring=k, sign=1).cuspidal_submodule()
sage: M.q_expansion_module(5, QQ)
Vector space of degree 5 and dimension 1 over Rational Field
Basis matrix:
[ 0  1 -2 -1  2]

An example that involves an eigenform with coefficients in a number field:

sage: M = ModularSymbols(23, sign=1).cuspidal_submodule()
sage: M.q_eigenform(4, 'gamma')
q + gamma*q^2 + (-2*gamma - 1)*q^3 + O(q^4)            
sage: M.q_expansion_module(11, QQ)
Vector space of degree 11 and dimension 2 over Rational Field
Basis matrix:
[ 0  1  0 -1 -1  0 -2  2 -1  2  2]
[ 0  0  1 -2 -1  2  1  2 -2  0 -2]

An example that is genuinely over a base field besides QQ.

sage: eps = DirichletGroup(11).0
sage: M = ModularSymbols(eps,3,sign=1).cuspidal_submodule(); M
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 and level 11, weight 3, character [zeta10], sign 1, over
Cyclotomic Field of order 10 and degree 4
sage: M.q_eigenform(4, 'beta')
q + (-zeta10^3 + 2*zeta10^2 - 2*zeta10)*q^2 + (2*zeta10^3 - 3*zeta10^2 +
3*zeta10 - 2)*q^3 + O(q^4)
sage: M.q_expansion_module(7, QQ)
Vector space of degree 7 and dimension 4 over Rational Field
Basis matrix:
[  0   1   0   0   0 -40  64]
[  0   0   1   0   0 -24  41]
[  0   0   0   1   0 -12  21]
[  0   0   0   0   1  -4   4]

An example involving an eigenform rational over the base, but the base is not QQ.

sage: k.<a> = NumberField(x^2-5)
sage: M = ModularSymbols(23, base_ring=k, sign=1).cuspidal_submodule()
sage: D = M.decomposition(); D
[
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(23) of weight 2 with sign 1 over Number Field in a
with defining polynomial x^2 - 5,
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(23) of weight 2 with sign 1 over Number Field in a
with defining polynomial x^2 - 5
]
sage: M.q_expansion_module(8, QQ)
Vector space of degree 8 and dimension 2 over Rational Field
Basis matrix:
[ 0  1  0 -1 -1  0 -2  2]
[ 0  0  1 -2 -1  2  1  2]

An example involving an eigenform not rational over the base and for which the base is not QQ.

sage: eps = DirichletGroup(25).0^2
sage: M = ModularSymbols(eps,2,sign=1).cuspidal_submodule(); M
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 4 and level 25, weight 2, character [zeta10], sign 1, over
Cyclotomic Field of order 10 and degree 4
sage: D = M.decomposition(); D
[
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 4 and level 25, weight 2, character [zeta10], sign 1, over
Cyclotomic Field of order 10 and degree 4
]
sage: D[0].q_eigenform(4, 'mu')
q + mu*q^2 + ((zeta10^3 + zeta10 - 1)*mu + zeta10^2 - 1)*q^3 + O(q^4)
sage: D[0].q_expansion_module(11, QQ)
Vector space of degree 11 and dimension 8 over Rational Field
Basis matrix:
[  0   1   0   0   0   0   0   0 -20  -3   0]
[  0   0   1   0   0   0   0   0 -16  -1   0]
[  0   0   0   1   0   0   0   0 -11  -2   0]
[  0   0   0   0   1   0   0   0  -8  -1   0]
[  0   0   0   0   0   1   0   0  -5  -1   0]
[  0   0   0   0   0   0   1   0  -3  -1   0]
[  0   0   0   0   0   0   0   1  -2   0   0]
[  0   0   0   0   0   0   0   0   0   0   1]
sage: D[0].q_expansion_module(11)
Vector space of degree 11 and dimension 2 over Cyclotomic Field of order 10
and degree 4
Basis matrix:
[                                  0                                   1   
0                        zeta10^2 - 1                       -zeta10^2 - 1  
-zeta10^3 - zeta10^2                   zeta10^2 - zeta10          
2*zeta10^3 + 2*zeta10 - 1    zeta10^3 - zeta10^2 - zeta10 + 1       
zeta10^3 - zeta10^2 + zeta10   -2*zeta10^3 + 2*zeta10^2 - zeta10]
[                                  0                                   0   
1               zeta10^3 + zeta10 - 1                         -zeta10 - 1  
-zeta10^3 - zeta10^2 -2*zeta10^3 + zeta10^2 - zeta10 + 1                   
zeta10^2                                   0                       
zeta10^3 + 1  2*zeta10^3 - zeta10^2 + zeta10 - 1]

EXAMPLES WITH SIGN 0 and R=QQ: ** TODO - this doesn't work yet - not implemented!! ** M = ModularSymbols(11,2).cuspidal_submodule() M.q_expansion_module() ... boom ...

EXAMPLES WITH SIGN 1 and R=ZZ (computes saturation):

sage: M = ModularSymbols(43,2, sign=1).cuspidal_submodule()
sage: M.q_expansion_module(8, QQ)
Vector space of degree 8 and dimension 3 over Rational Field
Basis matrix:
[   0    1    0    0    0    2   -2   -2]
[   0    0    1    0 -1/2    1 -3/2    0]
[   0    0    0    1 -1/2    2 -3/2   -1]
sage: M.q_expansion_module(8, ZZ)
Free module of degree 8 and rank 3 over Integer Ring
Echelon basis matrix:
[ 0  1  0  0  0  2 -2 -2]
[ 0  0  1  1 -1  3 -3 -1]
[ 0  0  0  2 -1  4 -3 -2]

rational_period_mapping( self)

Return the rational period mapping associated to self.

This is a homomorphism to a vector space whose kernel is the same as the kernel of the period mapping associated to self. For this to exist, self must be Hecke equivariant.

Use integral_period_mapping to obtain a homomorphism to a $ \mathbf{Z}$ -module, normalized so the image of integral modular symbols is exactly $ \mathbf{Z}^n$ .

sage: M = ModularSymbols(37)
sage: A = M[1]; A
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 5 for Gamma_0(37) of weight 2 with sign 0 over Rational Field
sage: r = A.rational_period_mapping(); r
Rational period mapping associated to Modular Symbols subspace of dimension
2 of Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with
sign 0 over Rational Field
sage: r(M.0)
(0, 0)
sage: r(M.1)
(1, 0)
sage: r.matrix()
[ 0  0]
[ 1  0]
[ 0  1]
[-1 -1]
[ 0  0]
sage: r.domain()
Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with sign
0 over Rational Field
sage: r.codomain()
Vector space of degree 2 and dimension 2 over Rational Field
Basis matrix:
[1 0]
[0 1]

set_default_prec( self, prec)

Set the default precision for computation of $ q$ -expansion associated to the ambient space of this space of modular symbols (and all subspaces).

sage: M = ModularSymbols(Gamma1(13),2)
sage: M.set_default_prec(5)
sage: M.cuspidal_submodule().q_expansion_basis()
[
q - 4*q^3 - q^4 + O(q^5),
q^2 - 2*q^3 - q^4 + O(q^5)
]

set_precision( self, prec)

Same as self.set_default_prec(prec).

sage: M = ModularSymbols(17,2)
sage: M.cuspidal_submodule().q_expansion_basis()
[
q - q^2 - q^4 - 2*q^5 + 4*q^7 + O(q^8)
]
sage: M.set_precision(10)
sage: M.cuspidal_submodule().q_expansion_basis()
[
q - q^2 - q^4 - 2*q^5 + 4*q^7 + 3*q^8 - 3*q^9 + O(q^10)
]

sign( self)

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
- if this is factor of quotient where * acts as -1,
+1
- if this is factor of quotient where * acts as +1,
0
- if this is full space of modular symbols (no quotient).

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

sign_submodule( self, 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

sage: M = ModularSymbols(29,2)
sage: M.sign_submodule(1)
Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 5 for Gamma_0(29) of weight 2 with sign 0 over Rational Field
sage: M.sign_submodule(-1)
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 5 for Gamma_0(29) of weight 2 with sign 0 over Rational Field
sage: M.sign_submodule(-1).sign()
-1

simple_factors( self)

Returns a list modular symbols spaces $ S$ where $ S$ is simple spaces of modular symbols (for the anemic Hecke algebra) and self is isomorphic to the direct sum of the $ S$ with some multiplicities, as a module over the anemic Hecke algebra. For the multiplicities use factorization() instead.

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

sage: ModularSymbols(1,100,sign=-1).simple_factors()
[Modular Symbols subspace of dimension 8 of Modular Symbols space of
dimension 8 for Gamma_0(1) of weight 100 with sign -1 over Rational Field]
sage: ModularSymbols(1,16,0,GF(5)).simple_factors()
[Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(1) of weight 16 with sign 0 over Finite Field of
size 5,
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(1) of weight 16 with sign 0 over Finite Field of
size 5,
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(1) of weight 16 with sign 0 over Finite Field of
size 5]

star_eigenvalues( self)

Returns the eigenvalues of the star involution acting on self.

sage: M = ModularSymbols(11)
sage: D = M.decomposition()
sage: M.star_eigenvalues()
[1, -1]
sage: D[0].star_eigenvalues()
[1]
sage: D[1].star_eigenvalues()
[1, -1]
sage: D[1].plus_submodule().star_eigenvalues()
[1]
sage: D[1].minus_submodule().star_eigenvalues()
[-1]

star_involution( self)

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

sturm_bound( self)

Returns the Sturm bound for this space of modular symbols.

Type sturm_bound? for more details.

sage: ModularSymbols(11,2).sturm_bound()
2
sage: ModularSymbols(389,2).sturm_bound()
65
sage: ModularSymbols(1,12).sturm_bound()
1
sage: ModularSymbols(1,36).sturm_bound()
3

Special Functions: __cmp__,$ \,$ __init__,$ \,$ _compute_sign_submodule,$ \,$ _q_eigenform_images,$ \,$ _q_expansion_basis_eigen,$ \,$ _q_expansion_basis_hecke_dual,$ \,$ _q_expansion_module,$ \,$ _q_expansion_module_integral,$ \,$ _q_expansion_module_rational,$ \,$ _set_sign

__cmp__( self, other)

Compare self and other.

When spaces are in a common ambient space, we order lexicographically by the sequence of traces of Hecke operators $ T_p$ , for all primes $ p$ . In general we order first by the group, then the weight, then the character, then the sign then the base ring, then the dimension.

sage: M = ModularSymbols(21,4) ; N = ModularSymbols(Gamma1(5),6)
sage: M.cuspidal_submodule().__cmp__(N)
1
sage: M.cuspidal_submodule() == N
False

_q_eigenform_images( self, A, prec, names)

Return list of images in space corresponding to self of eigenform corresponding to A under the degeneracy maps. This is mainly a helper function for other internal functions.

Input:

self
- space of modular symbols
A
- cuspidal simple space of level dividing the level of self and the same weight
prec
- a positive integer

sage: M = ModularSymbols(33,2,sign=1)
sage: A = M.modular_symbols_of_level(11).cuspidal_submodule()
sage: M._q_eigenform_images(A, 10, names='a')
[q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10),
 q^3 - 2*q^6 - q^9 + 2*q^12 + q^15 + 2*q^18 - 2*q^21 - 2*q^27 + O(q^30)]

_q_expansion_module( self, prec, [algorithm=hecke])

Return module spanned by the $ q$ -expansions corresponding to self.

_q_expansion_module_integral( self, prec)

Return module over $ \mathbf{Z}$ for the space spanned by the $ q$ -expansions corresponding to self. The base ring of self must be $ \mathbf{Q}$ or a number field, and self must be cuspidal. The returned space is a $ \mathbf{Z}$ -module, where the coordinates are the coefficients of $ q$ -expansions.

_q_expansion_module_rational( self, prec)

Return a free module over $ \mathbf{Z}$ for the space spanned by the $ q$ -expansions corresponding to self. The base ring of self must be $ \mathbf{Q}$ or a number field, and self must be cuspidal. The returned space is a $ \mathbf{Z}$ -module, where the coordinates are the coefficients of $ q$ -expansions.

Class: PeriodMapping

class PeriodMapping
PeriodMapping( self, modsym, A)

Functions: codomain,$ \,$ domain,$ \,$ matrix,$ \,$ modular_symbols_space

Special Functions: __call__,$ \,$ __init__

Class: RationalPeriodMapping

class RationalPeriodMapping

Special Functions: _repr_

_repr_( self)

Return the string representation of self.

sage: ModularSymbols(40,2).rational_period_mapping()._repr_()
'Rational period mapping associated to Modular Symbols space of dimension
13 for Gamma_0(40) of weight 2 with sign 0 over Rational Field'

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