### Navigation

- index
- modules |
- next |
- previous |
- Modular Symbols »

# Ambient spaces of modular symbols

This module defines the following classes. There is an abstract base class `ModularSymbolsAmbient`, derived from `space.ModularSymbolsSpace` and `hecke.AmbientHeckeModule`. As this is an abstract base class, only derived classes should be instantiated. There are five derived classes:

- `ModularSymbolsAmbient_wtk_g0`, for modular symbols of general weight \(k\) for \(\Gamma_0(N)\);
- `ModularSymbolsAmbient_wt2_g0` (derived from `ModularSymbolsAmbient_wtk_g0`), for modular symbols of weight 2 for \(\Gamma_0(N)\);
- `ModularSymbolsAmbient_wtk_g1`, for modular symbols of general weight \(k\) for \(\Gamma_1(N)\);
- `ModularSymbolsAmbient_wtk_gamma_h`, for modular symbols of general weight \(k\) for \(\Gamma_H\), where \(H\) is a subgroup of \(\ZZ/N\ZZ\);
- `ModularSymbolsAmbient_wtk_eps`, for modular symbols of general weight \(k\) and character \(\epsilon\).

EXAMPLES:

We compute a space of modular symbols modulo 2. The dimension is different from that of the corresponding space in characteristic 0:

    sage: M = ModularSymbols(11,4,base_ring=GF(2)); M
    Modular Symbols space of dimension 7 for Gamma_0(11) of weight 4
    with sign 0 over Finite Field of size 2
    sage: M.basis()
    ([X*Y,(1,0)], [X*Y,(1,8)], [X*Y,(1,9)], [X^2,(0,1)], [X^2,(1,8)], [X^2,(1,9)], [X^2,(1,10)])
    sage: M0 =  ModularSymbols(11,4,base_ring=QQ); M0
    Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4
    with sign 0 over Rational Field
    sage: M0.basis()
    ([X^2,(0,1)], [X^2,(1,6)], [X^2,(1,7)], [X^2,(1,8)], [X^2,(1,9)], [X^2,(1,10)])

The characteristic polynomial of the Hecke operator \(T_2\) has an extra factor \(x\).

    sage: M.T(2).matrix().fcp('x')
    (x + 1)^2 * x^5
    sage: M0.T(2).matrix().fcp('x')
    (x - 9)^2 * (x^2 - 2*x - 2)^2

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient`(group, weight, sign, base_ring, character=None, custom_init=None)

  Bases: `sage.modular.modsym.space.ModularSymbolsSpace`, `sage.modular.hecke.ambient_module.AmbientHeckeModule`

  An ambient space of modular symbols for a congruence subgroup of \(SL_2(\ZZ)\).

  This class is an abstract base class, so only derived classes should be instantiated.

  INPUT:

  - `weight` - an integer
  - `group` - a congruence subgroup.
  - `sign` - an integer, either -1, 0, or 1
  - `base_ring` - a commutative ring
  - `custom_init` - a function that is called with self as input before any computations are done using self; this could be used to set a custom modular symbols presentation.
  `base_extend`(R)

    Canonically change the base ring to R.

    EXAMPLE:

        sage: M = ModularSymbols(DirichletGroup(5).0, 7); MM = M.base_extend(CyclotomicField(8)); MM
        Modular Symbols space of dimension 6 and level 5, weight 7, character [zeta8^2], sign 0, over Cyclotomic Field of order 8 and degree 4
        sage: MM.base_extend(CyclotomicField(4))
        Traceback (most recent call last):
        ...
        ValueError: No coercion defined

  `boundary_map`()

    Return the boundary map to the corresponding space of boundary modular symbols.

    EXAMPLES:

        sage: ModularSymbols(20,2).boundary_map()
        Hecke module morphism boundary map defined by the matrix
        [ 1 -1  0  0  0  0]
        [ 0  1 -1  0  0  0]
        [ 0  1  0 -1  0  0]
        [ 0  0  0 -1  1  0]
        [ 0  1  0 -1  0  0]
        [ 0  0  1 -1  0  0]
        [ 0  1  0  0  0 -1]
        Domain: Modular Symbols space of dimension 7 for Gamma_0(20) of weight ...
        Codomain: Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(20) ...
        sage: type(ModularSymbols(20,2).boundary_map())
        <class 'sage.modular.hecke.morphism.HeckeModuleMorphism_matrix'>

  `boundary_space`()

    Return the subspace of boundary modular symbols of this modular symbols ambient space.

    EXAMPLES:

        sage: M = ModularSymbols(20, 2)
        sage: B = M.boundary_space(); B
        Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(20) of weight 2 and over Rational Field
        sage: M.cusps()
        [Infinity, 0, -1/4, 1/5, -1/2, 1/10]
        sage: M.dimension()
        7
        sage: B.dimension()
        6

  `change_ring`(R)

    Change the base ring to R.

    EXAMPLES:

        sage: ModularSymbols(Gamma1(13), 2).change_ring(GF(17))
        Modular Symbols space of dimension 15 for Gamma_1(13) of weight 2 with sign 0 and over Finite Field of size 17
        sage: M = ModularSymbols(DirichletGroup(5).0, 7); MM=M.change_ring(CyclotomicField(8)); MM
        Modular Symbols space of dimension 6 and level 5, weight 7, character [zeta8^2], sign 0, over Cyclotomic Field of order 8 and degree 4
        sage: MM.change_ring(CyclotomicField(4)) == M
        True
        sage: M.change_ring(QQ)
        Traceback (most recent call last):
        ...
        ValueError: cannot coerce element of order 4 into self

  `compact_newform_eigenvalues`(v, names='alpha')

    Return compact systems of eigenvalues for each Galois conjugacy class of cuspidal newforms in this ambient space.

    INPUT:

    - `v` - list of positive integers

    OUTPUT:

    - `list` - of pairs (E, x), where E*x is a vector with entries the eigenvalues \(a_n\) for \(n \in v\).

    EXAMPLES:

        sage: M = ModularSymbols(43,2,1)
        sage: X = M.compact_newform_eigenvalues(prime_range(10))
        sage: X[0][0] * X[0][1]
        (-2, -2, -4, 0)
        sage: X[1][0] * X[1][1]
        (alpha1, -alpha1, -alpha1 + 2, alpha1 - 2)

        sage: M = ModularSymbols(DirichletGroup(24,QQ).1,2,sign=1)
        sage: M.compact_newform_eigenvalues(prime_range(10),'a')
        [(
        [-1/2 -1/2]
        [ 1/2 -1/2]
        [  -1    1]
        [  -2    0], (1, -2*a0 - 1)
        )]
        sage: a = M.compact_newform_eigenvalues([1..10],'a')[0]
        sage: a[0]*a[1]
        (1, a0, a0 + 1, -2*a0 - 2, -2*a0 - 2, -a0 - 2, -2, 2*a0 + 4, -1, 2*a0 + 4)
        sage: M = ModularSymbols(DirichletGroup(13).0^2,2,sign=1)
        sage: M.compact_newform_eigenvalues(prime_range(10),'a')
        [(
        [  -zeta6 - 1]
        [ 2*zeta6 - 2]
        [-2*zeta6 + 1]
        [           0], (1)
        )]
        sage: a = M.compact_newform_eigenvalues([1..10],'a')[0]
        sage: a[0]*a[1]
        (1, -zeta6 - 1, 2*zeta6 - 2, zeta6, -2*zeta6 + 1, -2*zeta6 + 4, 0, 2*zeta6 - 1, -zeta6, 3*zeta6 - 3)

  `compute_presentation`()

    Compute and cache the presentation of this space.

    EXAMPLES:

        sage: ModularSymbols(11,2).compute_presentation() # no output

  `cuspidal_submodule`()

    The cuspidal submodule of this modular symbols ambient space.

    EXAMPLES:

        sage: M = ModularSymbols(12,2,0,GF(5)) ; M
        Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Finite Field of size 5
        sage: M.cuspidal_submodule()
        Modular Symbols subspace of dimension 0 of Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Finite Field of size 5
        sage: ModularSymbols(1,24,-1).cuspidal_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 24 with sign -1 over Rational Field

    The cuspidal submodule of the cuspidal submodule is itself:

        sage: M = ModularSymbols(389)
        sage: S = M.cuspidal_submodule()
        sage: S.cuspidal_submodule() is S
        True

  `cusps`()

    Return the set of cusps for this modular symbols space.

    EXAMPLES:

        sage: ModularSymbols(20,2).cusps()
        [Infinity, 0, -1/4, 1/5, -1/2, 1/10]

  `dual_star_involution_matrix`()

    Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.

    EXAMPLES:

        sage: ModularSymbols(20,2).dual_star_involution_matrix()
        [1 0 0 0 0 0 0]
        [0 1 0 0 0 0 0]
        [0 0 0 0 1 0 0]
        [0 0 0 1 0 0 0]
        [0 0 1 0 0 0 0]
        [0 0 0 0 0 1 0]
        [0 0 0 0 0 0 1]

  `eisenstein_submodule`()

    Return the Eisenstein submodule of this space of modular symbols.

    EXAMPLES:

        sage: ModularSymbols(20,2).eisenstein_submodule()
        Modular Symbols subspace of dimension 5 of Modular Symbols space of dimension 7 for Gamma_0(20) of weight 2 with sign 0 over Rational Field

  `element`(x)

    Creates and returns an element of self from a modular symbol, if possible.

    INPUT:

    - `x` - an object of one of the following types: ModularSymbol, ManinSymbol.

    OUTPUT:

    ModularSymbol - a modular symbol with parent self.

    EXAMPLES:

        sage: M = ModularSymbols(11,4,1)
        sage: M.T(3)
        Hecke operator T_3 on Modular Symbols space of dimension 4 for Gamma_0(11) of weight 4 with sign 1 over Rational Field
        sage: M.T(3)(M.0)
        28*[X^2,(0,1)] + 2*[X^2,(1,7)] - [X^2,(1,9)] - [X^2,(1,10)]
        sage: M.T(3)(M.0).element()
        (28, 2, -1, -1)

  `factor`()

    Returns a list of pairs \((S,e)\) where \(S\) is spaces of modular symbols and self is isomorphic to the direct sum of the \(S^e\) as a module over the anemic Hecke algebra adjoin the star involution. The cuspidal \(S\) are all simple, but the Eisenstein factors need not be simple.

    EXAMPLES:

        sage: ModularSymbols(Gamma0(22), 2).factorization()
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 *
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 *
        (Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field)

        sage: ModularSymbols(1,6,0,GF(2)).factorization()
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2) *
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2)

        sage: ModularSymbols(18,2).factorization()
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field) *
        (Modular Symbols subspace of dimension 5 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field)

        sage: M = ModularSymbols(DirichletGroup(38,CyclotomicField(3)).0^2,  2, +1); M
        Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2
        sage: M.factorization()                    # long time (about 8 seconds)
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2)

  `factorization`()

    Returns a list of pairs \((S,e)\) where \(S\) is spaces of modular symbols and self is isomorphic to the direct sum of the \(S^e\) as a module over the anemic Hecke algebra adjoin the star involution. The cuspidal \(S\) are all simple, but the Eisenstein factors need not be simple.

    EXAMPLES:

        sage: ModularSymbols(Gamma0(22), 2).factorization()
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 *
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 *
        (Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field)

        sage: ModularSymbols(1,6,0,GF(2)).factorization()
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2) *
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2)

        sage: ModularSymbols(18,2).factorization()
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field) *
        (Modular Symbols subspace of dimension 5 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field)

        sage: M = ModularSymbols(DirichletGroup(38,CyclotomicField(3)).0^2,  2, +1); M
        Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2
        sage: M.factorization()                    # long time (about 8 seconds)
        (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) *
        (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2)

  `integral_structure`(algorithm='default')

    Return the \(\ZZ\)-structure of this modular symbols space, generated by all integral modular symbols.

    INPUT:

    - `algorithm` - string (default: ‘default’ - choose heuristically)
      - `'pari'` - use pari for the HNF computation
      - `'padic'` - use p-adic algorithm (only good for dense case)

    ALGORITHM: It suffices to consider lattice generated by the free generating symbols \(X^iY^{k-2-i}.(u,v)\) after quotienting out by the \(S\) (and \(I\)) relations, since the quotient by these relations is the same over any ring.

    EXAMPLES: In weight 2 the rational basis is often integral.

        sage: M = ModularSymbols(11,2)
        sage: M.integral_structure()
        Free module of degree 3 and rank 3 over Integer Ring
        Echelon basis matrix:
        [1 0 0]
        [0 1 0]
        [0 0 1]

    This is rarely the case in higher weight:

        sage: M = ModularSymbols(6,4)
        sage: M.integral_structure()
        Free module of degree 6 and rank 6 over Integer Ring
        Echelon basis matrix:
        [  1   0   0   0   0   0]
        [  0   1   0   0   0   0]
        [  0   0 1/2 1/2 1/2 1/2]
        [  0   0   0   1   0   0]
        [  0   0   0   0   1   0]
        [  0   0   0   0   0   1]

    Here is an example involving \(\Gamma_1(N)\).

        sage: M = ModularSymbols(Gamma1(5),6)
        sage: M.integral_structure()
        Free module of degree 10 and rank 10 over Integer Ring
        Echelon basis matrix:
        [     1      0      0      0      0      0      0      0      0      0]
        [     0      1      0      0      0      0      0      0      0      0]
        [     0      0  1/102      0  5/204  1/136  23/24   3/17 43/136 69/136]
        [     0      0      0   1/48      0   1/48  23/24    1/6    1/8  17/24]
        [     0      0      0      0   1/24      0  23/24    1/3    1/6    1/2]
        [     0      0      0      0      0   1/24  23/24    1/3  11/24   5/24]
        [     0      0      0      0      0      0      1      0      0      0]
        [     0      0      0      0      0      0      0    1/2      0    1/2]
        [     0      0      0      0      0      0      0      0    1/2    1/2]
        [     0      0      0      0      0      0      0      0      0      1]

  `is_cuspidal`()

    Returns True if this space is cuspidal, else False.

    EXAMPLES:

        sage: M = ModularSymbols(20,2)
        sage: M.is_cuspidal()
        False
        sage: S = M.cuspidal_subspace()
        sage: S.is_cuspidal()
        True
        sage: S = M.eisenstein_subspace()
        sage: S.is_cuspidal()
        False

  `is_eisenstein`()

    Returns True if this space is Eisenstein, else False.

    EXAMPLES:

        sage: M = ModularSymbols(20,2)
        sage: M.is_eisenstein()
        False
        sage: S = M.eisenstein_submodule()
        sage: S.is_eisenstein()
        True
        sage: S = M.cuspidal_subspace()
        sage: S.is_eisenstein()
        False

  `manin_basis`()

    Return a list of indices into the list of Manin generators (see `self.manin_generators()`) such that those symbols form a basis for the quotient of the \(\QQ\)-vector space spanned by Manin symbols modulo the relations.

    EXAMPLES:

        sage: M = ModularSymbols(2,2)
        sage: M.manin_basis()
        [1]
        sage: [M.manin_generators()[i] for i in M.manin_basis()]
        [(1,0)]
        sage: M = ModularSymbols(6,2)
        sage: M.manin_basis()
        [1, 10, 11]
        sage: [M.manin_generators()[i] for i in M.manin_basis()]
        [(1,0), (3,1), (3,2)]

  `manin_generators`()

    Return list of all Manin symbols for this space. These are the generators in the presentation of this space by Manin symbols.

    EXAMPLES:

        sage: M = ModularSymbols(2,2)
        sage: M.manin_generators()
        [(0,1), (1,0), (1,1)]

        sage: M = ModularSymbols(1,6)
        sage: M.manin_generators()
        [[Y^4,(0,0)], [X*Y^3,(0,0)], [X^2*Y^2,(0,0)], [X^3*Y,(0,0)], [X^4,(0,0)]]

  `manin_gens_to_basis`()

    Return the matrix expressing the manin symbol generators in terms of the basis.

    EXAMPLES:

        sage: ModularSymbols(11,2).manin_gens_to_basis()
        [-1  0  0]
        [ 1  0  0]
        [ 0  0  0]
        [ 0  0  1]
        [ 0 -1  1]
        [ 0 -1  0]
        [ 0  0 -1]
        [ 0  0 -1]
        [ 0  1 -1]
        [ 0  1  0]
        [ 0  0  1]
        [ 0  0  0]

  `manin_symbol`(x, check=True)

    Construct a Manin Symbol from the given data.

    INPUT:

    - `x` (list) – either \([u,v]\) or \([i,u,v]\), where \(0\le i\le k-2\) where \(k\) is the weight, and \(u\),`v` are integers defining a valid element of \(\mathbb{P}^1(N)\), where \(N\) is the level.

    OUTPUT:

    (ManinSymbol) the monomial Manin Symbol associated to \([i;(u,v)]\), with \(i=0\) if not supplied, corresponding to the symbol \([X^i*Y^{k-2-i}, (u,v)]\).

    EXAMPLES:

        sage: M = ModularSymbols(11,4,1)
        sage: M.manin_symbol([2,5,6])
        [X^2,(1,10)]

  `manin_symbols`()

    Return the list of Manin symbols for this modular symbols ambient space.

    EXAMPLES:

        sage: ModularSymbols(11,2).manin_symbols()
        Manin Symbol List of weight 2 for Gamma0(11)

  `manin_symbols_basis`()

    A list of Manin symbols that form a basis for the ambient space self. INPUT:

    - `ModularSymbols self` - an ambient space of modular symbols

    OUTPUT:

    - `list` - a list of 2-tuples (if the weight is 2) or 3-tuples, which represent the Manin symbols basis for self.

    EXAMPLES:

        sage: m = ModularSymbols(23)
        sage: m.manin_symbols_basis()
        [(1,0), (1,17), (1,19), (1,20), (1,21)]
        sage: m = ModularSymbols(6, weight=4, sign=-1)
        sage: m.manin_symbols_basis()
        [[X^2,(2,1)]]

  `modular_symbol`(x, check=True)

    Create a modular symbol in this space.

    INPUT:

    - `x` (list) – a list of either 2 or 3 entries:

      > - 2 entries: \([\alpha, \beta]\) where \(\alpha\) and \(\beta\) are cusps;
      > - 3 entries: \([i, \alpha, \beta]\) where \(0\le i\le k-2\) and \(\alpha\) and \(\beta\) are cusps;

    - `check` (bool, default True) – flag that determines whether the input `x` needs processing: use check=False for efficiency if the input `x` is a list of length 3 whose first entry is an Integer, and whose second and third entries are Cusps (see examples).

    OUTPUT:

    (Modular Symbol) The modular symbol \(Y^{k-2}\{\alpha, \beta\}\). or \(X^i Y^{k-2-i}\{\alpha,\beta\}\).

    EXAMPLES:

        sage: set_modsym_print_mode('modular')
        sage: M = ModularSymbols(11)
        sage: M.modular_symbol([2/11, oo])
        -{-1/9, 0}
        sage: M.1
        {-1/8, 0}
        sage: M.modular_symbol([-1/8, 0])
        {-1/8, 0}
        sage: M.modular_symbol([0, -1/8, 0])
        {-1/8, 0}
        sage: M.modular_symbol([10, -1/8, 0])
        Traceback (most recent call last):
        ...
        ValueError: The first entry of the tuple (=[10, -1/8, 0]) must be an integer between 0 and k-2 (=0).

        sage: N = ModularSymbols(6,4)
        sage: set_modsym_print_mode('manin')
        sage: N([1,Cusp(-1/4),Cusp(0)])
        17/2*[X^2,(2,3)] - 9/2*[X^2,(2,5)] + 15/2*[X^2,(3,1)] - 15/2*[X^2,(3,2)]
        sage: N([1,Cusp(-1/2),Cusp(0)])
        1/2*[X^2,(2,3)] + 3/2*[X^2,(2,5)] + 3/2*[X^2,(3,1)] - 3/2*[X^2,(3,2)]

    Use check=False for efficiency if the input x is a list of length 3 whose first entry is an Integer, and whose second and third entries are cusps:

        sage: M.modular_symbol([0, Cusp(2/11), Cusp(oo)], check=False)
        -(1,9)

        sage: set_modsym_print_mode()   # return to default.

  `modular_symbol_sum`(x, check=True)

    Construct a modular symbol sum.

    INPUT:

    - `x` (list) – \([f, \alpha, \beta]\) where \(f = \sum_{i=0}^{k-2} a_i X^i Y^{k-2-i}\) is a homogeneous polynomial over \(\ZZ\) of degree \(k\) and \(\alpha\) and \(\beta\) are cusps.
    - `check` (bool, default True) – if True check the validity of the input tuple `x`

    OUTPUT:

    The sum \(\sum_{i=0}^{k-2} a_i [ i, \alpha, \beta ]\) as an element of this modular symbol space.

    EXAMPLES:

    > sage: M = ModularSymbols(11,4) sage: R.<X,Y>=QQ[] sage: M.modular_symbol_sum([X*Y,Cusp(0),Cusp(Infinity)]) -3/14*[X^2,(1,6)] + 1/14*[X^2,(1,7)] - 1/14*[X^2,(1,8)] + 1/2*[X^2,(1,9)] - 2/7*[X^2,(1,10)]

  `modular_symbols_of_sign`(sign)

    Returns a space of modular symbols with the same defining properties (weight, level, etc.) as this space except with given sign.

    INPUT:

    - `sign` (int) – A sign (\(+1\), \(-1\) or \(0\)).

    OUTPUT:

    (ModularSymbolsAmbient) A space of modular symbols with the same defining properties (weight, level, etc.) as this space except with given sign.

    EXAMPLES:

        sage: M = ModularSymbols(Gamma0(11),2,sign=0)
        sage: M
        Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field
        sage: M.modular_symbols_of_sign(-1)
        Modular Symbols space of dimension 1 for Gamma_0(11) of weight 2 with sign -1 over Rational Field
        sage: M = ModularSymbols(Gamma1(11),2,sign=0)
        sage: M.modular_symbols_of_sign(-1)
        Modular Symbols space of dimension 1 for Gamma_1(11) of weight 2 with sign -1 and over Rational Field

  `modular_symbols_of_weight`(k)

    Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight \(k\).

    INPUT:

    - `k` (int) – A positive integer.

    OUTPUT:

    (ModularSymbolsAmbient) A space of modular symbols with the same defining properties (level, sign) as this space except with given weight.

    EXAMPLES:

        sage: M = ModularSymbols(Gamma1(6),2,sign=0)
        sage: M.modular_symbols_of_weight(3)
        Modular Symbols space of dimension 4 for Gamma_1(6) of weight 3 with sign 0 and over Rational Field

  `new_submodule`(p=None)

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

    INPUT:

    - `p` - (default: None); if not None, return only the \(p\)-new submodule.

    OUTPUT:

    The new or \(p\)-new submodule of this modular symbols ambient space.

    EXAMPLES:

        sage: ModularSymbols(100).new_submodule()
        Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 31 for Gamma_0(100) of weight 2 with sign 0 over Rational Field
        sage: ModularSymbols(389).new_submodule()
        Modular Symbols space of dimension 65 for Gamma_0(389) of weight 2 with sign 0 over Rational Field

  `p1list`()

    Return a P1list of the level of this modular symbol space.

    EXAMPLES:

        sage: ModularSymbols(11,2).p1list()
        The projective line over the integers modulo 11

  `rank`()

    Returns the rank of this modular symbols ambient space.

    OUTPUT:

    (int) The rank of this space of modular symbols.

    EXAMPLES:

        sage: M = ModularSymbols(389)
        sage: M.rank()
        65

        sage: ModularSymbols(11,sign=0).rank()
        3
        sage: ModularSymbols(100,sign=0).rank()
        31
        sage: ModularSymbols(22,sign=1).rank()
        5
        sage: ModularSymbols(1,12).rank()
        3
        sage: ModularSymbols(3,4).rank()
        2
        sage: ModularSymbols(8,6,sign=-1).rank()
        3

  `star_involution`()

    Return the star involution on this modular symbols space.

    OUTPUT:

    (matrix) The matrix of the star involution on this space, which is induced by complex conjugation on modular symbols, with respect to the standard basis.

    EXAMPLES:

        sage: ModularSymbols(20,2).star_involution()
        Hecke module morphism Star involution on Modular Symbols space of dimension 7 for Gamma_0(20) of weight 2 with sign 0 over Rational Field defined by the matrix
        [1 0 0 0 0 0 0]
        [0 1 0 0 0 0 0]
        [0 0 0 0 1 0 0]
        [0 0 0 1 0 0 0]
        [0 0 1 0 0 0 0]
        [0 0 0 0 0 1 0]
        [0 0 0 0 0 0 1]
        Domain: Modular Symbols space of dimension 7 for Gamma_0(20) of weight ...
        Codomain: Modular Symbols space of dimension 7 for Gamma_0(20) of weight ...

  `submodule`(M, dual_free_module=None, check=True)

    Return the submodule with given generators or free module \(M\).

    INPUT:

    - `M` - either a submodule of this ambient free module, or generators for a submodule;

    - `dual_free_module` (bool, default None) – this may be

        useful to speed up certain calculations; it is the corresponding submodule of the ambient dual module;

    - `check` (bool, default True) – if True, check that \(M\) is

        a submodule, i.e. is invariant under all Hecke operators.

    OUTPUT:

    A subspace of this modular symbol space.

    EXAMPLES:

        sage: M = ModularSymbols(11)
        sage: M.submodule([M.0])
        Traceback (most recent call last):
        ...
        ValueError: The submodule must be invariant under all Hecke operators.
        sage: M.eisenstein_submodule().basis()
        ((1,0) - 1/5*(1,9),)
        sage: M.basis()
        ((1,0), (1,8), (1,9))
        sage: M.submodule([M.0 - 1/5*M.2])
        Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field

    Note

    It would make more sense to only check that \(M\) is invariant under the Hecke operators with index coprime to the level. Unfortunately, I do not know a reasonable algorithm for determining whether a module is invariant under just the anemic Hecke algebra, since I do not know an analogue of the Sturm bound for the anemic Hecke algebra. - William Stein, 2007-07-27

  `twisted_winding_element`(i, eps)

    Return the twisted winding element of given degree and character.

    INPUT:

    - `i` (int) – an integer, \(0\le i\le k-2\) where \(k\) is the weight.
    - `eps` (character) – a Dirichlet character

    OUTPUT:

    (modular symbol) The so-called ‘twisted winding element’:

    \[\sum_{a \in (\ZZ/m\ZZ)^\times} \varepsilon(a) * [ i, 0, a/m ].\]

    Note

    This will only work if the base ring of the modular symbol space contains the character values.

    EXAMPLES:

        sage: eps = DirichletGroup(5)[2]
        sage: K = eps.base_ring()
        sage: M = ModularSymbols(37,2,0,K)
        sage: M.twisted_winding_element(0,eps)
        2*(1,23) - 2*(1,32) + 2*(1,34)

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient_wt2_g0`(N, sign, F, custom_init=None)

  Bases: `sage.modular.modsym.ambient.ModularSymbolsAmbient_wtk_g0`

  Modular symbols for \(\Gamma_0(N)\) of integer weight \(2\) over the field \(F\).

  INPUT:

  - `N` - int, the level
  - `sign` - int, either -1, 0, or 1

  OUTPUT:

  The space of modular symbols of weight \(2\), trivial character, level \(N\) and given sign.

  EXAMPLES:

      sage: ModularSymbols(Gamma0(12),2)
      Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Rational Field

  `boundary_space`()

    Return the space of boundary modular symbols for this space.

    EXAMPLES:

        sage: M = ModularSymbols(100,2)
        sage: M.boundary_space()
        Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(100) of weight 2 and over Rational Field

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient_wtk_eps`(eps, weight, sign, base_ring, custom_init=None)

  Bases: `sage.modular.modsym.ambient.ModularSymbolsAmbient`

  Space of modular symbols with given weight, character, base ring and sign.

  INPUT:

  - `eps` - dirichlet.DirichletCharacter, the “Nebentypus” character.
  - `weight` - int, the weight = 2
  - `sign` - int, either -1, 0, or 1
  - `base_ring` - the base ring. It must be possible to change the ring of the character to this base ring (not always canonically).

  EXAMPLES:

      sage: eps = DirichletGroup(4).gen(0)
      sage: eps.order()
      2
      sage: ModularSymbols(eps, 2)
      Modular Symbols space of dimension 0 and level 4, weight 2, character [-1], sign 0, over Rational Field
      sage: ModularSymbols(eps, 3)
      Modular Symbols space of dimension 2 and level 4, weight 3, character [-1], sign 0, over Rational Field

  We next create a space with character of order bigger than 2.

      sage: eps = DirichletGroup(5).gen(0)
      sage: eps     # has order 4
      Dirichlet character modulo 5 of conductor 5 mapping 2 |--> zeta4
      sage: ModularSymbols(eps, 2).dimension()
      0
      sage: ModularSymbols(eps, 3).dimension()
      2

  Here is another example:

      sage: G, e = DirichletGroup(5).objgen()
      sage: M = ModularSymbols(e,3)
      sage: loads(M.dumps()) == M
      True

  `boundary_space`()

    Return the space of boundary modular symbols for this space.

    EXAMPLES:

        sage: eps = DirichletGroup(5).gen(0)
        sage: M = ModularSymbols(eps, 2)
        sage: M.boundary_space()
        Boundary Modular Symbols space of level 5, weight 2, character [zeta4] and dimension 0 over Cyclotomic Field of order 4 and degree 2

  `manin_symbols`()

    Return the Manin symbol list of this modular symbol space.

    EXAMPLES:

        sage: eps = DirichletGroup(5).gen(0)
        sage: M = ModularSymbols(eps, 2)
        sage: M.manin_symbols()
        Manin Symbol List of weight 2 for Gamma1(5) with character [zeta4]
        sage: len(M.manin_symbols())
        6

  `modular_symbols_of_level`(N)

    Returns a space of modular symbols with the same parameters as this space except with level \(N\).

    INPUT:

    - `N` (int) – a positive integer.

    OUTPUT:

    (Modular Symbol space) A space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with level \(N\).

    EXAMPLES:

        sage: eps = DirichletGroup(5).gen(0)
        sage: M = ModularSymbols(eps, 2); M
        Modular Symbols space of dimension 0 and level 5, weight 2, character [zeta4], sign 0, over Cyclotomic Field of order 4 and degree 2
        sage: M.modular_symbols_of_level(15)
        Modular Symbols space of dimension 0 and level 15, weight 2, character [1, zeta4], sign 0, over Cyclotomic Field of order 4 and degree 2

  `modular_symbols_of_sign`(sign)

    Returns a space of modular symbols with the same defining properties (weight, level, etc.) as this space except with given sign.

    INPUT:

    - `sign` (int) – A sign (\(+1\), \(-1\) or \(0\)).

    OUTPUT:

    (ModularSymbolsAmbient) A space of modular symbols with the same defining properties (weight, level, etc.) as this space except with given sign.

    EXAMPLES:

        sage: eps = DirichletGroup(5).gen(0)
        sage: M = ModularSymbols(eps, 2); M
        Modular Symbols space of dimension 0 and level 5, weight 2, character [zeta4], sign 0, over Cyclotomic Field of order 4 and degree 2
        sage: M.modular_symbols_of_sign(0) == M
        True
        sage: M.modular_symbols_of_sign(+1)
        Modular Symbols space of dimension 0 and level 5, weight 2, character [zeta4], sign 1, over Cyclotomic Field of order 4 and degree 2
        sage: M.modular_symbols_of_sign(-1)
        Modular Symbols space of dimension 0 and level 5, weight 2, character [zeta4], sign -1, over Cyclotomic Field of order 4 and degree 2

  `modular_symbols_of_weight`(k)

    Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight \(k\).

    INPUT:

    - `k` (int) – A positive integer.

    OUTPUT:

    (ModularSymbolsAmbient) A space of modular symbols with the same defining properties (level, sign) as this space except with given weight.

    EXAMPLES:

        sage: eps = DirichletGroup(5).gen(0)
        sage: M = ModularSymbols(eps, 2); M
        Modular Symbols space of dimension 0 and level 5, weight 2, character [zeta4], sign 0, over Cyclotomic Field of order 4 and degree 2
        sage: M.modular_symbols_of_weight(3)
        Modular Symbols space of dimension 2 and level 5, weight 3, character [zeta4], sign 0, over Cyclotomic Field of order 4 and degree 2
        sage: M.modular_symbols_of_weight(2) == M
        True

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient_wtk_g0`(N, k, sign, F, custom_init=None)

  Bases: `sage.modular.modsym.ambient.ModularSymbolsAmbient`

  Modular symbols for \(\Gamma_0(N)\) of integer weight \(k > 2\) over the field \(F\).

  For weight \(2\), it is faster to use `ModularSymbols_wt2_g0`.

  INPUT:

  - `N` - int, the level
  - `k` - integer weight = 2.
  - `sign` - int, either -1, 0, or 1
  - `F` - field

  EXAMPLES:

      sage: ModularSymbols(1,12)
      Modular Symbols space of dimension 3 for Gamma_0(1) of weight 12 with sign 0 over Rational Field
      sage: ModularSymbols(1,12, sign=1).dimension()
      2
      sage: ModularSymbols(15,4, sign=-1).dimension()
      4
      sage: ModularSymbols(6,6).dimension()
      10
      sage: ModularSymbols(36,4).dimension()
      36

  `boundary_space`()

    Return the space of boundary modular symbols for this space.

    EXAMPLES:

        sage: M = ModularSymbols(100,2)
        sage: M.boundary_space()
        Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(100) of weight 2 and over Rational Field

  `manin_symbols`()

    Return the Manin symbol list of this modular symbol space.

    EXAMPLES:

        sage: M = ModularSymbols(100,4)
        sage: M.manin_symbols()
        Manin Symbol List of weight 4 for Gamma0(100)
        sage: len(M.manin_symbols())
        540

  `modular_symbols_of_level`(N)

    Returns a space of modular symbols with the same parameters as this space except with level \(N\).

    INPUT:

    - `N` (int) – a positive integer.

    OUTPUT:

    (Modular Symbol space) A space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with level \(N\).

    For example, if self is the space of modular symbols of weight \(2\) for \(\Gamma_0(22)\), and level is \(11\), then this function returns the modular symbol space of weight \(2\) for \(\Gamma_0(11)\).

    EXAMPLES:

        sage: M = ModularSymbols(11)
        sage: M.modular_symbols_of_level(22)
        Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field
        sage: M = ModularSymbols(Gamma1(6))
        sage: M.modular_symbols_of_level(12)
        Modular Symbols space of dimension 9 for Gamma_1(12) of weight 2 with sign 0 and over Rational Field

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient_wtk_g1`(level, weight, sign, F, custom_init=None)

  Bases: `sage.modular.modsym.ambient.ModularSymbolsAmbient`

  INPUT:

  - `level` - int, the level
  - `weight` - int, the weight = 2
  - `sign` - int, either -1, 0, or 1
  - `F` - field

  EXAMPLES:

      sage: ModularSymbols(Gamma1(17),2)
      Modular Symbols space of dimension 25 for Gamma_1(17) of weight 2 with sign 0 and over Rational Field
      sage: [ModularSymbols(Gamma1(7),k).dimension() for k in [2,3,4,5]]
      [5, 8, 12, 16]

      sage: ModularSymbols(Gamma1(7),3)
      Modular Symbols space of dimension 8 for Gamma_1(7) of weight 3 with sign 0 and over Rational Field

  `boundary_space`()

    Return the space of boundary modular symbols for this space.

    EXAMPLES:

        sage: M = ModularSymbols(100,2)
        sage: M.boundary_space()
        Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(100) of weight 2 and over Rational Field

  `manin_symbols`()

    Return the Manin symbol list of this modular symbol space.

    EXAMPLES:

        sage: M = ModularSymbols(Gamma1(30),4)
        sage: M.manin_symbols()
        Manin Symbol List of weight 4 for Gamma1(30)
        sage: len(M.manin_symbols())
        1728

  `modular_symbols_of_level`(N)

    Returns a space of modular symbols with the same parameters as this space except with level \(N\).

    INPUT:

    - `N` (int) – a positive integer.

    OUTPUT:

    (Modular Symbol space) A space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with level \(N\).

    For example, if self is the space of modular symbols of weight \(2\) for \(\Gamma_0(22)\), and level is \(11\), then this function returns the modular symbol space of weight \(2\) for \(\Gamma_0(11)\).

    EXAMPLES:

        sage: M = ModularSymbols(Gamma1(30),4); M
        Modular Symbols space of dimension 144 for Gamma_1(30) of weight 4 with sign 0 and over Rational Field
        sage: M.modular_symbols_of_level(22)
        Modular Symbols space of dimension 90 for Gamma_1(22) of weight 4 with sign 0 and over Rational Field

class `sage.modular.modsym.ambient.``ModularSymbolsAmbient_wtk_gamma_h`(group, weight, sign, F, custom_init=None)

  Bases: `sage.modular.modsym.ambient.ModularSymbolsAmbient`

  Initialize a space of modular symbols for \(\Gamma_H(N)\).

  INPUT:

  - `group` - a congruence subgroup \(\Gamma_H(N)\).
  - `weight` - int, the weight = 2
  - `sign` - int, either -1, 0, or 1
  - `F` - field

  EXAMPLES:

      sage: ModularSymbols(GammaH(15,[4]),2)
      Modular Symbols space of dimension 9 for Congruence Subgroup Gamma_H(15) with H generated by [4] of weight 2 with sign 0 and over Rational Field

  `boundary_space`()

    Return the space of boundary modular symbols for this space.

    EXAMPLES:

        sage: M = ModularSymbols(GammaH(15,[4]),2)
        sage: M.boundary_space()
        Boundary Modular Symbols space for Congruence Subgroup Gamma_H(15) with H generated by [4] of weight 2 over Rational Field

  `manin_symbols`()

    Return the Manin symbol list of this modular symbol space.

    EXAMPLES:

        sage: M = ModularSymbols(GammaH(15,[4]),2)
        sage: M.manin_symbols()
        Manin Symbol List of weight 2 for Congruence Subgroup Gamma_H(15) with H generated by [4]
        sage: len(M.manin_symbols())
        96

  `modular_symbols_of_level`(N)

    Returns a space of modular symbols with the same parameters as this space except with level \(N\), which should be either a divisor or a multiple of the level of self.

    TESTS:

        sage: M = ModularSymbols(GammaH(15,[7]),6)
        sage: M.modular_symbols_of_level(5)
        Modular Symbols space of dimension 4 for Gamma_0(5) of weight 6 with sign 0 over Rational Field
        sage: M.modular_symbols_of_level(30)
        Traceback (most recent call last):
        ...
        ValueError: N (=30) should be a factor of the level of this space (=15)
        sage: M.modular_symbols_of_level(73)
        Traceback (most recent call last):
        ...
        ValueError: N (=73) should be a factor of the level of this space (=15)

### Navigation

- index
- modules |
- next |
- previous |
- Modular Symbols »