passagemath-schemes 10.6.38__cp314-cp314t-macosx_13_0_arm64.whl

sage/modular/modform/find_generators.py

@@ -0,0 +1,59 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.combinat sage.libs.flint
+r"""
+This module is now called ``ring.py`` (see :issue:`31559`). Do not import from here as
+it will generate a deprecation warning.
+
+TESTS::
+
+    sage: from sage.modular.modform.ring import find_generators
+    sage: find_generators(ModularFormsRing(1))
+    doctest:warning
+    ...
+    DeprecationWarning: find_generators is deprecated. Please use sage.modular.modform.ring.generators instead.
+    See https://github.com/sagemath/sage/issues/31559 for details.
+    [(4,
+    1 + 240*q + 2160*q^2 + 6720*q^3 + 17520*q^4 + 30240*q^5 + 60480*q^6 + 82560*q^7 + 140400*q^8 + 181680*q^9 + O(q^10)),
+    (6,
+    1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 - 4058208*q^6 - 8471232*q^7 - 17047800*q^8 - 29883672*q^9 + O(q^10))]
+
+::
+
+    sage: from sage.modular.modform.find_generators import find_generators
+    sage: find_generators(ModularFormsRing(1))
+    doctest:warning
+    ...
+    DeprecationWarning: Importing find_generators from here is deprecated; please use "from sage.modular.modform.ring import find_generators" instead.
+    See https://github.com/sagemath/sage/issues/31559 for details.
+    [(4,
+    1 + 240*q + 2160*q^2 + 6720*q^3 + 17520*q^4 + 30240*q^5 + 60480*q^6 + 82560*q^7 + 140400*q^8 + 181680*q^9 + O(q^10)),
+    (6,
+    1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 - 4058208*q^6 - 8471232*q^7 - 17047800*q^8 - 29883672*q^9 + O(q^10))]
+
+::
+
+    sage: from sage.modular.modform.ring import basis_for_modform_space
+    sage: basis_for_modform_space(ModularFormsRing(1), 4)
+    doctest:warning
+    ...
+    DeprecationWarning: basis_for_modform_space is deprecated. Please use sage.modular.modform.ring.q_expansion_basis instead.
+    See https://github.com/sagemath/sage/issues/31559 for details.
+    [1 + 240*q + O(q^2)]
+
+::
+
+    sage: from sage.modular.modform.find_generators import _span_of_forms_in_weight
+    sage: forms = [(4, 240*eisenstein_series_qexp(4,5)), (6,504*eisenstein_series_qexp(6,5))]
+    sage: _span_of_forms_in_weight(forms, 12, prec=5)
+    doctest:warning
+    ...
+    DeprecationWarning: Importing _span_of_forms_in_weight from here is deprecated; please use "from sage.modular.modform.ring import _span_of_forms_in_weight" instead.
+    See https://github.com/sagemath/sage/issues/31559 for details.
+    Vector space of degree 5 and dimension 2 over Rational Field
+    Basis matrix:
+    [        1         0    196560  16773120 398034000]
+    [        0         1       -24       252     -1472]
+"""
+
+from sage.misc.lazy_import import lazy_import
+lazy_import('sage.modular.modform.ring', ('_span_of_forms_in_weight', 'find_generators', 'basis_for_modform_space', 'ModularFormsRing'), deprecation=31559)

sage/modular/modform/half_integral.py

@@ -0,0 +1,154 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Compute spaces of half-integral weight modular forms
+
+Based on an algorithm in Basmaji's thesis.
+
+AUTHORS:
+
+- William Stein (2007-08)
+"""
+
+from sage.matrix.matrix_space import MatrixSpace
+from sage.modular.dirichlet import DirichletGroup
+
+from . import constructor
+
+from .theta import theta2_qexp, theta_qexp
+from copy import copy
+
+
+def half_integral_weight_modform_basis(chi, k, prec):
+    r"""
+    A basis for the space of weight `k/2` forms with character
+    `\chi`. The modulus of `\chi` must be divisible by
+    `16` and `k` must be odd and `>1`.
+
+    INPUT:
+
+    - ``chi`` -- a Dirichlet character with modulus divisible by 16
+
+    - ``k`` -- an odd integer > 1
+
+    - ``prec`` -- positive integer
+
+    OUTPUT: list of power series
+
+    .. warning::
+
+       1. This code is very slow because it requests computation of a
+          basis of modular forms for integral weight spaces, and that
+          computation is still very slow.
+
+       2. If you give an input prec that is too small, then the output
+          list of power series may be larger than the dimension of the
+          space of half-integral forms.
+
+    EXAMPLES:
+
+    We compute some half-integral weight forms of level 16\*7
+
+    ::
+
+        sage: half_integral_weight_modform_basis(DirichletGroup(16*7).0^2,3,30)
+        [q - 2*q^2 - q^9 + 2*q^14 + 6*q^18 - 2*q^21 - 4*q^22 - q^25 + O(q^30),
+         q^2 - q^14 - 3*q^18 + 2*q^22 + O(q^30),
+         q^4 - q^8 - q^16 + q^28 + O(q^30),
+         q^7 - 2*q^15 + O(q^30)]
+
+    The following illustrates that choosing too low of a precision can
+    give an incorrect answer.
+
+    ::
+
+        sage: half_integral_weight_modform_basis(DirichletGroup(16*7).0^2,3,20)
+        [q - 2*q^2 - q^9 + 2*q^14 + 6*q^18 + O(q^20),
+         q^2 - q^14 - 3*q^18 + O(q^20),
+         q^4 - 2*q^8 + 2*q^12 - 4*q^16 + O(q^20),
+         q^7 - 2*q^8 + 4*q^12 - 2*q^15 - 6*q^16 + O(q^20),
+         q^8 - 2*q^12 + 3*q^16 + O(q^20)]
+
+    We compute some spaces of low level and the first few possible
+    weights.
+
+    ::
+
+        sage: half_integral_weight_modform_basis(DirichletGroup(16,QQ).1, 3, 10)
+        []
+        sage: half_integral_weight_modform_basis(DirichletGroup(16,QQ).1, 5, 10)
+        [q - 2*q^3 - 2*q^5 + 4*q^7 - q^9 + O(q^10)]
+        sage: half_integral_weight_modform_basis(DirichletGroup(16,QQ).1, 7, 10)
+        [q - 2*q^2 + 4*q^3 + 4*q^4 - 10*q^5 - 16*q^7 + 19*q^9 + O(q^10),
+         q^2 - 2*q^3 - 2*q^4 + 4*q^5 + 4*q^7 - 8*q^9 + O(q^10),
+         q^3 - 2*q^5 - 2*q^7 + 4*q^9 + O(q^10)]
+        sage: half_integral_weight_modform_basis(DirichletGroup(16,QQ).1, 9, 10)
+        [q - 2*q^2 + 4*q^3 - 8*q^4 + 14*q^5 + 16*q^6 - 40*q^7 + 16*q^8 - 57*q^9 + O(q^10),
+         q^2 - 2*q^3 + 4*q^4 - 8*q^5 - 8*q^6 + 20*q^7 - 8*q^8 + 32*q^9 + O(q^10),
+         q^3 - 2*q^4 + 4*q^5 + 4*q^6 - 10*q^7 - 16*q^9 + O(q^10),
+         q^4 - 2*q^5 - 2*q^6 + 4*q^7 + 4*q^9 + O(q^10),
+         q^5 - 2*q^7 - 2*q^9 + O(q^10)]
+
+    This example once raised an error (see :issue:`5792`).
+
+    ::
+
+        sage: half_integral_weight_modform_basis(trivial_character(16),9,10)
+        [q - 2*q^2 + 4*q^3 - 8*q^4 + 4*q^6 - 16*q^7 + 48*q^8 - 15*q^9 + O(q^10),
+         q^2 - 2*q^3 + 4*q^4 - 2*q^6 + 8*q^7 - 24*q^8 + O(q^10),
+         q^3 - 2*q^4 - 4*q^7 + 12*q^8 + O(q^10),
+         q^4 - 6*q^8 + O(q^10)]
+
+
+    ALGORITHM: Basmaji (page 55 of his Essen thesis, "Ein Algorithmus
+    zur Berechnung von Hecke-Operatoren und Anwendungen auf modulare
+    Kurven", https://web.archive.org/web/20160905111513/http://wstein.org/scans/papers/basmaji/thesis_of_basmaji.dvi).
+
+    Let `S = S_{k+1}(\epsilon)` be the space of cusp forms of
+    even integer weight `k+1` and character
+    `\varepsilon = \chi \psi^{(k+1)/2}`, where `\psi`
+    is the nontrivial mod-4 Dirichlet character. Let `U` be the
+    subspace of `S \times S` of elements `(a,b)` such
+    that `\Theta_2 a = \Theta_3 b`. Then `U` is
+    isomorphic to `S_{k/2}(\chi)` via the map
+    `(a,b) \mapsto a/\Theta_3`.
+    """
+    if chi.modulus() % 16:
+        raise ValueError("the character must have modulus divisible by 16")
+
+    if not k % 2:
+        raise ValueError("k (=%s) must be odd" % k)
+
+    if k < 3:
+        raise ValueError("k (=%s) must be at least 3" % k)
+
+    chi = chi.minimize_base_ring()
+    psi = chi.parent()(DirichletGroup(4, chi.base_ring()).gen())
+    eps = chi*psi**((k+1) // 2)
+    eps = eps.minimize_base_ring()
+    M = constructor.ModularForms(eps, (k+1)//2)
+    C = M.cuspidal_subspace()
+    B = C.basis()
+
+    # This computation of S below -- of course --dominates the whole function.
+    S = [f.q_expansion(prec) for f in B]
+
+    T2 = theta2_qexp(prec)
+    T3 = theta_qexp(prec)
+    n = len(S)
+    MS = MatrixSpace(M.base_ring(), 2*n, prec)
+    A = copy(MS.zero_matrix())
+
+    for i in range(n):
+        T2f = T2*S[i]
+        T3f = T3*S[i]
+        for j in range(prec):
+            A[i, j] = T2f[j]
+            A[n+i, j] = -T3f[j]
+
+    B = A.kernel().basis()
+    a_vec = [sum([b[i]*S[i] for i in range(n)]) for b in B]
+    if len(a_vec) == 0:
+        return []
+    R = a_vec[0].parent()
+    t3 = R(T3)
+    return [R(a) / t3 for a in a_vec]

sage/modular/modform/hecke_operator_on_qexp.py

@@ -0,0 +1,247 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.flint
+"""
+Hecke operators on `q`-expansions
+"""
+# ****************************************************************************
+#       Copyright (C) 2004-2006 William Stein <wstein@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.arith.misc import divisors, gcd
+from sage.matrix.constructor import matrix
+from sage.matrix.matrix_space import MatrixSpace
+from sage.misc.lazy_import import lazy_import
+from sage.rings.infinity import Infinity
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+from sage.rings.power_series_ring_element import PowerSeries
+
+lazy_import('sage.rings.number_field.number_field', 'CyclotomicField')
+
+from sage.modular.dirichlet import DirichletGroup, DirichletCharacter
+from .element import ModularFormElement
+
+
+def hecke_operator_on_qexp(f, n, k, eps=None,
+                           prec=None, check=True, _return_list=False):
+    r"""
+    Given the `q`-expansion `f` of a modular form with character
+    `\varepsilon`, this function computes the image of `f` under the
+    Hecke operator `T_{n,k}` of weight `k`.
+
+    EXAMPLES::
+
+        sage: M = ModularForms(1,12)
+        sage: hecke_operator_on_qexp(M.basis()[0], 3, 12)
+        252*q - 6048*q^2 + 63504*q^3 - 370944*q^4 + O(q^5)
+        sage: hecke_operator_on_qexp(M.basis()[0], 1, 12, prec=7)
+        q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 + O(q^7)
+        sage: hecke_operator_on_qexp(M.basis()[0], 1, 12)
+        q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + 84480*q^8
+          - 113643*q^9 - 115920*q^10 + 534612*q^11 - 370944*q^12 - 577738*q^13 + O(q^14)
+
+        sage: M.prec(20)
+        20
+        sage: hecke_operator_on_qexp(M.basis()[0], 3, 12)
+        252*q - 6048*q^2 + 63504*q^3 - 370944*q^4 + 1217160*q^5 - 1524096*q^6 + O(q^7)
+        sage: hecke_operator_on_qexp(M.basis()[0], 1, 12)
+        q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + 84480*q^8
+          - 113643*q^9 - 115920*q^10 + 534612*q^11 - 370944*q^12 - 577738*q^13
+          + 401856*q^14 + 1217160*q^15 + 987136*q^16 - 6905934*q^17 + 2727432*q^18
+          + 10661420*q^19 - 7109760*q^20 + O(q^21)
+
+        sage: (hecke_operator_on_qexp(M.basis()[0], 1, 12)*252).add_bigoh(7)
+        252*q - 6048*q^2 + 63504*q^3 - 370944*q^4 + 1217160*q^5 - 1524096*q^6 + O(q^7)
+
+        sage: hecke_operator_on_qexp(M.basis()[0], 6, 12)
+        -6048*q + 145152*q^2 - 1524096*q^3 + O(q^4)
+
+    An example on a formal power series::
+
+        sage: R.<q> = QQ[[]]
+        sage: f = q + q^2 + q^3 + q^7 + O(q^8)
+        sage: hecke_operator_on_qexp(f, 3, 12)
+        q + O(q^3)
+        sage: hecke_operator_on_qexp(delta_qexp(24), 3, 12).prec()
+        8
+        sage: hecke_operator_on_qexp(delta_qexp(25), 3, 12).prec()
+        9
+
+    An example of computing `T_{p,k}` in characteristic `p`::
+
+        sage: p = 199
+        sage: fp = delta_qexp(prec=p^2+1, K=GF(p))
+        sage: tfp = hecke_operator_on_qexp(fp, p, 12)
+        sage: tfp == fp[p] * fp
+        True
+        sage: tf = hecke_operator_on_qexp(delta_qexp(prec=p^2+1), p, 12).change_ring(GF(p))
+        sage: tfp == tf
+        True
+    """
+    if eps is None:
+        # Need to have base_ring=ZZ to work over finite fields, since
+        # ZZ can coerce to GF(p), but QQ can't.
+        eps = DirichletGroup(1, base_ring=ZZ)[0]
+    if check:
+        if not isinstance(f, (PowerSeries, ModularFormElement)):
+            raise TypeError("f (=%s) must be a power series or modular form" % f)
+        if not isinstance(eps, DirichletCharacter):
+            raise TypeError("eps (=%s) must be a Dirichlet character" % eps)
+        k = Integer(k)
+        n = Integer(n)
+    v = []
+
+    if prec is None:
+        if isinstance(f, ModularFormElement):
+            # always want at least three coefficients, but not too many, unless
+            # requested
+            pr = max(f.prec(), f.parent().prec(), (n+1)*3)
+            pr = min(pr, 100*(n+1))
+            prec = pr // n + 1
+        else:
+            prec = (f.prec() / ZZ(n)).ceil()
+            if prec == Infinity:
+                prec = f.parent().default_prec() // n + 1
+
+    if f.prec() < prec:
+        f._compute_q_expansion(prec)
+
+    p = Integer(f.base_ring().characteristic())
+    if k != 1 and p.is_prime() and n.is_power_of(p):
+        # if computing T_{p^a} in characteristic p, use the simpler (and faster)
+        # formula
+        v = [f[m*n] for m in range(prec)]
+    else:
+        l = k - 1
+        for m in range(prec):
+            am = sum([eps(d) * d**l * f[m*n//(d*d)]
+                      for d in divisors(gcd(n, m)) if (m*n) % (d*d) == 0])
+            v.append(am)
+    if _return_list:
+        return v
+    if isinstance(f, ModularFormElement):
+        R = f.parent()._q_expansion_ring()
+    else:
+        R = f.parent()
+    return R(v, prec)
+
+
+def _hecke_operator_on_basis(B, V, n, k, eps):
+    """
+    Do the work for hecke_operator_on_basis once the input
+    is normalized.
+
+    EXAMPLES::
+
+        sage: hecke_operator_on_basis(ModularForms(1,16).q_expansion_basis(30), 3, 16) # indirect doctest
+        [   -3348        0]
+        [       0 14348908]
+
+    The following used to cause a segfault due to accidentally
+    transposed second and third argument (:issue:`2107`)::
+
+        sage: B = victor_miller_basis(100,30)
+        sage: t2 = hecke_operator_on_basis(B, 100, 2)
+        Traceback (most recent call last):
+        ...
+        ValueError: The given basis vectors must be linearly independent.
+    """
+    prec = V.degree()
+    TB = [hecke_operator_on_qexp(f, n, k, eps, prec, check=False, _return_list=True)
+                for f in B]
+    TB = [V.coordinate_vector(w) for w in TB]
+    return matrix(V.base_ring(), len(B), len(B), TB, sparse=False)
+
+
+def hecke_operator_on_basis(B, n, k, eps=None, already_echelonized=False):
+    r"""
+    Given a basis `B` of `q`-expansions for a space of modular forms
+    with character `\varepsilon` to precision at least `\#B\cdot n+1`,
+    this function computes the matrix of `T_n` relative to `B`.
+
+    .. NOTE::
+
+       If the elements of B are not known to sufficient precision,
+       this function will report that the vectors are linearly
+       dependent (since they are to the specified precision).
+
+    INPUT:
+
+    - ``B`` -- list of `q`-expansions
+
+    - ``n`` -- integer >= 1
+
+    - ``k`` -- integer
+
+    - ``eps`` -- Dirichlet character
+
+    - ``already_echelonized`` -- boolean (default: ``False``); if ``True``, use
+      that the basis is already in Echelon form, which saves a lot of time
+
+    EXAMPLES::
+
+        sage: sage.modular.modform.constructor.ModularForms_clear_cache()
+        sage: ModularForms(1,12).q_expansion_basis()
+        [q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6),
+         1 + 65520/691*q + 134250480/691*q^2 + 11606736960/691*q^3 + 274945048560/691*q^4 + 3199218815520/691*q^5 + O(q^6)]
+        sage: hecke_operator_on_basis(ModularForms(1,12).q_expansion_basis(), 3, 12)
+        Traceback (most recent call last):
+        ...
+        ValueError: The given basis vectors must be linearly independent.
+
+        sage: hecke_operator_on_basis(ModularForms(1,12).q_expansion_basis(30), 3, 12)
+        [   252      0]
+        [     0 177148]
+
+    TESTS:
+
+    This shows that the problem with finite fields reported at :issue:`8281` is solved::
+
+        sage: bas_mod5 = [f.change_ring(GF(5)) for f in victor_miller_basis(12, 20)]
+        sage: hecke_operator_on_basis(bas_mod5, 2, 12)
+        [4 0]
+        [0 1]
+
+    This shows that empty input is handled sensibly (:issue:`12202`)::
+
+        sage: # needs sage.rings.number_field
+        sage: x = hecke_operator_on_basis([], 3, 12); x
+        []
+        sage: x.parent()
+        Full MatrixSpace of 0 by 0 dense matrices over Cyclotomic Field of order 1 and degree 1
+        sage: y = hecke_operator_on_basis([], 3, 12, eps=DirichletGroup(13).0^2); y
+        []
+        sage: y.parent()
+        Full MatrixSpace of 0 by 0 dense matrices over Cyclotomic Field of order 12 and degree 4
+    """
+    if not isinstance(B, (list, tuple)):
+        raise TypeError("B (=%s) must be a list or tuple" % B)
+    if len(B) == 0:
+        if eps is None:
+            R = CyclotomicField(1)
+        else:
+            R = eps.base_ring()
+        return MatrixSpace(R, 0)(0)
+    f = B[0]
+    R = f.base_ring()
+    if eps is None:
+        eps = DirichletGroup(1, R)[0]
+    all_powerseries = True
+    for x in B:
+        if not isinstance(x, PowerSeries):
+            all_powerseries = False
+    if not all_powerseries:
+        raise TypeError("each element of B must be a power series")
+    n = Integer(n)
+    k = Integer(k)
+    prec = (f.prec() - 1) // n
+    A = R**prec
+    V = A.span_of_basis([g.padded_list(prec) for g in B],
+                        already_echelonized=already_echelonized)
+    return _hecke_operator_on_basis(B, V, n, k, eps)

sage/modular/modform/j_invariant.py

@@ -0,0 +1,47 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.flint
+r"""
+`q`-expansion of `j`-invariant
+"""
+from .eis_series import eisenstein_series_qexp
+from .vm_basis import delta_qexp
+from sage.rings.rational_field import QQ
+
+
+def j_invariant_qexp(prec=10, K=QQ):
+    r"""
+    Return the `q`-expansion of the `j`-invariant to
+    precision ``prec`` in the field `K`.
+
+    .. SEEALSO::
+
+        If you want to evaluate (numerically) the `j`-invariant at
+        certain points, see the special function :func:`elliptic_j`.
+
+    .. WARNING::
+
+        Stupid algorithm -- we divide by Delta, which is slow.
+
+    EXAMPLES::
+
+        sage: j_invariant_qexp(4)
+        q^-1 + 744 + 196884*q + 21493760*q^2 + 864299970*q^3 + O(q^4)
+        sage: j_invariant_qexp(2)
+        q^-1 + 744 + 196884*q + O(q^2)
+        sage: j_invariant_qexp(100, GF(2))
+        q^-1 + q^7 + q^15 + q^31 + q^47 + q^55 + q^71 + q^87 + O(q^100)
+    """
+    if prec <= -1:
+        raise ValueError("the prec must be nonnegative.")
+    prec += 2
+    g6 = -504*eisenstein_series_qexp(6, prec, K=QQ)
+    Delta = delta_qexp(prec).change_ring(QQ)
+    j = (g6*g6) * (~Delta) + 1728
+    if K != QQ:
+        return j.change_ring(K)
+    else:
+        return j
+
+
+# NOTE: this needs to be sped up.  The pari code src/basemath/trans3.c is
+# faster.

sage/modular/modform/l_series_gross_zagier.py

@@ -0,0 +1,133 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs database_cremona_mini_ellcurve
+r"""
+Gross-Zagier L-series
+"""
+from sage.rings.integer import Integer
+from sage.structure.sage_object import SageObject
+from sage.lfunctions.dokchitser import Dokchitser
+from .l_series_gross_zagier_coeffs import gross_zagier_L_series
+from sage.modular.dirichlet import kronecker_character
+
+
+class GrossZagierLseries(SageObject):
+
+    def __init__(self, E, A, prec=53):
+        r"""
+        Class for the Gross-Zagier `L`-series.
+
+        This is attached to a pair `(E,A)` where `E` is an elliptic curve over
+        `\QQ` and `A` is an ideal class in an imaginary quadratic number field.
+
+        For the exact definition, in the more general setting of modular forms
+        instead of elliptic curves, see section IV of [GZ1986]_.
+
+        INPUT:
+
+        - ``E`` -- an elliptic curve over `\QQ`
+
+        - ``A`` -- an ideal class in an imaginary quadratic number field
+
+        - ``prec`` -- integer (default: 53); giving the required precision
+
+        EXAMPLES::
+
+            sage: e = EllipticCurve('37a')
+            sage: K.<a> = QuadraticField(-40)
+            sage: A = K.class_group().gen(0)
+            sage: from sage.modular.modform.l_series_gross_zagier import GrossZagierLseries
+            sage: G = GrossZagierLseries(e, A)
+
+        TESTS::
+
+            sage: K.<b> = QuadraticField(131)
+            sage: A = K.class_group().one()
+            sage: G = GrossZagierLseries(e, A)
+            Traceback (most recent call last):
+            ...
+            ValueError: A is not an ideal class in an imaginary quadratic field
+        """
+        self._E = E
+        self._N = N = E.conductor()
+        self._A = A
+        ideal = A.ideal()
+        K = A.gens()[0].parent()
+        D = K.disc()
+        if not (K.degree() == 2 and D < 0):
+            raise ValueError("A is not an ideal class in an"
+                             " imaginary quadratic field")
+        Q = ideal.quadratic_form().reduced_form()
+        epsilon = - kronecker_character(D)(N)
+        self._dokchister = Dokchitser(N ** 2 * D ** 2,
+                                      [0, 0, 1, 1],
+                                      weight=2, eps=epsilon, prec=prec)
+        self._nterms = nterms = Integer(self._dokchister.num_coeffs())
+        if nterms > 1e6:
+            # just takes way to long
+            raise ValueError("Too many terms: {}".format(nterms))
+        zeta_ord = ideal.number_field().zeta_order()
+        an_list = gross_zagier_L_series(E.anlist(nterms + 1), Q, N, zeta_ord)
+        self._dokchister.gp().set('a', an_list[1:])
+        self._dokchister.init_coeffs('a[k]', 1)
+
+    def __call__(self, s, der=0):
+        r"""
+        Return the value at `s`.
+
+        INPUT:
+
+        - ``s`` -- complex number
+
+        - ``der`` -- order of derivative (default: 0)
+
+        EXAMPLES::
+
+            sage: e = EllipticCurve('37a')
+            sage: K.<a> = QuadraticField(-40)
+            sage: A = K.class_group().gen(0)
+            sage: from sage.modular.modform.l_series_gross_zagier import GrossZagierLseries
+            sage: G = GrossZagierLseries(e, A)
+            sage: G(3)
+            -0.272946890617590
+            sage: G(3, 1)
+            0.212442670030741
+        """
+        return self._dokchister.derivative(s, der)
+
+    def taylor_series(self, s=1, series_prec=6, var='z'):
+        r"""
+        Return the Taylor series at `s`.
+
+        INPUT:
+
+        - ``s`` -- complex number (default: 1)
+        - ``series_prec`` -- number of terms (default: 6) in the Taylor series
+        - ``var`` -- variable (default: ``'z'``)
+
+        EXAMPLES::
+
+            sage: e = EllipticCurve('37a')
+            sage: K.<a> = QuadraticField(-40)
+            sage: A = K.class_group().gen(0)
+            sage: from sage.modular.modform.l_series_gross_zagier import GrossZagierLseries
+            sage: G = GrossZagierLseries(e, A)
+            sage: G.taylor_series(2,3)
+            -0.613002046122894 + 0.490374999263514*z - 0.122903033710382*z^2 + O(z^3)
+        """
+        return self._dokchister.taylor_series(s, series_prec, var)
+
+    def _repr_(self):
+        """
+        Return the string representation.
+
+        EXAMPLES::
+
+            sage: e = EllipticCurve('37a')
+            sage: K.<a> = QuadraticField(-40)
+            sage: A = K.class_group().gen(0)
+            sage: from sage.modular.modform.l_series_gross_zagier import GrossZagierLseries
+            sage: GrossZagierLseries(e, A)
+            Gross Zagier L-series attached to Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field with ideal class Fractional ideal class (2, 1/2*a)
+        """
+        msg = "Gross Zagier L-series attached to {} with ideal class {}"
+        return msg.format(self._E, self._A)