Spaces of distributions for Pollack-Stevens modular symbols

The Pollack-Stevens version of modular symbols take values on a \(\Sigma_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.all import *
>>> from sage.modular.pollack_stevens.distributions import Symk
>>> S = Symk(Integer(6)); S
Sym^6 Q^2
>>> v = S(list(range(Integer(7)))); v
(0, 1, 2, 3, 4, 5, 6)
>>> v.act_right([Integer(1),Integer(2),Integer(3),Integer(4)])
(18432, 27136, 39936, 58752, 86400, 127008, 186624)

>>> S = Symk(Integer(4),Zp(Integer(5))); S
Sym^4 Z_5^2
>>> S([Integer(1),Integer(2),Integer(3),Integer(4),Integer(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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> D = OverconvergentDistributions(Integer(3), Integer(11), Integer(5)); D
Space of 11-adic distributions with k=3 action and precision cap 5
>>> D([Integer(1),Integer(2),Integer(3),Integer(4),Integer(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)[source]

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 – boolean (default: False)

  • dettwist – None or integer (twist by determinant); ignored for Symk spaces

  • act_padic – boolean (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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> OverconvergentDistributions(Integer(2), Integer(17), Integer(100))
Space of 17-adic distributions with k=2 action and precision cap 100

>>> D = OverconvergentDistributions(Integer(2), Integer(3), Integer(5)); D
Space of 3-adic distributions with k=2 action and precision cap 5
>>> 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)[source]

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]

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

>>> from sage.modular.btquotients.pautomorphicform import _btquot_adjuster
>>> V = Symk(Integer(3), adjuster = _btquot_adjuster())
>>> from sage.modular.pollack_stevens.sigma0 import Sigma0
>>> V.acting_matrix(Sigma0(Integer(1))([Integer(3),Integer(4),Integer(0),Integer(1)]), Integer(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)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> D = OverconvergentDistributions(Integer(0), Integer(5), Integer(10))
>>> D.approx_module()
Ambient free module of rank 10 over the principal ideal domain 5-adic Ring with capped absolute precision 10
>>> D.approx_module(Integer(1))
Ambient free module of rank 1 over the principal ideal domain 5-adic Ring with capped absolute precision 10
>>> D.approx_module(Integer(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

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

D.approx_module(11)
D.approx_module(-1)
basis(M=None)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(4)); D
Space of 7-adic distributions with k=0 action and precision cap 4
>>> 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))]
>>> D.basis(Integer(2))
[(1 + O(7^2), O(7)), (O(7^2), 1 + O(7))]
>>> D = Symk(Integer(3), base=QQ); D
Sym^3 Q^2
>>> D.basis()
[(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]
>>> D.basis(Integer(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()[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(10))
>>> 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)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = Symk(Integer(0), Qp(Integer(7))); D
Sym^0 Q_7^2
>>> D.lift(M=Integer(20))
Space of 7-adic distributions with k=0 action and precision cap 20
>>> D.lift(p=Integer(7), M=Integer(10))
Space of 7-adic distributions with k=0 action and precision cap 10
>>> D.lift(p=Integer(7), M=Integer(10), new_base_ring=QpCR(Integer(7),Integer(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()[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(10)); D
Space of 7-adic distributions with k=0 action and precision cap 10
>>> D.precision_cap()
10
>>> D = Symk(Integer(389), base=QQ); D
Sym^389 Q^2
>>> 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()[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7)); D
Space of 7-adic distributions with k=0 action and precision cap 20
>>> D.prime()
7
>>> D = Symk(Integer(4), base=GF(Integer(7))); D
Sym^4 (Finite Field of size 7)^2
>>> 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

>>> from sage.all import *
>>> D = Symk(Integer(4), base=Qp(Integer(7))); D
Sym^4 Q_7^2
>>> D.prime()
7
>>> D.is_symk()
True

D = Symk(4, base=Qp(7)); D
D.prime()
D.is_symk()
random_element(M=None, **args)[source]

Return a random element of the \(M\)-th approximation module with nonnegative 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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> D = OverconvergentDistributions(Integer(0), Integer(5), Integer(10))
>>> D.random_element()
(..., ..., ..., ..., ..., ..., ..., ..., ..., ...)
>>> D.random_element(Integer(0))
()
>>> D.random_element(Integer(5))
(..., ..., ..., ..., ...)
>>> D.random_element(-Integer(1))
Traceback (most recent call last):
...
ValueError: rank (=-1) must be nonnegative
>>> D.random_element(Integer(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()[source]

Return the weight of this distribution space.

The standard caveat applies, namely that the weight of \(Sym^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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7)); D
Space of 7-adic distributions with k=0 action and precision cap 20
>>> D.weight()
0
>>> OverconvergentDistributions(Integer(389), Integer(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)[source]

Bases: OverconvergentDistributions_abstract

The class of overconvergent distributions.

This class represents the module of finite approximation modules, which are finite-dimensional spaces with a \(\Sigma_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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> D = OverconvergentDistributions(Integer(0), Integer(5), Integer(10))
>>> TestSuite(D).run()

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
D = OverconvergentDistributions(0, 5, 10)
TestSuite(D).run()
change_ring(new_base_ring)[source]

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

INPUT:

  • new_base_ring – 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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(4)); D
Space of 7-adic distributions with k=0 action and precision cap 4
>>> D.base_ring()
7-adic Ring with capped absolute precision 4
>>> D2 = D.change_ring(QpCR(Integer(7))); D2
Space of 7-adic distributions with k=0 action and precision cap 4
>>> 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()[source]

Whether or not this distributions space is \(Sym^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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(4), Integer(17), Integer(10)); D
Space of 17-adic distributions with k=4 action and precision cap 10
>>> D.is_symk()
False
>>> D = Symk(Integer(4)); D
Sym^4 Q^2
>>> D.is_symk()
True
>>> D = Symk(Integer(4), base=GF(Integer(7))); D
Sym^4 (Finite Field of size 7)^2
>>> 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)[source]

Return distribution space got by specializing to \(Sym^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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(4)); D
Space of 7-adic distributions with k=0 action and precision cap 4
>>> D.is_symk()
False
>>> D2 = D.specialize(); D2
Sym^0 Z_7^2
>>> D2.is_symk()
True
>>> 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[source]

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 – boolean (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))

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(3), Integer(11), Integer(20))
>>> D
Space of 11-adic distributions with k=3 action and precision cap 20
>>> v = D([Integer(1),Integer(0),Integer(0),Integer(0),Integer(0)])
>>> v.act_right([Integer(2),Integer(1),Integer(0),Integer(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))

>>> from sage.all import *
>>> D = OverconvergentDistributions(Integer(3), Integer(11), Integer(20), dettwist=Integer(1))
>>> v = D([Integer(1),Integer(0),Integer(0),Integer(0),Integer(0)])
>>> v.act_right([Integer(2),Integer(1),Integer(0),Integer(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)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
>>> OverconvergentDistributions(Integer(20), Integer(3), Integer(10))              # indirect doctest
Space of 3-adic distributions with k=20 action and precision cap 10
>>> TestSuite(OverconvergentDistributions).run()

from sage.modular.pollack_stevens.distributions import OverconvergentDistributions
OverconvergentDistributions(20, 3, 10)              # indirect doctest
TestSuite(OverconvergentDistributions).run()
create_object(version, key)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> OverconvergentDistributions(Integer(0), Integer(7), Integer(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)[source]

Bases: OverconvergentDistributions_abstract

EXAMPLES:

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

>>> from sage.all import *
>>> D = sage.modular.pollack_stevens.distributions.Symk(Integer(4)); D
Sym^4 Q^2
>>> TestSuite(D).run() # indirect doctest

D = sage.modular.pollack_stevens.distributions.Symk(4); D
TestSuite(D).run() # indirect doctest
base_extend(new_base_ring)[source]

Extend scalars to a new base ring.

EXAMPLES:

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

>>> from sage.all import *
>>> Symk(Integer(3)).base_extend(Qp(Integer(3)))
Sym^3 Q_3^2

Symk(3).base_extend(Qp(3))
change_ring(new_base_ring)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(0), Integer(7), Integer(4)); D
Space of 7-adic distributions with k=0 action and precision cap 4
>>> D.base_ring()
7-adic Ring with capped absolute precision 4
>>> D2 = D.change_ring(QpCR(Integer(7))); D2
Space of 7-adic distributions with k=0 action and precision cap 4
>>> 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()[source]

Whether or not this distributions space is \(Sym^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.all import *
>>> from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk
>>> D = OverconvergentDistributions(Integer(4), Integer(17), Integer(10)); D
Space of 17-adic distributions with k=4 action and precision cap 10
>>> D.is_symk()
False
>>> D = Symk(Integer(4)); D
Sym^4 Q^2
>>> D.is_symk()
True
>>> D = Symk(Integer(4), base=GF(Integer(7))); D
Sym^4 (Finite Field of size 7)^2
>>> 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[source]

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 \(\QQ\))

  • character – Dirichlet character or None (default: None)

  • 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

>>> from sage.all import *
>>> D = Symk(Integer(4))
>>> loads(dumps(D)) is D
True
>>> loads(dumps(D)) == D
True
>>> from sage.modular.pollack_stevens.distributions import Symk
>>> Symk(Integer(5))
Sym^5 Q^2
>>> Symk(Integer(5), RR)
Sym^5 (Real Field with 53 bits of precision)^2
>>> Symk(Integer(5), oo.parent()) # don't do this
Sym^5 (The Infinity Ring)^2
>>> Symk(Integer(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)

>>> from sage.all import *
>>> V = Symk(Integer(6))
>>> v = V([Integer(1),Integer(0),Integer(0),Integer(0),Integer(0),Integer(0),Integer(0)])
>>> v.act_right([Integer(2),Integer(1),Integer(0),Integer(1)])
(64, 32, 16, 8, 4, 2, 1)
>>> V = Symk(Integer(6), dettwist=-Integer(1))
>>> v = V([Integer(1),Integer(0),Integer(0),Integer(0),Integer(0),Integer(0),Integer(0)])
>>> v.act_right([Integer(2),Integer(1),Integer(0),Integer(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)[source]

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.all import *
>>> from sage.modular.pollack_stevens.distributions import Symk
>>> Symk(Integer(6)) # indirect doctest
Sym^6 Q^2

>>> V = Symk(Integer(6), Qp(Integer(7)))
>>> 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)[source]

EXAMPLES:

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

>>> from sage.all import *
>>> from sage.modular.pollack_stevens.distributions import Symk
>>> Symk(Integer(6)) # indirect doctest
Sym^6 Q^2

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