Class AmbientHeckeModule

File: sage/modules/module.pyx (starting at line 26)

Coerce x into the ring.

Overrides: modules.module.Module.__call__

(inherited documentation)

Overrides: module.HeckeModule_free_module.__init__

Return the largest Hecke-stable complement of this space.
EXAMPLES:
    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

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.

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.
    
EXAMPLES:
    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 ...            

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.
           
EXAMPLES:
    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)

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.

Returns the intersection of self and other, which must both
lie in a common ambient space of modular symbols.

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

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 \emph{not} considered an
ambient space.

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

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

Overrides: module.HeckeModule_generic.is_full_hecke_module

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

Overrides: module.HeckeModule_free_module.is_submodule

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

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

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

Overrides: module.HeckeModule_generic.submodule

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

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.