26.3 Ambient Hecke modules

Module: sage.modular.hecke.ambient_module

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.

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]

fcp( self, 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.

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)

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

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=True], [check=None])

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

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

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__,$  $ _degeneracy_lowering_matrix,$  $ _degeneracy_raising_matrix,$  $ _hecke_image_of_ith_basis_element,$  $ _repr_,$  $ _set_dual_free_module

_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.