Module: sage.modular.hecke.ambient_module
Module-level Functions
x) |
Class: AmbientHeckeModule
self, base_ring, rank, level, weight) |
Functions: ambient_hecke_module,
complement,
decomposition_matrix,
decomposition_matrix_inverse,
degeneracy_map,
dual_free_module,
fcp,
free_module,
hecke_bound,
hecke_module_of_level,
intersection,
is_ambient,
is_full_hecke_module,
is_new,
is_old,
is_submodule,
linear_combination_of_basis,
new_submodule,
nonembedded_free_module,
old_submodule,
submodule,
submodule_from_nonembedded_module,
submodule_generated_by_images
self) |
Return the largest Hecke-stable complement of this space.
self) |
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
, then the first
few columns are an echelonized basis for
, the next an
echelonized basis for
, the next for
, etc.
self) |
Returns the inverse of the matrix returned by decomposition_matrix().
self, level, [t=1]) |
The t-th degeneracy map from self to the corresponding Hecke module 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.
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 morphism from self to corresponding the Hecke module of given level.
sage: M = ModularSymbols(11,sign=1) sage: d1 = M.degeneracy_map(33); d1 Hecke module morphism degeneracy map corresponding to f(q) |--> f(q) defined by the matrix (not printing 2 x 6 matrix) Domain: Modular Symbols space of dimension 2 for Gamma_0(11) of weight ... Codomain: Modular Symbols space of dimension 6 for Gamma_0(33) of weight ... sage: M.degeneracy_map(33,3).matrix() [ 3 2 2 0 -2 1] [ 0 2 0 -2 0 0] sage: M = ModularSymbols(33,sign=1) sage: d2 = M.degeneracy_map(11); d2.matrix() [ 1 0] [ 0 1/2] [ 0 -1] [ 0 1] [ -1 0] [ -1 0] sage: (d2*d1).matrix() [4 0] [0 4]
self, n) |
Returns the factorization of the characteristic polynomial of
the Hecke operator
of index
.
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.
sage: m = ModularSymbols(23, 2, sign=1) sage: m.fcp(2) (x - 3) * (x^2 + x - 1) sage: m.hecke_operator(2).charpoly().factor() (x - 3) * (x^2 + x - 1)
self) |
Return the free module underlying this ambient Hecke module.
self) |
Return an integer B such that the Hecke operators
, for
,
generate the full Hecke algebra as a module over the base ring. Note
that we include the
with
not coprime to the level.
self, 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.rank(), B.rank() (2, 3) sage: C = A.intersection(B); C.rank() # TODO 1
self) |
Returns True if and only if self is an ambient Hecke module.
WARNING: self can be ambient by virtue of being equal to an ambient space, even if it is not of type AmbientHeckeModule. 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
self, [compute=True]) |
Returns True if this space is invariant under the action of all Hecke operators, even those that divide the level.
self, V) |
Returns True if and only if self is a submodule of V.
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: m = ModularSymbols(33); m.rank() 9 sage: m.new_submodule().rank() 3 sage: m.new_submodule(3).rank() 4 sage: m.new_submodule(11).rank() 8
self, [p=None]) |
Returns the old or p-old submodule of self.
INPUT: p -- (default: None); if not None, return only the p-old submodule. OUTPUT: the old or p-old submodule of self
sage: m = ModularSymbols(33); m.rank() 9 sage: m.old_submodule().rank() 7 sage: m.old_submodule(3).rank() 6 sage: m.new_submodule(11).rank() 8
sage: e = DirichletGroup(16)([-1, 1]) sage: M = ModularSymbols(e, 3, sign=1); M Modular Symbols space of dimension 4 and level 16, weight 3, character [-1, 1], sign 1, over Rational Field sage: M.old_submodule() Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 4 and level 16, weight 3, character [-1, 1], sign 1, over Rational Field
self, M, [Mdual=True], [check=None]) |
Return the Hecke submodule of self defined by the free module M.
self, V, [Vdual=True], [check=None]) |
INPUT: V -- submodule of ambient free module of the same rank as the rank of self. OUTPUT: Hecke submodule of self
self, M) |
Return the submodule 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 ambient space.
Special Functions: __add__,
__call__,
_degeneracy_lowering_matrix,
_degeneracy_raising_matrix,
_hecke_image_of_ith_basis_element,
_repr_,
_set_dual_free_module
self, N, t) |
Matrix of the degeneracy map of index t to level N, where N is a divisor of the level.
self, N) |
Matrix of the degeneracy map (with t = 1) to level N, where N is a multiple of the level.
self, n, i) |
Return the image under the Hecke operator T_n of the i-th basis element.