Overconvergent p-adic modular forms for small primes

This module implements computations of the U_p-operator on overconvergent modular forms of level \Gamma_0(p), where p is one of the primes \{2, 3,
5, 7, 13\}, using the algorithms described in:

David Loeffler, “Spectral expansions of overconvergent modular functions”, Int. Math. Res. Not 2007(050).

AUTHORS:

  • David Loeffler (August 2008): initial version
class sage.modular.overconvergent.genus0.OverconvergentModularFormElement(parent, gexp=None, qexp=None)

A class representing an element of a space of overconvergent modular forms.

EXAMPLE:

sage: K.<w> = Qp(5).extension(x^7 - 5); s = OverconvergentModularForms(5, 6, 1/21, base_ring=K).0
sage: s == loads(dumps(s))
True
__cmp__(other)

Compare self to other.

EXAMPLES:

sage: o=OverconvergentModularForms(3, 0, 1/2)
sage: o([1, 1, 1, 0, 0, 0, 0]) == o([2, 1, 0])
False
sage: o([1, 1, 1, 0, 0, 0, 0]) == o([1,1])
True
__init__(parent, gexp=None, qexp=None)

Create an element of this space.

EXAMPLE:

sage: OverconvergentModularForms(3, 2, 1/6,prec=5).an_element() # indirect doctest
3-adic overconvergent modular form of weight-character 2 with q-expansion 3*q + 72*q^2 + 810*q^3 + 6096*q^4 + O(q^5)
__weakref__
list of weak references to the object (if defined)
_add_(other)

Add self to other (where other has the same parent as self).

EXAMPLES:

sage: M = OverconvergentModularForms(2, 12, 1/6)
sage: f = M.0
sage: f + f # indirect doctest
2-adic overconvergent modular form of weight-character 12 with q-expansion 2 - 131040/1414477*q ...
_lmul_(x)

Left multiplication by other.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 12, 1/6)
sage: f = M.0
sage: 2*f # indirect doctest
2-adic overconvergent modular form of weight-character 12 with q-expansion 2 - 131040/1414477*q ...
_notify_eigen(eigenvalue)

Flags this element as an eigenform. It then remembers some extra data.

EXAMPLE:

sage: OverconvergentModularForms(3, 16, 1/3).eigenfunctions(4) # indirect doctest
[...]
_pari_()

Return the Pari object corresponding to self, which is just the q-expansion of self as a formal power series. At present conversion of power series to Pari is only implemented if the base ring is \QQ.

(At present, in 3.4.1.alpha0, if the base ring isn’t QQ then a silly error message comes up because of a trivial typo in sage/rings/power_series_ring_element.py – isinstance is being given a constructor function, not a class, due to code refactoring. The really silly thing is that there was no doctest to catch this when IntegerRing became a function rather than a class. It’s really somewhat astonishing nobody has noticed since.)

EXAMPLES:

sage: f = OverconvergentModularForms(3, 0, 1/2).1
sage: pari(f) # indirect doctest
27*q + 324*q^2 + 2430*q^3 + 13716*q^4 + 64557*q^5 + 265356*q^6 + 983556*q^7 + 3353076*q^8 + 10670373*q^9 + 32031288*q^10 + 91455804*q^11 + 249948828*q^12 + 657261999*q^13 + 1669898592*q^14 + 4113612864*q^15 + 9853898292*q^16 + 23010586596*q^17 + 52494114852*q^18 + 117209543940*q^19 + O(q^20)
sage: pari(f.base_extend(Qp(3))) # misleading error message!
...
TypeError: isinstance() arg 2 must be a class, type, or tuple of classes and types
_repr_()

String representation of self

EXAMPLES:

sage: o=OverconvergentModularForms(3, 0, 1/2)
sage: o([1, 0, 1, 3])._repr_()
'3-adic overconvergent modular form of weight-character 0 with q-expansion 1 + 729*q^2 + 76545*q^3 + O(q^4)'
_rmul_(x)

Right multiplication by other.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 12, 1/6)
sage: f = M.0
sage: f * 3 # indirect doctest
2-adic overconvergent modular form of weight-character 12 with q-expansion 3 - 196560/1414477*q ...
additive_order()

Return the additive order of this element (required attribute for all elements deriving from sage.modules.ModuleElement)

EXAMPLES:

sage: M = OverconvergentModularForms(13, 10, 1/2, base_ring = Qp(13).extension(x^2 - 13,names='a'))
sage: M.gen(0).additive_order()
+Infinity
sage: M(0).additive_order()
1
base_extend(R)

Return a copy of self but with coefficients in the given ring.

EXAMPLES:

sage: M = OverconvergentModularForms(7, 10, 1/2, prec=5)
sage: f = M.1
sage: f.base_extend(Qp(7, 4))
7-adic overconvergent modular form of weight-character 10 with q-expansion (7 + O(7^5))*q + (6*7 + 4*7^2 + 7^3 + 6*7^4 + O(7^5))*q^2 + (5*7 + 5*7^2 + 7^4 + O(7^5))*q^3 + (7^2 + 4*7^3 + 3*7^4 + 2*7^5 + O(7^6))*q^4 + O(q^5)
eigenvalue()

Return the U_p-eigenvalue of this eigenform. Raises an error unless this element was explicitly flagged as an eigenform, using the _notify_eigen function.

EXAMPLE:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: f = M.eigenfunctions(3)[1]
sage: f.eigenvalue()
3^2 + 3^4 + 2*3^6 + 3^7 + 3^8 + 2*3^9 + 2*3^10 + 3^12 + 3^16 + 2*3^17 + 3^18 + 3^20 + 2*3^21 + 3^22 + 2*3^23 + 3^25 + 3^26 + 2*3^27 + 2*3^29 + 3^30 + 3^31 + 3^32 + 3^33 + 3^34 + 3^36 + 3^40 + 2*3^41 + 3^43 + 3^44 + 3^45 + 3^46 + 3^48 + 3^49 + 3^50 + 2*3^51 + 3^52 + 3^54 + 2*3^57 + 2*3^59 + 3^60 + 3^61 + 2*3^63 + 2*3^66 + 2*3^67 + 3^69 + 2*3^72 + 3^74 + 2*3^75 + 3^76 + 2*3^77 + 2*3^78 + 2*3^80 + 3^81 + 2*3^82 + 3^84 + 2*3^85 + 2*3^86 + 3^87 + 3^88 + 2*3^89 + 2*3^91 + 3^93 + 3^94 + 3^95 + 3^96 + 3^98 + 2*3^99 + O(3^100)
sage: M.gen(4).eigenvalue()
...
TypeError: eigenvalue only defined for eigenfunctions
gexp()

Return the formal power series in g corresponding to this overconvergent modular form (so the result is F where this modular form is E_k^\ast \times F(g), where g is the appropriately normalised parameter of X_0(p)).

EXAMPLE:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: f = M.eigenfunctions(3)[1]
sage: f.gexp()
(3^-3 + O(3^91))*g + (3^-1 + 1 + 2*3 + 3^2 + 2*3^3 + 3^5 + 3^7 + 3^10 + 3^11 + 3^14 + 3^15 + 3^16 + 2*3^19 + 3^21 + 3^22 + 2*3^23 + 2*3^24 + 3^26 + 2*3^27 + 3^29 + 3^31 + 3^34 + 2*3^35 + 2*3^36 + 3^38 + 2*3^39 + 3^41 + 2*3^42 + 2*3^43 + 2*3^44 + 2*3^46 + 2*3^47 + 3^48 + 2*3^49 + 2*3^50 + 3^51 + 2*3^54 + 2*3^55 + 2*3^56 + 3^57 + 2*3^58 + 2*3^59 + 2*3^60 + 3^61 + 3^62 + 3^63 + 3^64 + 2*3^65 + 3^67 + 3^68 + 2*3^69 + 3^70 + 2*3^71 + 2*3^74 + 3^76 + 2*3^77 + 3^78 + 2*3^79 + 2*3^80 + 3^84 + 2*3^85 + 2*3^86 + 3^88 + 2*3^89 + 3^91 + 3^92 + O(3^93))*g^2 + O(g^3)
governing_term(r)

The degree of the series term with largest norm on the r-overconvergent region.

EXAMPLES:

sage: o=OverconvergentModularForms(3, 0, 1/2)
sage: f=o.eigenfunctions(10)[1]
sage: f.governing_term(1/2)
1
is_eigenform()

Return True if this is an eigenform. At present this returns False unless this element was explicitly flagged as an eigenform, using the _notify_eigen function.

EXAMPLE:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: f = M.eigenfunctions(3)[1]
sage: f.is_eigenform()
True
sage: M.gen(4).is_eigenform()
False
is_integral()

Test whether or not this element has q-expansion coefficients that are p-adically integral. This should always be the case with eigenfunctions, but sometimes if n is very large this breaks down for unknown reasons!

EXAMPLE:

sage: M = OverconvergentModularForms(2, 0, 1/3)
sage: q = QQ[['q']].gen()
sage: M(q - 17*q^2 + O(q^3)).is_integral()
True
sage: M(q - q^2/2 + 6*q^7  + O(q^9)).is_integral()
False
prec()

Return the series expansion precision of this overconvergent modular form. (This is not the same as the p-adic precision of the coefficients.)

EXAMPLE:

sage: OverconvergentModularForms(5, 6, 1/3,prec=15).gen(1).prec()
15
prime()

If this is a p-adic modular form, return p.

EXAMPLE:

sage: OverconvergentModularForms(2, 0, 1/2).an_element().prime()
2
qexp()

Return the q-expansion of self, to as high precision as it is known.

EXAMPLE:

sage: OverconvergentModularForms(3, 4, 1/2).gen(0).qexp()
1 - 120/13*q - 1080/13*q^2 - 120/13*q^3 - 8760/13*q^4 - 15120/13*q^5 - 1080/13*q^6 - 41280/13*q^7 - 5400*q^8 - 120/13*q^9 - 136080/13*q^10 - 159840/13*q^11 - 8760/13*q^12 - 263760/13*q^13 - 371520/13*q^14 - 15120/13*q^15 - 561720/13*q^16 - 45360*q^17 - 1080/13*q^18 - 823200/13*q^19 + O(q^20)
r_ord(r)

The p-adic valuation of self on the r-overconvergent region.

EXAMPLES:

sage: o=OverconvergentModularForms(3, 0, 1/2)
sage: t = o([1, 1, 1/3])
sage: t.r_ord(1/2)
1
sage: t.r_ord(2/3)
3
slope()

Return the slope of this eigenform, i.e. the valuation of its U_p-eigenvalue. Raises an error unless this element was explicitly flagged as an eigenform, using the _notify_eigen function.

EXAMPLE:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: f = M.eigenfunctions(3)[1]
sage: f.slope()
2
sage: M.gen(4).slope()
...
TypeError: slope only defined for eigenfunctions
valuation_plot()

Draw a graph depicting the growth of the norm of this overconvergent modular form as it approaches the boundary of the overconvergent region.

EXAMPLE:

sage: o=OverconvergentModularForms(3, 0, 1/2)
sage: f=o.eigenfunctions(4)[1]
sage: f.valuation_plot()
weight()

Return the weight of this overconvergent modular form.

EXAMPLES:

sage: M = OverconvergentModularForms(13, 10, 1/2, base_ring = Qp(13).extension(x^2 - 13,names='a'))
sage: M.gen(0).weight()
10
sage.modular.overconvergent.genus0.OverconvergentModularForms(prime, weight, radius, base_ring=Rational Field, prec=20, char=None)

Create a space of overconvergent p-adic modular forms of level \Gamma_0(p), over the given base ring. The base ring need not be a p-adic ring (the spaces we compute with typically have bases over \QQ).

INPUT:

  • prime - a prime number p, which must be one of the primes \{2, 3,
5, 7, 13\}, or the congruence subgroup Gamma0(p) where p is one of these primes.
  • weight - an integer (which at present must be 0 or \ge 2), the weight.
  • radius - a rational number in the interval \left( 0, \frac{p}{p+1}
\right), the radius of overconvergence.
  • base_ring (default: \QQ), a ring over which to compute. This need not be a p-adic ring.
  • prec - an integer (default: 20), the number of q-expansion terms to compute.
  • char - a Dirichlet character modulo p or None (the default). Here None is interpreted as the trivial character modulo p.

The character \chi and weight k must satisfy (-1)^k = \chi(-1), and the base ring must contain an element v such that {\rm ord}_p(v) = \frac{12 r}{p-1} where r is the radius of overconvergence (and {\rm ord}_p is normalised so {\rm ord}_p(p) = 1).

EXAMPLES:

sage: OverconvergentModularForms(3, 0, 1/2)
Space of 3-adic 1/2-overconvergent modular forms of weight-character 0 over Rational Field
sage: OverconvergentModularForms(3, 16, 1/2)
Space of 3-adic 1/2-overconvergent modular forms of weight-character 16 over Rational Field
sage: OverconvergentModularForms(3, 3, 1/2, char = DirichletGroup(3,QQ).0)
Space of 3-adic 1/2-overconvergent modular forms of weight-character (3, 3, [-1]) over Rational Field
class sage.modular.overconvergent.genus0.OverconvergentModularFormsSpace(prime, weight, radius, base_ring, prec, char)

A space of overconvergent modular forms of level \Gamma_0(p), where p is a prime such that X_0(p) has genus 0.

Elements are represented as power series, with a formal power series F corresponding to the modular form E_k^\ast \times F(g) where E_k^\ast is the p-deprived Eisenstein series of weight-character k, and g is a uniformiser of X_0(p) normalised so that the r-overconvergent region X_0(p)_{\ge r} corresponds to |g| \le 1.

TESTS:

sage: K.<w> = Qp(13).extension(x^2-13); M = OverconvergentModularForms(13, 20, radius=1/2, base_ring=K)
sage: M is loads(dumps(M))
True
__call__(input)

Create an element of this space. Allowable inputs are:

  • elements of compatible spaces of modular forms or overconvergent modular forms
  • arbitrary power series in q
  • lists of elements of the base ring (interpreted as vectors in the basis given by self.gens()).

Precision may be specified by padding lists at the end with zeros; inputs with a higher precision than the set precision of this space will be rounded.

EXAMPLES:

From a q-expansion:

sage: M = OverconvergentModularForms(3, 0, 1/2, prec=5)
sage: R.<q> = QQ[[]]
sage: f=M(q + q^2 - q^3 + O(q^16)); f
3-adic overconvergent modular form of weight-character 0 with q-expansion q + q^2 - q^3 + O(q^5)
sage: M.coordinate_vector(f)
(0, 1/27, -11/729, 173/19683, -3172/531441)

From a list or a vector:

sage: M([1,0,1])
3-adic overconvergent modular form of weight-character 0 with q-expansion 1 + 729*q^2 + O(q^3)
sage: M([1,0,1,0,0])
3-adic overconvergent modular form of weight-character 0 with q-expansion 1 + 729*q^2 + 17496*q^3 + 236196*q^4 + O(q^5)
sage: f = M([1,0,1,0,0]); v = M.coordinate_vector(f); v
(1, 0, 1, 0, 0)
sage: M(v) == f
True

From a classical modular form:

sage: f = CuspForms(Gamma0(3), 12).0; f
q - 176*q^4 + 2430*q^5 + O(q^6)
sage: fdag = OverconvergentModularForms(3, 12, 1/3, prec=8)(f); fdag
3-adic overconvergent modular form of weight-character 12 with q-expansion q - 176*q^4 + 2430*q^5 - 5832*q^6 - 19336*q^7 + O(q^8)
sage: fdag.parent().coordinate_vector(f)*(1 + O(3^2))
(0, 3^-2 + O(3^0), 2*3^-3 + 2*3^-2 + O(3^-1), 3^-4 + 3^-3 + O(3^-2), 2 + 3 + O(3^2), 2*3 + 3^2 + O(3^3), 2*3^4 + 2*3^5 + O(3^6), 3^5 + 3^6 + O(3^7))
sage: OverconvergentModularForms(3, 6, 1/3)(f)
...
TypeError: Cannot create an element of 'Space of 3-adic ...' from element of incompatible space 'Cuspidal subspace ...'

We test that zero elements are handled properly:

sage: M(0)
3-adic overconvergent modular form of weight-character 0 with q-expansion O(q^5)
sage: M(O(q^3))
3-adic overconvergent modular form of weight-character 0 with q-expansion O(q^3)

We test coercion between spaces of different precision:

sage: M10 = OverconvergentModularForms(3, 0, 1/2, prec=10)
sage: f = M10.1
sage: M(f)
3-adic overconvergent modular form of weight-character 0 with q-expansion 27*q + 324*q^2 + 2430*q^3 + 13716*q^4 + O(q^5)
sage: M10(M(f))
3-adic overconvergent modular form of weight-character 0 with q-expansion 27*q + 324*q^2 + 2430*q^3 + 13716*q^4 + O(q^5)
__cmp__(other)

Compare self to other.

EXAMPLES:

sage: OverconvergentModularForms(3, 12, 1/2) == ModularForms(3, 12)
False
sage: OverconvergentModularForms(3, 0, 1/2) == OverconvergentModularForms(3, 0, 1/3)
False
sage: OverconvergentModularForms(3, 0, 1/2) == OverconvergentModularForms(3, 0, 1/2, base_ring = Qp(3))
False
sage: OverconvergentModularForms(3, 0, 1/2) == OverconvergentModularForms(3, 0, 1/2)
True
__init__(prime, weight, radius, base_ring, prec, char)

Create a space of overconvergent p-adic modular forms of level \Gamma_0(p), over the given base ring. The base ring need not be a p-adic ring (the spaces we compute with typically have bases over \QQ).

EXAMPLES:

sage: OverconvergentModularForms(3, 0, 1/2)
Space of 3-adic 1/2-overconvergent modular forms of weight-character 0 over Rational Field
__reduce__()

Return the function and arguments used to construct self. Used for pickling.

EXAMPLES:

sage: L.<w> = Qp(7).extension(x^2 - 7)
sage: OverconvergentModularForms(7, 0, 1/4, base_ring=L).__reduce__()
(<function OverconvergentModularForms at ...>, (7, 0, 1/4, Eisenstein Extension ..., 20, [1]))
_an_element_impl()

Return an element of this space (used by the coercion machinery).

EXAMPLE:

sage: OverconvergentModularForms(3, 2, 1/3, prec=4).an_element() # indirect doctest
3-adic overconvergent modular form of weight-character 2 with q-expansion 9*q + 216*q^2 + 2430*q^3 + O(q^4)
_coerce_from_ocmf(f)

Try to convert the overconvergent modular form f into an element of self. An error will be raised if this is obviously nonsense.

EXAMPLES::
sage: M = OverconvergentModularForms(3, 0, 1/2) sage: MM = M.base_extend(Qp(3)) sage: R.<q> = Qp(3)[[]]; f = MM(q + O(q^2)); f 3-adic overconvergent modular form of weight-character 0 with q-expansion (1 + O(3^20))*q + O(q^2) sage: M._coerce_from_ocmf(f) 3-adic overconvergent modular form of weight-character 0 with q-expansion q + O(q^2) sage: f in M # indirect doctest True
_coerce_impl(x)

Canonical coercion of x into self. Here the possibilities for x are more restricted.

TESTS:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: MM = M.base_extend(Qp(3))
sage: MM.has_coerce_map_from(M) # indirect doctest
True
sage: MM.coerce(M.1)
3-adic overconvergent modular form of weight-character 0 with q-expansion (3^3 + O(3^23))*q + (3^4 + 3^5 + O(3^24))*q^2 ...
sage: M.has_coerce_map_from(MM)
False
sage: M.coerce(1)
3-adic overconvergent modular form of weight-character 0 with q-expansion 1 + O(q^20)
_convert_to_basis(qexp)

Given a q-expansion, converts it to a vector in the basis of this space, to the maximum possible precision (which is the minimum of the q-adic precision of the q-expansion and the precision of self).

EXAMPLE:

sage: M = OverconvergentModularForms(2, 0, 1/2)
sage: R.<q> = QQ[[]]
sage: M._convert_to_basis(q + q^2 + O(q^4))
1/64*g - 23/4096*g^2 + 201/65536*g^3 + O(g^4)
_discover_recurrence_matrix(use_smithline=True)

Does hard work of calculating recurrence matrix, which is cached to avoid doing this every time.

EXAMPLE:

sage: o = OverconvergentModularForms(3,12,0)
sage: o._discover_recurrence_matrix() == o.recurrence_matrix()
True
_params()

Return the parameters that define this module uniquely: prime, weight, character, radius of overconvergence and base ring. Mostly used for pickling.

EXAMPLES:

sage: L.<w> = Qp(7).extension(x^2 - 7)
sage: OverconvergentModularForms(7, 0, 1/4, base_ring=L)._params()
(7, 0, 1/4, Eisenstein Extension ..., 20, [1])
_repr_()

Return a string representation of self.

EXAMPLES:

sage: OverconvergentModularForms(3, 0, 1/2)._repr_()
'Space of 3-adic 1/2-overconvergent modular forms of weight-character 0 over Rational Field'
_set_radius(radius)

Set the radius of overconvergence to be r, where r is a rational number in the interval 0 < r < \frac{p}{p+1}

This only makes sense if the base ring contains an element of normalised valuation \frac{12r}{p-1}. If this valuation is an integer, we use the appropriate power of p. Otherwise, we assume the base ring has a uniformiser method and take an appropriate power of the uniformiser, raising an error if no such element exists.

EXAMPLES:

sage: M = OverconvergentModularForms(3, 2, 1/2) # indirect doctest
sage: M._set_radius(1/3); M
Space of 3-adic 1/3-overconvergent modular forms of weight-character 2 over Rational Field

sage: L.<w> = Qp(3).extension(x^5 - 3)
sage: OverconvergentModularForms(3, 2, 1/30, base_ring=L).normalising_factor() # indirect doctest
w + O(w^101)

sage: OverconvergentModularForms(3, 2, 1/40, base_ring=L)
...
ValueError: no element of base ring (=Eisenstein Extension ...) has normalised valuation 3/20
base_extend(ring)

Return the base extension of self to the given base ring. There must be a canonical map to this ring from the current base ring, otherwise a TypeError will be raised.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 0, 1/2, base_ring = Qp(2))
sage: M.base_extend(Qp(2).extension(x^2 - 2, names="w"))
Space of 2-adic 1/2-overconvergent modular forms of weight-character 0 over Eisenstein Extension of 2-adic Field ...
sage: M.base_extend(QQ)
...
TypeError: Base extension of self (over '2-adic Field with capped relative precision 20') to ring 'Rational Field' not defined.
change_ring(ring)

Return the space corresponding to self but over the given base ring.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 0, 1/2)
sage: M.change_ring(Qp(2))
Space of 2-adic 1/2-overconvergent modular forms of weight-character 0 over 2-adic Field with ...
character()

Return the character of self. For overconvergent forms, the weight and the character are unified into the concept of a weight-character, so this returns exactly the same thing as self.weight().

EXAMPLE:

sage: OverconvergentModularForms(3, 0, 1/2).character()
0
sage: type(OverconvergentModularForms(3, 0, 1/2).character())
<class '...weightspace.AlgebraicWeight'>
sage: OverconvergentModularForms(3, 3, 1/2, char=DirichletGroup(3,QQ).0).character()
(3, 3, [-1])
coordinate_vector(x)

Write x as a vector with respect to the basis given by self.basis(). Here x must be an element of this space or something that can be converted into one. If x has precision less than the default precision of self, then the returned vector will be shorter.

EXAMPLES:

sage: M = OverconvergentModularForms(Gamma0(3), 0, 1/3, prec=4)
sage: M.coordinate_vector(M.gen(2))
(0, 0, 1, 0)
sage: q = QQ[['q']].gen(); M.coordinate_vector(q - q^2 + O(q^4))
(0, 1/9, -13/81, 74/243)
sage: M.coordinate_vector(q - q^2 + O(q^3))
(0, 1/9, -13/81)
cps_u(n, use_recurrence=False)

Compute the characteristic power series of U_p acting on self, using an n x n matrix.

EXAMPLES:

sage: OverconvergentModularForms(3, 16, 1/2, base_ring=Qp(3)).cps_u(4)
1 + O(3^20) + (2 + 2*3 + 2*3^2 + 2*3^4 + 3^5 + 3^6 + 3^7 + 3^11 + 3^12 + 2*3^14 + 3^16 + 3^18 + O(3^19))*T + (2*3^3 + 3^5 + 3^6 + 3^7 + 2*3^8 + 2*3^9 + 2*3^10 + 3^11 + 3^12 + 2*3^13 + 2*3^16 + 2*3^18 + O(3^19))*T^2 + (2*3^15 + 2*3^16 + 2*3^19 + 2*3^20 + 2*3^21 + O(3^22))*T^3 + (3^17 + 2*3^18 + 3^19 + 3^20 + 3^22 + 2*3^23 + 2*3^25 + 3^26 + O(3^27))*T^4
sage: OverconvergentModularForms(3, 16, 1/2, base_ring=Qp(3), prec=30).cps_u(10)
1 + O(3^20) + (2 + 2*3 + 2*3^2 + 2*3^4 + 3^5 + 3^6 + 3^7 + 2*3^15 + O(3^16))*T + (2*3^3 + 3^5 + 3^6 + 3^7 + 2*3^8 + 2*3^9 + 2*3^10 + 2*3^11 + 2*3^12 + 2*3^13 + 3^14 + 3^15 + O(3^16))*T^2 + (3^14 + 2*3^15 + 2*3^16 + 3^17 + 3^18 + O(3^19))*T^3 + (3^17 + 2*3^18 + 3^19 + 3^20 + 3^21 + O(3^24))*T^4 + (3^29 + 2*3^32 + O(3^33))*T^5 + (2*3^44 + O(3^45))*T^6 + (2*3^59 + O(3^60))*T^7 + (2*3^78 + O(3^79))*T^8
eigenfunctions(n, F=None, exact_arith=True)

Calculate approximations to eigenfunctions of self. These are the eigenfunctions of self.hecke_matrix(p, n), which are approximations to the true eigenfunctions. Returns a list of OverconvergentModularFormElement objects, in increasing order of slope.

INPUT:

  • n - integer. The size of the matrix to use.
  • F - None, or a field over which to calculate eigenvalues. If the field is None, the current base ring is used. If the base ring is not a p-adic ring, an error will be raised.
  • exact_arith - True or False (default True). If True, use exact rational arithmetic to calculate the matrix of the U operator and its characteristic power series, even when the base ring is an inexact p-adic ring. This is typically slower, but more numerically stable.

NOTE: Try using set_verbose(1, 'sage/modular/overconvergent') to get more feedback on what is going on in this algorithm. For even more feedback, use 2 instead of 1.

EXAMPLES:

sage: X = OverconvergentModularForms(2, 2, 1/6).eigenfunctions(8, Qp(2, 100))
sage: X[1]
2-adic overconvergent modular form of weight-character 2 with q-expansion (1 + O(2^36))*q + (2^4 + 2^5 + 2^9 + 2^10 + 2^12 + 2^13 + 2^15 + 2^17 + 2^19 + 2^20 + 2^21 + 2^23 + 2^28 + 2^30 + 2^31 + 2^32 + 2^34 + 2^36 + 2^37 + 2^39 + O(2^40))*q^2 + (2^2 + 2^7 + 2^8 + 2^9 + 2^12 + 2^13 + 2^16 + 2^17 + 2^21 + 2^23 + 2^25 + 2^28 + 2^33 + 2^34 + 2^36 + 2^37 + O(2^38))*q^3 + (2^8 + 2^11 + 2^14 + 2^19 + 2^21 + 2^22 + 2^24 + 2^25 + 2^26 + 2^27 + 2^28 + 2^29 + 2^32 + 2^33 + 2^35 + 2^36 + O(2^44))*q^4 + (2 + 2^2 + 2^9 + 2^13 + 2^15 + 2^17 + 2^19 + 2^21 + 2^23 + 2^26 + 2^27 + 2^28 + 2^30 + 2^33 + 2^34 + 2^35 + 2^36 + O(2^37))*q^5 + (2^6 + 2^7 + 2^15 + 2^16 + 2^21 + 2^24 + 2^25 + 2^28 + 2^29 + 2^33 + 2^34 + 2^37 + O(2^42))*q^6 + (2^3 + 2^8 + 2^9 + 2^10 + 2^11 + 2^12 + 2^14 + 2^15 + 2^17 + 2^19 + 2^20 + 2^21 + 2^23 + 2^25 + 2^26 + 2^34 + 2^37 + 2^38 + O(2^39))*q^7 + O(q^8)
sage: [x.slope() for x in X]
[0, 4, 8, 14, 16, 18, 26, 30]
gen(i)

Return the ith module generator of self.

EXAMPLE:

sage: M = OverconvergentModularForms(3, 2, 1/2, prec=4)
sage: M.gen(0)
3-adic overconvergent modular form of weight-character 2 with q-expansion 1 + 12*q + 36*q^2 + 12*q^3 + O(q^4)
sage: M.gen(1)
3-adic overconvergent modular form of weight-character 2 with q-expansion 27*q + 648*q^2 + 7290*q^3 + O(q^4)
sage: M.gen(30)
3-adic overconvergent modular form of weight-character 2 with q-expansion O(q^4)
gens()

Return a generator object that iterates over the (infinite) set of basis vectors of self.

EXAMPLES:

sage: o = OverconvergentModularForms(3, 12, 1/2)
sage: t = o.gens()
sage: t.next()
3-adic overconvergent modular form of weight-character 12 with q-expansion 1 - 32760/61203943*q - 67125240/61203943*q^2 - ...
sage: t.next()
3-adic overconvergent modular form of weight-character 12 with q-expansion 27*q + 19829193012/61203943*q^2 + 146902585770/61203943*q^3 + ...
gens_dict()

Return a dictionary mapping the names of generators of this space to their values. (Required by parent class definition.) As this does not make any sense here, this raises a TypeError.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 4, 1/6)
sage: M.gens_dict()
...
TypeError: gens_dict does not make sense as number of generators is infinite
hecke_matrix(m, n, use_recurrence=False, exact_arith=False)

Calculate the matrix of the T_m operator in the basis of this space, truncated to an n \times n matrix. Conventions are that operators act on the left on column vectors (this is the opposite of the conventions of the sage.modules.matrix_morphism class!) Uses naive q-expansion arguments if use_recurrence=False and uses the Kolberg style recurrences if use_recurrence=True.

The argument “exact_arith” causes the computation to be done with rational arithmetic, even if the base ring is an inexact p-adic ring. This is useful as there can be precision loss issues (particularly with use_recurrence=False).

EXAMPLES:

sage: OverconvergentModularForms(2, 0, 1/2).hecke_matrix(2, 4)
[    1     0     0     0]
[    0    24    64     0]
[    0    32  1152  4608]
[    0     0  3072 61440]
sage: OverconvergentModularForms(2, 12, 1/2, base_ring=pAdicField(2)).hecke_matrix(2, 3) * (1 + O(2^2))
[        1 + O(2^2)                  0                  0]
[                 0       2^3 + O(2^5)       2^6 + O(2^8)]
[                 0       2^4 + O(2^6) 2^7 + 2^8 + O(2^9)]
sage: OverconvergentModularForms(2, 12, 1/2, base_ring=pAdicField(2)).hecke_matrix(2, 3, exact_arith=True)
[                             1                              0                              0]
[                             0               33881928/1414477                             64]
[                             0 -192898739923312/2000745183529             1626332544/1414477]
hecke_operator(f, m)

Given an element f and an integer m, calculates the Hecke operator T_m acting on f.

The input may be either a “bare” power series, or an OverconvergentModularFormElement object; the return value will be of the same type.

EXAMPLE:

sage: M = OverconvergentModularForms(3, 0, 1/2)
sage: f = M.1
sage: M.hecke_operator(f, 3)
3-adic overconvergent modular form of weight-character 0 with q-expansion 2430*q + 265356*q^2 + 10670373*q^3 + 249948828*q^4 + 4113612864*q^5 + 52494114852*q^6 + O(q^7)
sage: M.hecke_operator(f.qexp(), 3)
2430*q + 265356*q^2 + 10670373*q^3 + 249948828*q^4 + 4113612864*q^5 + 52494114852*q^6 + O(q^7)
is_exact()

True if elements of this space are represented exactly, i.e., there is no precision loss when doing arithmetic. As this is never true for overconvergent modular forms spaces, this returns False.

EXAMPLES:

sage: OverconvergentModularForms(13, 12, 0).is_exact()
False
ngens()

The number of generators of self (as a module over its base ring), i.e. infinity.

EXAMPLES:

sage: M = OverconvergentModularForms(2, 4, 1/6)
sage: M.ngens()
+Infinity
normalising_factor()

The normalising factor c such that g = c f is a parameter for the r-overconvergent disc in X_0(p), where f is the standard uniformiser.

EXAMPLE:

sage: L.<w> = Qp(7).extension(x^2 - 7)
sage: OverconvergentModularForms(7, 0, 1/4, base_ring=L).normalising_factor()
w + O(w^41)
prec()

Return the series precision of self. Note that this is different from the p-adic precision of the base ring.

EXAMPLE:

sage: OverconvergentModularForms(3, 0, 1/2).prec()
20
sage: OverconvergentModularForms(3, 0, 1/2,prec=40).prec()
40
prime()

Return the residue characteristic of self, i.e. the prime p such that this is a p-adic space.

EXAMPLES:

sage: OverconvergentModularForms(5, 12, 1/3).prime()
5
radius()

The radius of overconvergence of this space.

EXAMPLE:

sage: OverconvergentModularForms(3, 0, 1/3).radius()
1/3
recurrence_matrix(use_smithline=True)

Return the recurrence matrix satisfied by the coefficients of U, that is a matrix R =(r_{rs})_{r,s=1 \dots p} such that u_{ij} =
\sum_{r,s=1}^p r_{rs} u_{i-r, j-s}. Uses an elegant construction which I believe is due to Smithline. See my paper in IMRN (full citation in reference manual).

EXAMPLES:

sage: OverconvergentModularForms(2, 0, 0).recurrence_matrix()
[  48    1]
[4096    0]
sage: OverconvergentModularForms(2, 0, 1/2).recurrence_matrix()
[48 64]
[64  0]
sage: OverconvergentModularForms(3, 0, 0).recurrence_matrix()
[   270     36      1]
[ 26244    729      0]
[531441      0      0]
sage: OverconvergentModularForms(5, 0, 0).recurrence_matrix()
[     1575      1300       315        30         1]
[   162500     39375      3750       125         0]
[  4921875    468750     15625         0         0]
[ 58593750   1953125         0         0         0]
[244140625         0         0         0         0]
sage: OverconvergentModularForms(7, 0, 0).recurrence_matrix()
[       4018        8624        5915        1904         322          28           1]
[     422576      289835       93296       15778        1372          49           0]
[   14201915     4571504      773122       67228        2401           0           0]
[  224003696    37882978     3294172      117649           0           0           0]
[ 1856265922   161414428     5764801           0           0           0           0]
[ 7909306972   282475249           0           0           0           0           0]
[13841287201           0           0           0           0           0           0]
sage: OverconvergentModularForms(13, 0, 0).recurrence_matrix()
[         15145         124852         354536 ...
slopes(n, use_recurrence=False)

Compute the slopes of the U_p operator acting on self, using an n x n matrix.

EXAMPLES::
sage: OverconvergentModularForms(5,2,1/3,base_ring=Qp(5),prec=100).slopes(5) [0, 2, 5, 6, 9] sage: OverconvergentModularForms(2,1,1/3,char=DirichletGroup(4,QQ).0).slopes(5) [0, 2, 4, 6, 8]
weight()

Return the character of self. For overconvergent forms, the weight and the character are unified into the concept of a weight-character, so this returns exactly the same thing as self.character().

EXAMPLE:

sage: OverconvergentModularForms(3, 0, 1/2).weight()
0
sage: type(OverconvergentModularForms(3, 0, 1/2).weight())
<class '...weightspace.AlgebraicWeight'>
sage: OverconvergentModularForms(3, 3, 1/2, char=DirichletGroup(3,QQ).0).weight()
(3, 3, [-1])

Previous topic

The space of p-adic weights

Next topic

Module of Supersingular Points

This Page