Submodules of Hecke modules - General Hecke Algebras and Hecke Modules

Skip to content
Back to top
View this page
Edit this page

# Submodules of Hecke modules

class sage.modular.hecke.submodule.HeckeSubmodule(ambient, submodule, dual_free_module=None, check=True)

  Bases: `HeckeModule_free_module`

  Submodule of a Hecke module.

  ambient()

    Synonym for ambient_hecke_module.

    EXAMPLES:

    Sage

        sage: CuspForms(2, 12).ambient()
        Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(2) of weight 12 over Rational Field

    Python

        >>> from sage.all import *
        >>> CuspForms(Integer(2), Integer(12)).ambient()
        Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(2) of weight 12 over Rational Field

  ambient_hecke_module()

    Return the ambient Hecke module of which this is a submodule.

    EXAMPLES:

    Sage

        sage: CuspForms(2, 12).ambient_hecke_module()
        Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(2) of weight 12 over Rational Field

    Python

        >>> from sage.all import *
        >>> CuspForms(Integer(2), Integer(12)).ambient_hecke_module()
        Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(2) of weight 12 over Rational Field

  complement(bound=None)

    Return the largest Hecke-stable complement of this space.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(15, 6).cuspidal_subspace()
        sage: M.complement()
        Modular Symbols subspace of dimension 4 of Modular Symbols space of dimension 20 for Gamma_0(15) of weight 6 with sign 0 over Rational Field
        sage: E = EllipticCurve("128a")
        sage: ME = E.modular_symbol_space()
        sage: ME.complement()
        Modular Symbols subspace of dimension 17 of Modular Symbols space of dimension 18 for Gamma_0(128) of weight 2 with sign 1 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(15), Integer(6)).cuspidal_subspace()
        >>> M.complement()
        Modular Symbols subspace of dimension 4 of Modular Symbols space of dimension 20 for Gamma_0(15) of weight 6 with sign 0 over Rational Field
        >>> E = EllipticCurve("128a")
        >>> ME = E.modular_symbol_space()
        >>> ME.complement()
        Modular Symbols subspace of dimension 17 of Modular Symbols space of dimension 18 for Gamma_0(128) of weight 2 with sign 1 over Rational Field

  degeneracy_map(level, t=1)

    The \(t\)-th degeneracy map from `self` to the space of ambient 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.

    INPUT:

    - `level` – positive integer; the level of the codomain of the map

    - `t` – integer; 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.

    EXAMPLES:

    Sage

        sage: D = ModularSymbols(10,4).cuspidal_submodule().decomposition(); 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 = D[1].degeneracy_map(5); d
        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 ...

    Python

        >>> from sage.all import *
        >>> D = ModularSymbols(Integer(10),Integer(4)).cuspidal_submodule().decomposition(); 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]
        >>> d = D[Integer(1)].degeneracy_map(Integer(5)); d
        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 ...

    Sage

        sage: d.rank()
        2
        sage: d.kernel()
        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
        sage: d.image()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(5) of weight 4 with sign 0 over Rational Field

    [Python]

        >>> from sage.all import *
        >>> d.rank()
        2
        >>> d.kernel()
        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
        >>> d.image()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(5) of weight 4 with sign 0 over Rational Field

  dual_free_module(bound=None, anemic=True, use_star=True)

    Compute embedded dual free module if possible.

    In general this will not be possible, e.g., if this space is not Hecke equivariant, possibly if it is not cuspidal, or if the characteristic is not 0. In all these cases we raise a `RuntimeError` exception.

    If `use_star` is `True` (which is the default), we also use the +/- eigenspaces for the star operator to find the dual free module of `self`. If `self` does not have a star involution, `use_star` will automatically be set to `False`.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(11, 2)
        sage: M.dual_free_module()
        Vector space of dimension 3 over Rational Field
        sage: Mpc = M.plus_submodule().cuspidal_submodule()
        sage: Mcp = M.cuspidal_submodule().plus_submodule()
        sage: Mcp.dual_free_module() == Mpc.dual_free_module()
        True
        sage: Mpc.dual_free_module()
        Vector space of degree 3 and dimension 1 over Rational Field
        Basis matrix:
        [  1 5/2   5]

        sage: M = ModularSymbols(35,2).cuspidal_submodule()
        sage: M.dual_free_module(use_star=False)
        Vector space of degree 9 and dimension 6 over Rational Field
        Basis matrix:
        [   1    0    0    0   -1    0    0    4   -2]
        [   0    1    0    0    0    0    0 -1/2  1/2]
        [   0    0    1    0    0    0    0 -1/2  1/2]
        [   0    0    0    1   -1    0    0    1    0]
        [   0    0    0    0    0    1    0   -2    1]
        [   0    0    0    0    0    0    1   -2    1]

        sage: M = ModularSymbols(40,2)
        sage: Mmc = M.minus_submodule().cuspidal_submodule()
        sage: Mcm = M.cuspidal_submodule().minus_submodule()
        sage: Mcm.dual_free_module() == Mmc.dual_free_module()
        True
        sage: Mcm.dual_free_module()
        Vector space of degree 13 and dimension 3 over Rational Field
        Basis matrix:
        [ 0  1  0  0  0  0  1  0 -1 -1  1 -1  0]
        [ 0  0  1  0 -1  0 -1  0  1  0  0  0  0]
        [ 0  0  0  0  0  1  1  0 -1  0  0  0  0]

        sage: M = ModularSymbols(43).cuspidal_submodule()
        sage: S = M[0].plus_submodule() + M[1].minus_submodule()
        sage: S.dual_free_module(use_star=False)
        Traceback (most recent call last):
        ...
        RuntimeError: Computation of complementary space failed (cut down to rank 7, but should have cut down to rank 4).
        sage: S.dual_free_module().dimension() == S.dimension()
        True

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(11), Integer(2))
        >>> M.dual_free_module()
        Vector space of dimension 3 over Rational Field
        >>> Mpc = M.plus_submodule().cuspidal_submodule()
        >>> Mcp = M.cuspidal_submodule().plus_submodule()
        >>> Mcp.dual_free_module() == Mpc.dual_free_module()
        True
        >>> Mpc.dual_free_module()
        Vector space of degree 3 and dimension 1 over Rational Field
        Basis matrix:
        [  1 5/2   5]

        >>> M = ModularSymbols(Integer(35),Integer(2)).cuspidal_submodule()
        >>> M.dual_free_module(use_star=False)
        Vector space of degree 9 and dimension 6 over Rational Field
        Basis matrix:
        [   1    0    0    0   -1    0    0    4   -2]
        [   0    1    0    0    0    0    0 -1/2  1/2]
        [   0    0    1    0    0    0    0 -1/2  1/2]
        [   0    0    0    1   -1    0    0    1    0]
        [   0    0    0    0    0    1    0   -2    1]
        [   0    0    0    0    0    0    1   -2    1]

        >>> M = ModularSymbols(Integer(40),Integer(2))
        >>> Mmc = M.minus_submodule().cuspidal_submodule()
        >>> Mcm = M.cuspidal_submodule().minus_submodule()
        >>> Mcm.dual_free_module() == Mmc.dual_free_module()
        True
        >>> Mcm.dual_free_module()
        Vector space of degree 13 and dimension 3 over Rational Field
        Basis matrix:
        [ 0  1  0  0  0  0  1  0 -1 -1  1 -1  0]
        [ 0  0  1  0 -1  0 -1  0  1  0  0  0  0]
        [ 0  0  0  0  0  1  1  0 -1  0  0  0  0]

        >>> M = ModularSymbols(Integer(43)).cuspidal_submodule()
        >>> S = M[Integer(0)].plus_submodule() + M[Integer(1)].minus_submodule()
        >>> S.dual_free_module(use_star=False)
        Traceback (most recent call last):
        ...
        RuntimeError: Computation of complementary space failed (cut down to rank 7, but should have cut down to rank 4).
        >>> S.dual_free_module().dimension() == S.dimension()
        True

    We test that Issue #5080 is fixed:

    Sage

        sage: EllipticCurve('128a').congruence_number()
        32

    [Python]

        >>> from sage.all import *
        >>> EllipticCurve('128a').congruence_number()
        32

  free_module()

    Return the free module corresponding to `self`.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(33,2).cuspidal_subspace() ; M
        Modular Symbols subspace of dimension 6 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        sage: M.free_module()
        Vector space of degree 9 and dimension 6 over Rational Field
        Basis matrix:
        [ 0  1  0  0  0  0  0 -1  1]
        [ 0  0  1  0  0  0  0 -1  1]
        [ 0  0  0  1  0  0  0 -1  1]
        [ 0  0  0  0  1  0  0 -1  1]
        [ 0  0  0  0  0  1  0 -1  1]
        [ 0  0  0  0  0  0  1 -1  0]

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(33),Integer(2)).cuspidal_subspace() ; M
        Modular Symbols subspace of dimension 6 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        >>> M.free_module()
        Vector space of degree 9 and dimension 6 over Rational Field
        Basis matrix:
        [ 0  1  0  0  0  0  0 -1  1]
        [ 0  0  1  0  0  0  0 -1  1]
        [ 0  0  0  1  0  0  0 -1  1]
        [ 0  0  0  0  1  0  0 -1  1]
        [ 0  0  0  0  0  1  0 -1  1]
        [ 0  0  0  0  0  0  1 -1  0]

  hecke_bound()

    Compute the Hecke bound for `self`.

    This is a number \(n\) such that the \(T_m\) for \(m \leq n\) generate the Hecke algebra.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(24,8)
        sage: M.hecke_bound()
        53
        sage: M.cuspidal_submodule().hecke_bound()
        32
        sage: M.eisenstein_submodule().hecke_bound()
        53

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(24),Integer(8))
        >>> M.hecke_bound()
        53
        >>> M.cuspidal_submodule().hecke_bound()
        32
        >>> M.eisenstein_submodule().hecke_bound()
        53

  intersection(other)

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

    EXAMPLES:

    Sage

        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.intersection(B); C.dimension()
        1

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(43), sign=Integer(1))
        >>> A = M[Integer(0)] + M[Integer(1)]
        >>> B = M[Integer(1)] + M[Integer(2)]
        >>> A.dimension(), B.dimension()
        (2, 3)
        >>> C = A.intersection(B); C.dimension()
        1

  is_ambient()

    Return `True` if `self` is an ambient space of modular symbols.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(17,4)
        sage: M.cuspidal_subspace().is_ambient()
        False
        sage: A = M.ambient_hecke_module()
        sage: S = A.submodule(A.basis())
        sage: sage.modular.hecke.submodule.HeckeSubmodule.is_ambient(S)
        True

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(17),Integer(4))
        >>> M.cuspidal_subspace().is_ambient()
        False
        >>> A = M.ambient_hecke_module()
        >>> S = A.submodule(A.basis())
        >>> sage.modular.hecke.submodule.HeckeSubmodule.is_ambient(S)
        True

  is_new(p=None)

    Return `True` if this Hecke module is \(p\)-new. If \(p\) is None, returns `True` if it is new.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(1,16)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S.is_new()
        True

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(1),Integer(16))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S.is_new()
        True

  is_old(p=None)

    Return `True` if this Hecke module is \(p\)-old. If \(p\) is `None`, returns `True` if it is old.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(50,2)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.old_submodule().free_module())
        sage: S.is_old()
        True
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.new_submodule().free_module())
        sage: S.is_old()
        False

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(50),Integer(2))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.old_submodule().free_module())
        >>> S.is_old()
        True
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.new_submodule().free_module())
        >>> S.is_old()
        False

  is_submodule(V)

    Return `True` if and only if `self` is a submodule of V.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(30,4)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S.is_submodule(M)
        True
        sage: SS = sage.modular.hecke.submodule.HeckeSubmodule(M, M.old_submodule().free_module())
        sage: S.is_submodule(SS)
        False

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(30),Integer(4))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S.is_submodule(M)
        True
        >>> SS = sage.modular.hecke.submodule.HeckeSubmodule(M, M.old_submodule().free_module())
        >>> S.is_submodule(SS)
        False

  linear_combination_of_basis(v)

    Return the linear combination of the basis of `self` given by the entries of \(v\).

    The result can be of different types, and is printed accordingly, depending on the type of submodule.

    EXAMPLES:

    Sage

        sage: M = ModularForms(Gamma0(2),12)

        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S.basis()
        ((1, 0, 0, 0), (0, 1, 0, 0))
        sage: S.linear_combination_of_basis([3, 10])
        (3, 10, 0, 0)

        sage: S = M.cuspidal_submodule()
        sage: S.basis()
        [q + 252*q^3 - 2048*q^4 + 4830*q^5 + O(q^6), q^2 - 24*q^4 + O(q^6)]
        sage: S.linear_combination_of_basis([3, 10])
        3*q + 10*q^2 + 756*q^3 - 6384*q^4 + 14490*q^5 + O(q^6)

    Python

        >>> from sage.all import *
        >>> M = ModularForms(Gamma0(Integer(2)),Integer(12))

        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S.basis()
        ((1, 0, 0, 0), (0, 1, 0, 0))
        >>> S.linear_combination_of_basis([Integer(3), Integer(10)])
        (3, 10, 0, 0)

        >>> S = M.cuspidal_submodule()
        >>> S.basis()
        [q + 252*q^3 - 2048*q^4 + 4830*q^5 + O(q^6), q^2 - 24*q^4 + O(q^6)]
        >>> S.linear_combination_of_basis([Integer(3), Integer(10)])
        3*q + 10*q^2 + 756*q^3 - 6384*q^4 + 14490*q^5 + O(q^6)

  module()

    Alias for code{self.free_module()}.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(17,4).cuspidal_subspace()
        sage: M.free_module() is M.module()
        True

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(17),Integer(4)).cuspidal_subspace()
        >>> M.free_module() is M.module()
        True

  new_submodule(p=None)

    Return the new or \(p\)-new submodule of this space of modular symbols.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(20,4)
        sage: M.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(20) of weight 4 with sign 0 over Rational Field
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S
        Rank 12 submodule of a Hecke module of level 20
        sage: S.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(20) of weight 4 with sign 0 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(20),Integer(4))
        >>> M.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(20) of weight 4 with sign 0 over Rational Field
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S
        Rank 12 submodule of a Hecke module of level 20
        >>> S.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(20) of weight 4 with sign 0 over Rational Field

  nonembedded_free_module()

    Return the free module corresponding to `self` as an abstract free module, i.e. not as an embedded vector space.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(12,6)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S
        Rank 14 submodule of a Hecke module of level 12
        sage: S.nonembedded_free_module()
        Vector space of dimension 14 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(12),Integer(6))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S
        Rank 14 submodule of a Hecke module of level 12
        >>> S.nonembedded_free_module()
        Vector space of dimension 14 over Rational Field

  old_submodule(p=None)

    Return the old or \(p\)-old submodule of this space of modular symbols.

    EXAMPLES: We compute the old and new submodules of \(\mathbf{S}_2(\Gamma_0(33))\).

    Sage

        sage: M = ModularSymbols(33); S = M.cuspidal_submodule(); S
        Modular Symbols subspace of dimension 6 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        sage: S.old_submodule()
        Modular Symbols subspace of dimension 4 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        sage: S.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(33)); S = M.cuspidal_submodule(); S
        Modular Symbols subspace of dimension 6 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        >>> S.old_submodule()
        Modular Symbols subspace of dimension 4 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
        >>> S.new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field

  rank()

    Return the rank of `self` as a free module over the base ring.

    EXAMPLES:

    Sage

        sage: ModularSymbols(6, 4).cuspidal_subspace().rank()
        2
        sage: ModularSymbols(6, 4).cuspidal_subspace().dimension()
        2

    Python

        >>> from sage.all import *
        >>> ModularSymbols(Integer(6), Integer(4)).cuspidal_subspace().rank()
        2
        >>> ModularSymbols(Integer(6), Integer(4)).cuspidal_subspace().dimension()
        2

  submodule(M, Mdual=None, check=True)

    Construct a submodule of `self` from the free module M, which must be a subspace of `self`.

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(18,4)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: S[0]
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(18) of weight 4 with sign 0 over Rational Field
        sage: S.submodule(S[0].free_module())
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(18) of weight 4 with sign 0 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(18),Integer(4))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> S[Integer(0)]
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(18) of weight 4 with sign 0 over Rational Field
        >>> S.submodule(S[Integer(0)].free_module())
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(18) of weight 4 with sign 0 over Rational Field

  submodule_from_nonembedded_module(V, Vdual=None, check=True)

    Construct a submodule of `self` from V. Here V should be a subspace of a vector space whose dimension is the same as that of `self`.

    INPUT:

    - `V` – submodule of ambient free module of the same rank as the rank of `self`

    - `check` – whether to check that V is Hecke equivariant

    OUTPUT: Hecke submodule of self

    EXAMPLES:

    Sage

        sage: M = ModularSymbols(37,2)
        sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        sage: V = (QQ**4).subspace([[1,-1,0,1/2],[0,0,1,-1/2]])
        sage: S.submodule_from_nonembedded_module(V)
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with sign 0 over Rational Field

    Python

        >>> from sage.all import *
        >>> M = ModularSymbols(Integer(37),Integer(2))
        >>> S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
        >>> V = (QQ**Integer(4)).subspace([[Integer(1),-Integer(1),Integer(0),Integer(1)/Integer(2)],[Integer(0),Integer(0),Integer(1),-Integer(1)/Integer(2)]])
        >>> S.submodule_from_nonembedded_module(V)
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with sign 0 over Rational Field