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_vector,
boundary_map,
commit,
cuspidal_subspace,
degeneracy_map,
dimension,
element,
embedded_subspace,
fcp,
filename,
hecke_algebra,
intersect,
is_ambient,
is_subspace,
load,
manin_symbols_basis,
modular_symbols_of_level,
new_subspace,
use_db,
zero_subspace
These methods are defined as follows:
v) |
Given a vector v in self.vector_space(), return the corresponding vector in the ambient modular symbols space.
) |
The boundary map to the corresponding space of boundary modular symbols.
) |
Try to commit this modular symbols space to the database.
) |
The cuspidal subspace.
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
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.
INPUT: ModularSymbols self -- a space 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.intersect(B); C.dimension() # TODO 1
) |
Returns true if and only if self is an ambient space of modular symbols, i.e., created by specifying a group, weight, character, and sign, and not by using a decomposition or other command.
WARNING: self could be equal to an ambient space, but not be an ambient space. For example, decomposing a simple ambient space yields a single factor, and that factor is not 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() False
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*Y^0,(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
) |
Returns true if self is loaded and saved to disk.
INPUT: ModularSymbols self -- an ambient space of modular symbols OUTPUT bool
) |
Returns the subspace of this space of modular symbols.
Instances of class ModularSymbolsAmbient also have the following special methods:
x) |
Coerce x into the modular symbols space. 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 self.
See About this document... for information on suggesting changes.