40.8 Ambient Hecke modules

Module: sage.modular.hecke.ambient_module

Ambient Hecke modules

Module-level Functions

is_AmbientHeckeModule( x)

Class: AmbientHeckeModule

class AmbientHeckeModule
Ambient Hecke module.
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

complement( self)

Return the largest Hecke-stable complement of this space.

sage: M=ModularSymbols(11,2,1)
sage: M
Modular Symbols space of dimension 2 for Gamma_0(11) of weight 2 with sign
1 over Rational Field
sage: M.complement()
Modular Symbols subspace of dimension 0 of Modular Symbols space of
dimension 2 for Gamma_0(11) of weight 2 with sign 1 over Rational Field
sage: C=M.cuspidal_subspace()
sage: C
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 for Gamma_0(11) of weight 2 with sign 1 over Rational Field
sage: C.complement()
Modular Symbols subspace of dimension 1 of Modular Symbols space of
dimension 2 for Gamma_0(11) of weight 2 with sign 1 over Rational Field

decomposition_matrix( 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 $ D_0, \ldots, D_n$ , then the first few columns are an echelonized basis for $ D_0$ , the next an echelonized basis for $ D_1$ , the next for $ D_2$ , etc.

decomposition_matrix_inverse( self)

Returns the inverse of the matrix returned by decomposition_matrix().

degeneracy_map( 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]

sage: M = ModularSymbols(3,12,sign=1)
sage: M.degeneracy_map(1)
Hecke module morphism degeneracy map corresponding to f(q) |--> f(q)
defined by the matrix
[1 0]
[0 0]
[0 1]
[0 1]
[0 1]
Domain: Modular Symbols space of dimension 5 for Gamma_0(3) of weight ...
Codomain: Modular Symbols space of dimension 2 for Gamma_0(1) of weight ...

sage: S = M.cuspidal_submodule()
sage: S.degeneracy_map(1)
Hecke module morphism defined by the matrix
[1 0]
[0 0]
[0 0]
Domain: Modular Symbols subspace of dimension 3 of Modular Symbols space
...
Codomain: Modular Symbols space of dimension 2 for Gamma_0(1) of weight ...

sage: D = ModularSymbols(10,4).cuspidal_submodule().decomposition()
sage: D
[
Modular Symbols subspace of dimension 2 of Modular Symbols space of
dimension 10 for Gamma_0(10) of weight 4 with sign 0 over Rational Field,
Modular Symbols subspace of dimension 4 of Modular Symbols space of
dimension 10 for Gamma_0(10) of weight 4 with sign 0 over Rational Field
]
sage: D[1].degeneracy_map(5)
Hecke module morphism defined by the matrix
[   0    0   -1    1]
[   0  1/2  3/2   -2]
[   0   -1    1    0]
[   0 -3/4 -1/4    1]
Domain: Modular Symbols subspace of dimension 4 of Modular Symbols space
...
Codomain: Modular Symbols space of dimension 4 for Gamma_0(5) of weight ...

fcp( self, n, [var=x])

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.
var
- variable of polynomiall

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('x').factor()
(x - 3) * (x^2 + x - 1)

free_module( self)

Return the free module underlying this ambient Hecke module.

hecke_bound( self)

Return an integer B such that the Hecke operators $ T_n$ , for $ n\leq B$ , generate the full Hecke algebra as a module over the base ring. Note that we include the $ n$ with $ n$ not coprime to the level.

intersection( 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

is_ambient( self)

Returns True if and only if self is an ambient Hecke module.

WARNING: self can only be ambient by being of type AmbientHeckeModule.

For example, decomposing a simple ambient space yields a single factor, and that factor is not 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()
False

is_full_hecke_module( self, [compute=True])

Returns True if this space is invariant under the action of all Hecke operators, even those that divide the level.

is_submodule( self, V)

Returns True if and only if self is a submodule of V.

new_submodule( 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

old_submodule( 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

submodule( self, M, [Mdual=None], [check=True])

Return the Hecke submodule of self defined by the free module M.

submodule_from_nonembedded_module( self, V, [Vdual=None], [check=True])

Input:

V
- submodule of ambient free module of the same rank as the rank of self.
Vdual
- used to pass in dual submodule
check
- whether to check that submodule is Hecke equivariant

Output: Hecke submodule of self

submodule_generated_by_images( 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__,$ \,$ __init__,$ \,$ _degeneracy_lowering_matrix,$ \,$ _degeneracy_raising_matrix,$ \,$ _hecke_image_of_ith_basis_element,$ \,$ _repr_,$ \,$ _set_dual_free_module,$ \,$ _submodule_class

_degeneracy_lowering_matrix( self, N, t)

Matrix of the degeneracy map of index t to level N, where N is a divisor of the level.

_degeneracy_raising_matrix( self, N)

Matrix of the degeneracy map (with t = 1) to level N, where N is a multiple of the level.

_hecke_image_of_ith_basis_element( self, n, i)

Return the image under the Hecke operator T_n of the i-th basis element.

See About this document... for information on suggesting changes.