Spaces of distributions for Pollack-Stevens modular symbols#

The Pollack-Stevens version of modular symbols take values on a $Σ_{0} (N)$ -module which can be either a symmetric power of the standard representation of GL2, or a finite approximation module to the module of overconvergent distributions.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import Symk
sage: S = Symk(6); S
Sym^6 Q^2
sage: v = S(list(range(7))); v
(0, 1, 2, 3, 4, 5, 6)
sage: v.act_right([1,2,3,4])
(18432, 27136, 39936, 58752, 86400, 127008, 186624)

sage: S = Symk(4,Zp(5)); S
Sym^4 Z_5^2
sage: S([1,2,3,4,5])
(1 + O(5^20), 2 + O(5^20), 3 + O(5^20), 4 + O(5^20), 5 + O(5^21))

from sage.modular.pollack_stevens.distributions import Symk
S = Symk(6); S
v = S(list(range(7))); v
v.act_right([1,2,3,4])
S = Symk(4,Zp(5)); S
S([1,2,3,4,5])

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: D = OverconvergentDistributions(3, 11, 5); D
Space of 11-adic distributions with k=3 action and precision cap 5
sage: D([1,2,3,4,5])
(1 + O(11^5), 2 + O(11^4), 3 + O(11^3), 4 + O(11^2), 5 + O(11))

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
D = OverconvergentDistributions(3, 11, 5); D
D([1,2,3,4,5])

class sage.modular.pollack_stevens.distributions.OverconvergentDistributions_abstract(k, p=None, prec_cap=None, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None, act_padic=False, implementation=None)#

Bases: Module

Parent object for distributions. Not to be used directly, see derived classes Symk_class and OverconvergentDistributions_class.

INPUT:

k – integer; $k$ is the usual modular forms weight minus 2
p – None or prime
prec_cap – None or positive integer
base – None or the base ring over which to construct the distributions
character – None or Dirichlet character
adjuster – None or a way to specify the action among different conventions
act_on_left – bool (default: False)
dettwist – None or integer (twist by determinant). Ignored for Symk spaces
act_padic – bool (default: False) If true, will allow action by $p$ -adic matrices.
implementation – string (default: None) Either automatic (if None), ‘vector’ or ‘long’.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: OverconvergentDistributions(2, 17, 100)
Space of 17-adic distributions with k=2 action and precision cap 100

sage: D = OverconvergentDistributions(2, 3, 5); D
Space of 3-adic distributions with k=2 action and precision cap 5
sage: type(D)
<class 'sage.modular.pollack_stevens.distributions.OverconvergentDistributions_class_with_category'>

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
OverconvergentDistributions(2, 17, 100)
D = OverconvergentDistributions(2, 3, 5); D
type(D)

acting_matrix(g, M)#

Return the matrix for the action of $g$ on self, truncated to the first $M$ moments.

EXAMPLES:

sage: V = Symk(3)
sage: from sage.modular.pollack_stevens.sigma0 import Sigma0
sage: V.acting_matrix(Sigma0(1)([3,4,0,1]), 4)
[27 36 48 64]
[ 0  9 24 48]
[ 0  0  3 12]
[ 0  0  0  1]

sage: from sage.modular.btquotients.pautomorphicform import _btquot_adjuster
sage: V = Symk(3, adjuster = _btquot_adjuster())
sage: from sage.modular.pollack_stevens.sigma0 import Sigma0
sage: V.acting_matrix(Sigma0(1)([3,4,0,1]), 4)
[  1   4  16  64]
[  0   3  24 144]
[  0   0   9 108]
[  0   0   0  27]

V = Symk(3)
from sage.modular.pollack_stevens.sigma0 import Sigma0
V.acting_matrix(Sigma0(1)([3,4,0,1]), 4)
from sage.modular.btquotients.pautomorphicform import _btquot_adjuster
V = Symk(3, adjuster = _btquot_adjuster())
from sage.modular.pollack_stevens.sigma0 import Sigma0
V.acting_matrix(Sigma0(1)([3,4,0,1]), 4)

approx_module(M=None)#

Return the $M$ -th approximation module, or if $M$ is not specified, return the largest approximation module.

INPUT:

M – None or nonnegative integer that is at most the precision cap

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: D = OverconvergentDistributions(0, 5, 10)
sage: D.approx_module()
Ambient free module of rank 10 over the principal ideal domain 5-adic Ring with capped absolute precision 10
sage: D.approx_module(1)
Ambient free module of rank 1 over the principal ideal domain 5-adic Ring with capped absolute precision 10
sage: D.approx_module(0)
Ambient free module of rank 0 over the principal ideal domain 5-adic Ring with capped absolute precision 10

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
D = OverconvergentDistributions(0, 5, 10)
D.approx_module()
D.approx_module(1)
D.approx_module(0)

Note that M must be at most the precision cap, and must be nonnegative:

sage: D.approx_module(11)
Traceback (most recent call last):
...
ValueError: M (=11) must be less than or equal to the precision cap (=10)
sage: D.approx_module(-1)
Traceback (most recent call last):
...
ValueError: rank (=-1) must be nonnegative

D.approx_module(11)
D.approx_module(-1)

basis(M=None)#

Return a basis for this space of distributions.

INPUT:

M – (Default: None) If not None, specifies the M-th approximation module, in case that this makes sense.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 4); D
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D.basis()
[(1 + O(7^4), O(7^3), O(7^2), O(7)),
 (O(7^4), 1 + O(7^3), O(7^2), O(7)),
 (O(7^4), O(7^3), 1 + O(7^2), O(7)),
 (O(7^4), O(7^3), O(7^2), 1 + O(7))]
sage: D.basis(2)
[(1 + O(7^2), O(7)), (O(7^2), 1 + O(7))]
sage: D = Symk(3, base=QQ); D
Sym^3 Q^2
sage: D.basis()
[(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]
sage: D.basis(2)
Traceback (most recent call last):
...
ValueError: Sym^k objects do not support approximation modules

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 4); D
D.basis()
D.basis(2)
D = Symk(3, base=QQ); D
D.basis()
D.basis(2)

clear_cache()#

Clear some caches that are created only for speed purposes.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 10)
sage: D.clear_cache()

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 10)
D.clear_cache()

lift(p=None, M=None, new_base_ring=None)#

Return distribution space that contains lifts with given p, precision cap M, and base ring new_base_ring.

INPUT:

p – prime or None
M – nonnegative integer or None
new_base_ring – ring or None

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = Symk(0, Qp(7)); D
Sym^0 Q_7^2
sage: D.lift(M=20)
Space of 7-adic distributions with k=0 action and precision cap 20
sage: D.lift(p=7, M=10)
Space of 7-adic distributions with k=0 action and precision cap 10
sage: D.lift(p=7, M=10, new_base_ring=QpCR(7,15)).base_ring()
7-adic Field with capped relative precision 15

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = Symk(0, Qp(7)); D
D.lift(M=20)
D.lift(p=7, M=10)
D.lift(p=7, M=10, new_base_ring=QpCR(7,15)).base_ring()

precision_cap()#

Return the precision cap on distributions.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 10); D
Space of 7-adic distributions with k=0 action and precision cap 10
sage: D.precision_cap()
10
sage: D = Symk(389, base=QQ); D
Sym^389 Q^2
sage: D.precision_cap()
390

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 10); D
D.precision_cap()
D = Symk(389, base=QQ); D
D.precision_cap()

prime()#

Return prime $p$ such that this is a space of $p$ -adic distributions.

In case this space is Symk of a non-padic field, we return 0.

OUTPUT:

a prime or 0

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7); D
Space of 7-adic distributions with k=0 action and precision cap 20
sage: D.prime()
7
sage: D = Symk(4, base=GF(7)); D
Sym^4 (Finite Field of size 7)^2
sage: D.prime()
0

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7); D
D.prime()
D = Symk(4, base=GF(7)); D
D.prime()

But Symk of a $p$ -adic field does work:

sage: D = Symk(4, base=Qp(7)); D
Sym^4 Q_7^2
sage: D.prime()
7
sage: D.is_symk()
True

D = Symk(4, base=Qp(7)); D
D.prime()
D.is_symk()

random_element(M=None, **args)#

Return a random element of the $M$ -th approximation module with non-negative valuation.

INPUT:

M – None or a nonnegative integer

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: D = OverconvergentDistributions(0, 5, 10)
sage: D.random_element()
(..., ..., ..., ..., ..., ..., ..., ..., ..., ...)
sage: D.random_element(0)
()
sage: D.random_element(5)
(..., ..., ..., ..., ...)
sage: D.random_element(-1)
Traceback (most recent call last):
...
ValueError: rank (=-1) must be nonnegative
sage: D.random_element(11)
Traceback (most recent call last):
...
ValueError: M (=11) must be less than or equal to the precision cap (=10)

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
D = OverconvergentDistributions(0, 5, 10)
D.random_element()
D.random_element(0)
D.random_element(5)
D.random_element(-1)
D.random_element(11)

weight()#

Return the weight of this distribution space. The standard caveat applies, namely that the weight of $S y m^{k}$ is defined to be $k$ , not $k + 2$ .

OUTPUT:

nonnegative integer

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7); D
Space of 7-adic distributions with k=0 action and precision cap 20
sage: D.weight()
0
sage: OverconvergentDistributions(389, 7).weight()
389

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7); D
D.weight()
OverconvergentDistributions(389, 7).weight()

class sage.modular.pollack_stevens.distributions.OverconvergentDistributions_class(k, p=None, prec_cap=None, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None, act_padic=False, implementation=None)#

Bases: OverconvergentDistributions_abstract

The class of overconvergent distributions

This class represents the module of finite approximation modules, which are finite-dimensional spaces with a $Σ_{0} (N)$ action which approximate the module of overconvergent distributions. There is a specialization map to the finite-dimensional Symk module as well.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: D = OverconvergentDistributions(0, 5, 10)
sage: TestSuite(D).run()

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
D = OverconvergentDistributions(0, 5, 10)
TestSuite(D).run()

change_ring(new_base_ring)#

Return space of distributions like this one, but with the base ring changed.

INPUT: a ring over which the distribution can be coerced.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 4); D
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D.base_ring()
7-adic Ring with capped absolute precision 4
sage: D2 = D.change_ring(QpCR(7)); D2
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D2.base_ring()
7-adic Field with capped relative precision 20

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 4); D
D.base_ring()
D2 = D.change_ring(QpCR(7)); D2
D2.base_ring()

is_symk()#

Whether or not this distributions space is $S y m^{k} (R)$ for some ring $R$ .

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(4, 17, 10); D
Space of 17-adic distributions with k=4 action and precision cap 10
sage: D.is_symk()
False
sage: D = Symk(4); D
Sym^4 Q^2
sage: D.is_symk()
True
sage: D = Symk(4, base=GF(7)); D
Sym^4 (Finite Field of size 7)^2
sage: D.is_symk()
True

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(4, 17, 10); D
D.is_symk()
D = Symk(4); D
D.is_symk()
D = Symk(4, base=GF(7)); D
D.is_symk()

specialize(new_base_ring=None)#

Return distribution space got by specializing to $S y m^{k}$ , over the new_base_ring. If new_base_ring is not given, use current base_ring.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 4); D
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D.is_symk()
False
sage: D2 = D.specialize(); D2
Sym^0 Z_7^2
sage: D2.is_symk()
True
sage: D2 = D.specialize(QQ); D2
Sym^0 Q^2

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 4); D
D.is_symk()
D2 = D.specialize(); D2
D2.is_symk()
D2 = D.specialize(QQ); D2

class sage.modular.pollack_stevens.distributions.OverconvergentDistributions_factory#

Bases: UniqueFactory

Create a space of distributions.

INPUT:

k – nonnegative integer
p – prime number or None
prec_cap – positive integer or None
base – ring or None
character – a Dirichlet character or None
adjuster – None or callable that turns 2 x 2 matrices into a 4-tuple
act_on_left – bool (default: False)
dettwist – integer or None (interpreted as 0)
act_padic – whether monoid should allow $p$ -adic coefficients
implementation – string (default: None). Either None (for automatic), ‘long’, or ‘vector’

EXAMPLES:

sage: D = OverconvergentDistributions(3, 11, 20)
sage: D
Space of 11-adic distributions with k=3 action and precision cap 20
sage: v = D([1,0,0,0,0])
sage: v.act_right([2,1,0,1])
(8 + O(11^5), 4 + O(11^4), 2 + O(11^3), 1 + O(11^2), 6 + O(11))

D = OverconvergentDistributions(3, 11, 20)
D
v = D([1,0,0,0,0])
v.act_right([2,1,0,1])

sage: D = OverconvergentDistributions(3, 11, 20, dettwist=1)
sage: v = D([1,0,0,0,0])
sage: v.act_right([2,1,0,1])
(5 + 11 + O(11^5), 8 + O(11^4), 4 + O(11^3), 2 + O(11^2), 1 + O(11))

D = OverconvergentDistributions(3, 11, 20, dettwist=1)
v = D([1,0,0,0,0])
v.act_right([2,1,0,1])

create_key(k, p=None, prec_cap=None, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None, act_padic=False, implementation=None)#

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
sage: OverconvergentDistributions(20, 3, 10)              # indirect doctest
Space of 3-adic distributions with k=20 action and precision cap 10
sage: TestSuite(OverconvergentDistributions).run()

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
OverconvergentDistributions(20, 3, 10)              # indirect doctest
TestSuite(OverconvergentDistributions).run()

create_object(version, key)#

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: OverconvergentDistributions(0, 7, 5)              # indirect doctest
Space of 7-adic distributions with k=0 action and precision cap 5

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
OverconvergentDistributions(0, 7, 5)              # indirect doctest

class sage.modular.pollack_stevens.distributions.Symk_class(k, base, character, adjuster, act_on_left, dettwist, act_padic, implementation)#

Bases: OverconvergentDistributions_abstract

EXAMPLES:

sage: D = sage.modular.pollack_stevens.distributions.Symk(4); D
Sym^4 Q^2
sage: TestSuite(D).run() # indirect doctest

D = sage.modular.pollack_stevens.distributions.Symk(4); D
TestSuite(D).run() # indirect doctest

base_extend(new_base_ring)#

Extend scalars to a new base ring.

EXAMPLES:

sage: Symk(3).base_extend(Qp(3))
Sym^3 Q_3^2

Symk(3).base_extend(Qp(3))

change_ring(new_base_ring)#

Return a Symk with the same $k$ but a different base ring.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(0, 7, 4); D
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D.base_ring()
7-adic Ring with capped absolute precision 4
sage: D2 = D.change_ring(QpCR(7)); D2
Space of 7-adic distributions with k=0 action and precision cap 4
sage: D2.base_ring()
7-adic Field with capped relative precision 20

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(0, 7, 4); D
D.base_ring()
D2 = D.change_ring(QpCR(7)); D2
D2.base_ring()

is_symk()#

Whether or not this distributions space is $S y m^{k} (R)$ for some ring $R$ .

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
sage: D = OverconvergentDistributions(4, 17, 10); D
Space of 17-adic distributions with k=4 action and precision cap 10
sage: D.is_symk()
False
sage: D = Symk(4); D
Sym^4 Q^2
sage: D.is_symk()
True
sage: D = Symk(4, base=GF(7)); D
Sym^4 (Finite Field of size 7)^2
sage: D.is_symk()
True

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
D = OverconvergentDistributions(4, 17, 10); D
D.is_symk()
D = Symk(4); D
D.is_symk()
D = Symk(4, base=GF(7)); D
D.is_symk()

class sage.modular.pollack_stevens.distributions.Symk_factory#

Bases: UniqueFactory

Create the space of polynomial distributions of degree $k$ (stored as a sequence of $k + 1$ moments).

INPUT:

k - (integer): the degree (degree $k$ corresponds to weight $k + 2$ modular forms)
base - (ring, default None): the base ring (None is interpreted as $Q$ )
character - (Dirichlet character or None, default None) the character
adjuster - (None or a callable that turns $2 \times 2$ matrices into a 4-tuple, default None)
act_on_left - (boolean, default False) whether to have the group acting on the left rather than the right.
dettwist (integer or None) – power of determinant to twist by

EXAMPLES:

sage: D = Symk(4)
sage: loads(dumps(D)) is D
True
sage: loads(dumps(D)) == D
True
sage: from sage.modular.pollack_stevens.distributions import Symk
sage: Symk(5)
Sym^5 Q^2
sage: Symk(5, RR)
Sym^5 (Real Field with 53 bits of precision)^2
sage: Symk(5, oo.parent()) # don't do this
Sym^5 (The Infinity Ring)^2
sage: Symk(5, act_on_left = True)
Sym^5 Q^2

D = Symk(4)
loads(dumps(D)) is D
loads(dumps(D)) == D
from sage.modular.pollack_stevens.distributions import Symk
Symk(5)
Symk(5, RR)
Symk(5, oo.parent()) # don't do this
Symk(5, act_on_left = True)

The dettwist attribute:

sage: V = Symk(6)
sage: v = V([1,0,0,0,0,0,0])
sage: v.act_right([2,1,0,1])
(64, 32, 16, 8, 4, 2, 1)
sage: V = Symk(6, dettwist=-1)
sage: v = V([1,0,0,0,0,0,0])
sage: v.act_right([2,1,0,1])
(32, 16, 8, 4, 2, 1, 1/2)

V = Symk(6)
v = V([1,0,0,0,0,0,0])
v.act_right([2,1,0,1])
V = Symk(6, dettwist=-1)
v = V([1,0,0,0,0,0,0])
v.act_right([2,1,0,1])

create_key(k, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None, act_padic=False, implementation=None)#

Sanitize input.

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import Symk
sage: Symk(6) # indirect doctest
Sym^6 Q^2

sage: V = Symk(6, Qp(7))
sage: TestSuite(V).run()

from sage.modular.pollack_stevens.distributions import Symk
Symk(6) # indirect doctest
V = Symk(6, Qp(7))
TestSuite(V).run()

create_object(version, key)#

EXAMPLES:

sage: from sage.modular.pollack_stevens.distributions import Symk
sage: Symk(6) # indirect doctest
Sym^6 Q^2

from sage.modular.pollack_stevens.distributions import Symk
Symk(6) # indirect doctest