group, weight, character, sign, base_field) |
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:
) |
Returns a basis for self.
) |
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.
) |
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.
n) |
The matrix of the n-th Hecke operator acting on the embedded_dual_vector_space of self.
) |
Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.
) |
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.
ASSUMPTION: self is a module over the anemic Hecke algebra.
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)
) |
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)
n) |
The matrix of the n-th Hecke operator acting on the basis for 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. OUTPUT: function.MatrixFunction -- the matrix function that represents the n-th Hecke operator on the chosen basis for self.
n) |
Return the characteristic polynomial of the n-th Hecke operator acting on this space.
INPUT: n -- integer OUTPUT: a polynomial
) |
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
[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
) |
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
[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
) |
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
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
got from the rows corresponding
to self, i.e., if the basis vectors for self appear as
columns
through
of
, then the projection matrix
is got from rows
through
of
. This is
because projection with respect to the B basis is just
given by an
row slice
of a diagonal matrix D
with 1's in the
through
positions, so projection
with respect to the standard basis is given by
, which is just rows
through
of
.
prec) |
Returns the q-expansion to precision prec of a newform associated to self, where self must be new, cuspidal, and simple.
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.
) |
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, [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
) |
) |
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
) |
Return the star involution on self, which is induced by complex conjugation on modular symbols.
) |
Returns the Sturm bound for this space of modular symbols.
Returns a positive integer
such that the Hecke operators
acting on cusp forms generate the
Hecke algebra as a
-module when the character is trivial
or quadratic. Otherwise,
generate the Hecke
algebra at least as a
-module, where
is
the ring generated by the values of the Dirichlet character
. Alternatively, this is a bound such that if two cusp
forms associated to this space of modular symbols are
congruent modulo
, then they are congruent
modulo
.
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
with character,
as one sees by taking a power of
. More precisely, if
for first
coefficients, then
for first
coefficents. Since the weight of
is
, it follows that if
, where
is the Sturm bound for
at weight
, then
has valuation large enough to be forced to be 0
at
by Sturm bound (which is valid if we choose
correctly). Thus
. Conclusion: For
with fixed character, the Sturm bound is
exactly the same as for
.
A key point is that we are finding
generators for
the Hecke algebra here, not
-generators. So if one wants
generators for the Hecke algebra over
, this bound must
be suitably modified.
n) |
Returns the
-th Hecke operator
. This function is a
synonym for
hecke_operator
.
) |
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
) |
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
) |
Returns the zero subspace of this space of modular symbols.
Instances of class ModularSymbolsSpace also have the following special functions:
__cmp__,
__contains__
Further documentation:
other) |
Compare self and other.
See About this document... for information on suggesting changes.