Coverage for local/lib/python2.7/site-packages/sage/modular/pollack

Right action by Monoid Sigma0(5) with coefficients in 5-adic Field with capped relative precision 20 on Space of 5-adic distributions with k=4 action and precision cap 10

"""

def __init__(self, Dk, character, adjuster, on_left, dettwist, padic=False):

r"""

Initialization.

TESTS::

sage: D = OverconvergentDistributions(4,5,10,base = Qp(5,20)); D # indirect doctest

Space of 5-adic distributions with k=4 action and precision cap 10

sage: D = Symk(10) # indirect doctest

"""

self._k = Dk._k

# if self._k < 0: raise ValueError("k must not be negative")

self._adjuster = adjuster

self._character = character

self._dettwist = dettwist

self._p = Dk._p

self._symk = Dk.is_symk()

self._actmat = {}

self._maxprecs = {}

if character is None:

self._Np = ZZ(1) # all of M2Z acts

else:

self._Np = character.modulus()

if not self._symk:

self._Np = self._Np.lcm(self._p)

if padic:

self._Sigma0 = Sigma0(self._Np, base_ring=Dk.base_ring(), adjuster=self._adjuster)

else:

self._Sigma0 = Sigma0(self._Np, base_ring=ZZ, adjuster=self._adjuster)

Action.__init__(self, self._Sigma0, Dk, on_left, operator.mul)

def clear_cache(self):

r"""

Clear the cached matrices which define the action of `U_p`

(these depend on the desired precision) and the

dictionary that stores the maximum precisions computed so far.

EXAMPLES::

sage: D = OverconvergentDistributions(4,5,4)

sage: D([1,2,5,3]) * D._act.actor()(Matrix(ZZ,2,2,[1,1,0,1]))

(1 + O(5^4), 3 + O(5^3), 2*5 + O(5^2), O(5))

sage: D._act.clear_cache()

"""

self._actmat = {}

self._maxprecs = {}

cpdef acting_matrix(self, g, M):

r"""

The matrix defining the action of ``g`` at precision ``M``.

INPUT:

- ``g`` -- an instance of

:class:`sage.matrix.matrix_generic_dense.Matrix_generic_dense`

- ``M`` -- a positive integer giving the precision at which

``g`` should act.

OUTPUT:

- An `M \times M` matrix so that the action of `g` on a

distribution with `M` moments is given by a vector-matrix

multiplication.

.. NOTE::

This function caches its results. To clear the cache use

:meth:`clear_cache`.

EXAMPLES::

sage: D = Symk(3)

sage: v = D([5,2,7,1])

sage: g = Matrix(ZZ,2,2,[1,3,0,1])

sage: v * D._act.actor()(g) # indirect doctest

(5, 17, 64, 253)

"""

g = g.matrix()

if not g in self._maxprecs:

A = self._compute_acting_matrix(g, M)

self._actmat[g] = {M: A}

self._maxprecs[g] = M

return A

else:

mats = self._actmat[g]

if M in mats:

return mats[M]

maxprec = self._maxprecs[g]

if M < maxprec:

A = mats[maxprec][:M, :M] # submatrix; might want to reduce precisions

mats[M] = A

return A

if M < 30: # This should not be hard-coded

maxprec = max([M, 2 * maxprec]) # This may be wasting memory

else:

maxprec = M

self._maxprecs[g] = maxprec

mats[maxprec] = self._compute_acting_matrix(g, maxprec) # could lift from current maxprec

if M == maxprec:

return mats[maxprec]

A = mats[maxprec][:M, :M] # submatrix; might want to reduce precisions

mats[M] = A

return A

cpdef _compute_acting_matrix(self, g, M):

r"""

Compute the matrix defining the action of ``g`` at precision ``M``.

INPUT:

- ``g`` -- a `2 \times 2` instance of

:class:`sage.matrices.matrix_integer_dense.Matrix_integer_dense`

- ``M`` -- a positive integer giving the precision at which

``g`` should act.

OUTPUT:

- ``G`` -- an `M \times M` matrix. If `v `is the vector of moments of a

distribution `\mu`, then `v*G` is the vector of moments of `\mu|[a,b;c,d]`

EXAMPLES::

sage: D = Symk(3)

sage: v = D([5,2,7,1])

sage: g = Matrix(ZZ,2,2,[-2,1,-1,0])

sage: v * D._act.actor()(g) # indirect doctest

(-107, 35, -12, 5)

"""

raise NotImplementedError

cdef class WeightKAction_vector(WeightKAction):

cpdef _compute_acting_matrix(self, g, M):

r"""

Compute the matrix defining the action of ``g`` at precision ``M``.

INPUT:

- ``g`` -- a `2 \times 2` instance of

:class:`sage.matrix.matrix_generic_dense.Matrix_generic_dense`

- ``M`` -- a positive integer giving the precision at which

``g`` should act.

OUTPUT:

- ``G`` -- an `M \times M` matrix. If `v` is the vector of moments of a

distribution `\mu`, then `v*G` is the vector of moments of `\mu|[a,b;c,d]`

EXAMPLES::

sage: D = Symk(3)

sage: v = D([5,2,7,1])

sage: g = Matrix(ZZ,2,2,[-2,1,-1,0])

sage: v * D._act.actor()(g) # indirect doctest

(-107, 35, -12, 5)

"""

#tim = verbose("Starting")

a, b, c, d = self._adjuster(g)

# if g.parent().base_ring().is_exact():

# self._check_mat(a, b, c, d)

k = self._k

if g.parent().base_ring() is ZZ:

if self._symk:

base_ring = QQ

else:

base_ring = Zmod(self._p ** M)

else:

base_ring = self.underlying_set().base_ring()

cdef Matrix B = matrix(base_ring, M, M)

if M == 0:

return B.change_ring(self.codomain().base_ring())

R = PowerSeriesRing(base_ring, 'y', default_prec=M)

y = R.gen()

#tim = verbose("Checked, made R",tim)

# special case for small precision, large weight

scale = (b + d * y) / (a + c * y)

t = (a + c * y) ** k # will already have precision M

cdef long row, col

#tim = verbose("Made matrix",tim)

for col in range(M):

for row in range(M):

B.set_unsafe(row, col, t[row])

t *= scale

#verbose("Finished loop",tim)

# the changering here is annoying, but otherwise we have to

# change ring each time we multiply

B = B.change_ring(self.codomain().base_ring())

if self._character is not None:

B *= self._character(a)

if self._dettwist is not None:

B *= (a * d - b * c) ** (self._dettwist)

return B

cpdef _call_(self, _v, g):

r"""

The right action of ``g`` on a distribution.

INPUT:

- ``_v`` -- a :class:`Dist_vector` instance, the distribution

on which to act.

- ``g`` -- a `2 \times 2` instance of

:class:`sage.matrix.matrix_integer_dense.Matrix_integer_dense`.

OUTPUT:

- the distribution ``_v * g``.

EXAMPLES::

sage: D = sage.modular.pollack_stevens.distributions.Symk(2)

sage: v = D([2,3,4])

sage: g = Matrix(ZZ,2,2,[3,-1,1,0])

sage: v * D._act.actor()(g) # indirect doctest

(40, -9, 2)

"""

# if g is a matrix it needs to be immutable

# hashing on arithmetic_subgroup_elements is by str

if self.is_left():

_v, g = g, _v

if g == 1:

return _v

cdef Dist_vector v = <Dist_vector?>_v

cdef Dist_vector ans = v._new_c()

try:

g.set_immutable()

except AttributeError:

pass

coeffmodule = v._moments.parent()

v_moments = v._moments

ans._moments = v_moments * self.acting_matrix(g, len(v_moments))

ans.ordp = v.ordp

return ans

# cdef inline long mymod(long a, unsigned long pM):

# """

# Returns the remainder ``a % pM``.

# INPUT:

# - ``a`` -- a long

# - ``pM`` -- an unsigned long

# OUTPUT:

# - ``a % pM`` as a positive integer.

# """

# a = a % pM

# if a < 0:

# a += pM

# return a

# cdef class SimpleMat(SageObject):

# r"""

# A simple class emulating a square matrix that holds its values as

# a C array of longs.

# INPUT:

# - ``M`` -- a positive integer, the dimension of the matrix

# EXAMPLES::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# def __cinit__(self, unsigned long M):

# r"""

# Memory initialization.

# TESTS::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# self._inited = False

# self.M = M

# self._mat = <long*>sage_malloc(M * M * sizeof(long))

# if self._mat == NULL:

# raise MemoryError

# self._inited = True

# def __getitem__(self, i):

# r"""

# INPUT:

# - ``i`` -- a tuple containing two slices, each from `0` to `M'` for some `M' < M`

# OUTPUT:

# - A new SimpleMat of size `M'` with the top left `M' \times

# M'` block of values copied over.

# EXAMPLES::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# cdef Py_ssize_t r, c, Mnew, Morig = self.M

# cdef SimpleMat ans

# if isinstance(i,tuple) and len(i) == 2:

# a, b = i

# if isinstance(a, slice) and isinstance(b, slice):

# r0, r1, rs = a.indices(Morig)

# c0, c1, cs = b.indices(Morig)

# if r0 != 0 or c0 != 0 or rs != 1 or cs != 1:

# raise NotImplementedError

# Mr = r1

# Mc = c1

# if Mr != Mc:

# raise ValueError("result not square")

# Mnew = Mr

# if Mnew > Morig:

# raise IndexError("index out of range")

# ans = SimpleMat(Mnew)

# for r in range(Mnew):

# for c in range(Mnew):

# ans._mat[Mnew * c + r] = self._mat[Morig * c + r]

# return ans

# raise NotImplementedError

# def __dealloc__(self):

# r"""

# Deallocation.

# TESTS::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# sage_free(self._mat)

# cdef class WeightKAction_long(WeightKAction):

# cpdef _compute_acting_matrix(self, g, _M):

# r"""

# INPUT:

# - ``g`` -- a `2 \times 2` instance of

# :class:`sage.matrices.matrix_integer_dense.Matrix_integer_dense`

# - ``_M`` -- a positive integer giving the precision at which

# ``g`` should act.

# OUTPUT:

# - A :class:`SimpleMat` that gives the action of ``g`` at

# precision ``_M`` in the sense that the moments of the result

# are obtained from the moments of the input by a

# vector-matrix multiplication.

# EXAMPLES::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# _a, _b, _c, _d = self._adjuster(g)

# #if self._character is not None: raise NotImplementedError

# # self._check_mat(_a, _b, _c, _d)

# cdef long k = self._k

# cdef Py_ssize_t row, col, M = _M

# cdef nmod_poly_t t, scale, xM, bdy

# cdef mp_limb_t pM = self._p ** M # unsigned long

# cdef long a, b, c, d

# a = mymod(ZZ(_a), pM)

# b = mymod(ZZ(_b), pM)

# c = mymod(ZZ(_c), pM)

# d = mymod(ZZ(_d), pM)

# cdef mp_limb_t pMinv = 1 / pM # n_preinvert_limb(pM) # DEBUG!!! was pM

# nmod_poly_init2_preinv(t, pM, pMinv, M)

# nmod_poly_init2_preinv(scale, pM, pMinv, M)

# nmod_poly_init2_preinv(xM, pM, pMinv, M)

# nmod_poly_init2_preinv(bdy, pM, pMinv, 2)

# nmod_poly_set_coeff_ui(xM, M, 1)

# nmod_poly_set_coeff_ui(t, 0, a)

# nmod_poly_set_coeff_ui(t, 1, c)

# nmod_poly_inv_series(scale, t, M)

# nmod_poly_set_coeff_ui(bdy, 0, b)

# nmod_poly_set_coeff_ui(bdy, 1, d)

# nmod_poly_mullow(scale, scale, bdy, M) # scale = (b+dy)/(a+cy)

# nmod_poly_pow_trunc(t, t, k, M) # t = (a+cy)^k

# cdef SimpleMat B = SimpleMat(M)

# for col in range(M):

# for row in range(M):

# B._mat[M * col + row] = nmod_poly_get_coeff_ui(t, row)

# if col < M - 1:

# nmod_poly_mullow(t, t, scale, M)

# if self._character is not None:

# B = B * self._character(_a, _b, _c, _d)

# return B

# cpdef _call_(self, _v, g):

# r"""

# Application of the action.

# INPUT:

# - ``_v`` -- a :class:`Dist_long` instance, the distribution on

# which to act.

# - ``g`` -- a `2 \times 2` instance of

# :class:`sage.matrix.matrix_integer_dense.Matrix_integer_dense`.

# OUTPUT:

# - The image of ``_v`` under the action of ``g``.

# EXAMPLES::

# sage: from sage.modular.pollack_stevens.distributions import OverconvergentDistributions, Symk

# """

# if self.is_left():

# _v, g = g, _v

# cdef Dist_long v = <Dist_long?>_v

# cdef Dist_long ans = v._new_c()

# ans.relprec = v.relprec

# ans.ordp = v.ordp

# cdef long pM = self._p ** ans.relprec

# cdef SimpleMat B = <SimpleMat>self.acting_matrix(g, ans.relprec)

# cdef long row, col, entry = 0

# for col in range(ans.relprec):

# ans._moments[col] = 0

# for row in range(ans.relprec):

# mom = v._moments[row]

# # DEBUG BELOW

# # if not mom.parent().base_ring().is_exact():

# # try:

# # mom = mom.apply_map(operator.methodcaller('lift'))

# # except AttributeError:

# # pass

# ans._moments[col] += mymod(B._mat[entry] * mom, pM)

# entry += 1

# ans.normalize()

# return ans

Coverage for local/lib/python2.7/site-packages/sage/modular/pollack_stevens/dist.pyx : 70%

491 statements 346 run 145 missing 0 excluded