Coverage for local/lib/python2.7/site-packages/sage/modular/modform/element.py: 79%

0.999645711124771397835729622033153189549796658647254961493709341358991830134499267117001769570658192128781135161587571716303826382489492569725002840546129937149159065273765309218543427544527498868033604310899372849565046516553245752253255585377793879866297612679545029546953895098375829822346290125161

Check that :trac:`23247` is fixed::

sage: F = Newforms(1,12)[0]

sage: chi = DirichletGroup(7).0

sage: abs(F.symsquare_lseries(chi).check_functional_equation()) < 1e-5

True

AUTHORS:

- Martin Raum (2011) -- original code posted to sage-nt

- David Loeffler (2015) -- added support for twists, integrated into

Sage library

"""

from sage.lfunctions.all import Dokchitser

weight = self.weight()

C = ComplexField(prec)

if self.level() != 1:

raise NotImplementedError("Symmetric square L-functions only implemented for level 1")

# compute the requested embedding

if isinstance(embedding, RingHomomorphism):

# Target of embedding might have precision less than desired, so

# need to refine

K = self.base_ring()

emb = NumberFieldEmbedding(K, ComplexField(prec), embedding(K.gen()))

else:

emb = self.base_ring().embeddings(ComplexField(prec))[embedding]

if chi is None:

eps = 1

N = 1

else:

assert chi.is_primitive()

chi = chi.change_ring(C)

eps = chi.gauss_sum()**3 / chi.base_ring()(chi.conductor())**QQ( (3, 2) )

N = chi.conductor()**3

if (chi is None) or chi.is_even():

L = Dokchitser(N, [0, 1, -weight + 2], 2 * weight - 1,

eps, prec=prec)

else:

L = Dokchitser(N, [0, 1, -weight + 1], 2 * weight - 1,

eps * C((0, 1)), prec=prec)

lcoeffs_prec = L.num_coeffs()

t = verbose("Computing %s coefficients of F" % lcoeffs_prec, level=1)

F_series = [u**2 for u in self.qexp(lcoeffs_prec + 1).list()[1:]]

verbose("done", t, level=1)

# utility function for Dirichlet convolution of series

def dirichlet_convolution(A, B):

return [sum(A[d-1] * B[n/d - 1] for d in divisors(n))

for n in range(1, 1 + min(len(A), len(B)))]

# The Dirichlet series for \zeta(2 s - 2 k + 2)

riemann_series = [ n**(weight - 1) if n.is_square() else 0

for n in xsrange(1, lcoeffs_prec + 1) ]

# The Dirichlet series for 1 / \zeta(s - k + 1)

mu_series = [ moebius(n) * n**(weight - 1) for n in xsrange(1, lcoeffs_prec + 1) ]

conv_series = dirichlet_convolution(mu_series, riemann_series)

dirichlet_series = dirichlet_convolution(conv_series, F_series)

# If the base ring is QQ we pass the coefficients to GP/PARI as exact

# rationals. Otherwise, need to use the embedding.

if self.base_ring() != QQ:

dirichlet_series = map(emb, dirichlet_series)

if chi is not None:

pari_precode_chi = str(chi.values()) + "[n%" + str(chi.conductor()) + "+1]; "

else:

pari_precode_chi = "1"

pari_precode = "hhh(n) = " + str(dirichlet_series) + "[n] * " + pari_precode_chi

L.init_coeffs( "hhh(k)", w="conj(hhh(k))",

pari_precode=pari_precode)

return L

def petersson_norm(self, embedding=0, prec=53):

r"""

Compute the Petersson scalar product of f with itself:

.. MATH::

\langle f, f \rangle = \int_{\Gamma_0(N) \backslash \mathbb{H}} |f(x + iy)|^2 y^k\, \mathrm{d}x\, \mathrm{d}y.

Only implemented for N = 1 at present. It is assumed that `f` has real

coefficients. The norm is computed as a special value of the symmetric

square L-function, using the identity

.. MATH::

\langle f, f \rangle = \frac{(k-1)! L(\mathrm{Sym}^2 f, k)}{2^{2k-1} \pi^{k+1}}

INPUT:

- ``embedding``: embedding of the coefficient field into `\RR` or

`\CC`, or an integer `i` (interpreted as the `i`-th embedding)

(default: 0)

- ``prec`` (integer, default 53): precision in bits

EXAMPLES::

sage: CuspForms(1, 16).0.petersson_norm()

verbose -1 (...: dokchitser.py, __call__) Warning: Loss of 2 decimal digits due to cancellation

2.16906134759063e-6

The Petersson norm depends on a choice of embedding::

sage: set_verbose(-2, "dokchitser.py") # disable precision-loss warnings

sage: F = Newforms(1, 24, names='a')[0]

sage: F.petersson_norm(embedding=0)

0.000107836545077234

sage: F.petersson_norm(embedding=1)

0.000128992800758160

TESTS:

Verify that the Petersson norm is a quadratic form::

sage: F, G = CuspForms(1, 24).basis()

sage: X = lambda u: u.petersson_norm(prec=100)

sage: (X(F + G) + X(F - G) - 2*X(F) - 2*X(G)).abs() < 1e-25

True

"""

pi = RealField(prec).pi()

L = self.symsquare_lseries(prec=prec, embedding=embedding)

k = self.weight()

return (ZZ(k - 1).factorial() / 2**(2*k - 1) / pi**(k+1)) * L(k).real_part()

def _q_expansion_bound(self, eps):

r"""

This function takes as input a modular form, ``self`` and a

Dirichlet character ``eps`` and returns an integer bound such

that if ``self`` and its twist by ``eps`` have the same

q-expansion up to this bound, then they are equal.

The bound is taken from [Mu1997]_. See also [Shi1971]_, Proposition

3.64.

INPUT:

- ``eps`` -- a Dirichlet character

OUTPUT:

A positive integer.

EXAMPLES:

Here is an example that can easily be checked by hand. ::

sage: M = ModularForms(Gamma0(11), 2)

sage: C = M.cuspidal_submodule()

sage: f = C.gens()[0]

sage: F = CyclotomicField(5)

sage: D = DirichletGroup(11, F)

sage: eps = D.gens()[0]

sage: f._q_expansion_bound(eps)

The level of ``self`` does not have to be related to the conductor

of eps. ::

sage: M = ModularForms(Gamma0(1), 12)

sage: C = M.cuspidal_submodule()

sage: Delta = C.gens()[0]

sage: F = CyclotomicField(12)

sage: D = DirichletGroup(13, F)

sage: eps = D.gens()[0]

sage: Delta._q_expansion_bound(eps)

182

"""

chi = self.character()

M = lcm([self.level(), eps.conductor()**2,

chi.conductor() * eps.conductor()])

y = QQ(self.weight()) / QQ(12) * M

for p in M.prime_divisors():

y *= (1 + 1/QQ(p))

return y.ceil()

@cached_method

def has_cm(self):

r"""

Return whether the modular form ``self`` has complex multiplication.

OUTPUT:

Boolean

.. SEEALSO::

- :meth:`cm_discriminant` (to return the CM field)

- :meth:`sage.schemes.elliptic_curves.ell_rational_field.has_cm`

EXAMPLES::

sage: G = DirichletGroup(21); eps = G.0 * G.1

sage: Newforms(eps, 2)[0].has_cm()

True

This example illustrates what happens when

candidate_characters(self) is the empty list. ::

sage: M = ModularForms(Gamma0(1), 12)

sage: C = M.cuspidal_submodule()

sage: Delta = C.gens()[0]

sage: Delta.has_cm()

False

We now compare the function has_cm between elliptic curves and

their associated modular forms. ::

sage: E = EllipticCurve([-1, 0])

sage: f = E.modular_form()

sage: f.has_cm()

True

sage: E.has_cm() == f.has_cm()

True

Here is a non-cm example coming from elliptic curves. ::

sage: E = EllipticCurve('11a')

sage: f = E.modular_form()

sage: f.has_cm()

False

sage: E.has_cm() == f.has_cm()

True

"""

N = self.level()

M = self.character().conductor()

for p in N.prime_factors():

if M % p and N.valuation(p) == 1:

verbose("Form is Steinberg at %s, cannot be CM" % p, level=1)

return False

cand_chars = [(x, self._q_expansion_bound(x)) for x in DirichletGroup(N, QQ) if x.is_odd()]

verbose("Conductors of candidate characters: %s" % (", ".join(str(x[0].conductor()) for x in cand_chars)), level=1)

verbose("Qexp bounds: %s" % (", ".join(str(x[1]) for x in cand_chars)), level=1)

# If there are no candidate characters, then self cannot have CM.

if not cand_chars:

return False

# Test each prime and discard characters for which eps(p) != 1 when f[p] != 0.

p = ZZ(2)

while p <= min(B for (eps, B) in cand_chars):

verbose("Checking p = %s (%s candidate characters left))" % (p, len(cand_chars)), level=1)

# We only have to test the CM condition at primes that do not

# divide the level of self.

if not self.level() % p:

p = p.next_prime()

continue

# Evaluating characters is cheap, while computing f[p] is

# expensive, so if eps(p) = 1 for all p, then we don't bother to

# compute f[p].

cand_chars = [(eps, B) for (eps, B) in cand_chars if (eps(p) == 1 or self[p] == 0)]

if len(cand_chars) == 0:

# f doesn't have CM

return False

# go on to next prime

p = p.next_prime()

B0 = min(B for (eps, B) in cand_chars)

C = [eps for (eps, B) in cand_chars if B == B0]

if len(C) > 1:

# can't happen (except in weight 1, which isn't implemented yet

# anyway)

raise ArithmeticError("Got multiple characters in has_cm")

self.__cm_char = C[0].primitive_character()

return True

def cm_discriminant(self):

r"""

Return the discriminant of the CM field associated to this form. An

error will be raised if the form isn't of CM type.

EXAMPLES::

sage: Newforms(49, 2)[0].cm_discriminant()

-7

sage: CuspForms(1, 12).gen(0).cm_discriminant()

Traceback (most recent call last):

...

ValueError: Not a CM form

"""

if not self.has_cm(): raise ValueError("Not a CM form")

return -self.__cm_char.conductor()

class Newform(ModularForm_abstract):

def __init__(self, parent, component, names, check=True):

r"""

Initialize a Newform object.

INPUT:

- ``parent`` - An ambient cuspidal space of modular forms for

which self is a newform.

- ``component`` - A simple component of a cuspidal modular

symbols space of any sign corresponding to this newform.

- ``check`` - If check is ``True``, check that parent and

component have the same weight, level, and character, that

component has sign 1 and is simple, and that the types are

correct on all inputs.

EXAMPLES::

sage: sage.modular.modform.element.Newform(CuspForms(11,2), ModularSymbols(11,2,sign=1).cuspidal_subspace(), 'a')

q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)

sage: f = Newforms(DirichletGroup(5).0, 7,names='a')[0]; f[2].trace(f.base_ring().base_field())

-5*zeta4 - 5

"""

from .space import is_ModularFormsSpace

if check:

if not is_ModularFormsSpace(parent):

raise TypeError("parent must be a space of modular forms")

if not is_ModularSymbolsSpace(component):

raise TypeError("component must be a space of modular symbols")

if parent.group() != component.group():

raise ValueError("parent and component must be defined by the same congruence subgroup")

if parent.weight() != component.weight():

raise ValueError("parent and component must have the same weight")

if not component.is_cuspidal():

raise ValueError("component must be cuspidal")

if not component.is_simple():

raise ValueError("component must be simple")

extension_field = component.eigenvalue(1,name=names).parent()

if extension_field != parent.base_ring(): # .degree() != 1 and rings.is_NumberField(extension_field):

assert extension_field.base_field() == parent.base_ring()

extension_field = parent.base_ring().extension(extension_field.relative_polynomial(), names=names)

self.__name = names

ModuleElement.__init__(self, parent.base_extend(extension_field))

self.__modsym_space = component

self.__hecke_eigenvalue_field = extension_field

def _name(self):

"""

Return the name of the generator of the Hecke eigenvalue field

of self. Note that a name exists even when this field is QQ.

EXAMPLES::

sage: [ f._name() for f in Newforms(38,4,names='a') ]

['a0', 'a1', 'a2']

"""

return self.__name

def _compute_q_expansion(self, prec):

"""

Return the q-expansion of self to precision prec.

EXAMPLES::

sage: forms = Newforms(31, 6, names='a')

sage: forms[0]._compute_q_expansion(10)

sage: forms[0]._compute_q_expansion(15)

q + a0*q^2 + (5/704*a0^4 + 43/704*a0^3 - 61/88*a0^2 - 197/44*a0 + 717/88)*q^3 + (a0^2 - 32)*q^4 + (-31/352*a0^4 - 249/352*a0^3 + 111/22*a0^2 + 218/11*a0 - 2879/44)*q^5 + (-1/352*a0^4 - 79/352*a0^3 - 67/44*a0^2 + 13/22*a0 - 425/44)*q^6 + (17/88*a0^4 + 133/88*a0^3 - 405/44*a0^2 - 1005/22*a0 - 35/11)*q^7 + (a0^3 - 64*a0)*q^8 + (39/352*a0^4 + 441/352*a0^3 - 93/44*a0^2 - 441/22*a0 - 5293/44)*q^9 + (15/176*a0^4 - 135/176*a0^3 - 185/11*a0^2 + 311/11*a0 + 2635/22)*q^10 + (-291/704*a0^4 - 3629/704*a0^3 + 1139/88*a0^2 + 10295/44*a0 - 21067/88)*q^11 + (-75/176*a0^4 - 645/176*a0^3 + 475/22*a0^2 + 1503/11*a0 - 5651/22)*q^12 + (207/704*a0^4 + 2977/704*a0^3 + 581/88*a0^2 - 3307/44*a0 - 35753/88)*q^13 + (-5/22*a0^4 + 39/11*a0^3 + 763/22*a0^2 - 2296/11*a0 - 2890/11)*q^14 + O(q^15)

"""

return self.modular_symbols(1).q_eigenform(prec, names=self._name())

def __eq__(self, other):

"""

Return True if self equals other, and False otherwise.

EXAMPLES::

sage: f1, f2 = Newforms(17,4,names='a')

sage: f1.__eq__(f1)

True

sage: f1.__eq__(f2)

False

We test comparison of equal newforms with different parents

(see :trac:`18478`)::

sage: f = Newforms(Gamma1(11), 2)[0]; f

q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)

sage: g = Newforms(Gamma0(11), 2)[0]; g

q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)

sage: f == g

True

sage: f = Newforms(DirichletGroup(4)[1], 5)[0]; f

q - 4*q^2 + 16*q^4 - 14*q^5 + O(q^6)

sage: g = Newforms(Gamma1(4), 5)[0]; g

q - 4*q^2 + 16*q^4 - 14*q^5 + O(q^6)

sage: f == g

True

"""

if (not isinstance(other, ModularForm_abstract)

or self.weight() != other.weight()):

return False

if isinstance(other, Newform):

if (self.level() != other.level() or

self.character() != other.character()):

return False

# The two parents may have different Sturm bounds in case

# one of them is a space of cusp forms with character

# (possibly trivial, i.e. for the group Gamma0(n)) and the

# other is a space of cusp forms for Gamma1(n). It is

# safe to take the smaller bound because we have checked

# that the characters agree.

bound = min(self.parent().sturm_bound(),

other.parent().sturm_bound())

return self.q_expansion(bound) == other.q_expansion(bound)

# other is a ModularFormElement

return self.element() == other

def abelian_variety(self):

"""

Return the abelian variety associated to self.

EXAMPLES::

sage: Newforms(14,2)[0]

q - q^2 - 2*q^3 + q^4 + O(q^6)

sage: Newforms(14,2)[0].abelian_variety()

Newform abelian subvariety 14a of dimension 1 of J0(14)

sage: Newforms(1, 12)[0].abelian_variety()

Traceback (most recent call last):

...

TypeError: f must have weight 2

"""

try:

return self.__abelian_variety

except AttributeError:

from sage.modular.abvar.abvar_newform import ModularAbelianVariety_newform

self.__abelian_variety = ModularAbelianVariety_newform(self)

return self.__abelian_variety

def hecke_eigenvalue_field(self):

r"""

Return the field generated over the rationals by the

coefficients of this newform.

EXAMPLES::

sage: ls = Newforms(35, 2, names='a') ; ls

[q + q^3 - 2*q^4 - q^5 + O(q^6),

q + a1*q^2 + (-a1 - 1)*q^3 + (-a1 + 2)*q^4 + q^5 + O(q^6)]

sage: ls[0].hecke_eigenvalue_field()

Rational Field

sage: ls[1].hecke_eigenvalue_field()

Number Field in a1 with defining polynomial x^2 + x - 4

"""

return self.__hecke_eigenvalue_field

def coefficient(self, n):

"""

Return the coefficient of `q^n` in the power series of self.

INPUT:

- ``n`` - a positive integer

OUTPUT:

- the coefficient of `q^n` in the power series of self.

EXAMPLES::

sage: f = Newforms(11)[0]; f

q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)

sage: f.coefficient(100)

-8

sage: g = Newforms(23, names='a')[0]; g

q + a0*q^2 + (-2*a0 - 1)*q^3 + (-a0 - 1)*q^4 + 2*a0*q^5 + O(q^6)

sage: g.coefficient(3)

-2*a0 - 1

"""

return self.modular_symbols(1).eigenvalue(n, self._name())

def _compute(self, X):

"""

Compute the coefficients of `q^n` of the power series of self,

for `n` in the list `X`. The results are not cached. (Use

coefficients for cached results).

EXAMPLES::

sage: f = Newforms(39,4,names='a')[1] ; f

q + a1*q^2 - 3*q^3 + (2*a1 + 5)*q^4 + (-2*a1 + 14)*q^5 + O(q^6)

sage: f._compute([2,3,7])

[a1, -3, -2*a1 + 2]

sage: f._compute([])

[]

Check that :trac:`20793` is fixed::

sage: f = Newforms(83, 2, names='a')[1]; f

q + a1*q^2 + (1/2*a1^4 - 1/2*a1^3 - 7/2*a1^2 + 3/2*a1 + 4)*q^3 + (a1^2 - 2)*q^4 + (-1/2*a1^5 - 1/2*a1^4 + 9/2*a1^3 + 7/2*a1^2 - 8*a1 - 2)*q^5 + O(q^6)

sage: K = f.hecke_eigenvalue_field(); K

Number Field in a1 with defining polynomial x^6 - x^5 - 9*x^4 + 7*x^3 + 20*x^2 - 12*x - 8

sage: l = f.coefficients(20); l[-1]

-a1^4 + 5*a1^2 - 4

sage: l[-1].parent() is K

True

"""

M = self.modular_symbols(1)

return [M.eigenvalue(x, name=self._name()) for x in X]

def element(self):

"""

Find an element of the ambient space of modular forms which

represents this newform.

.. note::

This can be quite expensive. Also, the polynomial defining

the field of Hecke eigenvalues should be considered random,

since it is generated by a random sum of Hecke

operators. (The field itself is not random, of course.)

EXAMPLES::

sage: ls = Newforms(38,4,names='a')

sage: ls[0]

q - 2*q^2 - 2*q^3 + 4*q^4 - 9*q^5 + O(q^6)

sage: ls # random

[q - 2*q^2 - 2*q^3 + 4*q^4 - 9*q^5 + O(q^6),

q - 2*q^2 + (-a1 - 2)*q^3 + 4*q^4 + (2*a1 + 10)*q^5 + O(q^6),

q + 2*q^2 + (1/2*a2 - 1)*q^3 + 4*q^4 + (-3/2*a2 + 12)*q^5 + O(q^6)]

sage: type(ls[0])

sage: ls[2][3].minpoly()

x^2 - 9*x + 2

sage: ls2 = [ x.element() for x in ls ]

sage: ls2 # random

[q - 2*q^2 - 2*q^3 + 4*q^4 - 9*q^5 + O(q^6),

q - 2*q^2 + (-a1 - 2)*q^3 + 4*q^4 + (2*a1 + 10)*q^5 + O(q^6),

q + 2*q^2 + (1/2*a2 - 1)*q^3 + 4*q^4 + (-3/2*a2 + 12)*q^5 + O(q^6)]

sage: type(ls2[0])

sage: ls2[2][3].minpoly()

x^2 - 9*x + 2

"""

S = self.parent()

return S(self.q_expansion(S.sturm_bound()))

def is_cuspidal(self):

"""

Return True. For compatibility with elements of modular forms spaces.

EXAMPLES::

sage: Newforms(11, 2)[0].is_cuspidal()

True

"""

return True

def modular_symbols(self, sign=0):

"""

Return the subspace with the specified sign of the space of

modular symbols corresponding to this newform.

EXAMPLES::

sage: f = Newforms(18,4)[0]

sage: f.modular_symbols()

Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 18 for Gamma_0(18) of weight 4 with sign 0 over Rational Field

sage: f.modular_symbols(1)

Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 11 for Gamma_0(18) of weight 4 with sign 1 over Rational Field

"""

return self.__modsym_space.modular_symbols_of_sign(sign)

@cached_method

def modsym_eigenspace(self, sign=0):

"""

Return a submodule of dimension 1 or 2 of the ambient space of

the sign 0 modular symbols space associated to ``self``,

base-extended to the Hecke eigenvalue field, which is an

eigenspace for the Hecke operators with the same eigenvalues

as this newform, *and* is an eigenspace for the star

involution of the appropriate sign if the sign is not 0.

EXAMPLES::

sage: N = Newform("37a")

sage: N.modular_symbols(0)

Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 5 for Gamma_0(37) of weight 2 with sign 0 over Rational Field

sage: M = N.modular_symbols(0)

sage: V = N.modsym_eigenspace(1); V

Vector space of degree 5 and dimension 1 over Rational Field

Basis matrix:

[ 0 1 -1 1 0]

sage: V.0 in M.free_module()

True

sage: V=N.modsym_eigenspace(-1); V

Vector space of degree 5 and dimension 1 over Rational Field

Basis matrix:

[ 0 0 0 1 -1/2]

sage: V.0 in M.free_module()

True

"""

M = self.modular_symbols(sign=0)

if sign != 0:

Ms = M.sign_submodule(sign)

r = 1

else:

Ms = M

r = 2

# silly thing: can't do Ms.eigenvector(), even when Ms is simple,

# because it can't be relied on to choose the coefficient fields

# consistently

A = M.ambient()

X = Ms.free_module().base_extend(self.hecke_eigenvalue_field())

p = ZZ(2)

while X.rank() > r:

assert p <= M.sturm_bound()

X = (A.hecke_matrix(p) - self[p]).kernel_on(X)

p = p.next_prime()

# should really return a modular symbol submodule object, but these are

# not implemented over non-minimal base rings

return X

def _defining_modular_symbols(self):

"""

Return the modular symbols space corresponding to self.

EXAMPLES::

sage: Newforms(43,2,names='a')

[q - 2*q^2 - 2*q^3 + 2*q^4 - 4*q^5 + O(q^6),

q + a1*q^2 - a1*q^3 + (-a1 + 2)*q^5 + O(q^6)]

sage: [ x._defining_modular_symbols() for x in Newforms(43,2,names='a') ]

[Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field,

Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field]

sage: ModularSymbols(43,2,sign=1).cuspidal_subspace().new_subspace().decomposition()

[

Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field,

Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1 over Rational Field

]

"""

return self.__modsym_space

def number(self):

"""

Return the index of this space in the list of simple, new,

cuspidal subspaces of the full space of modular symbols for

this weight and level.

EXAMPLES::

sage: Newforms(43, 2, names='a')[1].number()

"""

return self._defining_modular_symbols().ambient().cuspidal_subspace().new_subspace().decomposition().index(self._defining_modular_symbols())

def __bool__(self):

"""

Return ``True``, as newforms are never zero.

EXAMPLES::

sage: bool(Newforms(14,2)[0])

True

"""

return True

__nonzero__ = __bool__

def character(self):

r"""

The nebentypus character of this newform (as a Dirichlet character with

values in the field of Hecke eigenvalues of the form).

EXAMPLES::

sage: Newforms(Gamma1(7), 4,names='a')[1].character()

Dirichlet character modulo 7 of conductor 7 mapping 3 |--> 1/2*a1

sage: chi = DirichletGroup(3).0; Newforms(chi, 7)[0].character() == chi

True

"""

return self._defining_modular_symbols().q_eigenform_character(self._name())

###########################

# Atkin--Lehner operators #

###########################

def _atkin_lehner_action_from_qexp(self, Q, embedding=None):

"""

Return the result of the Atkin-Lehner operator `W_Q` on

``self``, using a formula based on `q`-expansions.

INPUT:

- ``self`` -- a newform `f`

- ``Q`` -- a prime power exactly dividing the level of ``self``

- ``embedding`` -- (optional) embedding of the coefficient

field of `f` into a field containing the relevant Gauss sums

OUTPUT:

A pair `(w, f^*)` where `f^*` is a :class:`Newform` and `w` is

a scalar such that `W_Q f = w f^*`. The parent of `w` is the

codomain of ``embedding`` if specified, otherwise it is (a

suitable extension of) the coefficient field of `f`.

.. NOTE::

This method assumes that the `Q`-th coefficient in the

`q`-expansion of ``self`` is non-zero.

TESTS::

sage: f = Newforms(Gamma0(18), 4)[0]; f

q + 2*q^2 + 4*q^4 - 6*q^5 + O(q^6)

sage: f._atkin_lehner_action_from_qexp(2)

(-2, q + 2*q^2 + 4*q^4 - 6*q^5 + O(q^6))

sage: f._atkin_lehner_action_from_qexp(9)

Traceback (most recent call last):

...

ValueError: a_Q must be nonzero

An example with odd weight::

sage: f = Newforms(Gamma1(15), 3, names='a')[2]; f

q + a2*q^2 + (-a2 - 2)*q^3 - q^4 - a2*q^5 + O(q^6)

sage: f._atkin_lehner_action_from_qexp(5)

(a2, q + a2*q^2 + (-a2 - 2)*q^3 - q^4 - a2*q^5 + O(q^6))

"""

from sage.misc.all import prod

a_Q = self[Q]

epsilon = self.character()

dec = epsilon.decomposition()

eps_Q = [eps for eps in dec if eps.modulus() == Q][0]

eta = prod([eps(Q) for eps in dec if eps.modulus() != Q])

if not a_Q:

raise ValueError("a_Q must be nonzero")

f_star = self.twist(~eps_Q, level=self.level())

if embedding is not None:

a_Q = embedding(a_Q)

eps_Q = eps_Q.change_ring(embedding)

eta = embedding(eta)

if eps_Q.is_trivial():

g = -1

else:

# eps_Q is primitive of conductor Q

g = eps_Q.gauss_sum()

return Q**(self.weight() - 2) * eta * g / a_Q, f_star

def _atkin_lehner_action_from_modsym(self, d, embedding=None):

"""

Return the result of the Atkin-Lehner operator `W_d` on

``self``, using the action of `W_d` on modular symbols.

INPUT:

- ``self`` -- a newform `f`

- ``d`` -- a positive integer exactly dividing the level of ``self``

- ``embedding`` -- (optional) embedding of the coefficient

field of `f` into a field containing the relevant Gauss sums

OUTPUT:

A pair `(w, f^*)` where `f^*` is a :class:`Newform` and `w` is

a scalar such that `W_d f = w f^*`. The parent of `w` is the

codomain of ``embedding`` if specified, otherwise it is (a

suitable extension of) the coefficient field of `f`.

.. NOTE::

This algorithm only works if the character of `f` is trivial at

`d`, so `f^* = f`. Nonetheless we return the pair `(w, f)` for

consistency.

EXAMPLES::

sage: F = Newforms(Gamma1(15), 3, names='a')[2]

sage: F._atkin_lehner_action_from_modsym(5)

(a2, q + a2*q^2 + (-a2 - 2)*q^3 - q^4 - a2*q^5 + O(q^6))

sage: _ == F._atkin_lehner_action_from_qexp(5)

True

"""

if d.gcd(self.character().conductor()) != 1:

raise ValueError("character must be trivial at d")

X = self.modsym_eigenspace(sign=0)

A = self.modular_symbols(sign=0).ambient()

W = A.atkin_lehner_operator(d).matrix().base_extend(self.hecke_eigenvalue_field()).restrict(X)

assert W.is_scalar()

w = W[0,0]

if embedding is not None:

w = embedding(w)

return w, self

def atkin_lehner_action(self, d, embedding=None):

"""

Return the result of the Atkin-Lehner operator `W_d` on

``self``.

INPUT:

- ``d`` -- a positive integer exactly dividing the level `N`

of ``self``, i.e. `d` divides `N` and is coprime to `N/d`

- ``embedding`` -- (optional) embedding of the base ring of

``self`` into another ring

OUTPUT:

A pair `(w, f^*)` where `f^*` is a :class:`Newform` and `w` is

a scalar such that `W_d f = w f^*`. This `w` is called the

Atkin-Lehner pseudo-eigenvalue of `W_d` acting on `f`.

The parent of `w` is the codomain of ``embedding`` if

specified, otherwise it is (a suitable extension of) the

coefficient field of `f`.

ALGORITHM:

The action is computed using the results of [AL1978]_,

Sections 1 and 2.

.. SEEALSO::

For the conventions used to define the operator `W_d`, see

:meth:`ModularForm_abstract.atkin_lehner_action`.

EXAMPLES::

sage: f = Newforms(Gamma1(30), 2, names='a')[1]

sage: emb = f.base_ring().complex_embeddings()[0]

sage: for d in divisors(30):

....: print(f.atkin_lehner_action(d, embedding=emb))

(1.00000000000000, q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6))

(1.00000000000000*I, q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6))

(-1.00000000000000*I, q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6))

(-0.894427190999916 + 0.447213595499958*I, q - a1*q^2 + a1*q^3 - q^4 + (-a1 - 2)*q^5 + O(q^6))

(1.00000000000000, q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6))

(-0.447213595499958 - 0.894427190999916*I, q - a1*q^2 + a1*q^3 - q^4 + (-a1 - 2)*q^5 + O(q^6))

(0.447213595499958 + 0.894427190999916*I, q - a1*q^2 + a1*q^3 - q^4 + (-a1 - 2)*q^5 + O(q^6))

(-0.894427190999916 + 0.447213595499958*I, q - a1*q^2 + a1*q^3 - q^4 + (-a1 - 2)*q^5 + O(q^6))

The above computation can also be done exactly:

sage: K.<z> = CyclotomicField(20) # long time

sage: g = Newforms(Gamma1(30), 2, K, names='a')[1] # long time

sage: for d in divisors(30): # long time

....: print(g.atkin_lehner_action(d)) # long time

(1, q - z^5*q^2 + z^5*q^3 - q^4 + (-z^5 - 2)*q^5 + O(q^6))

(z^5, q - z^5*q^2 + z^5*q^3 - q^4 + (-z^5 - 2)*q^5 + O(q^6))

(-z^5, q - z^5*q^2 + z^5*q^3 - q^4 + (-z^5 - 2)*q^5 + O(q^6))

(2/5*z^7 + 4/5*z^6 - 1/5*z^5 - 4/5*z^4 + 2/5*z^3 - 2/5, q + z^5*q^2 - z^5*q^3 - q^4 + (z^5 - 2)*q^5 + O(q^6))

(1, q - z^5*q^2 + z^5*q^3 - q^4 + (-z^5 - 2)*q^5 + O(q^6))

(-4/5*z^7 + 2/5*z^6 + 2/5*z^5 - 2/5*z^4 - 4/5*z^3 - 1/5, q + z^5*q^2 - z^5*q^3 - q^4 + (z^5 - 2)*q^5 + O(q^6))

(4/5*z^7 - 2/5*z^6 - 2/5*z^5 + 2/5*z^4 + 4/5*z^3 + 1/5, q + z^5*q^2 - z^5*q^3 - q^4 + (z^5 - 2)*q^5 + O(q^6))

(2/5*z^7 + 4/5*z^6 - 1/5*z^5 - 4/5*z^4 + 2/5*z^3 - 2/5, q + z^5*q^2 - z^5*q^3 - q^4 + (z^5 - 2)*q^5 + O(q^6))

We can compute the eigenvalue of `W_{p^e}` in certain cases

where the `p`-th coefficient of `f` is zero:

sage: f = Newforms(169, names='a')[0]; f

q + a0*q^2 + 2*q^3 + q^4 - a0*q^5 + O(q^6)

sage: f[13]

sage: f.atkin_lehner_eigenvalue(169)

-1

TESTS::

sage: K.<a> = QuadraticField(1129)

sage: f = Newforms(Gamma0(20), 8, base_ring=K)[2]; f

q + (2*a - 10)*q^3 + 125*q^5 + O(q^6)

sage: f.atkin_lehner_action(2)

(-1, q + (2*a - 10)*q^3 + 125*q^5 + O(q^6))

sage: f = Newforms(Gamma1(11), 2)[0]

sage: f.atkin_lehner_action(2)

Traceback (most recent call last):

...

ValueError: d (= 2) does not divide the level (= 11)

"""

# normalise d

d = ZZ(d)

N = self.level()

if not d.divides(N):

raise ValueError('d (= {}) does not divide the level (= {})'.format(d, N))

d = N // N.prime_to_m_part(d)

if d == 1:

w = self.base_ring().one()

if embedding is not None:

w = embedding(w)

return w, self

q, e = d.factor()[0]

Q = q**e

M = d // Q

eps_Q = [eps for eps in self.character().decomposition() if eps.modulus() == Q][0]

eps = eps_Q(M)

if embedding is not None:

eps = embedding(eps)

if self[Q]:

eta0, g0 = self._atkin_lehner_action_from_qexp(Q, embedding)

elif eps_Q.is_trivial():

eta0, g0 = self._atkin_lehner_action_from_modsym(Q, embedding)

else:

raise NotImplementedError("Unable to determine local constant at prime %s" % q)

eta1, g1 = g0.atkin_lehner_action(M, embedding)

return eps * eta0 * eta1, g1

def twist(self, chi, level=None, check=True):

r"""

Return the twist of the newform ``self`` by the Dirichlet

character ``chi``.

If ``self`` is a newform `f` with character `\epsilon` and

`q`-expansion

.. MATH::

f(q) = \sum_{n=1}^\infty a_n q^n,

then the twist by `\chi` is the unique newform `f\otimes\chi`

with character `\epsilon\chi^2` and `q`-expansion

.. MATH::

(f\otimes\chi)(q) = \sum_{n=1}^\infty b_n q^n

satisfying `b_n = \chi(n) a_n` for all but finitely many `n`.

INPUT:

- ``chi`` -- a Dirichlet character. Note that Sage must be able to

determine a common base field into which both the Hecke eigenvalue

field of self, and the field of values of ``chi``, can be embedded.

- ``level`` -- (optional) the level `N` of the twisted form.

By default, the algorithm tries to compute `N` using

[AL1978]_, Theorem 3.1.

- ``check`` -- (optional) boolean; if ``True`` (default), ensure that

the space of modular symbols that is computed is genuinely simple and

new. This makes it less likely that a wrong result is returned if an

incorrect ``level`` is specified.

OUTPUT:

The form `f\otimes\chi` as an element of the set of newforms

for `\Gamma_1(N)` with character `\epsilon\chi^2`.

EXAMPLES::

sage: G = DirichletGroup(3, base_ring=QQ)

sage: Delta = Newforms(SL2Z, 12)[0]; Delta

q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6)

sage: Delta.twist(G[0]) == Delta

True

sage: Delta.twist(G[1]) # long time (about 5 s)

q + 24*q^2 - 1472*q^4 - 4830*q^5 + O(q^6)

sage: M = CuspForms(Gamma1(13), 2)

sage: f = M.newforms('a')[0]; f

q + a0*q^2 + (-2*a0 - 4)*q^3 + (-a0 - 1)*q^4 + (2*a0 + 3)*q^5 + O(q^6)

sage: f.twist(G[1])

q - a0*q^2 + (-a0 - 1)*q^4 + (-2*a0 - 3)*q^5 + O(q^6)

sage: f = Newforms(Gamma1(30), 2, names='a')[1]; f

q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6)

sage: f.twist(f.character())

Traceback (most recent call last):

...

NotImplementedError: cannot calculate 5-primary part of the level of the twist of q + a1*q^2 - a1*q^3 - q^4 + (a1 - 2)*q^5 + O(q^6) by Dirichlet character modulo 5 of conductor 5 mapping 2 |--> -1

sage: f.twist(f.character(), level=30)

q - a1*q^2 + a1*q^3 - q^4 + (-a1 - 2)*q^5 + O(q^6)

TESTS:

We test that feeding inappropriate values of the ``level`` parameter is handled gracefully::

sage: chi = DirichletGroup(1)[0]

sage: Delta.twist(chi, level=3)

Traceback (most recent call last):

...

ValueError: twist of q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6) by Dirichlet character modulo 1 of conductor 1 is not a newform of level 3

Twisting and twisting back works::

sage: f = Newforms(11)[0]

sage: chi = DirichletGroup(5).0

sage: f.twist(chi).twist(~chi, level=11) == f

True

AUTHORS:

- Peter Bruin (April 2015)

"""

from sage.modular.all import CuspForms

R = coercion_model.common_parent(self.base_ring(), chi.base_ring())

N = self.level()

epsilon = self.character()

chi = chi.primitive_character()

if level is None:

N_epsilon = epsilon.conductor()

N_chi = chi.conductor()

G = DirichletGroup(N_epsilon.lcm(N_chi), base_ring=R)

epsilon_chi = G(epsilon) * G(chi)

N_epsilon_chi = epsilon_chi.conductor()

for q in N_chi.prime_divisors():

# See [AL1978], Theorem 3.1.

alpha = N_epsilon.valuation(q)

beta = N_chi.valuation(q)

gamma = N.valuation(q)

delta = max(alpha + beta, 2*beta, gamma)

if delta == gamma and max(alpha + beta, 2*beta) < gamma:

continue

if delta > gamma and N_epsilon_chi.valuation(q) == max(alpha, beta):

continue

raise NotImplementedError('cannot calculate %s-primary part of the level of the twist of %s by %s'

% (q, self, chi))

level = lcm([N, N_epsilon * N_chi, N_chi**2])

# determine the character of the twisted form

G = DirichletGroup(lcm([N, chi.modulus(), level]), base_ring=R)

eps_new = (G(epsilon) * G(chi)**2).restrict(level)

# create an ambient space

D = ModularSymbols(eps_new, self.weight(), base_ring=R, sign=1).new_submodule()

S = CuspForms(eps_new, self.weight(), base_ring=R)

# pull out the eigenspace

for p in prime_range(500):

if p.divides(N) or p.divides(chi.level()):

continue

D = (D.hecke_operator(p) - self[p]*chi(p)).kernel()

if D.rank() == 1: break

if D.is_zero():

raise ValueError('twist of %s by %s is not a newform of level %s' % (self, chi, level))

else:

raise RuntimeError('unable to identify modular symbols for twist of %s by %s' % (self, chi))

return Newform(S, D, names='_', check=check)

class ModularFormElement(ModularForm_abstract, element.HeckeModuleElement):

def __init__(self, parent, x, check=True):

r"""

An element of a space of modular forms.

INPUT:

- ``parent`` - ModularForms (an ambient space of modular forms)

- ``x`` - a vector on the basis for parent

- ``check`` - if check is ``True``, check the types of the

inputs.

OUTPUT:

- ``ModularFormElement`` - a modular form

EXAMPLES::

sage: M = ModularForms(Gamma0(11),2)

sage: f = M.0

sage: f.parent()

Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field

"""

from .space import ModularFormsSpace

if not isinstance(parent, ModularFormsSpace):

raise TypeError("First argument must be an ambient space of modular forms.")

element.HeckeModuleElement.__init__(self, parent, x)

def _compute_q_expansion(self, prec):

"""

Computes the q-expansion of self to precision prec.

EXAMPLES::

sage: f = EllipticCurve('37a').modular_form()

sage: f.q_expansion() ## indirect doctest

q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6)

sage: f._compute_q_expansion(10)

q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + 6*q^6 - q^7 + 6*q^9 + O(q^10)

"""

return self.parent()._q_expansion(element = self.element(), prec=prec)

def _add_(self, other):

"""

Add self to other.

EXAMPLES::

sage: f = ModularForms(DirichletGroup(17).0^2,2).2

sage: g = ModularForms(DirichletGroup(17).0^2,2).1

sage: f

q + (-zeta8^2 + 2)*q^2 + (zeta8 + 3)*q^3 + (-2*zeta8^2 + 3)*q^4 + (-zeta8 + 5)*q^5 + O(q^6)

sage: g

1 + (-14/73*zeta8^3 + 57/73*zeta8^2 + 13/73*zeta8 - 6/73)*q^2 + (-90/73*zeta8^3 + 64/73*zeta8^2 - 52/73*zeta8 + 24/73)*q^3 + (-81/73*zeta8^3 + 189/73*zeta8^2 - 3/73*zeta8 + 153/73)*q^4 + (72/73*zeta8^3 + 124/73*zeta8^2 + 100/73*zeta8 + 156/73)*q^5 + O(q^6)

sage: f+g ## indirect doctest

1 + q + (-14/73*zeta8^3 - 16/73*zeta8^2 + 13/73*zeta8 + 140/73)*q^2 + (-90/73*zeta8^3 + 64/73*zeta8^2 + 21/73*zeta8 + 243/73)*q^3 + (-81/73*zeta8^3 + 43/73*zeta8^2 - 3/73*zeta8 + 372/73)*q^4 + (72/73*zeta8^3 + 124/73*zeta8^2 + 27/73*zeta8 + 521/73)*q^5 + O(q^6)

"""

return ModularFormElement(self.parent(), self.element() + other.element())

def __mul__(self, other):

r"""

Calculate the product self * other.

This tries to determine the

characters of self and other, in order to avoid having to compute a

(potentially very large) Gamma1 space. Note that this might lead to

a modular form that is defined with respect to a larger subgroup than

the factors are.

An example with character::

sage: f = ModularForms(DirichletGroup(3).0, 3).0

sage: f * f

1 + 108*q^2 + 144*q^3 + 2916*q^4 + 8640*q^5 + O(q^6)

sage: (f*f).parent()

Modular Forms space of dimension 3 for Congruence Subgroup Gamma0(3) of weight 6 over Rational Field

sage: (f*f*f).parent()

Modular Forms space of dimension 4, character [-1] and weight 9 over Rational Field

An example where the character is computed on-the-fly::

sage: f = ModularForms(Gamma1(3), 5).0

sage: f*f

1 - 180*q^2 - 480*q^3 + 8100*q^4 + 35712*q^5 + O(q^6)

sage: (f*f).parent()

Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(3) of weight 10 over Rational Field

sage: f = ModularForms(Gamma1(3), 7).0

sage: f*f

q^2 - 54*q^4 + 128*q^5 + O(q^6)

sage: (f*f).parent()

Modular Forms space of dimension 5 for Congruence Subgroup Gamma0(3) of weight 14 over Rational Field

An example with no character::

sage: f = ModularForms(Gamma1(5), 2).0

sage: f*f

1 + 120*q^3 - 240*q^4 + 480*q^5 + O(q^6)

sage: (f*f).parent()

Modular Forms space of dimension 5 for Congruence Subgroup Gamma1(5) of weight 4 over Rational Field

TESTS:

This shows that the issue at :trac:`7548` is fixed::

sage: M = CuspForms(Gamma0(5*3^2), 2)

sage: f = M.basis()[0]

sage: 2*f

2*q - 2*q^4 + O(q^6)

sage: f*2

2*q - 2*q^4 + O(q^6)

"""

# boring case: scalar multiplication

if not isinstance(other, ModularFormElement):

return element.HeckeModuleElement.__mul__(self, other)

# first ensure the levels are equal

if self.level() != other.level():

raise NotImplementedError("Cannot multiply forms of different levels")

# find out about characters

try:

eps1 = self.character()

verbose("character of left is %s" % eps1)

eps2 = other.character()

verbose("character of right is %s" % eps2)

newchar = eps1 * eps2

verbose("character of product is %s" % newchar)

except (NotImplementedError, ValueError):

newchar = None

verbose("character of product not determined")

# now do the math

from .constructor import ModularForms

if newchar is not None:

verbose("creating a parent with char")

newparent = ModularForms(newchar, self.weight() + other.weight(), base_ring = newchar.base_ring())

verbose("parent is %s" % newparent)

else:

newparent = ModularForms(self.group(), self.weight() + other.weight(), base_ring = ZZ)

m = newparent.sturm_bound()

newqexp = self.qexp(m) * other.qexp(m)

return newparent.base_extend(newqexp.base_ring())(newqexp)

modform_lseries = deprecated_function_alias(16917,

ModularForm_abstract.lseries)

def atkin_lehner_action(self, d, embedding=None):

"""

Return the result of the Atkin-Lehner operator `W_d` on

``self``.

INPUT:

- ``d`` -- a positive integer exactly dividing the level `N`

of ``self``, i.e. `d` divides `N` and is coprime to `N/d`

- ``embedding`` -- ignored (but accepted for compatibility

with :meth:`Newform.atkin_lehner_action`)

OUTPUT:

The Atkin-Lehner eigenvalue of `W_d` on ``self``. This is

either `1` or `-1`.

If ``self`` is not an eigenform for `W_d`, a ``ValueError`` is

raised.

.. SEEALSO::

For the conventions used to define the operator `W_d`, see

:meth:`ModularForm_abstract.atkin_lehner_action`.

EXAMPLES::

sage: CuspForms(1, 30).0.atkin_lehner_eigenvalue()

sage: CuspForms(2, 8).0.atkin_lehner_eigenvalue()

Traceback (most recent call last):

...

NotImplementedError: Don't know how to compute Atkin-Lehner matrix acting on this space (try using a newform constructor instead)

"""

try:

f = self.parent().atkin_lehner_operator(d)(self)

except NotImplementedError:

raise NotImplementedError("Don't know how to compute Atkin-Lehner matrix acting on this space" \

+ " (try using a newform constructor instead)")

if f == self:

return QQ.one(), f

elif f == -self:

return QQ(-1), f

else:

raise ValueError("%r is not an eigenform for W_%r" % (self, d))

def twist(self, chi, level=None):

r"""

Return the twist of the modular form ``self`` by the Dirichlet

character ``chi``.

If ``self`` is a modular form `f` with character `\epsilon`

and `q`-expansion

.. MATH::

f(q) = \sum_{n=0}^\infty a_n q^n,

then the twist by `\chi` is a modular form `f_\chi` with

character `\epsilon\chi^2` and `q`-expansion

.. MATH::

f_\chi(q) = \sum_{n=0}^\infty \chi(n) a_n q^n.

INPUT:

- ``chi`` -- a Dirichlet character

- ``level`` -- (optional) the level `N` of the twisted form.

By default, the algorithm chooses some not necessarily

minimal value for `N` using [AL1978]_, Proposition 3.1,

(See also [Kob1993]_, Proposition III.3.17, for a simpler

but slightly weaker bound.)

OUTPUT:

The form `f_\chi` as an element of the space of modular forms

for `\Gamma_1(N)` with character `\epsilon\chi^2`.

EXAMPLES::

sage: f = CuspForms(11, 2).0

sage: f.parent()

Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field

sage: f.q_expansion(6)

q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6)

sage: eps = DirichletGroup(3).0

sage: eps.parent()

Group of Dirichlet characters modulo 3 with values in Cyclotomic Field of order 2 and degree 1

sage: f_eps = f.twist(eps)

sage: f_eps.parent()

Cuspidal subspace of dimension 9 of Modular Forms space of dimension 16 for Congruence Subgroup Gamma0(99) of weight 2 over Cyclotomic Field of order 2 and degree 1

sage: f_eps.q_expansion(6)

q + 2*q^2 + 2*q^4 - q^5 + O(q^6)

Modular forms without character are supported::

sage: M = ModularForms(Gamma1(5), 2)

sage: f = M.gen(0); f

1 + 60*q^3 - 120*q^4 + 240*q^5 + O(q^6)

sage: chi = DirichletGroup(2)[0]

sage: f.twist(chi)

60*q^3 + 240*q^5 + O(q^6)

The base field of the twisted form is extended if necessary::

sage: E4 = ModularForms(1, 4).gen(0)

sage: E4.parent()

Modular Forms space of dimension 1 for Modular Group SL(2,Z) of weight 4 over Rational Field

sage: chi = DirichletGroup(5)[1]

sage: chi.base_ring()

Cyclotomic Field of order 4 and degree 2

sage: E4_chi = E4.twist(chi)

sage: E4_chi.parent()

Modular Forms space of dimension 10, character [-1] and weight 4 over Cyclotomic Field of order 4 and degree 2

REFERENCES:

- [AL1978]_

- [Kob1993]_

AUTHORS:

- \L. J. P. Kilford (2009-08-28)

- Peter Bruin (2015-03-30)

"""

from sage.modular.all import CuspForms, ModularForms

from sage.rings.all import PowerSeriesRing

R = coercion_model.common_parent(self.base_ring(), chi.base_ring())

N = self.level()

Q = chi.modulus()

try:

epsilon = self.character()

except ValueError:

epsilon = None

constructor = CuspForms if self.is_cuspidal() else ModularForms

if epsilon is not None:

if level is None:

# See [AL1978], Proposition 3.1.

level = lcm([N, epsilon.conductor() * Q, Q**2])

G = DirichletGroup(level, base_ring=R)

M = constructor(G(epsilon) * G(chi)**2, self.weight(), base_ring=R)

else:

from sage.modular.arithgroup.all import Gamma1

if level is None:

# See [AL1978], Proposition 3.1.

level = lcm([N, Q]) * Q

M = constructor(Gamma1(level), self.weight(), base_ring=R)

bound = M.sturm_bound() + 1

S = PowerSeriesRing(R, 'q')

f_twist = S([self[i] * chi(i) for i in range(bound)], prec=bound)

return M(f_twist)

class ModularFormElement_elliptic_curve(ModularFormElement):

r"""

A modular form attached to an elliptic curve over `\QQ`.

"""

def __init__(self, parent, E):

"""

Modular form attached to an elliptic curve as an element

of a space of modular forms.

EXAMPLES::

sage: E = EllipticCurve('5077a')

sage: f = E.modular_form()

sage: f

q - 2*q^2 - 3*q^3 + 2*q^4 - 4*q^5 + O(q^6)

sage: f.q_expansion(10)

q - 2*q^2 - 3*q^3 + 2*q^4 - 4*q^5 + 6*q^6 - 4*q^7 + 6*q^9 + O(q^10)

sage: f.parent()

Modular Forms space of dimension 423 for Congruence Subgroup Gamma0(5077) of weight 2 over Rational Field

sage: E = EllipticCurve('37a')

sage: f = E.modular_form() ; f

q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6)

sage: f == loads(dumps(f))

True

"""

ModularFormElement.__init__(self, parent, None)

## parent.find_in_space( E.q_expansion(parent.hecke_bound()) ))

self.__E = E

def elliptic_curve(self):

"""

Return elliptic curve associated to self.

EXAMPLES::

sage: E = EllipticCurve('11a')

sage: f = E.modular_form()

sage: f.elliptic_curve()

Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field

sage: f.elliptic_curve() is E

True

"""

return self.__E

def _compute_element(self):

"""

Compute self as a linear combination of the basis elements

of parent.

EXAMPLES::

sage: EllipticCurve('11a1').modular_form()._compute_element()

(1, 0)

sage: EllipticCurve('389a1').modular_form()._compute_element()

(1, -2, -2, 2, -3, 4, -5, 0, 1, 6, -4, -4, -3, 10, 6, -4, -6, -2, 5, -6, 10, 8, -4, 0, 4, 6, 4, -10, -6, -12, 4, 8, 0)

"""

M = self.parent()

S = M.cuspidal_subspace()

## return S.find_in_space( self.__E.q_expansion( S.q_expansion_basis()[0].prec() ) ) + [0] * ( M.dimension() - S.dimension() )

return vector(S.find_in_space( self.__E.q_expansion( S.sturm_bound() ) ) + [0] * ( M.dimension() - S.dimension() ))

def _compute_q_expansion(self, prec):

r"""

The `q`-expansion of the modular form to precision `O(q^\text{prec})`.

This function takes one argument, which is the integer prec.

EXAMPLES::

sage: E = EllipticCurve('11a') ; f = E.modular_form()

sage: f._compute_q_expansion(10)

q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10)

sage: f._compute_q_expansion(30)

q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 - 2*q^10 + q^11 - 2*q^12 + 4*q^13 + 4*q^14 - q^15 - 4*q^16 - 2*q^17 + 4*q^18 + 2*q^20 + 2*q^21 - 2*q^22 - q^23 - 4*q^25 - 8*q^26 + 5*q^27 - 4*q^28 + O(q^30)

sage: f._compute_q_expansion(10)

q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10)

"""

return self.__E.q_expansion(prec)

def atkin_lehner_action(self, d, embedding=None):

"""

Return the result of the Atkin-Lehner operator `W_d` on

``self``.

INPUT:

- ``d`` -- a positive integer exactly dividing the level `N`

of ``self``, i.e. `d` divides `N` and is coprime to `N/d`

- ``embedding`` -- ignored (but accepted for compatibility

with :meth:`Newform.atkin_lehner_action`)

OUTPUT:

The pair ``(w, self)`` where `w` is the Atkin-Lehner

eigenvalue of `W_d` on ``self``. This is either `1` or `-1`.

EXAMPLES::

sage: EllipticCurve('57a1').newform().atkin_lehner_eigenvalue()

sage: EllipticCurve('57b1').newform().atkin_lehner_eigenvalue()

-1

sage: EllipticCurve('57b1').newform().atkin_lehner_eigenvalue(19)

"""

if d == self.level():

w = -self.__E.root_number()

else:

# The space of modular symbols attached to E is

# one-dimensional.

w = self.__E.modular_symbol_space().atkin_lehner_operator(d).matrix()[0,0]

return w, self

class EisensteinSeries(ModularFormElement):

"""

An Eisenstein series.

EXAMPLES::

sage: E = EisensteinForms(1,12)

sage: E.eisenstein_series()

[

691/65520 + q + 2049*q^2 + 177148*q^3 + 4196353*q^4 + 48828126*q^5 + O(q^6)

]

sage: E = EisensteinForms(11,2)

sage: E.eisenstein_series()

[

5/12 + q + 3*q^2 + 4*q^3 + 7*q^4 + 6*q^5 + O(q^6)

]

sage: E = EisensteinForms(Gamma1(7),2)

sage: E.set_precision(4)

sage: E.eisenstein_series()

[

1/4 + q + 3*q^2 + 4*q^3 + O(q^4),

1/7*zeta6 - 3/7 + q + (-2*zeta6 + 1)*q^2 + (3*zeta6 - 2)*q^3 + O(q^4),

q + (-zeta6 + 2)*q^2 + (zeta6 + 2)*q^3 + O(q^4),

-1/7*zeta6 - 2/7 + q + (2*zeta6 - 1)*q^2 + (-3*zeta6 + 1)*q^3 + O(q^4),

q + (zeta6 + 1)*q^2 + (-zeta6 + 3)*q^3 + O(q^4)

]

"""

def __init__(self, parent, vector, t, chi, psi):

"""

An Eisenstein series.

EXAMPLES::

sage: E = EisensteinForms(1,12) ## indirect doctest

sage: E.eisenstein_series()

[

691/65520 + q + 2049*q^2 + 177148*q^3 + 4196353*q^4 + 48828126*q^5 + O(q^6)

]

sage: E = EisensteinForms(11,2)

sage: E.eisenstein_series()

[

5/12 + q + 3*q^2 + 4*q^3 + 7*q^4 + 6*q^5 + O(q^6)

]

sage: E = EisensteinForms(Gamma1(7),2)

sage: E.set_precision(4)

sage: E.eisenstein_series()

[

1/4 + q + 3*q^2 + 4*q^3 + O(q^4),

1/7*zeta6 - 3/7 + q + (-2*zeta6 + 1)*q^2 + (3*zeta6 - 2)*q^3 + O(q^4),

q + (-zeta6 + 2)*q^2 + (zeta6 + 2)*q^3 + O(q^4),

-1/7*zeta6 - 2/7 + q + (2*zeta6 - 1)*q^2 + (-3*zeta6 + 1)*q^3 + O(q^4),

q + (zeta6 + 1)*q^2 + (-zeta6 + 3)*q^3 + O(q^4)

]

"""

N = parent.level()

K = parent.base_ring()

if chi.parent().modulus() != N or psi.parent().modulus() != N:

raise ArithmeticError("Incompatible moduli")

if chi.parent().base_ring() != K or psi.parent().base_ring() != K:

raise ArithmeticError("Incompatible base rings")

t = int(t)

#if not isinstance(t, int): raise TypeError, "weight must be an int"

if parent.weight() == 2 and chi.is_trivial() \

and psi.is_trivial() and t==1:

raise ArithmeticError("If chi and psi are trivial and k=2, then t must be >1.")

ModularFormElement.__init__(self, parent, vector)

self.__chi = chi

self.__psi = psi

self.__t = t

def _compute_q_expansion(self, prec=None):

"""

Compute the q-expansion of self to precision prec.

EXAMPLES::

sage: EisensteinForms(11,2).eisenstein_series()[0]._compute_q_expansion(10)

5/12 + q + 3*q^2 + 4*q^3 + 7*q^4 + 6*q^5 + 12*q^6 + 8*q^7 + 15*q^8 + 13*q^9 + O(q^10)

"""

if prec is None:

prec = self.parent().prec()

F = self._compute(list(range(prec)))

R = self.parent()._q_expansion_ring()

return R(F, prec)

def _compute(self, X):

r"""

Compute the coefficients of `q^n` of the power series of self,

for `n` in the list `X`. The results are not cached. (Use

coefficients for cached results).

EXAMPLES::

sage: e = DirichletGroup(11).gen()

sage: f = EisensteinForms(e, 3).eisenstein_series()[0]

sage: f._compute([3,4,5])

[-9*zeta10^3 + 1,

16*zeta10^2 + 4*zeta10 + 1,

25*zeta10^3 - 25*zeta10^2 + 25*zeta10 - 24]

"""

if self.weight() == 2 and (self.__chi.is_trivial() and self.__psi.is_trivial()):

return self.__compute_weight2_trivial_character(X)

else: # general case

return self.__compute_general_case(X)

def __compute_weight2_trivial_character(self, X):

r"""

Compute coefficients for self an Eisenstein series of the form

`E_2 - t*E_2(q^t)`. Computes `a_n` for each `n \in X`.

EXAMPLES::

sage: EisensteinForms(14,2).eisenstein_series()[0]._EisensteinSeries__compute_weight2_trivial_character([0])

[1/24]

sage: EisensteinForms(14,2).eisenstein_series()[0]._EisensteinSeries__compute_weight2_trivial_character([0,4,11,38])

[1/24, 1, 12, 20]

"""

F = self.base_ring()

v = []

t = self.__t

for n in X:

if n < 0:

pass

elif n == 0:

v.append(F(t-1)/F(24))

else:

an = sigma(n,1)

if n % t == 0:

an -= t * sigma(n//t,1)

v.append(an)

return v

def __compute_general_case(self, X):

"""

Returns the list coefficients of `q^n` of the power series of self,

for `n` in the list `X`. The results are not cached. (Use

coefficients for cached results).

General case (except weight 2, trivial character, where this

is wrong!) `\chi` is a primitive character of conductor `L`

`\psi` is a primitive character of conductor `M` We have

`MLt \mid N`, and

.. MATH::

E_k(chi,psi,t) =

c_0 + sum_{m \geq 1}[sum_{n|m} psi(n) * chi(m/n) * n^(k-1)] q^{mt},

with `c_0=0` if `L>1`, and `c_0=L(1-k,psi)/2` if `L=1` (that

second `L` is an `L`-function `L`).

EXAMPLES::

sage: e = DirichletGroup(11).gen()

sage: f = EisensteinForms(e, 3).eisenstein_series()[0]

sage: f._EisensteinSeries__compute_general_case([1])

[1]

sage: f._EisensteinSeries__compute_general_case([2])

[4*zeta10 + 1]

sage: f._EisensteinSeries__compute_general_case([0,1,2])

[15/11*zeta10^3 - 9/11*zeta10^2 - 26/11*zeta10 - 10/11, 1, 4*zeta10 + 1]

"""

c0, chi, psi, K, n, t, L, M = self.__defining_parameters()

zero = K.zero()

k = self.weight()

v = []

for i in X:

if i == 0:

v.append(c0)

continue

if i % t != 0:

v.append(zero)

else:

m = i // t

v.append(sum([psi(d) * chi(m / d) * d ** (k - 1)

for d in divisors(m)]))

return v

def __defining_parameters(self):

r"""

Return defining parameters for ``self``.

EXAMPLES::

sage: EisensteinForms(11,2).eisenstein_series()[0]._EisensteinSeries__defining_parameters()

(-1/24, Dirichlet character modulo 1 of conductor 1, Dirichlet character modulo 1 of conductor 1, Rational Field, 2, 11, 1, 1)

"""

try:

return self.__defining_params

except AttributeError:

chi = self.__chi.primitive_character()

psi = self.__psi.primitive_character()

k = self.weight()

t = self.__t

L = chi.conductor()

M = psi.conductor()

K = chi.base_ring()

n = K.zeta_order()

if L == 1:

c0 = K(-psi.bernoulli(k))/K(2*k)

else:

c0 = K(0)

self.__defining_params = (c0, chi, psi, K, n, t, L, M)

return self.__defining_params

def chi(self):

"""

Return the parameter chi associated to self.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].chi()

Dirichlet character modulo 17 of conductor 17 mapping 3 |--> zeta16

"""

return self.__chi

def psi(self):

"""

Return the parameter psi associated to self.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].psi()

Dirichlet character modulo 17 of conductor 1 mapping 3 |--> 1

"""

return self.__psi

def t(self):

"""

Return the parameter t associated to self.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].t()

"""

return self.__t

def parameters(self):

"""

Return chi, psi, and t, which are the defining parameters of self.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].parameters()

(Dirichlet character modulo 17 of conductor 17 mapping 3 |--> zeta16, Dirichlet character modulo 17 of conductor 1 mapping 3 |--> 1, 1)

"""

return self.__chi, self.__psi, self.__t

def L(self):

"""

Return the conductor of self.chi().

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].L()

"""

return self.__chi.conductor()

def M(self):

"""

Return the conductor of self.psi().

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].M()

"""

return self.__psi.conductor()

def character(self):

"""

Return the character associated to self.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].character()

Dirichlet character modulo 17 of conductor 17 mapping 3 |--> zeta16

sage: chi = DirichletGroup(7)[4]

sage: E = EisensteinForms(chi).eisenstein_series() ; E

[

-1/7*zeta6 - 2/7 + q + (2*zeta6 - 1)*q^2 + (-3*zeta6 + 1)*q^3 + (-2*zeta6 - 1)*q^4 + (5*zeta6 - 4)*q^5 + O(q^6),

q + (zeta6 + 1)*q^2 + (-zeta6 + 3)*q^3 + (zeta6 + 2)*q^4 + (zeta6 + 4)*q^5 + O(q^6)

]

sage: E[0].character() == chi

True

sage: E[1].character() == chi

True

TESTS::

sage: [ [ f.character() == chi for f in EisensteinForms(chi).eisenstein_series() ] for chi in DirichletGroup(17) ]

[[True], [], [True, True], [], [True, True], [], [True, True], [], [True, True], [], [True, True], [], [True, True], [], [True, True], []]

sage: [ [ f.character() == chi for f in EisensteinForms(chi).eisenstein_series() ] for chi in DirichletGroup(16) ]

[[True, True, True, True, True], [], [True, True], [], [True, True, True, True], [], [True, True], []]

"""

try:

return self.__character

except AttributeError:

self.__character = self.__chi * self.__psi

return self.__character

def new_level(self):

"""

Return level at which self is new.

EXAMPLES::

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].level()

sage: EisensteinForms(DirichletGroup(17).0,99).eisenstein_series()[1].new_level()

sage: [ [x.level(), x.new_level()] for x in EisensteinForms(DirichletGroup(60).0^2,2).eisenstein_series() ]

[[60, 2], [60, 3], [60, 2], [60, 5], [60, 2], [60, 2], [60, 2], [60, 3], [60, 2], [60, 2], [60, 2]]

"""

if self.__chi.is_trivial() and self.__psi.is_trivial() and self.weight() == 2:

return factor(self.__t)[0][0]

return self.L()*self.M()

Coverage for local/lib/python2.7/site-packages/sage/modular/modform/element.py : 79%

628 statements 495 run 133 missing 0 excluded