41.3 Ambient spaces of modular symbols

Module: sage.modular.modsym.ambient

Ambient spaces of modular symbols.

We compute a space of modular symbols modulo 2. The dimension is different than that of the corresponding space in characteristic 0:

sage: M = ModularSymbols(11,4,base_ring=GF(2)); M
Modular Symbols space of dimension 7 for Gamma_0(11) of weight 4
with sign 0 over Finite Field of size 2
sage: M.basis()
([X*Y,(1,0)], [X*Y,(1,8)], [X*Y,(1,9)], [X^2,(0,1)], [X^2,(1,8)],
[X^2,(1,9)], [X^2,(1,10)])
sage: M0 =  ModularSymbols(11,4,base_ring=QQ); M0
Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4
with sign 0 over Rational Field
sage: M0.basis()
([X^2,(0,1)], [X^2,(1,6)], [X^2,(1,7)], [X^2,(1,8)], [X^2,(1,9)],
[X^2,(1,10)])

The charpoly of the Hecke operator $ T_2$ has an extra factor $ x$ .

sage: M.T(2).matrix().fcp('x')
(x + 1)^2 * x^5
sage: M0.T(2).matrix().fcp('x')
(x - 9)^2 * (x^2 - 2*x - 2)^2

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,$ \,$ cusps,$ \,$ dual_star_involution_matrix,$ \,$ eisenstein_submodule,$ \,$ element,$ \,$ factor,$ \,$ factorization,$ \,$ integral_structure,$ \,$ is_cuspidal,$ \,$ is_eisenstein,$ \,$ manin_basis,$ \,$ manin_generators,$ \,$ manin_gens_to_basis,$ \,$ manin_symbol,$ \,$ manin_symbols,$ \,$ manin_symbols_basis,$ \,$ modular_symbol,$ \,$ modular_symbol_sum,$ \,$ modular_symbols_of_sign,$ \,$ modular_symbols_of_weight,$ \,$ new_submodule,$ \,$ p1list,$ \,$ rank,$ \,$ relation_matrix,$ \,$ star_involution,$ \,$ submodule,$ \,$ twisted_winding_element

boundary_map( self)

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

cuspidal_submodule( self)

The cuspidal submodule of self.

sage: M = ModularSymbols(12,2,0,GF(5)) ; M
Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign
0 over Finite Field of size 5
sage: M.cuspidal_submodule()
Modular Symbols subspace of dimension 0 of Modular Symbols space of
dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Finite Field of
size 5
sage: ModularSymbols(1,24,-1).cuspidal_submodule()
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 2 for Gamma_0(1) of weight 24 with sign -1 over Rational Field

The cuspidal submodule of the cuspidal submodule is itself:

sage: M = ModularSymbols(389)
sage: S = M.cuspidal_submodule()
sage: S.cuspidal_submodule() is S
True

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.

factor( self)

Synonym for self.factorization().

factorization( self)

Returns a list of pairs $ (S,e)$ where $ S$ is 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. The cuspidal $ S$ are all simple, but the Eisenstein factors need not be simple.

sage: ModularSymbols(Gamma0(22), 2).factorization()
(Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2
* 
(Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2
* 
(Modular Symbols subspace of dimension 3 of Modular Symbols space of
dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field)

sage: ModularSymbols(1,6,0,GF(2)).factorization()
(Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of
size 2) * 
(Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of
size 2)

sage: ModularSymbols(18,2).factorization()
(Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field) * 
(Modular Symbols subspace of dimension 5 of Modular Symbols space of
dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field)

sage: M = ModularSymbols(DirichletGroup(38,CyclotomicField(3)).1^2,  2, +1); M
Modular Symbols space of dimension 7 and level 38, weight 2, character [1,
zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2
sage: M.factorization()                    # long time (about 8 seconds)
(Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over
Cyclotomic Field of order 3 and degree 2) *
(Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over
Cyclotomic Field of order 3 and degree 2) *
(Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over
Cyclotomic Field of order 3 and degree 2) *
(Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over
Cyclotomic Field of order 3 and degree 2)

integral_structure( self, [algorithm=default])

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

Input:

algorithm
- string (default: 'default' - choose heuristically)
'pari'
- use pari for the HNF computation
'padic'
- use p-adic algorithm (only good for dense case)

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){\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])
-{8/9,1}
sage: M.1
{7/8,1}
sage: M.modular_symbol([-1/8, 0])
{7/8,1}
sage: M.modular_symbol([0, -1/8, 0])
{7/8,1}
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).

sage: N = ModularSymbols(6,4)
sage: set_modsym_print_mode('manin')
sage: N([1,Cusp(-1/4),Cusp(0)])
17/2*[X^2,(2,3)] - 9/2*[X^2,(2,5)] + 15/2*[X^2,(3,1)] - 15/2*[X^2,(3,2)]
sage: N([1,Cusp(-1/2),Cusp(0)])
1/2*[X^2,(2,3)] + 3/2*[X^2,(2,5)] + 3/2*[X^2,(3,1)] - 3/2*[X^2,(3,2)]

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)

sage: set_modsym_print_mode()   # return to default.

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

Take a 3-element list consisting of a homogeneous polynomial in degree self.weight()-2 over ZZ, and return the corresponding sum of modular symbols as an element of self. That is, if x is [f, alpha, beta], where $ f = \sum_{i=0}^{k-2} a_i X^i Y^{k-2-i}$ , return $ \sum_{i=0}^{k-2} a_i * [ i, alpha, beta ]$ .

modular_symbols_of_sign( self, sign)

Returns a space of modular symbols with the same defining properties (weight, level, 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

new_submodule( self, [p=None])

Returns the new or p-new submodule of self.

Input:

p
- (default: None); if not None, return only the p-new submodule.

Output: the new or p-new submodule of self

sage: ModularSymbols(100).new_submodule()
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 31 for Gamma_0(100) of weight 2 with sign 0 over Rational Field
sage: ModularSymbols(389).new_submodule()
Modular Symbols space of dimension 65 for Gamma_0(389) of weight 2 with
sign 0 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.

submodule( self, M, [dual_free_module=None], [check=True])

Return the submdoule of self with given generators or free module M.

Input:

M
- a submodule of the ambient free module or generators for a submodule
dual_free_module (optional)
- this may be useful to speed up certain calculations; it is the corresponding submodule of the ambient dual module
check
- bool (optional: default - True); if True, actually check that M is a module, which means it is invariant under all Hecke operators.

sage: M = ModularSymbols(11)
sage: M.submodule([M.0])
Traceback (most recent call last):
...
ValueError: The submodule must be invariant under all Hecke operators.
sage: M.eisenstein_submodule().basis()
((1,0) - 1/5*(1,9),)
sage: M.basis()
((1,0), (1,8), (1,9))
sage: M.submodule([M.0 - 1/5*M.2])
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field

NOTE: It would make more sense to only check that M is invariant under the Hecke operators with index coprime to the level. Unfortunately, I do not know a reasonable algorithm for determining whether a module is invariant under just the anemic Hecke algebra, since I do not know an analogue of the Sturm bound for the anemic Hecke algebra. - William Stein, 2007-07-27

twisted_winding_element( self, i, eps)

Given a space of modular symbols, an integer 0 <= i <= k-2, and a Dirichlet character eps, return the so-called 'twisted winding element':

$\displaystyle \sum_{a \in (\mathbf{Z}/m\mathbf{Z})^\times} \varepsilon (a) * [ i, 0, a/m ].
$

Special Functions: __call__,$ \,$ __cmp__,$ \,$ __init__,$ \,$ _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_atkin_lehner_matrix( self, d)

Input:

d
- integer that divides level

Output: matrix

An example at level 29:

sage: M = ModularSymbols((DirichletGroup(29,QQ).0), 2,1); M
Modular Symbols space of dimension 4 and level 29, weight 2, character
[-1], sign 1, over Rational Field
sage: w = M._compute_atkin_lehner_matrix(29)
sage: w^2 == 1
True
sage: w.fcp()
(x - 1)^2 * (x + 1)^2

This doesn't work since the character has order > 2:

sage: M = ModularSymbols((DirichletGroup(13).0), 2,1); M
Modular Symbols space of dimension 0 and level 13, weight 2, character
[zeta12], sign 1, over Cyclotomic Field of order 12 and degree 4
sage: M._compute_atkin_lehner_matrix(13)
Traceback (most recent call last):
...
ValueError: Atkin-Lehner only leaves space invariant when character is
trivial or quadratic.  In general it sends M_k(chi) to M_k(1/chi)

Note that Atkin-Lehner does make sense on $ \Gamma_1(13)$ , but doesn't commute with the Hecke operators:

sage: M = ModularSymbols(Gamma1(13),2)
sage: w = M.atkin_lehner_operator(13).matrix()
sage: t = M.T(2).matrix()
sage: t*w == w*t
False
sage: w^2 == 1
True

_compute_hecke_matrix_prime( self, p, [rows=None])

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')
x^2 - 9*x + 8

sage: m = ModularSymbols(1,weight=12)
sage: m._compute_hecke_matrix_prime(2).charpoly('x')
x^3 - 2001*x^2 - 97776*x - 1180224
sage: m._compute_hecke_matrix_prime(13).charpoly('x')
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')
x^2 - 18*x + 81

sage: m = ModularSymbols(6,4)
sage: m._compute_hecke_matrix_prime(2).charpoly('x')
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')
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')
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')
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')
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')
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')
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')
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

sage: ModularSymbols(1,12,0,GF(5)).minus_submodule() ## indirect doctest
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 3 for Gamma_0(1) of weight 12 with sign 0 over Finite Field of
size 5

_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

$\displaystyle 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

class ModularSymbolsAmbient_wt2_g0
Modular symbols for Gamma_0(N) of integer weight 2 over the field F.
ModularSymbolsAmbient_wt2_g0( self, N, sign, F)

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: __init__,$ \,$ _compute_hecke_matrix_prime,$ \,$ _cuspidal_new_submodule_dimension_formula,$ \,$ _cuspidal_submodule_dimension_formula,$ \,$ _dimension_formula

_compute_hecke_matrix_prime( self, p, [rows=None])

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')
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: __init__,$ \,$ _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

$\displaystyle x \mapsto \sum_{g in R} g.x
$

where g.x is the formal linear fractional transformation on modular symbols.

Class: ModularSymbolsAmbient_wtk_g0

class ModularSymbolsAmbient_wtk_g0
Modular symbols for $ \Gamma_0(N)$ of integer weight $ k > 2$ over the field $ F$ .
ModularSymbolsAmbient_wtk_g0( self, N, k, sign, F)

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.

Input:

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

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: __init__,$ \,$ _cuspidal_new_submodule_dimension_formula,$ \,$ _cuspidal_submodule_dimension_formula,$ \,$ _degeneracy_raising_matrix,$ \,$ _dimension_formula,$ \,$ _repr_

Class: ModularSymbolsAmbient_wtk_g1

class ModularSymbolsAmbient_wtk_g1
ModularSymbolsAmbient_wtk_g1( self, level, weight, sign, F)

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
F
- field

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: __init__,$ \,$ _compute_hecke_matrix_prime_power,$ \,$ _cuspidal_new_submodule_dimension_formula,$ \,$ _cuspidal_submodule_dimension_formula,$ \,$ _degeneracy_raising_matrix,$ \,$ _dimension_formula,$ \,$ _repr_

Class: ModularSymbolsAmbient_wtk_gamma_h

class ModularSymbolsAmbient_wtk_gamma_h
ModularSymbolsAmbient_wtk_gamma_h( self, group, weight, sign, F)

Initialize a space of modular symbols for $ \Gamma_H(N)$ .

Input:

group
- a congruence subgroup $ \Gamma_H(N)$ .
weight
- int, the weight >= 2
sign
- int, either -1, 0, or 1
F
- field

sage: ModularSymbols(GammaH(15,[4]),2)
Modular Symbols space of dimension 9 for Congruence Subgroup Gamma_H(15)
with H generated by [4] of weight 2 with sign 0 and over Rational Field

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: __init__,$ \,$ _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.