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
group, weight, sign, base_ring, [character=None]) |
Initialize a space of modular symbols.
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:
) |
The boundary map to the corresponding space of boundary modular symbols.
) |
The cuspidal submodule.
) |
Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.
) |
Return the Eisenstein submodule of this space of modular symbols.
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.
) |
Returns a list of pairs
where
is simple spaces of
modular symbols and self is isomorphic to the direct sum of
the
as a module over the anemic Hecke algebra
adjoin the star involution.
) |
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)]]
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
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
) |
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
) |
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:
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:
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.
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
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
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.
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.