passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/all__sagemath_pari.py

@@ -0,0 +1,26 @@
+# sage_setup: distribution = sagemath-pari
+# delvewheel: patch
+r"""
+Top level of the distribution package sagemath-pari
+
+This distribution makes the following features available::
+
+    sage: from sage.features.sagemath import *
+    sage: sage__libs__pari().is_present()
+    FeatureTestResult('sage.libs.pari', True)
+    sage: sage__rings__finite_rings().is_present()
+    FeatureTestResult('sage.rings.finite_rings', True)
+"""
+
+from .all__sagemath_categories import *
+
+from sage.databases.all__sagemath_pari import *
+from sage.groups.all__sagemath_pari import *
+from sage.libs.all__sagemath_pari import *
+from sage.quadratic_forms.all__sagemath_pari import *
+from sage.rings.all__sagemath_pari import *
+
+# Relink imported lazy_import objects to point to the appropriate namespace
+from sage.misc.lazy_import import clean_namespace
+clean_namespace()
+del clean_namespace

sage/databases/all__sagemath_pari.py

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-pari
+
+from sage.misc.lazy_import import lazy_import
+
+lazy_import('sage.databases.conway', 'ConwayPolynomials')
+
+del lazy_import

sage/databases/conway.py

@@ -0,0 +1,274 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Frank Lübeck's tables of Conway polynomials over finite fields
+"""
+# ****************************************************************************
+#
+#       Copyright (C) 2005-2006 William Stein <wstein@gmail.com>
+#       Copyright (C) 2010      Alexandru Ghitza
+#       Copyright (C) 2013      R. Andrew Ohana <andrew.ohana@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 collections.abc import Mapping
+
+
+class DictInMapping(Mapping):
+    def __init__(self, dict):
+        """
+        Places dict into a non-mutable mapping.
+
+        TESTS::
+
+            sage: from sage.databases.conway import DictInMapping
+            sage: d = {}
+            sage: m = DictInMapping(d); m
+            {}
+            sage: d[0] = 1; m
+            {0: 1}
+            sage: m[2] = 3
+            Traceback (most recent call last):
+            ...
+            TypeError: 'DictInMapping' object does not support item assignment
+        """
+        self._store = dict
+
+    def __getitem__(self, key):
+        """
+        TESTS::
+
+            sage: from sage.databases.conway import DictInMapping
+            sage: DictInMapping({'foo': 'bar'})['foo']
+            'bar'
+        """
+        return self._store[key]
+
+    def __len__(self):
+        """
+        TESTS::
+
+            sage: from sage.databases.conway import DictInMapping
+            sage: d = {}
+            sage: m = DictInMapping(d); len(m)
+            0
+            sage: d['foo'] = 'bar'; len(m)
+            1
+        """
+        return len(self._store)
+
+    def __iter__(self):
+        """
+        TESTS::
+
+            sage: from sage.databases.conway import DictInMapping
+            sage: next(iter(DictInMapping({'foo': 'bar'})))
+            'foo'
+        """
+        return iter(self._store)
+
+    def __repr__(self):
+        """
+        TESTS::
+
+            sage: from sage.databases.conway import DictInMapping
+            sage: DictInMapping({'foo': 'bar'})
+            {'foo': 'bar'}
+        """
+        return repr(self._store)
+
+
+class ConwayPolynomials(Mapping):
+    def __init__(self):
+        """
+        Initialize the database.
+
+        TESTS::
+
+            sage: c = ConwayPolynomials()
+            sage: c
+            Frank Lübeck's database of Conway polynomials
+        """
+        import conway_polynomials
+        self._store = conway_polynomials.database()
+
+    def __repr__(self):
+        """
+        Return a description of this database.
+
+        TESTS::
+
+            sage: c = ConwayPolynomials()
+            sage: c.__repr__()
+            "Frank Lübeck's database of Conway polynomials"
+        """
+        return "Frank Lübeck's database of Conway polynomials"
+
+    def __getitem__(self, key):
+        """
+        If key is a pair of integers ``p,n``, return the Conway
+        polynomial of degree ``n`` over ``GF(p)``.
+
+        If key is an integer ``p``, return a non-mutable mapping
+        whose keys are the degrees of the polynomial values.
+
+        TESTS::
+
+            sage: c = ConwayPolynomials()
+            sage: c[60859]
+            {1: (60856, 1), 2: (3, 60854, 1),
+                    3: (60856, 8, 0, 1), 4: (3, 32881, 3, 0, 1)}
+            sage: c[60869, 3]
+            (60867, 2, 0, 1)
+        """
+        try:
+            return DictInMapping(self._store[key])
+        except KeyError as err:
+            try:
+                if isinstance(key, (tuple, list)):
+                    if len(key) == 2:
+                        return self._store[key[0]][key[1]]
+            except KeyError:
+                pass
+            raise err
+
+    def __len__(self):
+        """
+        Return the number of polynomials in this database.
+
+        TESTS:
+
+        The database currently contains `35357` polynomials, but due to
+        :issue:`35357` it will be extended by Conway polynomials of
+        degrees `1`, `2` and `3` for primes between `65537` and `110000`,
+        thus leading to a new total of `47090` entries::
+
+            sage: c = ConwayPolynomials()
+            sage: len(c) in [35357, 47090]
+            True
+        """
+        try:
+            return self._len
+        except AttributeError:
+            pass
+        self._len = sum(len(a) for a in self._store.values())
+        return self._len
+
+    def __iter__(self):
+        """
+        Return an iterator over the keys of this database.
+
+        TESTS::
+
+            sage: c = ConwayPolynomials()
+            sage: itr = iter(c)
+            sage: next(itr)  # random
+            (65537, 4)
+        """
+        for a, b in self._store.items():
+            for c in b:
+                yield a, c
+
+    def polynomial(self, p, n):
+        """
+        Return the Conway polynomial of degree ``n`` over ``GF(p)``,
+        or raise a :exc:`RuntimeError` if this polynomial is not in the
+        database.
+
+        .. NOTE::
+
+            See also the global function ``conway_polynomial`` for
+            a more user-friendly way of accessing the polynomial.
+
+        INPUT:
+
+        - ``p`` -- prime number
+
+        - ``n`` -- positive integer
+
+        OUTPUT:
+
+        List of Python int's giving the coefficients of the corresponding
+        Conway polynomial in ascending order of degree.
+
+        EXAMPLES::
+
+            sage: c = ConwayPolynomials()
+            sage: c.polynomial(3, 21)
+            (1, 2, 0, 2, 0, 1, 2, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
+            sage: c.polynomial(97, 128)
+            Traceback (most recent call last):
+            ...
+            RuntimeError: Conway polynomial over F_97 of degree 128 not in database.
+        """
+        try:
+            return self[p, n]
+        except KeyError:
+            raise RuntimeError("Conway polynomial over F_%s of degree %s not in database." % (p, n))
+
+    def has_polynomial(self, p, n) -> bool:
+        """
+        Return ``True`` if the database of Conway polynomials contains the
+        polynomial of degree ``n`` over ``GF(p)``.
+
+        INPUT:
+
+        - ``p`` -- prime number
+
+        - ``n`` -- positive integer
+
+        EXAMPLES::
+
+            sage: c = ConwayPolynomials()
+            sage: c.has_polynomial(97, 12)
+            True
+            sage: c.has_polynomial(60821, 5)
+            False
+        """
+        return (p, n) in self
+
+    def primes(self):
+        """
+        Return the list of prime numbers ``p`` for which the database of
+        Conway polynomials contains polynomials over ``GF(p)``.
+
+        EXAMPLES::
+
+            sage: c = ConwayPolynomials()
+            sage: P = c.primes()
+            sage: 2 in P
+            True
+            sage: next_prime(10^7) in P
+            False
+        """
+        return self._store.keys()
+
+    def degrees(self, p):
+        """
+        Return the list of integers ``n`` for which the database of Conway
+        polynomials contains the polynomial of degree ``n`` over ``GF(p)``.
+
+        EXAMPLES::
+
+            sage: c = ConwayPolynomials()
+            sage: c.degrees(60821)
+            [1, 2, 3, 4]
+            sage: c.degrees(next_prime(10^7))
+            []
+        """
+        if p not in self._store:
+            return []
+        return list(self._store[p])
+
+    def __reduce__(self):
+        """
+        TESTS::
+
+            sage: c = ConwayPolynomials()
+            sage: loads(dumps(c)) == c
+            True
+        """
+        return (ConwayPolynomials, ())

sage/ext/all__sagemath_pari.py

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

sage/ext/memory.pyx

@@ -0,0 +1,98 @@
+# sage_setup: distribution = sagemath-pari
+"""
+Low-level memory allocation functions
+
+TESTS:
+
+Check that an error is raised if we try to allocate a
+ridiculously large integer, see :issue:`15363`::
+
+    sage: try:
+    ....:     2^(2^63-3)
+    ....: except (OverflowError, RuntimeError, FloatingPointError):
+    ....:     print ('Overflow error')
+    ...Overflow error
+
+AUTHORS:
+
+- Jeroen Demeyer (2011-01-13): initial version (:issue:`10258`)
+
+- Jeroen Demeyer (2014-12-14): add more functions (:issue:`10257`)
+
+- Jeroen Demeyer (2015-03-02): move from ``c_lib`` to Cython (:issue:`17881`)
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2011-2015 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+# 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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from cysignals.memory cimport sig_malloc, sig_realloc, sig_free
+from cysignals.signals cimport sig_error
+
+from sage.libs.gmp.misc cimport mp_set_memory_functions
+
+cdef extern from "Python.h":
+    # Declare as returning void without except value
+    void PyErr_Format(object exception, char *format, ...)
+    int unlikely(int) nogil  # Defined by Cython
+
+
+cdef void alloc_error(size_t size) noexcept nogil:
+    """
+    Jump back to ``sig_on()``, raising a :exc:`MemoryError`.
+    """
+    with gil:
+        PyErr_Format(MemoryError, "failed to allocate %zu bytes", size)
+    sig_error()
+
+
+cdef void* sage_sig_malloc(size_t size) noexcept nogil:
+    """
+    ``malloc()`` function for the MPIR/GMP library.
+
+    Out-of-memory errors are handled using the ``sig_error`` mechanism.
+    """
+    cdef void* p = sig_malloc(size)
+    if unlikely(p == NULL):
+        alloc_error(size)
+    return p
+
+
+cdef void* sage_sig_realloc(void *ptr, size_t old_size, size_t new_size) noexcept nogil:
+    """
+    ``realloc()`` function for the MPIR/GMP library.
+
+    Out-of-memory errors are handled using the ``sig_error`` mechanism.
+    """
+    cdef void* p = sig_realloc(ptr, new_size)
+    if unlikely(p == NULL):
+        alloc_error(new_size)
+    return p
+
+
+cdef void sage_sig_free(void *ptr, size_t size) noexcept nogil:
+    """
+    ``free()`` function for the MPIR/GMP library.
+    """
+    sig_free(ptr)
+
+
+def init_memory_functions():
+    """
+    Set the MPIR/GMP memory functions to the above functions.
+
+    EXAMPLES::
+
+        sage: from sage.ext.memory import init_memory_functions
+        sage: init_memory_functions()
+    """
+    mp_set_memory_functions(sage_sig_malloc, sage_sig_realloc, sage_sig_free)
+
+
+init_memory_functions()

sage/ext_data/pari/buzzard/DimensionSk.g

@@ -0,0 +1,286 @@
+\\ DimensionSk.g, V2.2: program to compute dimensions of spaces of cusp
+\\ forms with non-trivial character.
+\\
+\\ By Kevin Buzzard (buzzard@ic.ac.uk)
+\\
+\\ Please report any problems to buzzard@ic.ac.uk .
+\\
+\\ Needs: genusn.g function S0(n,k)
+\\
+\\ This started off as my port of William's DimensionCuspForms magma script,
+\\ and has grown since then.
+\\
+\\
+\\ Version history:
+\\
+\\ V2.2: Fixed a bug in localevaluate() pointed out by Fernando Gouvea:
+\\       s was used as a local variable but not declared as such.
+\\       (this did actually cause problems with another script, Tpprog.g,
+\\       which happened to use s for something else), 14/2/2002.
+\\
+\\ V2.1: minor tidying up and added a few \\ lines, 10/8/2001.
+\\
+\\ V2.0: severe tidying up, e.g. got rid of all the \s at end
+\\ of lines and used the { trick instead; used local() for local
+\\ variables instead of the old version, and so on, 9/8/2001.
+\\
+\\ V1.0, 26/7/00, just found it in the mess.
+\\
+\\ TODO: Optimise CohenOesterle2 and CohenOesterle3, currently they
+\\       are ridiculous. See the magma version.
+\\
+\\ Remarks: has a superugly way of storing Dirichlet characters.
+\\
+\\ Syntax for characters:
+\\
+\\ eps is [N, i x 3 matrix], where eps[2][,1] is the primes dividing
+\\ N, eps[2][,2] is the powers of these primes that divide N, and eps[2][,3]
+\\ is the following: for p odd, p^n||N, it's t such that znprimroot(p^n)
+\\ gets sent to exp(2*pi*i/phi(p^n))^t. And for p=2, it's
+\\ 0 for 2^1, it's 0 (trivial) or -1 (non-trivial) for 2^2, and for p^n>=8
+\\ it's either t>=0 for the even char sending 5 to exp(2*pi*i/p^(n-2))^t,
+\\ or t<=-1 for the odd char sending 5 to exp(2*pi*i/p^(n-2))^(-1-t).
+\\ (so either 0<=t<2^(n-2) or -1>=t>-1-2^(n-2) )
+
+\\ Examples of creation:
+\\
+\\ TrivialCharacter(100) creates the trivial character of level 100.
+\\ DirichletCharacter(45,[1,2]) creates the character of level 45
+\\ which is the product of the character of level 9 sending
+\\ znprimroot(9)=2 to exp(2*Pi*I/6)^1 and the character of level 5
+\\ sending znprimroot(5)=2 to exp(2*Pi*I/4)^2=-1.
+
+print("DimensionCuspForms(eps,k) computes the dimension of the space");
+print("of cusp forms of character eps and weight k (note that eps knows");
+print("its level!) The syntax for characters is rather complicated, see");
+print("the detailed remarks at the beginning of the source code for");
+print("more information.");
+
+
+nearestinteger(z)=
+{
+  if(abs(z-round(z))>10^(-10),
+    error("argument ",z," not near to an integer in nearestinteger()")
+  ,
+    real(round(z))
+  )
+}
+
+DimensionCuspForms(eps,k)=
+{
+  local(N=0);
+  if(k<=0,
+    0
+  ,
+    if(k==1,
+      error("Can't compute dimension of a space of cusp forms of weight one")
+    );
+
+    N=eps[1];
+    if(istrivial(eps),
+      S0(N,k)
+    ,
+      if(nearestinteger(evaluate(eps,N-1))!=(-1)^k,
+        0
+      ,
+        nearestinteger(idxG0(N)*(k-1)/12 \
+         +CohenOesterle1(eps,k)+CohenOesterle2(eps,k)+CohenOesterle3(eps,k))
+      )
+    )
+  )
+}
+
+DimensionModularForms(eps,k)=
+{
+  local(N=0);
+  if(k<=0,
+    0
+  ,
+    if(k==1,
+      error("Can't compute dimension of a space of modular
+       forms of weight one")
+    );
+    \\ k>=2
+
+    N=eps[1];
+    if(nearestinteger(evaluate(eps,N-1))!=(-1)^k,
+      0
+    ,
+      if(istrivial(eps),
+        S0(N,k)+c0(N)-(k==2)
+      ,
+        nearestinteger(idxG0(N)*(k-1)/12 \
+         -CohenOesterle1(eps,k)+CohenOesterle2(eps,k)+CohenOesterle3(eps,k) \
+         -(k==2))
+      )
+    )
+  )
+}
+
+CohenOesterle1(eps,k)=
+{
+  local(facN,f,facf);
+  facN=matrix(matsize(eps[2])[1],2,i,j,eps[2][i,j]);
+  f=charconductor(eps);
+  facf=facN;facf[,2]=vectorv(matsize(facN)[1],i,valuation(f,facN[i,1]));
+
+  (-1/2)*prod(i=1,matsize(facN)[1],lambda(facN[i,2],facf[i,2],facN[i,1]))
+}
+
+CohenOesterle2(eps,k)=
+{
+  local(N,gamma_k=0);
+  N=eps[1];
+  if(k%4==2,gamma_k=-1/4,if(k%4==0,gamma_k=1/4));
+  if(gamma_k==0,
+    0
+  ,
+    gamma_k*sum(i=0,N-1,if((i^2+1)%N==0,evaluate(eps,i),0))
+  )
+}
+
+CohenOesterle3(eps,k)=
+{
+  local(N,mu_k=0);
+  N=eps[1];
+  if(k%3==2,mu_k=-1/3,if(k%3==0,mu_k=1/3));
+  if(mu_k==0,
+    0
+  ,
+    mu_k*sum(i=0,N-1,if((i^2+i+1)%N==0,evaluate(eps,i),0))
+  )
+}
+
+lambda(r,s,p)=
+{
+  if(2*s<=r,
+    if(r%2==0,
+      p^(r\2)+p^((r\2)-1)
+    ,
+      2*p^((r-1)\2)
+    )
+  ,
+   2*p^(r-s)
+  )
+}
+
+evaluate(eps,n)=
+{
+  if(gcd(n,eps[1])>1,
+    0
+  ,
+    if(istrivial(eps),
+      1
+    ,
+      \\ main case here.
+      prod(i=1,matsize(eps[2])[1],localevaluate(eps[2][i,],n))
+    )
+  )
+}
+
+localevaluate(v,n)=
+{
+  local(p,e,s,t);
+  p=v[1];e=v[2];t=v[3];
+  if(p==2, \\ deal with 2 separately
+    if(e==1,
+      1
+    ,
+      s=if(n%4==1,1,-1);
+      if(t>=0,
+        exp(2*Pi*I/2^(e-2)*t*z2log(Mod(n*s,2^e)))
+      ,
+        s*exp(2*Pi*I/2^(e-2)*(-1-t)*z2log(Mod(n*s,2^e)))
+      )
+    )
+  ,
+    exp(2*Pi*I/(p-1)/p^(e-1)*t*znlog(n,znprimroot(p^e)))
+  )
+}
+
+charconductor(eps)=
+{
+  if(istrivial(eps),
+    1
+  ,
+    prod(i=1,matsize(eps[2])[1],localconductor(eps[2][i,]))
+  )
+}
+
+localconductor(v)=
+{
+  local(p,e,t,tp);
+  p=v[1];e=v[2];t=v[3];
+  if(p==2, \\ deal with this case first
+    if(e==1||t==0,
+      1
+    ,
+      if(e==2||t==-1,
+        4
+      ,
+        \\ p=2 and e>=3 and im(5) isn't trivial
+        tp=if(t>=0,t,-1-t); \\ 1<=tp<2^(e-2)
+        2^(e-valuation(tp,2))
+      )
+    )
+  ,
+  \\ p odd
+    if(t==0,
+      1
+    ,
+      p^(e-valuation(t,p))
+    )
+  )
+}
+
+z2log(t)=
+{
+  \\ This returns the 2-adic log of t.
+  if(padicprec(t,2)<3,
+    1
+  ,
+    truncate(log(lift(t)+O(2^padicprec(t,2)))/log(5+O(2^padicprec(t,2))))
+  )
+}
+
+idxG0(N)=
+{
+  local(facN);
+  facN=factor(N);
+  prod(i=1,matsize(facN)[1],facN[i,1]^facN[i,2]+facN[i,1]^(facN[i,2]-1))
+}
+
+istrivial(eps)=(eps[2][,3]==vectorv(matsize(eps[2])[1],i,0))
+
+TrivialCharacter(N)=
+{
+  local(facN);
+  facN=factor(N);
+
+  [N,matrix(matsize(facN)[1],3,i,j,if(j<3,facN[i,j],0))]
+}
+
+DirichletCharacter(N,v)=
+{
+  local(facN);
+  facN=factor(N);
+  [N,matrix(matsize(facN)[1],3,i,j,if(j<3,facN[i,j],v[i]))]
+}
+
+\\
+\\ Syntax for DirichletCharacter: takes (N,v) where N>0 is an integer
+\\ and v is a vector of length equal to the number of factors of N;
+\\ p_i will get assigned v[i]. Note that we *CAN* have factors
+\\ in a non-standard order. Equality of chars will be difficult but
+\\ who cares!
+
+charmult(chi1,chi2)=
+{
+  if(gcd(chi1[1],chi2[1])>1,
+    error("Too lazy to multiply Dirichlet characters together properly")
+  );
+
+  [chi1[1]*chi2[1],concat(chi1[2]~,chi2[2]~)~]
+}
+
+