This class is an abstract base class, so only derived classes should be instantiated. INPUT: weight - int, the weight, must be >= 2 group - congroup.CongruenceGroup, a congruence subgroup. sign - int, either -1, 0, or 1 base_field - rings.Ring (defaults to the rational numbers)
[group=None], [weight=Rational Field], [sign=0], [base_field=2], [character=1]) |
Initialize a space of modular symbols.
ambient_space,
ambient_vector,
atkin_lehner_operator,
boundary_map,
boundary_space,
commit,
complement,
compute_presentation,
cuspidal_subspace,
decomposition_matrix,
decomposition_matrix_inverse,
degeneracy_map,
dimension,
dual_star_involution_matrix,
eisenstein_subspace,
element,
embedded_dual_vector_space,
embedded_vector_space,
fcp,
filename,
hecke_algebra,
hecke_bound,
intersection,
is_ambient,
is_anemic_hecke_module,
is_cuspidal,
is_eisenstein,
is_full_hecke_module,
is_new,
is_subspace,
linear_combination_of_basis,
load,
manin_basis,
manin_generators,
manin_gens_to_basis,
manin_relations,
manin_symbols,
manin_symbols_basis,
modular_symbols_of_level,
new_subspace,
p1list,
relation_matrix,
star_involution,
subspace_generated_by_images,
use_db
Further documentation:
v) |
Given a vector v in self.vector_space(), return the corresponding element in the vector space of the ambient modular symbols space.
d) |
Return the Atkin-Lehner operator W_d on this space, where d is a divisor of the level N such that N/d and d are coprime.
) |
The boundary map to the corresponding space of boundary modular symbols.
) |
Try to commit this modular symbols space to the database.
) |
Return the largest Hecke-stable complement of this space.
) |
The cuspidal subspace.
) |
Returns the matrix whose columns form a basis for the canonical sorted decomposition of self coming from the Hecke operators.
If the simple factors are D_0,...,D_n, then the first few columns are an echelon basis for D_0, the next an echelon basis for D_1, the next a basis for D_2, etc.
) |
Returns the inverse of the matrix returned by decomposition_matrix().
level, [t=1]) |
The t-th degeneracy map from self to modular symbols of the given level. The level of self must be a divisor or multiple of level, and t must be a divisor of the quotient.
NOTE: We use Proposition 2.6.15 in Merel's 1585 paper (or Prop 15 in the dvi version of that paper).
INPUT: level -- int, the level of the codomain of the map (positive int). t -- int, the parameter of the degeneracy map, i.e., the map is related to f(q) |--> f(q^t). OUTPUT: A linear function from self to the space of modular symbols of given level with the same weight, character, sign, etc., as this space.
) |
Returns the dimension of self.
INPUT: ModularSymbols self -- arbitrary space of modular symbols OUTPUT: int -- the dimension
ALGORITHM: If self is a subspace, then it is defined by a vector space, and the dimension is known. If self is ambient, this function computes a presentation for self, and return the number of free generators in the presentation. The dimension could also be computed in many cases using dimension formulas, but we don't do this.
sage: M = ModularSymbols(389) sage: M.dimension() 65
) |
Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.
) |
Return the Eisenstein subspace 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 the vector subspace of the vector space of the ambient space that defines self as a subspace of modular symbols.
OUTPUT: VectorSpace - a vector space.
n) |
Returns the factorization of the characteristic polynomial of the Hecke operator T_n of index n.
INPUT: ModularSymbols self -- space of modular symbols invariant under the Hecke operator of index n. int n -- a positive integer. OUTPUT: list -- list of the pairs (g,e), where g is an irreducible factor of the characteristic polynomial of T_n, and e is its multiplicity.
ALGORITHM: Call hecke_operator to compute the hecke operator, call charpoly on that, and call factor on the result of charpoly. Thus the implementation is just a one-line call to other functions.
sage: m = ModularSymbols(23, 2, sign=1) sage: m.fcp(2) [(x - 3, 1), (x^2 + x - 1, 1)] sage: m.hecke_operator(2).charpoly().factor() [(x - 3, 1), (x^2 + x - 1, 1)]
) |
Returns the filename of self that should be used to store self in the database.
INPUT: self -- space of modular symbols OUTPUT: str -- a string
) |
Returns the Hecke algebra associated to self.
INPUT: ModularSymbols -- Hecke stable space of modular symbols OUTPUT: hecke.HeckeAlgebra -- the Hecke algebra attached to self.
ALGORITHM: Creates the hecke.HeckeAlgebra attached to self. For how that works, see the documentation of the hecke module.
other) |
Returns the intersection of self and other, which must both lie in a common ambient space of modular symbols.
sage: M = ModularSymbols(43, sign=1) sage: A = M[0] + M[1] sage: B = M[1] + M[2] sage: A.dimension(), B.dimension() (2, 3) sage: C = A.intersection(B); C.dimension() # TODO 1
) |
Returns true if and only if self is an ambient space of modular symbols. command.
WARNING: self can be ambient by virtue of being equal to an ambient space, even if it is not of type ModularSymbolsAmbient. For example, decomposing a simple ambient space yields a single factor, and that factor *is* also considered an ambient space.
sage: m = ModularSymbols(10) sage: m.is_ambient() True
sage: a = m[0] # the unique simple factor sage: a == m True sage: a.is_ambient() True
V) |
Returns True if and only if self is a subspace of V.
) |
Try to load the ambient space self from the database.
INPUT: ModularSymbols self -- an ambient space of modular symbols OUTPUT: bool -- True on success and False on failure.
) |
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)]]
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).
[p=None]) |
Returns the new or p-new subspace of self.
INPUT: p -- (default: None); if not None, return only the p-new subspace. OUTPUT: ModularSymbols -- the new or p-new subspace of self
sage: m = ModularSymbols(33); m.dimension() 9 sage: m.new_subspace().dimension() 3 sage: m.new_subspace(3).dimension() 4 sage: m.new_subspace(11).dimension() 8
) |
Return the star involution on self, which is induced by complex conjugation on modular symbols.
M) |
Return the subspace of this ambient modular symbols space generated by the images under all degeneracy maps of M. The space M must have the same weight, sign, and group or character as this space.
) |
Returns true if self is loaded and saved to disk.
INPUT: ModularSymbols self -- an ambient space of modular symbols OUTPUT bool
Instances of class ModularSymbolsAmbient also have the following special functions:
__add__,
__call__,
__getitem__,
__len__
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:
VectorSpace - returns the modular symbols subspace of self defined defined by this vector space. The input vector space must be over the same base field and be of the same degree as the dimension of self.
See About this document... for information on suggesting changes.