Pollack-Stevens’ modular symbols spaces¶

This module contains a class for spaces of modular symbols that use Glenn Stevens’ conventions, as explained in [PS2011].

There are two main differences between the modular symbols in this directory and the ones in sage.modular.modsym:

There is a shift in the weight: weight \(k=0\) here corresponds to weight \(k=2\) there.
There is a duality: these modular symbols are functions from \(\textrm{Div}^0(P^1(\QQ))\) (cohomological objects), the others are formal linear combinations of \(\textrm{Div}^0(P^1(\QQ))\) (homological objects).

EXAMPLES:

First we create the space of modular symbols of weight 0 (\(k=2\)) and level 11:

Sage

sage: M = PollackStevensModularSymbols(Gamma0(11), 0); M
Space of modular symbols for Congruence Subgroup Gamma0(11) with sign 0 and values in Sym^0 Q^2

Python

>>> from sage.all import *
>>> M = PollackStevensModularSymbols(Gamma0(Integer(11)), Integer(0)); M
Space of modular symbols for Congruence Subgroup Gamma0(11) with sign 0 and values in Sym^0 Q^2

Sage Live

M = PollackStevensModularSymbols(Gamma0(11), 0); M

One can also create a space of overconvergent modular symbols, by specifying a prime and a precision:

Sage

sage: M = PollackStevensModularSymbols(Gamma0(11), p = 5, prec_cap = 10, weight = 0); M
Space of overconvergent modular symbols for Congruence Subgroup Gamma0(11) with sign 0 and values in Space of 5-adic distributions with k=0 action and precision cap 10

Python

>>> from sage.all import *
>>> M = PollackStevensModularSymbols(Gamma0(Integer(11)), p = Integer(5), prec_cap = Integer(10), weight = Integer(0)); M
Space of overconvergent modular symbols for Congruence Subgroup Gamma0(11) with sign 0 and values in Space of 5-adic distributions with k=0 action and precision cap 10

Sage Live

M = PollackStevensModularSymbols(Gamma0(11), p = 5, prec_cap = 10, weight = 0); M

Currently not much functionality is available on the whole space, and these spaces are mainly used as parents for the modular symbols. These can be constructed from the corresponding classical modular symbols (or even elliptic curves) as follows:

Sage

sage: A = ModularSymbols(13, sign=1, weight=4).decomposition()[0]
sage: A.is_cuspidal()
True
sage: from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
sage: f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 13 with values in Sym^2 Q^2
sage: f.values()
[(-13, 0, -1),
 (247/2, 13/2, -6),
 (39/2, 117/2, 42),
 (-39/2, 39, 111/2),
 (-247/2, -117, -209/2)]
sage: f.parent()
Space of modular symbols for Congruence Subgroup Gamma0(13) with sign 1 and values in Sym^2 Q^2

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(13), sign=Integer(1), weight=Integer(4)).decomposition()[Integer(0)]
>>> A.is_cuspidal()
True
>>> from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
>>> f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 13 with values in Sym^2 Q^2
>>> f.values()
[(-13, 0, -1),
 (247/2, 13/2, -6),
 (39/2, 117/2, 42),
 (-39/2, 39, 111/2),
 (-247/2, -117, -209/2)]
>>> f.parent()
Space of modular symbols for Congruence Subgroup Gamma0(13) with sign 1 and values in Sym^2 Q^2

Sage Live

A = ModularSymbols(13, sign=1, weight=4).decomposition()[0]
A.is_cuspidal()
from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
f = ps_modsym_from_simple_modsym_space(A); f
f.values()
f.parent()

Sage

sage: E = EllipticCurve('37a1')
sage: phi = E.pollack_stevens_modular_symbol(); phi
Modular symbol of level 37 with values in Sym^0 Q^2
sage: phi.values()
[0, 1, 0, 0, 0, -1, 1, 0, 0]
sage: phi.parent()
Space of modular symbols for Congruence Subgroup Gamma0(37) with sign 0 and values in Sym^0 Q^2

Python

>>> from sage.all import *
>>> E = EllipticCurve('37a1')
>>> phi = E.pollack_stevens_modular_symbol(); phi
Modular symbol of level 37 with values in Sym^0 Q^2
>>> phi.values()
[0, 1, 0, 0, 0, -1, 1, 0, 0]
>>> phi.parent()
Space of modular symbols for Congruence Subgroup Gamma0(37) with sign 0 and values in Sym^0 Q^2

Sage Live

E = EllipticCurve('37a1')
phi = E.pollack_stevens_modular_symbol(); phi
phi.values()
phi.parent()

class sage.modular.pollack_stevens.space.PollackStevensModularSymbols_factory[source]¶

Bases: UniqueFactory

Create a space of Pollack-Stevens modular symbols.

INPUT:

group – integer or congruence subgroup
weight – integer \(\ge 0\), or None
sign – integer; -1, 0, 1
base_ring – ring or None
p – prime or None
prec_cap – positive integer or None
coefficients – the coefficient module (a special type of module, typically distributions), or None

If an explicit coefficient module is given, then the arguments weight, base_ring, prec_cap, and p are redundant and must be None. They are only relevant if coefficients is None, in which case the coefficient module is inferred from the other data.

Note

We emphasize that in the Pollack-Stevens notation, the weight is the usual weight minus 2, so a classical weight 2 modular form corresponds to a modular symbol of “weight 0”.

EXAMPLES:

Sage

sage: M = PollackStevensModularSymbols(Gamma0(7), weight=0, prec_cap = None); M
Space of modular symbols for Congruence Subgroup Gamma0(7) with sign 0 and values in Sym^0 Q^2

Python

>>> from sage.all import *
>>> M = PollackStevensModularSymbols(Gamma0(Integer(7)), weight=Integer(0), prec_cap = None); M
Space of modular symbols for Congruence Subgroup Gamma0(7) with sign 0 and values in Sym^0 Q^2

Sage Live

M = PollackStevensModularSymbols(Gamma0(7), weight=0, prec_cap = None); M

An example with an explicit coefficient module:

Sage

sage: D = OverconvergentDistributions(3, 7, prec_cap=10)
sage: M = PollackStevensModularSymbols(Gamma0(7), coefficients=D); M
Space of overconvergent modular symbols for Congruence Subgroup Gamma0(7) with sign 0 and values in Space of 7-adic distributions with k=3 action and precision cap 10

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(3), Integer(7), prec_cap=Integer(10))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(7)), coefficients=D); M
Space of overconvergent modular symbols for Congruence Subgroup Gamma0(7) with sign 0 and values in Space of 7-adic distributions with k=3 action and precision cap 10

Sage Live

D = OverconvergentDistributions(3, 7, prec_cap=10)
M = PollackStevensModularSymbols(Gamma0(7), coefficients=D); M

create_key(group, weight=None, sign=0, base_ring=None, p=None, prec_cap=None, coefficients=None)[source]¶

Sanitize input.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(3, 7, prec_cap=10)
sage: M = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(3), Integer(7), prec_cap=Integer(10))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(7)), coefficients=D) # indirect doctest

Sage Live

D = OverconvergentDistributions(3, 7, prec_cap=10)
M = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest

create_object(version, key)[source]¶

Create a space of modular symbols from key.

INPUT:

version – the version of the object to create
key – tuple of parameters, as created by create_key()

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(5, 7, 15)
sage: M = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest
sage: M2 = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest
sage: M is M2
True

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(5), Integer(7), Integer(15))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(7)), coefficients=D) # indirect doctest
>>> M2 = PollackStevensModularSymbols(Gamma0(Integer(7)), coefficients=D) # indirect doctest
>>> M is M2
True

Sage Live

D = OverconvergentDistributions(5, 7, 15)
M = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest
M2 = PollackStevensModularSymbols(Gamma0(7), coefficients=D) # indirect doctest
M is M2

class sage.modular.pollack_stevens.space.PollackStevensModularSymbolspace(group, coefficients, sign=0)[source]¶

Bases: Module

A class for spaces of modular symbols that use Glenn Stevens’ conventions. This class should not be instantiated directly by the user: this is handled by the factory object PollackStevensModularSymbols_factory.

INPUT:

group – congruence subgroup
coefficients – a coefficient module
sign – (default: 0) 0, -1, or 1

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 11)
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D); M.sign()
0
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D, sign=-1); M.sign()
-1
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D, sign=1); M.sign()
1

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D); M.sign()
0
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D, sign=-Integer(1)); M.sign()
-1
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D, sign=Integer(1)); M.sign()
1

Sage Live

D = OverconvergentDistributions(2, 11)
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D); M.sign()
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D, sign=-1); M.sign()
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D, sign=1); M.sign()

change_ring(new_base_ring)[source]¶

Change the base ring of this space to new_base_ring.

INPUT:

new_base_ring – a ring

OUTPUT: a space of modular symbols over the specified base

EXAMPLES:

Sage

sage: from sage.modular.pollack_stevens.distributions import Symk
sage: D = Symk(4)
sage: M = PollackStevensModularSymbols(Gamma(6), coefficients=D); M
Space of modular symbols for Congruence Subgroup Gamma(6) with sign 0 and values in Sym^4 Q^2
sage: M.change_ring(Qp(5,8))
Space of modular symbols for Congruence Subgroup Gamma(6) with sign 0 and values in Sym^4 Q_5^2

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.distributions import Symk
>>> D = Symk(Integer(4))
>>> M = PollackStevensModularSymbols(Gamma(Integer(6)), coefficients=D); M
Space of modular symbols for Congruence Subgroup Gamma(6) with sign 0 and values in Sym^4 Q^2
>>> M.change_ring(Qp(Integer(5),Integer(8)))
Space of modular symbols for Congruence Subgroup Gamma(6) with sign 0 and values in Sym^4 Q_5^2

Sage Live

from sage.modular.pollack_stevens.distributions import Symk
D = Symk(4)
M = PollackStevensModularSymbols(Gamma(6), coefficients=D); M
M.change_ring(Qp(5,8))

coefficient_module()[source]¶

Return the coefficient module of this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 11)
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
sage: M.coefficient_module()
Space of 11-adic distributions with k=2 action and precision cap 20
sage: M.coefficient_module() is D
True

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D)
>>> M.coefficient_module()
Space of 11-adic distributions with k=2 action and precision cap 20
>>> M.coefficient_module() is D
True

Sage Live

D = OverconvergentDistributions(2, 11)
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
M.coefficient_module()
M.coefficient_module() is D

group()[source]¶

Return the congruence subgroup of this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 5)
sage: G = Gamma0(23)
sage: M = PollackStevensModularSymbols(G, coefficients=D)
sage: M.group()
Congruence Subgroup Gamma0(23)
sage: D = Symk(4)
sage: G = Gamma1(11)
sage: M = PollackStevensModularSymbols(G, coefficients=D)
sage: M.group()
Congruence Subgroup Gamma1(11)

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(5))
>>> G = Gamma0(Integer(23))
>>> M = PollackStevensModularSymbols(G, coefficients=D)
>>> M.group()
Congruence Subgroup Gamma0(23)
>>> D = Symk(Integer(4))
>>> G = Gamma1(Integer(11))
>>> M = PollackStevensModularSymbols(G, coefficients=D)
>>> M.group()
Congruence Subgroup Gamma1(11)

Sage Live

D = OverconvergentDistributions(2, 5)
G = Gamma0(23)
M = PollackStevensModularSymbols(G, coefficients=D)
M.group()
D = Symk(4)
G = Gamma1(11)
M = PollackStevensModularSymbols(G, coefficients=D)
M.group()

level()[source]¶

Return the level \(N\), where this space is of level \(\Gamma_0(N)\).

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(7, 11)
sage: M = PollackStevensModularSymbols(Gamma1(14), coefficients=D)
sage: M.level()
14

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(7), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma1(Integer(14)), coefficients=D)
>>> M.level()
14

Sage Live

D = OverconvergentDistributions(7, 11)
M = PollackStevensModularSymbols(Gamma1(14), coefficients=D)
M.level()

ncoset_reps()[source]¶

Return the number of coset representatives defining the domain of the modular symbols in this space.

OUTPUT:

The number of coset representatives stored in the manin relations. (Just the size of \(P^1(\ZZ/N\ZZ)\))

EXAMPLES:

Sage

sage: D = Symk(2)
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
sage: M.ncoset_reps()
3

Python

>>> from sage.all import *
>>> D = Symk(Integer(2))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D)
>>> M.ncoset_reps()
3

Sage Live

D = Symk(2)
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
M.ncoset_reps()

ngens()[source]¶

Return the number of generators defining this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(4, 29)
sage: M = PollackStevensModularSymbols(Gamma1(12), coefficients=D)
sage: M.ngens()
5
sage: D = Symk(2)
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
sage: M.ngens()
2

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(4), Integer(29))
>>> M = PollackStevensModularSymbols(Gamma1(Integer(12)), coefficients=D)
>>> M.ngens()
5
>>> D = Symk(Integer(2))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D)
>>> M.ngens()
2

Sage Live

D = OverconvergentDistributions(4, 29)
M = PollackStevensModularSymbols(Gamma1(12), coefficients=D)
M.ngens()
D = Symk(2)
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
M.ngens()

precision_cap()[source]¶

Return the number of moments of each element of this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 5)
sage: M = PollackStevensModularSymbols(Gamma1(13), coefficients=D)
sage: M.precision_cap()
20
sage: D = OverconvergentDistributions(3, 7, prec_cap=10)
sage: M = PollackStevensModularSymbols(Gamma0(7), coefficients=D)
sage: M.precision_cap()
10

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(5))
>>> M = PollackStevensModularSymbols(Gamma1(Integer(13)), coefficients=D)
>>> M.precision_cap()
20
>>> D = OverconvergentDistributions(Integer(3), Integer(7), prec_cap=Integer(10))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(7)), coefficients=D)
>>> M.precision_cap()
10

Sage Live

D = OverconvergentDistributions(2, 5)
M = PollackStevensModularSymbols(Gamma1(13), coefficients=D)
M.precision_cap()
D = OverconvergentDistributions(3, 7, prec_cap=10)
M = PollackStevensModularSymbols(Gamma0(7), coefficients=D)
M.precision_cap()

prime()[source]¶

Return the prime of this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 11)
sage: M = PollackStevensModularSymbols(Gamma(2), coefficients=D)
sage: M.prime()
11

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma(Integer(2)), coefficients=D)
>>> M.prime()
11

Sage Live

D = OverconvergentDistributions(2, 11)
M = PollackStevensModularSymbols(Gamma(2), coefficients=D)
M.prime()

random_element(M=None)[source]¶

Return a random overconvergent modular symbol in this space with \(M\) moments.

INPUT:

M – positive integer

OUTPUT: an element of the modular symbol space with \(M\) moments

Returns a random element in this space by randomly choosing values of distributions on all but one divisor, and solves the difference equation to determine the value on the last divisor.

Sage

sage: D = OverconvergentDistributions(2, 11)
sage: M = PollackStevensModularSymbols(Gamma0(11), coefficients=D)
sage: M.random_element(10)
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(11)), coefficients=D)
>>> M.random_element(Integer(10))
Traceback (most recent call last):
...
NotImplementedError

Sage Live

D = OverconvergentDistributions(2, 11)
M = PollackStevensModularSymbols(Gamma0(11), coefficients=D)
M.random_element(10)

sign()[source]¶

Return the sign of this space.

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(3, 17)
sage: M = PollackStevensModularSymbols(Gamma(5), coefficients=D)
sage: M.sign()
0
sage: D = Symk(4)
sage: M = PollackStevensModularSymbols(Gamma1(8), coefficients=D, sign=-1)
sage: M.sign()
-1

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(3), Integer(17))
>>> M = PollackStevensModularSymbols(Gamma(Integer(5)), coefficients=D)
>>> M.sign()
0
>>> D = Symk(Integer(4))
>>> M = PollackStevensModularSymbols(Gamma1(Integer(8)), coefficients=D, sign=-Integer(1))
>>> M.sign()
-1

Sage Live

D = OverconvergentDistributions(3, 17)
M = PollackStevensModularSymbols(Gamma(5), coefficients=D)
M.sign()
D = Symk(4)
M = PollackStevensModularSymbols(Gamma1(8), coefficients=D, sign=-1)
M.sign()

source()[source]¶

Return the domain of the modular symbols in this space.

OUTPUT: a sage.modular.pollack_stevens.fund_domain.PollackStevensModularDomain

EXAMPLES:

Sage

sage: D = OverconvergentDistributions(2, 11)
sage: M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
sage: M.source()
Manin Relations of level 2

Python

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(2), Integer(11))
>>> M = PollackStevensModularSymbols(Gamma0(Integer(2)), coefficients=D)
>>> M.source()
Manin Relations of level 2

Sage Live

D = OverconvergentDistributions(2, 11)
M = PollackStevensModularSymbols(Gamma0(2), coefficients=D)
M.source()

weight()[source]¶

Return the weight of this space.

Warning

We emphasize that in the Pollack-Stevens notation, this is the usual weight minus 2, so a classical weight 2 modular form corresponds to a modular symbol of “weight 0”.

EXAMPLES:

Sage

sage: D = Symk(5)
sage: M = PollackStevensModularSymbols(Gamma1(7), coefficients=D)
sage: M.weight()
5

Python

>>> from sage.all import *
>>> D = Symk(Integer(5))
>>> M = PollackStevensModularSymbols(Gamma1(Integer(7)), coefficients=D)
>>> M.weight()
5

Sage Live

D = Symk(5)
M = PollackStevensModularSymbols(Gamma1(7), coefficients=D)
M.weight()

sage.modular.pollack_stevens.space.cusps_from_mat(g)[source]¶

Return the cusps associated to an element of a congruence subgroup.

INPUT:

g – an element of a congruence subgroup or a matrix

OUTPUT: a tuple of cusps associated to g

EXAMPLES:

Sage

sage: from sage.modular.pollack_stevens.space import cusps_from_mat
sage: g = SL2Z.one()
sage: cusps_from_mat(g)
(+Infinity, 0)

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.space import cusps_from_mat
>>> g = SL2Z.one()
>>> cusps_from_mat(g)
(+Infinity, 0)

Sage Live

from sage.modular.pollack_stevens.space import cusps_from_mat
g = SL2Z.one()
cusps_from_mat(g)

You can also just give the matrix of g:

Sage

sage: type(g)
<class 'sage.modular.arithgroup.arithgroup_element.ArithmeticSubgroupElement'>
sage: cusps_from_mat(g.matrix())
(+Infinity, 0)

Python

>>> from sage.all import *
>>> type(g)
<class 'sage.modular.arithgroup.arithgroup_element.ArithmeticSubgroupElement'>
>>> cusps_from_mat(g.matrix())
(+Infinity, 0)

Sage Live

type(g)
cusps_from_mat(g.matrix())

Another example:

Sage

sage: from sage.modular.pollack_stevens.space import cusps_from_mat
sage: g = GammaH(3, [2]).generators()[1].matrix(); g
[-1  1]
[-3  2]
sage: cusps_from_mat(g)
(1/3, 1/2)

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.space import cusps_from_mat
>>> g = GammaH(Integer(3), [Integer(2)]).generators()[Integer(1)].matrix(); g
[-1  1]
[-3  2]
>>> cusps_from_mat(g)
(1/3, 1/2)

Sage Live

from sage.modular.pollack_stevens.space import cusps_from_mat
g = GammaH(3, [2]).generators()[1].matrix(); g
cusps_from_mat(g)

sage.modular.pollack_stevens.space.ps_modsym_from_elliptic_curve(E, sign=0, implementation='eclib')[source]¶

Return the overconvergent modular symbol associated to an elliptic curve defined over the rationals.

INPUT:

E – an elliptic curve defined over the rationals
sign – the sign (default: 0). If nonzero, returns either the plus (if sign == 1) or the minus (if sign == -1) modular symbol. The default of 0 returns the sum of the plus and minus symbols.
implementation – either 'eclib' (default) or 'sage'. This determines which implementation of the underlying classical modular symbols is used.

OUTPUT: the overconvergent modular symbol associated to E

EXAMPLES:

Sage

sage: E = EllipticCurve('113a1')
sage: symb = E.pollack_stevens_modular_symbol() # indirect doctest
sage: symb
Modular symbol of level 113 with values in Sym^0 Q^2
sage: symb.values()
[-1/2, 1, -1, 0, 0, 1, 1, -1, 0, -1, 0, 0, 0, 1, -1, 0, 0, 0, 1, 0, 0]

sage: E = EllipticCurve([0,1])
sage: symb = E.pollack_stevens_modular_symbol()
sage: symb.values()
[-1/6, 1/3, 1/2, 1/6, -1/6, 1/3, -1/3, -1/2, -1/6, 1/6, 0, -1/6, -1/6]

Python

>>> from sage.all import *
>>> E = EllipticCurve('113a1')
>>> symb = E.pollack_stevens_modular_symbol() # indirect doctest
>>> symb
Modular symbol of level 113 with values in Sym^0 Q^2
>>> symb.values()
[-1/2, 1, -1, 0, 0, 1, 1, -1, 0, -1, 0, 0, 0, 1, -1, 0, 0, 0, 1, 0, 0]

>>> E = EllipticCurve([Integer(0),Integer(1)])
>>> symb = E.pollack_stevens_modular_symbol()
>>> symb.values()
[-1/6, 1/3, 1/2, 1/6, -1/6, 1/3, -1/3, -1/2, -1/6, 1/6, 0, -1/6, -1/6]

Sage Live

E = EllipticCurve('113a1')
symb = E.pollack_stevens_modular_symbol() # indirect doctest
symb
symb.values()
E = EllipticCurve([0,1])
symb = E.pollack_stevens_modular_symbol()
symb.values()

sage.modular.pollack_stevens.space.ps_modsym_from_simple_modsym_space(A, name='alpha')[source]¶

Return some choice – only well defined up a nonzero scalar (!) – of an overconvergent modular symbol that corresponds to A.

INPUT:

A – nonzero simple Hecke equivariant new space of modular symbols, which need not be cuspidal

OUTPUT:

A choice of corresponding overconvergent modular symbols; when dim(A)>1, we make an arbitrary choice of defining polynomial for the codomain field.

EXAMPLES:

The level 11 example:

Sage

sage: from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
sage: A = ModularSymbols(11, sign=1, weight=2).decomposition()[0]
sage: A.is_cuspidal()
True
sage: f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 11 with values in Sym^0 Q^2
sage: f.values()
[1, -5/2, -5/2]
sage: f.weight()         # this is A.weight()-2  !!!!!!
0

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
>>> A = ModularSymbols(Integer(11), sign=Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> A.is_cuspidal()
True
>>> f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 11 with values in Sym^0 Q^2
>>> f.values()
[1, -5/2, -5/2]
>>> f.weight()         # this is A.weight()-2  !!!!!!
0

Sage Live

from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
A = ModularSymbols(11, sign=1, weight=2).decomposition()[0]
A.is_cuspidal()
f = ps_modsym_from_simple_modsym_space(A); f
f.values()
f.weight()         # this is A.weight()-2  !!!!!!

And the -1 sign for the level 11 example:

Sage

sage: A = ModularSymbols(11, sign=-1, weight=2).decomposition()[0]
sage: f = ps_modsym_from_simple_modsym_space(A); f.values()
[0, 1, -1]

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(11), sign=-Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> f = ps_modsym_from_simple_modsym_space(A); f.values()
[0, 1, -1]

Sage Live

A = ModularSymbols(11, sign=-1, weight=2).decomposition()[0]
f = ps_modsym_from_simple_modsym_space(A); f.values()

A does not have to be cuspidal; it can be Eisenstein:

Sage

sage: A = ModularSymbols(11, sign=1, weight=2).decomposition()[1]
sage: A.is_cuspidal()
False
sage: f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 11 with values in Sym^0 Q^2
sage: f.values()
[1, 0, 0]

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(11), sign=Integer(1), weight=Integer(2)).decomposition()[Integer(1)]
>>> A.is_cuspidal()
False
>>> f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 11 with values in Sym^0 Q^2
>>> f.values()
[1, 0, 0]

Sage Live

A = ModularSymbols(11, sign=1, weight=2).decomposition()[1]
A.is_cuspidal()
f = ps_modsym_from_simple_modsym_space(A); f
f.values()

We create the simplest weight 2 example in which A has dimension bigger than 1:

Sage

sage: A = ModularSymbols(23, sign=1, weight=2).decomposition()[0]
sage: f = ps_modsym_from_simple_modsym_space(A); f.values()
[1, 0, 0, 0, 0]
sage: A = ModularSymbols(23, sign=-1, weight=2).decomposition()[0]
sage: f = ps_modsym_from_simple_modsym_space(A); f.values()
[0, 1, -alpha, alpha, -1]
sage: f.base_ring()
Number Field in alpha with defining polynomial x^2 + x - 1

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(23), sign=Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> f = ps_modsym_from_simple_modsym_space(A); f.values()
[1, 0, 0, 0, 0]
>>> A = ModularSymbols(Integer(23), sign=-Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> f = ps_modsym_from_simple_modsym_space(A); f.values()
[0, 1, -alpha, alpha, -1]
>>> f.base_ring()
Number Field in alpha with defining polynomial x^2 + x - 1

Sage Live

A = ModularSymbols(23, sign=1, weight=2).decomposition()[0]
f = ps_modsym_from_simple_modsym_space(A); f.values()
A = ModularSymbols(23, sign=-1, weight=2).decomposition()[0]
f = ps_modsym_from_simple_modsym_space(A); f.values()
f.base_ring()

We create the +1 modular symbol attached to the weight 12 modular form Delta:

Sage

sage: A = ModularSymbols(1, sign=+1, weight=12).decomposition()[0]
sage: f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 1 with values in Sym^10 Q^2
sage: f.values()
[(-1620/691, 0, 1, 0, -9/14, 0, 9/14, 0, -1, 0, 1620/691), (1620/691, 1620/691, 929/691, -453/691, -29145/9674, -42965/9674, -2526/691, -453/691, 1620/691, 1620/691, 0), (0, -1620/691, -1620/691, 453/691, 2526/691, 42965/9674, 29145/9674, 453/691, -929/691, -1620/691, -1620/691)]

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(1), sign=+Integer(1), weight=Integer(12)).decomposition()[Integer(0)]
>>> f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 1 with values in Sym^10 Q^2
>>> f.values()
[(-1620/691, 0, 1, 0, -9/14, 0, 9/14, 0, -1, 0, 1620/691), (1620/691, 1620/691, 929/691, -453/691, -29145/9674, -42965/9674, -2526/691, -453/691, 1620/691, 1620/691, 0), (0, -1620/691, -1620/691, 453/691, 2526/691, 42965/9674, 29145/9674, 453/691, -929/691, -1620/691, -1620/691)]

Sage Live

A = ModularSymbols(1, sign=+1, weight=12).decomposition()[0]
f = ps_modsym_from_simple_modsym_space(A); f
f.values()

And, the -1 modular symbol attached to Delta:

Sage

sage: A = ModularSymbols(1, sign=-1, weight=12).decomposition()[0]
sage: f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 1 with values in Sym^10 Q^2
sage: f.values()
[(0, 1, 0, -25/48, 0, 5/12, 0, -25/48, 0, 1, 0), (0, -1, -2, -119/48, -23/12, -5/24, 23/12, 3, 2, 0, 0), (0, 0, 2, 3, 23/12, -5/24, -23/12, -119/48, -2, -1, 0)]

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(1), sign=-Integer(1), weight=Integer(12)).decomposition()[Integer(0)]
>>> f = ps_modsym_from_simple_modsym_space(A); f
Modular symbol of level 1 with values in Sym^10 Q^2
>>> f.values()
[(0, 1, 0, -25/48, 0, 5/12, 0, -25/48, 0, 1, 0), (0, -1, -2, -119/48, -23/12, -5/24, 23/12, 3, 2, 0, 0), (0, 0, 2, 3, 23/12, -5/24, -23/12, -119/48, -2, -1, 0)]

Sage Live

A = ModularSymbols(1, sign=-1, weight=12).decomposition()[0]
f = ps_modsym_from_simple_modsym_space(A); f
f.values()

A consistency check with sage.modular.pollack_stevens.space.ps_modsym_from_simple_modsym_space():

Sage

sage: from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
sage: E = EllipticCurve('11a')
sage: f_E = E.pollack_stevens_modular_symbol(); f_E.values()
[-1/5, 1, 0]
sage: A = ModularSymbols(11, sign=1, weight=2).decomposition()[0]
sage: f_plus = ps_modsym_from_simple_modsym_space(A); f_plus.values()
[1, -5/2, -5/2]
sage: A = ModularSymbols(11, sign=-1, weight=2).decomposition()[0]
sage: f_minus = ps_modsym_from_simple_modsym_space(A); f_minus.values()
[0, 1, -1]

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
>>> E = EllipticCurve('11a')
>>> f_E = E.pollack_stevens_modular_symbol(); f_E.values()
[-1/5, 1, 0]
>>> A = ModularSymbols(Integer(11), sign=Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> f_plus = ps_modsym_from_simple_modsym_space(A); f_plus.values()
[1, -5/2, -5/2]
>>> A = ModularSymbols(Integer(11), sign=-Integer(1), weight=Integer(2)).decomposition()[Integer(0)]
>>> f_minus = ps_modsym_from_simple_modsym_space(A); f_minus.values()
[0, 1, -1]

Sage Live

from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
E = EllipticCurve('11a')
f_E = E.pollack_stevens_modular_symbol(); f_E.values()
A = ModularSymbols(11, sign=1, weight=2).decomposition()[0]
f_plus = ps_modsym_from_simple_modsym_space(A); f_plus.values()
A = ModularSymbols(11, sign=-1, weight=2).decomposition()[0]
f_minus = ps_modsym_from_simple_modsym_space(A); f_minus.values()

We find that a linear combination of the plus and minus parts equals the Pollack-Stevens symbol attached to E. This illustrates how ps_modsym_from_simple_modsym_space is only well-defined up to a nonzero scalar:

Sage

sage: (-1/5)*vector(QQ, f_plus.values()) + (1/2)*vector(QQ, f_minus.values())
(-1/5, 1, 0)
sage: vector(QQ, f_E.values())
(-1/5, 1, 0)

Python

>>> from sage.all import *
>>> (-Integer(1)/Integer(5))*vector(QQ, f_plus.values()) + (Integer(1)/Integer(2))*vector(QQ, f_minus.values())
(-1/5, 1, 0)
>>> vector(QQ, f_E.values())
(-1/5, 1, 0)

Sage Live

(-1/5)*vector(QQ, f_plus.values()) + (1/2)*vector(QQ, f_minus.values())
vector(QQ, f_E.values())

The next few examples all illustrate the ways in which exceptions are raised if A does not satisfy various constraints.

First, A must be new:

Sage

sage: A = ModularSymbols(33,sign=1).cuspidal_subspace().old_subspace()
sage: ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must be new

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(33),sign=Integer(1)).cuspidal_subspace().old_subspace()
>>> ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must be new

Sage Live

A = ModularSymbols(33,sign=1).cuspidal_subspace().old_subspace()
ps_modsym_from_simple_modsym_space(A)

A must be simple:

Sage

sage: A = ModularSymbols(43,sign=1).cuspidal_subspace()
sage: ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must be simple

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(43),sign=Integer(1)).cuspidal_subspace()
>>> ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must be simple

Sage Live

A = ModularSymbols(43,sign=1).cuspidal_subspace()
ps_modsym_from_simple_modsym_space(A)

A must have sign -1 or +1 in order to be simple:

Sage

sage: A = ModularSymbols(11).cuspidal_subspace()
sage: ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must have sign +1 or -1 (otherwise it is not simple)

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(11)).cuspidal_subspace()
>>> ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must have sign +1 or -1 (otherwise it is not simple)

Sage Live

A = ModularSymbols(11).cuspidal_subspace()
ps_modsym_from_simple_modsym_space(A)

The dimension must be positive:

Sage

sage: A = ModularSymbols(10).cuspidal_subspace(); A
Modular Symbols subspace of dimension 0 of Modular Symbols space of dimension 3 for Gamma_0(10) of weight 2 with sign 0 over Rational Field
sage: ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must have positive dimension

Python

>>> from sage.all import *
>>> A = ModularSymbols(Integer(10)).cuspidal_subspace(); A
Modular Symbols subspace of dimension 0 of Modular Symbols space of dimension 3 for Gamma_0(10) of weight 2 with sign 0 over Rational Field
>>> ps_modsym_from_simple_modsym_space(A)
Traceback (most recent call last):
...
ValueError: A must have positive dimension

Sage Live

A = ModularSymbols(10).cuspidal_subspace(); A
ps_modsym_from_simple_modsym_space(A)

We check that forms of nontrivial character are getting handled correctly:

Sage

sage: from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
sage: f = Newforms(Gamma1(13), names='a')[0]
sage: phi = ps_modsym_from_simple_modsym_space(f.modular_symbols(1))
sage: phi.hecke(7)
Modular symbol of level 13 with values in Sym^0 (Number Field in alpha with defining polynomial x^2 + 3*x + 3)^2 twisted by Dirichlet character modulo 13 of conductor 13 mapping 2 |--> -alpha - 1
sage: phi.hecke(7).values()
[0, 0, 0, 0, 0]

Python

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
>>> f = Newforms(Gamma1(Integer(13)), names='a')[Integer(0)]
>>> phi = ps_modsym_from_simple_modsym_space(f.modular_symbols(Integer(1)))
>>> phi.hecke(Integer(7))
Modular symbol of level 13 with values in Sym^0 (Number Field in alpha with defining polynomial x^2 + 3*x + 3)^2 twisted by Dirichlet character modulo 13 of conductor 13 mapping 2 |--> -alpha - 1
>>> phi.hecke(Integer(7)).values()
[0, 0, 0, 0, 0]

Sage Live

from sage.modular.pollack_stevens.space import ps_modsym_from_simple_modsym_space
f = Newforms(Gamma1(13), names='a')[0]
phi = ps_modsym_from_simple_modsym_space(f.modular_symbols(1))
phi.hecke(7)
phi.hecke(7).values()