passagemath-schemes 10.5.48__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.47__cp312-cp312-musllinux_1_2_aarch64.whl

sage/modular/multiple_zeta.py

@@ -421,7 +421,7 @@ class MultizetaValues(Singleton):
         sage: parent(M((2,3,4,5), prec=128))
         Real Field with 128 bits of precision
     """
-    def __init__(self):
+    def __init__(self) -> None:
         """
         When first called, pre-compute up to weight 8 at precision 1024.
 
@@ -444,7 +444,7 @@ class MultizetaValues(Singleton):
         """
         return f"Cached multiple zeta values at precision {self.prec} up to weight {self.max_weight}"
 
-    def reset(self, max_weight=8, prec=1024):
+    def reset(self, max_weight=8, prec=1024) -> None:
         r"""
         Reset the cache to its default values or to given arguments.
 
@@ -465,7 +465,7 @@ class MultizetaValues(Singleton):
         self.max_weight = int(max_weight)
         self._data = pari.zetamultall(self.max_weight, precision=self.prec)
 
-    def update(self, max_weight, prec):
+    def update(self, max_weight, prec) -> None:
         """
         Compute and store more values if needed.
 
@@ -551,7 +551,7 @@ class MultizetaValues(Singleton):
 Values = MultizetaValues()
 
 
-def extend_multiplicative_basis(B, n) -> Iterator:
+def extend_multiplicative_basis(B, n) -> Iterator[tuple]:
     """
     Extend a multiplicative basis into a basis.
 
@@ -648,7 +648,7 @@ class Multizetas(CombinatorialFreeModule):
         sage: z
         ζ(1,2,3)
     """
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         """
         TESTS::
 
@@ -727,7 +727,7 @@ class Multizetas(CombinatorialFreeModule):
         """
         return self([]), self([2]), self([3]), self([4]), self((1, 2))
 
-    def an_element(self):
+    def _an_element_(self):
         r"""
         Return an element of the algebra.
 
@@ -1254,7 +1254,7 @@ class Multizetas(CombinatorialFreeModule):
                 raise TypeError('invalid comparison for multizetas')
             return self.iterated()._richcmp_(other.iterated(), op)
 
-        def __hash__(self):
+        def __hash__(self) -> int:
             """
             Return the hash of ``self``.
 
@@ -1405,7 +1405,7 @@ class Multizetas_iterated(CombinatorialFreeModule):
         sage: M((1,0))*M((1,0,0))
         6*I(11000) + 3*I(10100) + I(10010)
     """
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         """
         TESTS::
 
@@ -1804,16 +1804,14 @@ class Multizetas_iterated(CombinatorialFreeModule):
         compo = tuple(iterated_to_composition(w))
         if compo in B_data[N]:
             # do not forget the sign
-            result_QQ = (-1)**len(compo) * phi_on_multiplicative_basis(compo)
-            return result_QQ
+            return (-1)**len(compo) * phi_on_multiplicative_basis(compo)
         u = compute_u_on_basis(w)
         rho_inverse_u = rho_inverse(u)
         xi = self.composition_on_basis(w, QQ)
         c_xi = (xi - rho_inverse_u)._numerical_approx_pari()
         c_xi /= Multizeta(N)._numerical_approx_pari()
         c_xi = c_xi.bestappr().sage()  # in QQ
-        result_QQ = u + c_xi * f(N)
-        return result_QQ
+        return u + c_xi * f(N)
 
     @lazy_attribute
     def phi(self):
@@ -2068,7 +2066,7 @@ class All_iterated(CombinatorialFreeModule):
         sage: x.regularise()
         -I(10)
     """
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         """
         TESTS::
 

sage/modular/multiple_zeta_F_algebra.py

@@ -234,9 +234,7 @@ def morphism_constructor(data: dict, start=3):
             v = codomain.half_product(data[letter], v)
         return v
 
-    morphism = domain._module_morphism(morphism_on_basis, codomain=codomain)
-
-    return morphism
+    return domain._module_morphism(morphism_on_basis, codomain=codomain)
 
 
 class F_algebra(CombinatorialFreeModule):
@@ -267,7 +265,7 @@ class F_algebra(CombinatorialFreeModule):
         sage: s = f2*f3+f5; s
         f5 + f2*f3
     """
-    def __init__(self, R, start=3):
+    def __init__(self, R, start=3) -> None:
         r"""
         Initialize ``self``.
 
@@ -461,7 +459,7 @@ class F_algebra(CombinatorialFreeModule):
         B *= ZZ(2)**(3 * i - 1) * ZZ(3)**i / ZZ(2 * i).factorial()
         return B * f2**i
 
-    def an_element(self):
+    def _an_element_(self):
         """
         Return a typical element.
 
@@ -474,7 +472,7 @@ class F_algebra(CombinatorialFreeModule):
         """
         return self("253") + 3 * self("235")
 
-    def some_elements(self):
+    def some_elements(self) -> list:
         """
         Return some typical elements.
 

sage/modular/overconvergent/genus0.py

@@ -195,6 +195,7 @@ classical) does not apply.
 #  Distributed under the terms of the GNU General Public License (GPL)
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from typing import Iterator
 
 import weakref
 
@@ -429,7 +430,7 @@ class OverconvergentModularFormsSpace(Module):
     # Boring functions that access internal data #
     ##############################################
 
-    def is_exact(self):
+    def is_exact(self) -> bool:
         r"""
         Return ``True`` if elements of this space are represented exactly.
 
@@ -694,7 +695,7 @@ class OverconvergentModularFormsSpace(Module):
         """
         return self._radius
 
-    def gens(self):
+    def gens(self) -> Iterator:
         r"""
         Return a generator object that iterates over the (infinite) set of
         basis vectors of ``self``.
@@ -1501,7 +1502,7 @@ class OverconvergentModularFormElement(ModuleElement):
         """
         return self.gexp().prec()
 
-    def is_eigenform(self):
+    def is_eigenform(self) -> bool:
         r"""
         Return ``True`` if this is an eigenform.
 
@@ -1668,7 +1669,7 @@ class OverconvergentModularFormElement(ModuleElement):
         self._eigenvalue = eigenvalue
         self._slope = eigenvalue.normalized_valuation()
 
-    def is_integral(self):
+    def is_integral(self) -> bool:
         r"""
         Test whether this element has `q`-expansion coefficients that are `p`-adically integral.
 

sage/modular/overconvergent/hecke_series.py

@@ -1050,7 +1050,7 @@ def level1_UpGj(p, klist, m, extra_data=False):
 # *** CODE FOR GENERAL LEVEL ***
 
 
-def is_valid_weight_list(klist, p):
+def is_valid_weight_list(klist, p) -> None:
     r"""
     This function checks that ``klist`` is a nonempty list of integers all of
     which are congruent modulo `(p-1)`. Otherwise, it will raise a
@@ -1078,7 +1078,7 @@ def is_valid_weight_list(klist, p):
     if len(klist) == 0:
         raise ValueError("List of weights must be non-empty")
     k0 = klist[0] % (p - 1)
-    for i in range(1,len(klist)):
+    for i in range(1, len(klist)):
         if (klist[i] % (p-1)) != k0:
             raise ValueError("List of weights must be all congruent modulo p-1 = %s, but given list contains %s and %s which are not congruent" % (p - 1, klist[0], klist[i]))
 

sage/modular/pollack_stevens/distributions.py

@@ -703,7 +703,7 @@ class Symk_class(OverconvergentDistributions_abstract):
             s += " twisted by %s" % self._character
         return s
 
-    def is_symk(self):
+    def is_symk(self) -> bool:
         """
         Whether or not this distributions space is `Sym^k(R)` for some ring `R`.
 
@@ -803,7 +803,7 @@ class OverconvergentDistributions_class(OverconvergentDistributions_abstract):
             s += " twistted by " + " * ".join(twiststuff)
         return s
 
-    def is_symk(self):
+    def is_symk(self) -> bool:
         """
         Whether or not this distributions space is `Sym^k(R)` for some ring `R`.
 

sage/modular/pollack_stevens/fund_domain.py

@@ -130,20 +130,16 @@ class PollackStevensModularDomain(SageObject):
         self._reps = reps
 
         self._indices = sorted(indices)
-        self._gens = [M2Z(reps[i]) for i in self._indices]
+        self._gens = tuple(M2Z(reps[i]) for i in self._indices)
         self._ngens = len(indices)
 
         if len(rels) != len(reps):
             raise ValueError("length of reps and length of rels must be equal")
         self._rels = rels
-        self._rel_dict = {}
-        for j, L in enumerate(rels):
-            self._rel_dict[reps[j]] = L
+        self._rel_dict = {reps[j]: L for j, L in enumerate(rels)}
 
         self._equiv_ind = equiv_ind
-        self._equiv_rep = {}
-        for ky in equiv_ind:
-            self._equiv_rep[ky] = reps[equiv_ind[ky]]
+        self._equiv_rep = {ky: reps[vy] for ky, vy in equiv_ind.items()}
 
     def _repr_(self):
         r"""
@@ -204,19 +200,19 @@ class PollackStevensModularDomain(SageObject):
         """
         return iter(self._reps)
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return the list of coset representatives chosen as generators.
+        Return the tuple of coset representatives chosen as generators.
 
         EXAMPLES::
 
             sage: from sage.modular.pollack_stevens.fund_domain import ManinRelations
             sage: A = ManinRelations(11)
             sage: A.gens()
-            [
+            (
             [1 0]  [ 0 -1]  [-1 -1]
             [0 1], [ 1  3], [ 3  2]
-            ]
+            )
         """
         return self._gens
 
@@ -1148,7 +1144,7 @@ class ManinRelations(PollackStevensModularDomain):
 
         # Initialize some lists
 
-        C = [QQ(-1), "?", QQ(0)]
+        C = [QQ(-1), "?", QQ.zero()]
 
         # Initialize the list of cusps at the bottom of the fund. domain.
         # The ? denotes that it has not yet been checked if more cusps need
@@ -1156,12 +1152,12 @@ class ManinRelations(PollackStevensModularDomain):
 
         full_domain = False     # Says that we are not done yet!
 
-        v = [False for r in range(sP)]
+        v = [False] * sP
         # This initializes a list indexed by P^1(Z/NZ) which keeps track of
         # which right coset representatives we've found for Gamma_0(N)/SL_2(Z)
         # thru the construction of a fundamental domain
 
-        # Includeds the coset repns formed by the original ideal triangle
+        # Includes the coset repns formed by the original ideal triangle
         # (with corners at -1, 0, infty)
 
         v[P.index(0, 1)] = True
@@ -1176,8 +1172,8 @@ class ManinRelations(PollackStevensModularDomain):
             # This loop runs through the current set of cusps
             # and checks to see if more cusps should be added
             # -----------------------------------------------
-            for s in range(1, len(C), 2):  # range over odd indices in the
-                                           # final list C
+            for s in range(1, len(C), 2):
+                # range over odd indices in the final list C
                 if C[s] == "?":
 
                     # Single out our two cusps (path from cusp2 to cusp1)
@@ -1193,9 +1189,9 @@ class ManinRelations(PollackStevensModularDomain):
                     # This is the point where it is determined whether
                     # or not the adjacent triangle should be added
                     # ------------------------------------------------
-                    pos = P.index(b2, b1)   # The Sage index of the bottom
-                                                 # row of our unimodular
-                                           # transformation gam
+                    pos = P.index(b2, b1)
+                    # The Sage index of the bottom row of our
+                    # unimodular transformation gam
 
                     # Check if we need to flip (since this P1 element has not
                     # yet been accounted for!)
@@ -1219,16 +1215,18 @@ class ManinRelations(PollackStevensModularDomain):
                             # where gam is the matrix corresponding to the
                             # unimodular path connecting cusp1 to cusp2
 
-                            C[s] = "i"  # The '?' is changed to an 'i'
-                             # indicating that a new cusp needs to
-                                        #  be inserted here
+                            C[s] = "i"
+                            # The '?' is changed to an 'i' indicating
+                            # that a new cusp needs to be inserted here
                             full_domain = False
                         else:
-                            C[s] = "x"  # The '?' is changed to an 'x' and no
-                                        # more checking below is needed! =)
+                            C[s] = "x"
+                            # The '?' is changed to an 'x' and no
+                            # more checking below is needed! =)
                     else:
-                        C[s] = "x"  # The '?' is changed to an 'x' and no more
-                                           # checking below is needed! =)
+                        C[s] = "x"
+                        # The '?' is changed to an 'x' and no more
+                        # checking below is needed! =)
 
             # Now insert the missing cusps (where there is an 'i' in
             # the final list)
@@ -1260,10 +1258,9 @@ class ManinRelations(PollackStevensModularDomain):
 
         # Remove the (now superfluous) extra string characters that appear
         # in the odd list entries
-        C = [QQ(C[ss]) for ss in range(0, len(C), 2)]
-        return C
+        return [QQ(C[ss]) for ss in range(0, len(C), 2)]
 
-    def is_unimodular_path(self, r1, r2):
+    def is_unimodular_path(self, r1, r2) -> bool:
         r"""
         Determine whether two (non-infinite) cusps are connected by a
         unimodular path.

sage/modular/pollack_stevens/manin_map.py

@@ -45,13 +45,19 @@ EXAMPLES::
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.rings.continued_fraction import convergents
-from .sigma0 import Sigma0
-from .fund_domain import t00, t10, t01, t11, M2Z
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
+
 from sage.matrix.matrix_space import MatrixSpace
+from sage.rings.continued_fraction import convergents
 from sage.rings.integer_ring import ZZ
 from sage.structure.element import coercion_model
 
+from .fund_domain import M2Z, t00, t01, t10, t11
+from .sigma0 import Sigma0
+
 
 def unimod_matrices_to_infty(r, s):
     r"""
@@ -317,13 +323,13 @@ class ManinMap:
             sage: from sage.modular.pollack_stevens.fund_domain import ManinRelations
             sage: S = Symk(0,QQ)
             sage: MR = ManinRelations(37); MR.gens()
-            [
+            (
             [1 0]  [ 0 -1]  [-1 -1]  [-1 -2]  [-2 -3]  [-3 -1]  [-1 -4]  [-4 -3]
             [0 1], [ 1  4], [ 4  3], [ 3  5], [ 5  7], [ 7  2], [ 2  7], [ 7  5],
             <BLANKLINE>
             [-2 -3]
             [ 3  4]
-            ]
+            )
 
             sage: data  = {M2Z([-2,-3,5,7]): S(0), M2Z([1,0,0,1]): S(0), M2Z([-1,-2,3,5]): S(0), M2Z([-1,-4,2,7]): S(1), M2Z([0,-1,1,4]): S(1), M2Z([-3,-1,7,2]): S(-1), M2Z([-2,-3,3,4]): S(0), M2Z([-4,-3,7,5]): S(0), M2Z([-1,-1,4,3]): S(0)}
             sage: D = OverconvergentDistributions(2, 37, 40)
@@ -356,13 +362,13 @@ class ManinMap:
             sage: from sage.modular.pollack_stevens.fund_domain import ManinRelations
             sage: S = Symk(0,QQ)
             sage: MR = ManinRelations(37); MR.gens()
-            [
+            (
             [1 0]  [ 0 -1]  [-1 -1]  [-1 -2]  [-2 -3]  [-3 -1]  [-1 -4]  [-4 -3]
             [0 1], [ 1  4], [ 4  3], [ 3  5], [ 5  7], [ 7  2], [ 2  7], [ 7  5],
             <BLANKLINE>
             [-2 -3]
             [ 3  4]
-            ]
+            )
 
             sage: data  = {M2Z([-2,-3,5,7]): S(0), M2Z([1,0,0,1]): S(0), M2Z([-1,-2,3,5]): S(0), M2Z([-1,-4,2,7]): S(1), M2Z([0,-1,1,4]): S(1), M2Z([-3,-1,7,2]): S(-1), M2Z([-2,-3,3,4]): S(0), M2Z([-4,-3,7,5]): S(0), M2Z([-1,-1,4,3]): S(0)}
             sage: f = ManinMap(S,MR,data)
@@ -692,7 +698,7 @@ class ManinMap:
             D[ky] = self(gamma * ky) * gamma
         return self.__class__(self._codomain, self._manin, D, check=False)
 
-    def normalize(self):
+    def normalize(self) -> Self:
         r"""
         Normalize every value of ``self`` -- e.g., reduce each value's
         `j`-th moment modulo `p^{N-j}`.
@@ -850,5 +856,4 @@ class ManinMap:
             # construction functor in order to scale by something
             # outside the base ring.
             D[g] = W(self._eval_sl2(g) - (self(pmat * g) * pmat).scale(scalar))
-        ans = self.__class__(W, manin, D, check=False)
-        return ans
+        return self.__class__(W, manin, D, check=False)

sage/modular/pollack_stevens/modsym.py

@@ -38,8 +38,12 @@ EXAMPLES::
 # *****************************************************************************
 
 import operator
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
 
-from sage.arith.misc import next_prime, gcd, kronecker
+from sage.arith.misc import gcd, kronecker, next_prime
 from sage.categories.action import Action
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import lazy_import
@@ -54,10 +58,9 @@ from sage.structure.richcmp import op_EQ, op_NE
 lazy_import('sage.rings.padics.factory', 'Qp')
 lazy_import('sage.rings.padics.padic_generic', 'pAdicGeneric')
 
+from .fund_domain import M2Z
 from .manin_map import ManinMap
 from .sigma0 import Sigma0
-from .fund_domain import M2Z
-
 
 minusproj = [1, 0, 0, -1]
 
@@ -108,13 +111,12 @@ def _iterate_Up(Phi, p, M, ap, q, aq, check):
     verbose("Iterating U_p", level=2)
     Psi = apinv * Phi.hecke(p)
 
-    for attempts in range(M-1):
+    for attempts in range(M - 1):
         verbose("%s attempt (val = %s/%s)" % (attempts + 1,(Phi-Psi).valuation(),M), level=2)
         Phi = Psi
         Psi = apinv * Phi.hecke(p)
         Psi._normalize()
-    Phi = ~(q ** (k + 1) + 1 - aq) * Phi
-    return Phi
+    return ~(q ** (k + 1) + 1 - aq) * Phi
 
 
 class PSModSymAction(Action):
@@ -234,7 +236,7 @@ class PSModularSymbolElement(ModuleElement):
         """
         return [self._map[g] for g in self.parent().source().gens()]
 
-    def _normalize(self, **kwds):
+    def _normalize(self, **kwds) -> Self:
         """
         Normalize all of the values of the symbol ``self``.
 
@@ -681,15 +683,15 @@ class PSModularSymbolElement(ModuleElement):
         #     aq.add_bigoh(M)
         return aq
 
-    def is_ordinary(self, p=None, P=None):
+    def is_ordinary(self, p=None, P=None) -> bool:
         r"""
-        Return true if the `p`-th eigenvalue is a `p`-adic unit.
+        Return ``True`` if the `p`-th eigenvalue is a `p`-adic unit.
 
         INPUT:
 
-        - ``p`` -- a positive integral prime, or None (default: ``None``)
-        - ``P`` -- a prime of the base ring above `p`, or None. This is ignored
-          unless the base ring is a number field
+        - ``p`` -- a positive integral prime, or ``None`` (default: ``None``)
+        - ``P`` -- a prime of the base ring above `p`, or ``None``.
+          This is ignored unless the base ring is a number field
 
         OUTPUT: boolean
 
@@ -827,11 +829,10 @@ class PSModularSymbolElement(ModuleElement):
             if not (g in MR.reps_with_two_torsion()
                     or g in MR.reps_with_three_torsion()):
                 t += f[g] * MR.gammas[g] - f[g]
+            elif g in MR.reps_with_two_torsion():
+                t -= f[g]
             else:
-                if g in MR.reps_with_two_torsion():
-                    t -= f[g]
-                else:
-                    t -= f[g]   # what ?? same thing ??
+                t -= f[g]   # what ?? same thing ??
 
         id = MR.gens()[0]
         if f[id] * MR.gammas[id] - f[id] != -t:
@@ -1102,8 +1103,7 @@ class PSModularSymbolElement_symk(PSModularSymbolElement):
             Dist = V.coefficient_module()
             psi = K.hom([K.gen()], L)
             embedded_sym = self.parent().element_class(self._map.apply(psi, codomain=Dist, to_moments=True), V, construct=True)
-            ans = [embedded_sym, psi]
-            return ans
+            return [embedded_sym, psi]
         else:
             roots = [r[0] for r in v]
             ans = []

sage/modular/quasimodform/element.py

@@ -53,9 +53,9 @@ class QuasiModularFormsElement(ModuleElement):
 
         sage: QM = QuasiModularForms(1)
         sage: QM.gens()
-        [1 - 24*q - 72*q^2 - 96*q^3 - 168*q^4 - 144*q^5 + O(q^6),
+        (1 - 24*q - 72*q^2 - 96*q^3 - 168*q^4 - 144*q^5 + O(q^6),
         1 + 240*q + 2160*q^2 + 6720*q^3 + 17520*q^4 + 30240*q^5 + O(q^6),
-        1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 + O(q^6)]
+        1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 + O(q^6))
         sage: QM.0 + QM.1
         2 + 216*q + 2088*q^2 + 6624*q^3 + 17352*q^4 + 30096*q^5 + O(q^6)
         sage: QM.0 * QM.1
@@ -340,7 +340,7 @@ class QuasiModularFormsElement(ModuleElement):
                              "homogeneous element")
         return self._polynomial.degree()
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         r"""
         Return whether the given quasimodular form is zero.
 
@@ -361,7 +361,7 @@ class QuasiModularFormsElement(ModuleElement):
         """
         return not self
 
-    def is_one(self):
+    def is_one(self) -> bool:
         r"""
         Return whether the given quasimodular form is 1, i.e. the
         multiplicative identity.
@@ -381,7 +381,7 @@ class QuasiModularFormsElement(ModuleElement):
         """
         return self._polynomial.is_one()
 
-    def is_graded_modular_form(self):
+    def is_graded_modular_form(self) -> bool:
         r"""
         Return whether the given quasimodular form is a
         graded modular form element
@@ -421,7 +421,7 @@ class QuasiModularFormsElement(ModuleElement):
         """
         return self._polynomial.degree() <= 0
 
-    def is_modular_form(self):
+    def is_modular_form(self) -> bool:
         r"""
         Return whether the given quasimodular form is a modular form.
 
@@ -483,10 +483,10 @@ class QuasiModularFormsElement(ModuleElement):
         E2 = poly_gens[0]
         poly_gens = poly_gens[1:]
         modform_poly_gens = self.parent().modular_forms_subring().polynomial_ring(names='x').gens()
-        subs_dictionnary = {}
+        subs_dictionary = {}
         for idx, g in enumerate(modform_poly_gens):
-            subs_dictionnary[g] = poly_gens[idx]
-        return sum(f.to_polynomial().subs(subs_dictionnary) * E2 ** exp for exp, f in enumerate(self._polynomial.coefficients(sparse=False)))
+            subs_dictionary[g] = poly_gens[idx]
+        return sum(f.to_polynomial().subs(subs_dictionary) * E2 ** exp for exp, f in enumerate(self._polynomial.coefficients(sparse=False)))
 
     to_polynomial = polynomial # alias
 
@@ -512,7 +512,7 @@ class QuasiModularFormsElement(ModuleElement):
         """
         return sorted(self.homogeneous_components().keys())
 
-    def is_homogeneous(self):
+    def is_homogeneous(self) -> bool:
         r"""
         Return whether the graded quasimodular form is a homogeneous element,
         that is, it lives in a unique graded components of the parent of