passagemath-schemes 10.8.1a4__cp314-cp314t-macosx_13_0_arm64.whl

sage/modular/modform/submodule.py

@@ -0,0 +1,118 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+"""
+Submodules of spaces of modular forms
+
+EXAMPLES::
+
+    sage: M = ModularForms(Gamma1(13),2); M
+    Modular Forms space of dimension 13 for
+     Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+    sage: M.eisenstein_subspace()
+    Eisenstein subspace of dimension 11 of Modular Forms space of dimension 13 for
+     Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+    sage: M == loads(dumps(M))
+    True
+    sage: M.cuspidal_subspace()
+    Cuspidal subspace of dimension 2 of Modular Forms space of dimension 13 for
+     Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+"""
+
+#########################################################################
+#       Copyright (C) 2004--2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+#########################################################################
+
+from .space import ModularFormsSpace
+
+import sage.modular.hecke.submodule
+
+
+class ModularFormsSubmodule(ModularFormsSpace,
+                            sage.modular.hecke.submodule.HeckeSubmodule):
+    """
+    A submodule of an ambient space of modular forms.
+    """
+    def __init__(self, ambient_module, submodule, dual=None, check=False):
+        """
+        INPUT:
+
+        - ``ambient_module`` -- ModularFormsSpace
+        - ``submodule`` -- a submodule of the ambient space
+        - ``dual_module`` -- (default: ``None``) ignored
+        - ``check`` -- boolean (default: ``False``); whether to check that the
+          submodule is Hecke equivariant
+
+        EXAMPLES::
+
+          sage: M = ModularForms(Gamma1(13),2); M
+          Modular Forms space of dimension 13 for Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+          sage: M.eisenstein_subspace()
+          Eisenstein subspace of dimension 11 of Modular Forms space of dimension 13 for Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+        """
+        A = ambient_module
+        sage.modular.hecke.submodule.HeckeSubmodule.__init__(self, A, submodule, check=check)
+        ModularFormsSpace.__init__(self, A.group(), A.weight(),
+                                         A.character(), A.base_ring())
+
+    def _repr_(self):
+        """
+        EXAMPLES::
+
+          sage: ModularForms(Gamma1(13),2).eisenstein_subspace()._repr_()
+          'Eisenstein subspace of dimension 11 of Modular Forms space of dimension 13 for Congruence Subgroup Gamma1(13) of weight 2 over Rational Field'
+        """
+        return "Modular Forms subspace of dimension %s of %s" % (self.dimension(), self.ambient_module())
+
+    def _compute_coefficients(self, element, X):
+        """
+        Compute all coefficients of the modular form element in ``self`` for
+        indices in X.
+
+        TODO: Implement this function.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(6,4).cuspidal_subspace()
+            sage: M._compute_coefficients( M.basis()[0], range(1,100) )
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def _compute_q_expansion_basis(self, prec):
+        """
+        Compute ``q_expansions`` to precision ``prec`` for each element in
+        ``self.basis()``.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(Gamma1(13),2); M
+            Modular Forms space of dimension 13 for Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+            sage: S = M.eisenstein_subspace(); S
+            Eisenstein subspace of dimension 11 of Modular Forms space of dimension 13 for Congruence Subgroup Gamma1(13) of weight 2 over Rational Field
+            sage: S._compute_q_expansion_basis(5)
+            [1 + O(q^5),
+             q + O(q^5),
+             q^2 + O(q^5),
+             q^3 + O(q^5),
+             q^4 + O(q^5),
+             O(q^5),
+             O(q^5),
+             O(q^5),
+             O(q^5),
+             O(q^5),
+             O(q^5)]
+        """
+        A = self.ambient_module()
+        return [A._q_expansion(element=f.element(), prec=prec)
+                for f in self.basis()]
+
+
+# TODO
+class ModularFormsSubmoduleWithBasis(ModularFormsSubmodule):
+    pass

sage/modular/modform/tests.py

@@ -0,0 +1,64 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+"""
+TESTS:
+
+Test consistency between modular forms and modular symbols Eisenstein
+series charpolys, which are computed in completely separate ways. ::
+
+    sage: for N in range(25,33):
+    ....:    m = ModularForms(N)
+    ....:    e = m.eisenstein_subspace()
+    ....:    f = e.hecke_polynomial(2)
+    ....:    g = ModularSymbols(N).eisenstein_submodule().hecke_polynomial(2)
+    ....:    print("{} {}".format(N, f == g))
+    25 True
+    26 True
+    27 True
+    28 True
+    29 True
+    30 True
+    31 True
+    32 True
+
+Another similar consistency check::
+
+    sage: for N in range(1,26):
+    ....:    eps = (N > 2 and DirichletGroup(N,QQ).0) or N
+    ....:    m = ModularForms(eps)
+    ....:    e = m.eisenstein_subspace()
+    ....:    f = e.hecke_polynomial(2)
+    ....:    g = ModularSymbols(eps).eisenstein_submodule().hecke_polynomial(2)
+    ....:    print("{} {}".format(N, f == g))
+    1 True
+    2 True
+    3 True
+    4 True
+    5 True
+    6 True
+    7 True
+    8 True
+    9 True
+    10 True
+    11 True
+    12 True
+    13 True
+    14 True
+    15 True
+    16 True
+    17 True
+    18 True
+    19 True
+    20 True
+    21 True
+    22 True
+    23 True
+    24 True
+    25 True
+
+We check that bug :issue:`8541` (traced to a linear algebra problem) is fixed::
+
+    sage: f = CuspForms(DirichletGroup(5).0,5).0
+    sage: f[15]
+    30*zeta4 - 210
+"""

sage/modular/modform/theta.py

@@ -0,0 +1,110 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+`q`-expansions of theta series
+
+AUTHOR:
+
+- William Stein
+"""
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+from sage.rings.power_series_ring import PowerSeriesRing
+
+from math import sqrt
+
+
+def theta2_qexp(prec=10, var='q', K=ZZ, sparse=False):
+    r"""
+    Return the `q`-expansion of the series `\theta_2 = \sum_{n \text{ odd}} q^{n^2}`.
+
+    INPUT:
+
+    - ``prec`` -- integer; the absolute precision of the output
+    - ``var`` -- (default: ``'q'``) variable name
+    - ``K`` -- (default: ZZ) base ring of answer
+
+    OUTPUT: a power series over K
+
+    EXAMPLES::
+
+        sage: theta2_qexp(18)
+        q + q^9 + O(q^18)
+        sage: theta2_qexp(49)
+        q + q^9 + q^25 + O(q^49)
+        sage: theta2_qexp(100, 'q', QQ)
+        q + q^9 + q^25 + q^49 + q^81 + O(q^100)
+        sage: f = theta2_qexp(100, 't', GF(3)); f
+        t + t^9 + t^25 + t^49 + t^81 + O(t^100)
+        sage: parent(f)
+        Power Series Ring in t over Finite Field of size 3
+        sage: theta2_qexp(200)
+        q + q^9 + q^25 + q^49 + q^81 + q^121 + q^169 + O(q^200)
+        sage: f = theta2_qexp(20,sparse=True); f
+        q + q^9 + O(q^20)
+        sage: parent(f)
+        Sparse Power Series Ring in q over Integer Ring
+    """
+    prec = Integer(prec)
+    if prec <= 0:
+        raise ValueError("prec must be positive")
+    if sparse:
+        v = {}
+    else:
+        v = [Integer(0)] * prec
+    one = Integer(1)
+    n = int(sqrt(prec))
+    if n*n < prec:
+        n += 1
+    for m in range(1, n, 2):
+        v[m*m] = one
+    R = PowerSeriesRing(K, sparse=sparse, names=var)
+    return R(v, prec=prec)
+
+
+def theta_qexp(prec=10, var='q', K=ZZ, sparse=False):
+    r"""
+    Return the `q`-expansion of the standard `\theta` series
+    `\theta = 1 + 2\sum_{n=1}^{\infty} q^{n^2}`.
+
+    INPUT:
+
+    - ``prec`` -- integer; the absolute precision of the output
+    - ``var`` -- (default: ``'q'``) variable name
+    - ``K`` -- (default: ZZ) base ring of answer
+
+    OUTPUT: a power series over K
+
+    EXAMPLES::
+
+        sage: theta_qexp(25)
+        1 + 2*q + 2*q^4 + 2*q^9 + 2*q^16 + O(q^25)
+        sage: theta_qexp(10)
+        1 + 2*q + 2*q^4 + 2*q^9 + O(q^10)
+        sage: theta_qexp(100)
+        1 + 2*q + 2*q^4 + 2*q^9 + 2*q^16 + 2*q^25 + 2*q^36 + 2*q^49 + 2*q^64 + 2*q^81 + O(q^100)
+        sage: theta_qexp(100, 't')
+        1 + 2*t + 2*t^4 + 2*t^9 + 2*t^16 + 2*t^25 + 2*t^36 + 2*t^49 + 2*t^64 + 2*t^81 + O(t^100)
+        sage: theta_qexp(100, 't', GF(2))
+        1 + O(t^100)
+        sage: f = theta_qexp(20,sparse=True); f
+        1 + 2*q + 2*q^4 + 2*q^9 + 2*q^16 + O(q^20)
+        sage: parent(f)
+        Sparse Power Series Ring in q over Integer Ring
+    """
+    prec = Integer(prec)
+    if prec <= 0:
+        raise ValueError("prec must be positive")
+    if sparse:
+        v = {}
+    else:
+        v = [Integer(0)] * prec
+    v[0] = Integer(1)
+    two = Integer(2)
+    n = int(sqrt(prec))
+    if n*n != prec:
+        n += 1
+    for m in range(1, n):
+        v[m*m] = two
+
+    R = PowerSeriesRing(K, sparse=sparse, names=var)
+    return R(v, prec=prec)

sage/modular/modform/vm_basis.py

@@ -0,0 +1,380 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.flint
+r"""
+The Victor Miller basis
+
+This module contains functions for quick calculation of a basis of
+`q`-expansions for the space of modular forms of level 1 and any weight. The
+basis returned is the Victor Miller basis, which is the unique basis of
+elliptic modular forms `f_1, \dots, f_d` for which `a_i(f_j) = \delta_{ij}`
+for `1 \le i, j \le d` (where `d` is the dimension of the space).
+
+This basis is calculated using a standard set of generators for the ring of
+modular forms, using the fast multiplication algorithms for polynomials and
+power series provided by the FLINT library. (This is far quicker than using
+modular symbols).
+
+TESTS::
+
+    sage: ModularSymbols(1, 36, 1).cuspidal_submodule().q_expansion_basis(30) == victor_miller_basis(36, 30, cusp_only=True)
+    True
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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/
+# ****************************************************************************
+
+import math
+
+from sage.libs.flint.fmpz_poly_sage import Fmpz_poly
+from sage.misc.verbose import verbose
+from sage.modular.modform.eis_series_cython import eisenstein_series_poly
+from sage.rings.big_oh import O as bigO
+from sage.rings.finite_rings.integer_mod_ring import Integers
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.power_series_ring import PowerSeriesRing
+from sage.rings.rational_field import QQ
+from sage.structure.sequence import Sequence
+
+
+def victor_miller_basis(k, prec=10, cusp_only=False, var='q'):
+    r"""
+    Compute and return the Victor Miller basis for modular forms of
+    weight `k` and level 1 to precision `O(q^{prec})`.  If
+    ``cusp_only`` is True, return only a basis for the cuspidal
+    subspace.
+
+    INPUT:
+
+    - ``k`` -- integer
+
+    - ``prec`` -- (default: 10) a positive integer
+
+    - ``cusp_only`` -- boolean (default: ``False``)
+
+    - ``var`` -- string (default: ``'q'``)
+
+    OUTPUT: a sequence whose entries are power series in ``ZZ[[var]]``
+
+    EXAMPLES::
+
+        sage: victor_miller_basis(1, 6)
+        []
+        sage: victor_miller_basis(0, 6)
+        [1 + O(q^6)]
+        sage: victor_miller_basis(2, 6)
+        []
+        sage: victor_miller_basis(4, 6)
+        [1 + 240*q + 2160*q^2 + 6720*q^3 + 17520*q^4 + 30240*q^5 + O(q^6)]
+
+        sage: victor_miller_basis(6, 6, var='w')
+        [1 - 504*w - 16632*w^2 - 122976*w^3 - 532728*w^4 - 1575504*w^5 + O(w^6)]
+
+        sage: victor_miller_basis(6, 6)
+        [1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 + O(q^6)]
+        sage: victor_miller_basis(12, 6)
+        [1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + 4629381120*q^5 + O(q^6),
+         q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6)]
+
+        sage: victor_miller_basis(12, 6, cusp_only=True)
+        [q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 + O(q^6)]
+        sage: victor_miller_basis(24, 6, cusp_only=True)
+        [q + 195660*q^3 + 12080128*q^4 + 44656110*q^5 + O(q^6),
+         q^2 - 48*q^3 + 1080*q^4 - 15040*q^5 + O(q^6)]
+        sage: victor_miller_basis(24, 6)
+        [1 + 52416000*q^3 + 39007332000*q^4 + 6609020221440*q^5 + O(q^6),
+         q + 195660*q^3 + 12080128*q^4 + 44656110*q^5 + O(q^6),
+         q^2 - 48*q^3 + 1080*q^4 - 15040*q^5 + O(q^6)]
+        sage: victor_miller_basis(32, 6)
+        [1 + 2611200*q^3 + 19524758400*q^4 + 19715347537920*q^5 + O(q^6),
+         q + 50220*q^3 + 87866368*q^4 + 18647219790*q^5 + O(q^6),
+         q^2 + 432*q^3 + 39960*q^4 - 1418560*q^5 + O(q^6)]
+
+        sage: victor_miller_basis(40,200)[1:] == victor_miller_basis(40,200,cusp_only=True)
+        True
+        sage: victor_miller_basis(200,40)[1:] == victor_miller_basis(200,40,cusp_only=True)
+        True
+
+    AUTHORS:
+
+    - William Stein, Craig Citro: original code
+
+    - Martin Raum (2009-08-02): use FLINT for polynomial arithmetic (instead of NTL)
+    """
+    k = Integer(k)
+    if k % 2 == 1 or k == 2:
+        return Sequence([])
+    elif k < 0:
+        raise ValueError("k must be nonnegative")
+    elif k == 0:
+        return Sequence([PowerSeriesRing(ZZ,var)(1).add_bigoh(prec)], cr=True)
+    e = k.mod(12)
+    if e == 2:
+        e += 12
+    n = (k-e) // 12
+
+    if n == 0 and cusp_only:
+        return Sequence([])
+
+    # If prec is less than or equal to the dimension of the space of
+    # cusp forms, which is just n, then we know the answer, and we
+    # simply return it.
+    if prec <= n:
+        q = PowerSeriesRing(ZZ,var).gen(0)
+        err = bigO(q**prec)
+        ls = [0] * (n+1)
+        if not cusp_only:
+            ls[0] = 1 + err
+        for i in range(1,prec):
+            ls[i] = q**i + err
+        for i in range(prec,n+1):
+            ls[i] = err
+        return Sequence(ls, cr=True)
+
+    F6 = eisenstein_series_poly(6, prec)
+
+    if e == 0:
+        A = Fmpz_poly(1)
+    elif e == 4:
+        A = eisenstein_series_poly(4, prec)
+    elif e == 6:
+        A = F6
+    elif e == 8:
+        A = eisenstein_series_poly(8, prec)
+    elif e == 10:
+        A = eisenstein_series_poly(10, prec)
+    else:  # e == 14
+        A = eisenstein_series_poly(14, prec)
+
+    if A[0] == -1:
+        A = -A
+
+    if n == 0:
+        return Sequence([PowerSeriesRing(ZZ,var)(A.list()).add_bigoh(prec)],cr=True)
+
+    F6_squared = F6**2
+    F6_squared._unsafe_mutate_truncate(prec)
+    D = _delta_poly(prec)
+    Fprod = F6_squared
+    Dprod = D
+
+    if cusp_only:
+        ls = [Fmpz_poly(0)] + [A] * n
+    else:
+        ls = [A] * (n + 1)
+
+    for i in range(1, n + 1):
+        ls[n-i] *= Fprod
+        ls[i] *= Dprod
+        ls[n-i]._unsafe_mutate_truncate(prec)
+        ls[i]._unsafe_mutate_truncate(prec)
+
+        Fprod *= F6_squared
+        Dprod *= D
+        Fprod._unsafe_mutate_truncate(prec)
+        Dprod._unsafe_mutate_truncate(prec)
+
+    P = PowerSeriesRing(ZZ, var)
+    if cusp_only:
+        for i in range(1, n + 1):
+            for j in range(1, i):
+                ls[j] = ls[j] - ls[j][i]*ls[i]
+
+        return Sequence([P(l.list()).add_bigoh(prec) for l in ls[1:]], cr=True)
+
+    for i in range(1, n + 1):
+        for j in range(i):
+            ls[j] = ls[j] - ls[j][i] * ls[i]
+
+    return Sequence([P(l.list()).add_bigoh(prec) for l in ls], cr=True)
+
+
+def _delta_poly(prec=10):
+    """
+    Return the `q`-expansion of Delta as a FLINT polynomial. Used internally by
+    the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`
+    for more information.
+
+    INPUT:
+
+    - ``prec`` -- integer; the absolute precision of the output
+
+    OUTPUT:
+
+        the `q`-expansion of Delta to precision ``prec``, as a FLINT
+        :class:`~sage.libs.flint.fmpz_poly.Fmpz_poly` object.
+
+    EXAMPLES::
+
+        sage: from sage.modular.modform.vm_basis import _delta_poly
+        sage: _delta_poly(7)
+        7  0 1 -24 252 -1472 4830 -6048
+    """
+    if prec <= 0:
+        raise ValueError("prec must be positive")
+    v = [0] * prec
+
+    # Let F = \sum_{n >= 0} (-1)^n (2n+1) q^(floor(n(n+1)/2)).
+    # Then delta is F^8.
+
+    # First compute F^2 directly by naive polynomial multiplication,
+    # since F is very sparse.
+
+    stop = int((-1+math.sqrt(1+8*prec))/2.0)
+    # make list of index/value pairs for the sparse poly
+    values = [(n*(n+1)//2, ((-2*n-1) if (n & 1) else (2*n+1)))
+              for n in range(stop + 1)]
+
+    for (i1, v1) in values:
+        for (i2, v2) in values:
+            try:
+                v[i1 + i2] += v1 * v2
+            except IndexError:
+                break
+
+    f = Fmpz_poly(v)
+    t = verbose('made series')
+    f = f * f
+    f._unsafe_mutate_truncate(prec)
+    t = verbose('squared (2 of 3)', t)
+    f = f * f
+    f._unsafe_mutate_truncate(prec - 1)
+    t = verbose('squared (3 of 3)', t)
+    f = f.left_shift(1)
+    t = verbose('shifted', t)
+    return f
+
+
+def _delta_poly_modulo(N, prec=10):
+    r"""
+    Return the `q`-expansion of `\Delta` modulo `N`. Used internally by
+    the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`
+    for more information.
+
+    INPUT:
+
+    - ``N`` -- positive integer modulo which we want to compute `\Delta`
+
+    - ``prec`` -- integer; the absolute precision of the output
+
+    OUTPUT:
+
+    the polynomial of degree ``prec``-1 which is the truncation
+    of `\Delta` modulo `N`, as an element of the polynomial
+    ring in `q` over the integers modulo `N`.
+
+    EXAMPLES::
+
+        sage: from sage.modular.modform.vm_basis import _delta_poly_modulo
+        sage: _delta_poly_modulo(5, 7)
+        2*q^6 + 3*q^4 + 2*q^3 + q^2 + q
+        sage: _delta_poly_modulo(10, 12)
+        2*q^11 + 7*q^9 + 6*q^7 + 2*q^6 + 8*q^4 + 2*q^3 + 6*q^2 + q
+    """
+    if prec <= 0:
+        raise ValueError("prec must be positive")
+    v = [0] * prec
+
+    # Let F = \sum_{n >= 0} (-1)^n (2n+1) q^(floor(n(n+1)/2)).
+    # Then delta is F^8.
+
+    stop = int((-1+math.sqrt(8*prec))/2.0)
+
+    for n in range(stop+1):
+        v[n*(n+1)//2] = ((N-1)*(2*n+1) if (n & 1) else (2*n+1))
+
+    P = PolynomialRing(Integers(N), 'q')
+    f = P(v)
+    t = verbose('made series')
+    # fast way of computing f*f truncated at prec
+    f = f._mul_trunc_(f, prec)
+    t = verbose('squared (1 of 3)', t)
+    f = f._mul_trunc_(f, prec)
+    t = verbose('squared (2 of 3)', t)
+    f = f._mul_trunc_(f, prec - 1)
+    t = verbose('squared (3 of 3)', t)
+    f = f.shift(1)
+    t = verbose('shifted', t)
+
+    return f
+
+
+def delta_qexp(prec=10, var='q', K=ZZ):
+    r"""
+    Return the `q`-expansion of the weight 12 cusp form `\Delta` as a power
+    series with coefficients in the ring K (`= \ZZ` by default).
+
+    INPUT:
+
+    - ``prec`` -- integer (default: 10); the absolute precision of the output
+      (must be positive)
+
+    - ``var`` -- string (default: ``'q'``); variable name
+
+    - ``K`` -- ring (default: `\ZZ`); base ring of answer
+
+    OUTPUT: a power series over K in the variable ``var``
+
+    ALGORITHM:
+
+    Compute the theta series
+
+    .. MATH::
+
+        \sum_{n \ge 0} (-1)^n (2n+1) q^{n(n+1)/2},
+
+    a very simple explicit modular form whose 8th power is `\Delta`. Then
+    compute the 8th power. All computations are done over `\ZZ` or `\ZZ`
+    modulo `N` depending on the characteristic of the given coefficient
+    ring `K`, and coerced into `K` afterwards.
+
+    EXAMPLES::
+
+        sage: delta_qexp(7)
+        q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 + O(q^7)
+        sage: delta_qexp(7,'z')
+        z - 24*z^2 + 252*z^3 - 1472*z^4 + 4830*z^5 - 6048*z^6 + O(z^7)
+        sage: delta_qexp(-3)
+        Traceback (most recent call last):
+        ...
+        ValueError: prec must be positive
+        sage: delta_qexp(20, K = GF(3))
+        q + q^4 + 2*q^7 + 2*q^13 + q^16 + 2*q^19 + O(q^20)
+        sage: delta_qexp(20, K = GF(3^5, 'a'))
+        q + q^4 + 2*q^7 + 2*q^13 + q^16 + 2*q^19 + O(q^20)
+        sage: delta_qexp(10, K = IntegerModRing(60))
+        q + 36*q^2 + 12*q^3 + 28*q^4 + 30*q^5 + 12*q^6 + 56*q^7 + 57*q^9 + O(q^10)
+
+    TESTS:
+
+    Test algorithm with modular arithmetic (see also :issue:`11804`)::
+
+        sage: delta_qexp(10^4).change_ring(GF(13)) == delta_qexp(10^4, K=GF(13))
+        True
+        sage: delta_qexp(1000).change_ring(IntegerModRing(5^100)) == delta_qexp(1000, K=IntegerModRing(5^100))
+        True
+
+    AUTHORS:
+
+    - William Stein: original code
+
+    - David Harvey (2007-05): sped up first squaring step
+
+    - Martin Raum (2009-08-02): use FLINT for polynomial arithmetic (instead of NTL)
+    """
+    R = PowerSeriesRing(K, var)
+    if K in (ZZ, QQ):
+        return R(_delta_poly(prec).list(), prec, check=False)
+    ch = K.characteristic()
+    if ch > 0 and prec > 150:
+        return R(_delta_poly_modulo(ch, prec), prec, check=False)
+    else:
+        # compute over ZZ and coerce
+        return R(_delta_poly(prec).list(), prec, check=True)