passagemath-sympow 10.6.32__cp312-abi3-macosx_13_0_x86_64.whl

passagemath_sympow-10.6.32.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: passagemath-sympow
+Version: 10.6.32
+Summary: passagemath: Special values of symmetric power elliptic curve L-functions with sympow
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Provides-Extra: test
+Requires-Dist: passagemath-schemes; extra == "test"
+Requires-Dist: passagemath-linbox; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+
+=====================================================================================
+passagemath: Special values of symmetric power elliptic curve L-functions with sympow
+=====================================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-sympow`` provides an interface
+to sympow.
+
+
+What is included
+----------------
+
+* Binary wheels on PyPI contain prebuilt copies of the sympow executable and data files.
+
+
+Examples
+--------
+
+Using the sympow program on the command line::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-sympow" sage -sh -c sympow
+
+
+Finding the installation location of the sympow executable::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-sympow[test]" ipython
+
+    In [1]: from sage.features.lrs import LrsNash
+
+    In [2]: LrsNash().absolute_filename()
+    Out[2]: '/Users/mkoeppe/.local/pipx/.cache/db3f5a0e2996f81/lib/python3.11/site-packages/sage_wheels/bin/lrsnash'

passagemath_sympow-10.6.32.dist-info/RECORD

@@ -0,0 +1,42 @@
+passagemath_sympow-10.6.32.dist-info/RECORD,,
+passagemath_sympow-10.6.32.dist-info/WHEEL,sha256=gwKIK4GslukC4grWlA2UD8HfZLRoT26ai3xdEG2as3I,153
+passagemath_sympow-10.6.32.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_sympow-10.6.32.dist-info/METADATA,sha256=NdPMf5vzRYpUcgCtXNgA3g8vGj1iHsQt7yUYWkDcci8,5000
+sage_wheels/bin/sympow,sha256=rklA9IVqV9r25VZqQ6b3QLvuL1AASIb_mLvqmXZIyCo,222632
+sage_wheels/libexec/sympow/new_data,sha256=F060BmFoGkihyUptBAfw0DpwFYZUemhykIaHKfHE4Ns,957
+sage_wheels/share/sympow/standard1.gp,sha256=kdsKt-9UqXcJN-XWlz9a5NXlgO88tmRWbZyh-903MmM,838
+sage_wheels/share/sympow/standard2.gp,sha256=2Ejuk9vr9Ot1UAjlI8f-DSaJyeD8wnGc8ii3Rx8XniY,1036
+sage_wheels/share/sympow/standard3.gp,sha256=qh9UOhtfsVTzd-5zKYOmacC0E0foJnidizC6HB0zqYs,341
+sage_wheels/share/sympow/datafiles/A018S.txt,sha256=AuZnw3SrIz4LOxAYoo9F9kZORNkrrs3UkOXg8cYdI_0,1044
+sage_wheels/share/sympow/datafiles/param_data,sha256=oOlJ7C7GhQ7E2UKlRE0trCjjqegX4Ry3b_95AbzZatg,415
+sage_wheels/share/sympow/datafiles/M02HM.txt,sha256=8pFxq5VPcpdfb80w8kRZpNCx9al1eJJ7JUH6dH5JSo8,808795
+sage_wheels/share/sympow/datafiles/A016M.txt,sha256=6gThIJYyhQEw4BR-M_lr9IzaB6KO3dOxtW_p5adLhBE,186548
+sage_wheels/share/sympow/datafiles/A014S.txt,sha256=HUKbdV17Hmgp-QVS4mKVzDgdJH0gFYDZN7nupcVwyJg,885
+sage_wheels/share/sympow/datafiles/A01OS.txt,sha256=SP9b8Eky4JK7rLM1EAtARFlcOgMCbKq7cy5x8mBzHeY,771
+sage_wheels/share/sympow/datafiles/A015S.txt,sha256=PHH_9bKUJgljXHSEFAztwrQ-SqdT6TrltCrkXhwJcKY,930
+sage_wheels/share/sympow/datafiles/A017M.txt,sha256=P-UOk-ldHB9zMhiFvV_7ZKNMhLe2DCOjALr7Hgsj7W8,186659
+sage_wheels/share/sympow/datafiles/A019S.txt,sha256=HbVsJiCUt3uuG8GcO4yC6wEIv1ZxBvbJ6b27q6n3yRI,1091
+sage_wheels/share/sympow/datafiles/m02EM.txt,sha256=2yZAIaDACKoYqcGmaSxT78evMZ_MkJi_4ISu9Wec3Sc,740005
+sage_wheels/share/sympow/datafiles/A012S.txt,sha256=gJLj0Nt-X7jQVDVewCxMzmzYTBRwgc07MIlfbV8m6oU,806
+sage_wheels/share/sympow/datafiles/M02LS.txt,sha256=gBX6K_2qRLFTprPkkoLrlm_3tIOvszskpFwNafDshZ4,1793
+sage_wheels/share/sympow/datafiles/m01EM.txt,sha256=3wn8YYvDfk9nbAlfOC5VuqTQNjYCldnaPEBYNb2F074,740463
+sage_wheels/share/sympow/datafiles/A013S.txt,sha256=5O-SWMZB26E_3FN7JbSQBVSmsRkEV4Lqd_A0PaHEtDQ,847
+sage_wheels/share/sympow/datafiles/A012M.txt,sha256=0y1gYMB2hXW0I5WmiLa__tQ-PDm7nNG82Yvj-D1Q9m8,278373
+sage_wheels/share/sympow/datafiles/M02LM.txt,sha256=92G7nHxY0JVzgo2DfXcHQdhV3JiN7lY28lNiUcF3nQw,807816
+sage_wheels/share/sympow/datafiles/m01ES.txt,sha256=0zU1VHUXjrFj0flG6JBef8uhf4MewYagTvxvtkx2qFE,1143
+sage_wheels/share/sympow/datafiles/A013M.txt,sha256=8TXqA1USNFMKLSO3kNsSnWzC6Da9DY9lmoYpF0jCAvk,186341
+sage_wheels/share/sympow/datafiles/A018M.txt,sha256=BnsvURa5YxNZiSMwy4DPT624nDI_CB3lxsAVkQ83Bms,93584
+sage_wheels/share/sympow/datafiles/M02HS.txt,sha256=iM8sJZcAUfzAucY1J-CCmoH9ZINgyjAuO5lKPXzXzoA,1658
+sage_wheels/share/sympow/datafiles/A016S.txt,sha256=cHdwwGt0Td5w6uqFpnPTxWfiHHYqRV4Ap9i5pE6sk3Q,965
+sage_wheels/share/sympow/datafiles/A014M.txt,sha256=OZZjrJl0RUkcceXC08z-24h7nF-48Avh5fUbJe9fETg,186440
+sage_wheels/share/sympow/datafiles/A01OM.txt,sha256=wXCro5Lzz6gBTUCwPEJ61mr2ljWjrLt4gFAY3spW8co,278326
+sage_wheels/share/sympow/datafiles/A015M.txt,sha256=2Y-VGY2arRXQmaWTCnYO5oUWWgja9mScTTHnYEwLo2s,186449
+sage_wheels/share/sympow/datafiles/A017S.txt,sha256=ko85lrS4vLIvjHSGA_laajJsNKB0AlNQKHeENgU_LWA,1010
+sage_wheels/share/sympow/datafiles/A019M.txt,sha256=gJ7RyIkrhq4gff36VLqEFODLP0z4J9ggGU7stKswVTE,93630
+sage_wheels/share/sympow/datafiles/m02ES.txt,sha256=9KdG7RqSiCA7uHHjQ4lLkW5oW6MTDVsyYdgv9ik-9ng,1090
+sage/all__sagemath_sympow.py,sha256=Cuovg0JqrDrWSwP2h2LMIErEH7QID2ijfGScMFWyr1g,356
+sage/lfunctions/all__sagemath_sympow.py,sha256=obBm1i3iPXkic7eZmtkG3qlsOo6EgKwOwMHTzQG51Xw,158
+sage/lfunctions/sympow.py,sha256=ZMX6wQsXTS0i93PGx39NA0y1Pi49FTcmJOl5aWjtie0,14187
+sage/libs/sympow.abi3.so,sha256=Xi_7IPrmRc3X4Co4fHm9WgkEDbnlgsUHFP_RPMu8tpY,21712
+sage/libs/sympow.pyx,sha256=xt-4MuDOFRKo25LAAglALz7ESIBIiQv_7l8VzVYw4Zc,45
+sage/libs/all__sagemath_sympow.py,sha256=xt-4MuDOFRKo25LAAglALz7ESIBIiQv_7l8VzVYw4Zc,45

passagemath_sympow-10.6.32.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-abi3-macosx_13_0_x86_64
+Generator: delocate 0.13.1.dev42+ga0af70b54
+

passagemath_sympow-10.6.32.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+sage

sage/all__sagemath_sympow.py

@@ -0,0 +1,17 @@
+# sage_setup: distribution = sagemath-sympow
+# delvewheel: patch
+
+try:
+    from sage.all__sagemath_repl import *
+except ImportError:
+    pass
+
+from sage.all__sagemath_modules import *
+from sage.all__sagemath_linbox import *
+
+try:
+    from sage.all__sagemath_schemes import *
+except ImportError:
+    pass
+
+from sage.lfunctions.all__sagemath_sympow import *

sage/lfunctions/all__sagemath_sympow.py

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-sympow
+
+from sage.misc.lazy_import import lazy_import
+
+lazy_import("sage.lfunctions.sympow", "sympow")
+
+del lazy_import

sage/lfunctions/sympow.py

@@ -0,0 +1,424 @@
+# sage_setup: distribution = sagemath-sympow
+r"""
+Watkins symmetric power `L`-function calculator
+
+SYMPOW is a package to compute special values of symmetric power
+elliptic curve `L`-functions. It can compute up to about 64 digits of
+precision. This interface provides complete access to sympow, which
+is a standard part of Sage (and includes the extra data files).
+
+.. NOTE::
+
+    Each call to ``sympow`` runs a complete
+    ``sympow`` process. This incurs about 0.2 seconds
+    overhead.
+
+AUTHORS:
+
+- Mark Watkins (2005-2006): wrote and released sympow
+
+- William Stein (2006-03-05): wrote Sage interface
+
+ACKNOWLEDGEMENT (from sympow readme):
+
+-  The quad-double package was modified from David Bailey's
+   package: http://crd.lbl.gov/~dhbailey/mpdist/
+
+-  The ``squfof`` implementation was modified from
+   Allan Steel's version of Arjen Lenstra's original LIP-based code.
+
+-  The ``ec_ap`` code was originally written for the
+   kernel of MAGMA, but was modified to use small integers when
+   possible.
+
+-  SYMPOW was originally developed using PARI, but due to licensing
+   difficulties, this was eliminated. SYMPOW also does not use the
+   standard math libraries unless Configure is run with the -lm
+   option. SYMPOW still uses GP to compute the meshes of inverse
+   Mellin transforms (this is done when a new symmetric power is added
+   to datafiles).
+"""
+
+########################################################################
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+########################################################################
+
+import os
+import shlex
+
+from sage.features.sympow import Sympow as sympow_executable
+from sage.structure.sage_object import SageObject
+from sage.misc.pager import pager
+from sage.misc.verbose import verbose
+from sage.rings.integer import Integer
+
+
+class Sympow(SageObject):
+    r"""
+    Watkins Symmetric Power `L`-function Calculator.
+
+    Type ``sympow.[tab]`` for a list of useful commands
+    that are implemented using the command line interface, but return
+    objects that make sense in Sage.
+
+    You can also use the complete command-line interface of sympow via
+    this class. Type ``sympow.help()`` for a list of
+    commands and how to call them.
+    """
+    def _repr_(self):
+        """
+        Return a string describing this calculator module
+        """
+        return "Watkins Symmetric Power L-function Calculator"
+
+    def __call__(self, args):
+        """
+        Used to call sympow with given args
+        """
+        cmd = f'{shlex.quote(sympow_executable().absolute_filename())} {args}'
+        with os.popen(cmd) as f:
+            v = f.read().strip()
+        verbose(v, level=2)
+        return v
+
+    def _fix_err(self, err):
+        w = err
+        j = w.rfind('./sympow')
+        if j != -1:
+            w = w[:j - 1] + "sympow('" + w[j + 9:] + ')'
+        return w
+
+    def _curve_str(self, E):
+        return '-curve "%s"' % (str(list(E.minimal_model().a_invariants())).replace(' ', ''))
+
+    def L(self, E, n, prec):
+        r"""
+        Return `L(\mathrm{Sym}^{(n)}(E, \text{edge}))` to prec digits of
+        precision, where edge is the *right* edge. Here `n` must be
+        even.
+
+        INPUT:
+
+        - ``E`` -- elliptic curve
+
+        - ``n`` -- even integer
+
+        - ``prec`` -- integer
+
+        OUTPUT: real number to prec digits of precision as a string
+
+        .. NOTE::
+
+           Before using this function for the first time for a given
+           `n`, you may have to type ``sympow('-new_data n')``,
+           where ``n`` is replaced by your value of `n`.
+
+        If you would like to see the extensive output sympow prints when
+        running this function, just type ``set_verbose(2)``.
+
+        EXAMPLES:
+
+        These examples only work if you run ``sympow -new_data 2`` in a
+        Sage shell first. Alternatively, within Sage, execute::
+
+            sage: sympow('-new_data 2')  # not tested
+
+        This command precomputes some data needed for the following
+        examples. ::
+
+            sage: a = sympow.L(EllipticCurve('11a'), 2, 16)  # not tested
+            sage: a                                          # not tested
+            '1.057599244590958E+00'
+            sage: RR(a)                                      # not tested
+            1.05759924459096
+        """
+        if n % 2 == 1:
+            raise ValueError("n (=%s) must be even" % n)
+        if prec > 64:
+            raise ValueError("prec (=%s) must be at most 64" % prec)
+        if prec < 1:
+            raise ValueError("prec (=%s) must be at least 1" % prec)
+        v = self('-sp %sp%s %s' % (n, prec, self._curve_str(E)))
+        i = v.rfind(': ')
+        if i == -1:
+            print(self._fix_err(v))
+            raise RuntimeError("failed to compute symmetric power")
+        x = v[i + 2:]
+        return x
+
+    def Lderivs(self, E, n, prec, d):
+        r"""
+        Return `0`-th to `d`-th derivatives of
+        `L(\mathrm{Sym}^{(n)}(E,s)` to prec digits of precision, where
+        `s` is the right edge if `n` is even and the center
+        if `n` is odd.
+
+        INPUT:
+
+        - ``E`` -- elliptic curve
+
+        - ``n`` -- integer (even or odd)
+
+        - ``prec`` -- integer
+
+        - ``d`` -- integer
+
+        OUTPUT: string, exactly as output by sympow
+
+        .. NOTE::
+
+           To use this function you may have to run a few commands
+           like ``sympow('-new_data 1d2')``, each which takes a
+           few minutes. If this function fails it will indicate what commands
+           have to be run.
+
+        EXAMPLES::
+
+            sage: print(sympow.Lderivs(EllipticCurve('11a'), 1, 16, 2))  # not tested
+            ...
+             1n0: 2.538418608559107E-01
+             1w0: 2.538418608559108E-01
+             1n1: 1.032321840884568E-01
+             1w1: 1.059251499158892E-01
+             1n2: 3.238743180659171E-02
+             1w2: 3.414818600982502E-02
+        """
+        if prec > 64:
+            raise ValueError("prec (=%s) must be at most 64" % prec)
+        if prec < 1:
+            raise ValueError("prec (=%s) must be at least 1" % prec)
+        v = self('-sp %sp%sd%s %s' % (n, prec, d, self._curve_str(E)))
+        return self._fix_err(v)
+
+    def modular_degree(self, E):
+        """
+        Return the modular degree of the elliptic curve E, assuming the
+        Stevens conjecture.
+
+        INPUT:
+
+        - ``E`` -- elliptic curve over Q
+
+        OUTPUT:
+
+        - ``integer`` -- modular degree
+
+        EXAMPLES: We compute the modular degrees of the lowest known
+        conductor curves of the first few ranks::
+
+            sage: sympow.modular_degree(EllipticCurve('11a'))
+            1
+            sage: sympow.modular_degree(EllipticCurve('37a'))
+            2
+            sage: sympow.modular_degree(EllipticCurve('389a'))
+            40
+            sage: sympow.modular_degree(EllipticCurve('5077a'))
+            1984
+            sage: sympow.modular_degree(EllipticCurve([1, -1, 0, -79, 289]))
+            334976
+        """
+        v = self('%s -moddeg' % self._curve_str(E))
+        s = 'Modular Degree is '
+        i = v.find(s)
+        if i == -1:
+            print(self._fix_err(v))
+            raise RuntimeError("failed to compute modular degree")
+        return Integer(v[i + len(s):])
+
+    def analytic_rank(self, E):
+        r"""
+        Return the analytic rank and leading `L`-value of the
+        elliptic curve `E`.
+
+        INPUT:
+
+        - ``E`` -- elliptic curve over Q
+
+        OUTPUT:
+
+        - ``integer`` -- analytic rank
+
+        - ``string`` -- leading coefficient (as string)
+
+
+        .. NOTE::
+
+           The analytic rank is *not* computed provably correctly in general.
+
+        .. NOTE::
+
+           In computing the analytic rank we consider
+           `L^{(r)}(E,1)` to be `0` if
+           `L^{(r)}(E,1)/\Omega_E > 0.0001`.
+
+        EXAMPLES: We compute the analytic ranks of the lowest known
+        conductor curves of the first few ranks::
+
+            sage: sympow.analytic_rank(EllipticCurve('11a'))
+            (0, '2.53842e-01')
+            sage: sympow.analytic_rank(EllipticCurve('37a'))
+            (1, '3.06000e-01')
+            sage: sympow.analytic_rank(EllipticCurve('389a'))
+            (2, '7.59317e-01')
+            sage: sympow.analytic_rank(EllipticCurve('5077a'))
+            (3, '1.73185e+00')
+            sage: sympow.analytic_rank(EllipticCurve([1, -1, 0, -79, 289]))
+            (4, '8.94385e+00')
+            sage: sympow.analytic_rank(EllipticCurve([0, 0, 1, -79, 342]))  # long time
+            (5, '3.02857e+01')
+            sage: sympow.analytic_rank(EllipticCurve([1, 1, 0, -2582, 48720]))  # long time
+            (6, '3.20781e+02')
+            sage: sympow.analytic_rank(EllipticCurve([0, 0, 0, -10012, 346900]))  # long time
+            (7, '1.32517e+03')
+        """
+        v = self('%s -analrank' % self._curve_str(E))
+        s = 'Analytic Rank is '
+        i = v.rfind(s)
+        if i == -1:
+            print(self._fix_err(v))
+            raise RuntimeError("failed to compute analytic rank")
+        j = v.rfind(':')
+        r = Integer(v[i + len(s):j])
+        i = v.rfind(' ')
+        L = v[i + 1:]
+        return r, L
+
+    def new_data(self, n):
+        """
+        Pre-compute data files needed for computation of `n`-th symmetric
+        powers.
+        """
+        print(self('-new_data %s' % n))
+
+    def help(self):
+        h = """
+     sympow('-sp 2p16 -curve "[1,2,3,4,5]"')
+will compute L(Sym^2 E,edge) for E=[1,2,3,4,5] to 16 digits of precision
+The result
+ 2n0: 8.370510845377639E-01
+ 2w0: 8.370510845377586E-01
+consists of two calculations using different parameters to test the
+functional equation (to see if these are sufficiently close).
+
+     sympow('-sp 3p12d2,4p8 -curve "[1,2,3,4,5]"')
+will compute the 0th-2nd derivatives of L(Sym^3 E,center) to 12 digits
+and L(Sym^4 E,edge) to 8 digits
+
+Special cases: When a curve has CM, Hecke power can be used instead
+
+     sympow('-sp 7p12d1 -hecke -curve "[0,0,1,-16758,835805]"')
+
+will compute the 0th-1st derivatives of L(Sym^7 psi,special) to 12 digits.
+
+Bloch-Kato numbers can be obtained for powers not congruent to 0 mod 4:
+
+     sympow('-sp 2bp16 -curve "[1,2,3,4,5]"')
+
+should return
+ 2n0: 4.640000000000006E+02
+ 2w0: 4.639999999999976E+02
+which can be seen to be very close to the integer 464.
+
+Modular degrees can be computed with the -moddeg option.
+
+     sympow('-curve "[1,2,3,4,5]" -moddeg')
+
+should return
+Modular Degree is 464
+
+Analytic ranks can be computed with the -analrank option.
+
+     sympow('-curve "[1,2,3,4,5]" -analrank')
+
+should return
+Analytic Rank is 1 : L'-value 3.51873e+00
+
+and (if the mesh file for the fifth derivative is present)
+
+     sympow('-curve "[0,0,1,-79,342]" -analrank')
+
+should return
+Analytic Rank is 5 : leading L-term 3.02857e+01
+
+========================================================================
+
+Adding new symmetric powers:
+
+SYMPOW keeps data for symmetric powers in the directory datafiles
+If a pre-computed mesh of inverse Mellin transform values is not
+available for a given symmetric power, SYMPOW will fail. The command
+
+     sympow('-new_data 2')
+
+will add the data the 2nd symmetric power, while
+
+     sympow('-new_data 3d2')
+
+will add the data for the 2nd derivative and 3rd symmetric power,
+
+     sympow('-new_data 6d0h')
+
+will add the data for the `0`-th derivative of the `6`-th Hecke power, and
+
+     sympow('-new_data 4c')
+
+will add data for the `4`-th symmetric power for curves with CM
+(these need to be done separately for powers divisible by 4).
+
+The mesh files are stored in binary form, and thus endian-ness is a
+worry when moving from one platform to another.
+
+To enable modular degree computations, the 2nd symmetric power must
+be extant, and analytic rank requires derivatives of the 1st power.
+
+===================================================================
+
+Output of "!sympow -help":
+
+ -bound #      an upper BOUND for how many ap to compute
+ -help         print the help message and exit
+ -info [] []   only report local information for primes/sympows
+               1st argument is prime range, 2nd is sympow range
+ -local        only report local information (bad primes)
+ -curve []     input a curve in [a1,a2,a3,a4,a6] form
+ -label []     label the given curve
+ -quiet        turn off some messages
+ -verbose      turn on some messages
+ -rootno #     compute the root number of the #th symmetric power
+ -moddeg       compute the modular degree
+ -analrank     compute the analytic rank
+ -sloppy []    for use with -analrank; have X sloppy digits
+ -nocm         abort if curve has complex multiplication
+ -noqt         ignore even powers of non-minimal quad twists
+ -hecke        compute Hecke symmetric powers for a CM curve
+ -maxtable     set the max size of factor tables: 2^27 default
+ -sp  []       argument to specify which powers
+               this is a comma separated list
+               in each entry, the 1st datum is the sympow
+               then could come b which turns Bloch-Kato on
+               then could come w# which specifies how many tests
+               then could come s# which says # sloppy digits
+               then must come p# which specifies the precision
+                    or P# which says ignore BOUND for this power
+               then must come d# which says the derivative bound
+                    or D# which says do only this derivative
+                    (neither need be indicated for even powers)
+               default is 2w3s1p32,3bp16d1,4p8
+ -new_data []  will compute inverse Mellin transform mesh for
+               the given data: the format is [sp]d[dv]{h,c}
+               sp is the symmetric power, dv is the derivative,
+               h indicates Hecke powers, and c indicates CM case
+               d[dv] is given only for odd or Hecke powers
+               Examples: 1d3 2 2d1h 3d2 4 4c 5d0 6 7d0h 11d1 12c
+               NOTE: new_data runs a shell script that uses GP
+Other options are used internally/recursively by -new_data
+"""
+        pager()(h)
+
+
+# An instance
+sympow = Sympow()

sage/libs/all__sagemath_sympow.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-sympow

sage/libs/sympow.pyx

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-sympow

sage_wheels/libexec/sympow/new_data

@@ -0,0 +1,43 @@
+#! /bin/sh
+#
+# This script should not need to be run directly,
+# but will be automatically executed via "sympow -new_data []"
+#
+# example direct usages
+# sh new_data /bin/sh /usr/bin/gp '-sp 3 -dv 2'
+# sh new_data /bin/sh /usr/bin/gp '-cm -sp 4'
+# sh new_data /bin/sh /usr/bin/gp '-sp 2'
+# sh new_data /bin/sh /usr/bin/gp '-hecke -sp 3 -dv 1'
+
+set -e
+
+if [ -z $SYMPOW_INVOCATIONNAME ];
+then
+echo "**ERROR**: unset environment variable SYMPOW_INVOCATIONNAME"; exit;
+fi
+
+if [ $# != 3 ];
+then
+echo "**ERROR**: Wrong number of input parameters"; exit;
+fi
+
+SYMPOW="$SYMPOW_INVOCATIONNAME ${SYMPOW_OPTS_VERBOSITY:--quiet}"
+
+echo "Running the new_data script for $3"
+
+SH=$1
+GP="$2 ${SYMPOW_OPTS_GP--D debugmem=0}"
+
+echo "Making the datafiles for $3"
+echo ""
+$SYMPOW -rewarp
+$SYMPOW -shell1 "$3" | $SH
+echo "Running the gp script"
+echo ""
+$SYMPOW -pari "$3" | $GP -f -q > /dev/null
+echo ""
+$SYMPOW -shell2 "$3" | $SH
+$SYMPOW -rewarp
+echo "Finished with $3"
+
+exit 0