passagemath-flint 10.5.42__cp311-cp311-macosx_14_0_arm64.whl → 10.6.1rc1__cp311-cp311-macosx_14_0_arm64.whl

sage/rings/number_field/number_field_element.pyx

@@ -889,6 +889,43 @@ cdef class NumberFieldElement(NumberFieldElement_base):
 
         EXAMPLES::
 
+            sage: x = polygen(ZZ, 'x')
+            sage: K.<a> = NumberField(x^3 - 2)
+            sage: a._random_element()  # random
+            -1/2*a^2 - 4
+            sage: K.<a> = NumberField(x^2 - 5)
+            sage: a._random_element()  # random
+            -1/48*a - 1/2
+
+        With denominator bound one, we always get integral elements::
+
+            sage: K = QuadraticField(2)
+            sage: uu = [K.random_element(den_bound=1) for _ in range(5)]
+            sage: uu  # random
+            [0, a + 2, -12*a - 2, -a + 1, -a - 2]
+            sage: all(u.is_integral() for u in uu)
+            True
+
+        Without this constraint, we do not always get them::
+
+            sage: K = QuadraticField(2)
+            sage: uu = [K.random_element() for _ in range(100)]
+            sage: all(u.is_integral() for u in uu)
+            False
+
+        Random integral elements can also be picked using the random_element
+        method of the number field's "ring of integers" or "maximal order" ::
+
+            sage: K = QuadraticField(2)
+            sage: O = K.maximal_order()
+            sage: O.random_element()  # random
+            5*a - 6
+            sage: O = K.ring_of_integers()
+            sage: O.random_element()  # random
+            -4*a + 1
+
+        TESTS::
+
             sage: x = polygen(ZZ, 'x')
             sage: K.<a> = NumberField(x^3 - 2)
             sage: a._random_element().parent() is K
@@ -5311,6 +5348,23 @@ cdef class OrderElement_absolute(NumberFieldElement_absolute):
         """
         return self._parent.number_field()(NumberFieldElement_absolute.__invert__(self))
 
+    def canonical_associate(self):
+        """
+        Return a canonical associate.
+
+        Only implemented here because order elements inherit from field elements,
+        but the canonical associate implemented there does not apply here.
+
+        EXAMPLES::
+
+            sage: x = polygen(ZZ, 'x')
+            sage: K = NumberField(x^3 - x + 2, 'a')
+            sage: OK = K.ring_of_integers()
+            sage: (OK.1).canonical_associate()
+            NotImplemented
+        """
+        return NotImplemented
+
 
 cdef class OrderElement_relative(NumberFieldElement_relative):
     """
@@ -5524,6 +5578,24 @@ cdef class OrderElement_relative(NumberFieldElement_relative):
         R = ZZ[var]
         return R(K(self).absolute_minpoly(var))
 
+    def canonical_associate(self):
+        """
+        Return a canonical associate.
+
+        Only implemented here because order elements inherit from
+        field elements, but the canonical associate implemented there
+        does not apply here.
+
+        EXAMPLES::
+
+            sage: x = ZZ['x'].0
+            sage: K.<a,b> = NumberField([x^2 + 1, x^2 - 3])
+            sage: OK = K.maximal_order()
+            sage: (OK.1).canonical_associate()
+            NotImplemented
+        """
+        return NotImplemented
+
 
 class CoordinateFunction():
     r"""

sage/rings/number_field/number_field_element_quadratic.pyx

@@ -420,7 +420,7 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         """
         Used for pickling.
 
-        TESTS:
+        TESTS::
 
             sage: x = polygen(ZZ, 'x')
             sage: K.<a> = NumberField(x^2 - 13)
@@ -438,6 +438,23 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         return __make_NumberFieldElement_quadratic1, (self._parent, type(self), a, b, denom)
 
     cdef int _randomize(self, num_bound, den_bound, distribution) except -1:
+        """
+        TESTS::
+
+            sage: a = ZZ.random_element(-100, 100)
+            sage: while a.is_square():
+            ....:     a = ZZ.random_element(-100, 100)
+            sage: K = QuadraticField(a)
+            sage: K.random_element().parent() is K  # indirect doctest
+            True
+            sage: len(set(K.random_element() for _ in range(100))) >= 40
+            True
+
+        Verify that :issue:`30017` is fixed::
+
+            sage: all(K.random_element().is_integral() for s in range(100))
+            False
+        """
         cdef Integer temp, denom1, denom2
 
         # in theory, we could just generate two random numerators and
@@ -448,17 +465,20 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
         # of the random element code, it's worth doing slightly more
         # work to make this possible.
 
-        # normalize denominator bound
-        if den_bound is None or den_bound < 1:
-            den_bound = 1
-
         # generate denominators
-        denom1 = <Integer>(ZZ.random_element(x=1,
-                                             y=den_bound+1,
-                                             distribution=distribution))
-        denom2 = <Integer>(ZZ.random_element(x=1,
-                                             y=den_bound+1,
-                                             distribution=distribution))
+        if den_bound is None:
+            denom1 = <Integer>(1 + abs(ZZ.random_element(distribution=distribution)))
+            denom2 = <Integer>(1 + abs(ZZ.random_element(distribution=distribution)))
+        else:
+            # normalize denominator bound
+            if den_bound < 1:
+                den_bound = 1
+            denom1 = <Integer>(ZZ.random_element(x=1,
+                                                 y=den_bound+1,
+                                                 distribution=distribution))
+            denom2 = <Integer>(ZZ.random_element(x=1,
+                                                 y=den_bound+1,
+                                                 distribution=distribution))
 
         # set a, b
         temp = <Integer>(ZZ.random_element(x=num_bound, distribution=distribution))
@@ -2383,8 +2403,6 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
 
         TESTS::
 
-            sage: import warnings
-            sage: warnings.filterwarnings("ignore", category=DeprecationWarning)
             sage: K2.<sqrt2> = QuadraticField(2)
             sage: K3.<sqrt3> = QuadraticField(3)
             sage: K5.<sqrt5> = QuadraticField(5)
@@ -2399,15 +2417,15 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute):
             ....:    assert round(a+b*sqrt(5.)) == round(a+b*sqrt5), (a, b)
         """
         n = self.floor()
-        test = 2 * (self - n).abs()
+        test = 2 * (self - n)
         if test < 1:
             return n
         elif test > 1:
             return n + 1
-        elif self > 0:
-            return n + 1
-        else:
+        elif n % 2 == 0:
             return n
+        else:
+            return n + 1
 
 
 cdef class NumberFieldElement_quadratic_sqrt(NumberFieldElement_quadratic):

sage/rings/number_field/number_field_morphisms.pyx

@@ -238,12 +238,12 @@ cdef class EmbeddedNumberFieldMorphism(NumberFieldEmbedding):
         """
         if ambient_field is None:
             if K.coerce_embedding() is None:
-                raise TypeError("No embedding available for %s"%K)
+                raise TypeError("No embedding available for %s" % K)
             Kemb = K
             while Kemb.coerce_embedding() is not None:
                 Kemb = Kemb.coerce_embedding().codomain()
             if L.coerce_embedding() is None:
-                raise TypeError("No embedding available for %s"%L)
+                raise TypeError("No embedding available for %s" % L)
             Lemb = L
             while Lemb.coerce_embedding() is not None:
                 Lemb = Lemb.coerce_embedding().codomain()

sage/rings/number_field/number_field_rel.py

@@ -40,7 +40,7 @@ We do some arithmetic in a tower of relative number fields::
     sage: a.parent()
     Number Field in sqrt2 with defining polynomial x^2 - 2 over its base field
 
-.. WARNING:
+.. WARNING::
 
     Doing arithmetic in towers of relative fields that depends on canonical
     coercions is currently VERY SLOW.  It is much better to explicitly coerce

sage/rings/number_field/order.py

@@ -79,6 +79,7 @@ AUTHORS:
 # ****************************************************************************
 
 from sage.categories.integral_domains import IntegralDomains
+from sage.categories.noetherian_rings import NoetherianRings
 from sage.misc.cachefunc import cached_method
 from sage.structure.parent import Parent
 from sage.structure.sequence import Sequence
@@ -458,6 +459,16 @@ class Order(Parent, sage.rings.abc.Order):
         Traceback (most recent call last):
         ...
         ValueError: the rank of the span of gens is wrong
+
+    Orders are always Noetherian::
+
+        sage: x = polygen(ZZ, 'x')
+        sage: L.<alpha> = NumberField(x**4 - x**2 + 7)
+        sage: O = L.maximal_order() ; O.is_noetherian()
+        True
+        sage: E.<w> = NumberField(x^2 - x + 2)
+        sage: OE = E.ring_of_integers(); OE.is_noetherian()
+        True
     """
 
     def __init__(self, K):
@@ -480,8 +491,9 @@ class Order(Parent, sage.rings.abc.Order):
             0.0535229072603327 + 1.20934552493846*I
         """
         self._K = K
+        cat = IntegralDomains() & NoetherianRings()
         Parent.__init__(self, base=ZZ, names=K.variable_names(),
-                        normalize=False, category=IntegralDomains())
+                        normalize=False, category=cat)
         self._populate_coercion_lists_(embedding=self.number_field())
         if self.absolute_degree() == 2:
             self.is_maximal()       # cache
@@ -616,22 +628,6 @@ class Order(Parent, sage.rings.abc.Order):
         """
         return False
 
-    def is_noetherian(self):
-        r"""
-        Return ``True`` (because orders are always Noetherian).
-
-        EXAMPLES::
-
-            sage: x = polygen(ZZ, 'x')
-            sage: L.<alpha> = NumberField(x**4 - x**2 + 7)
-            sage: O = L.maximal_order() ; O.is_noetherian()
-            True
-            sage: E.<w> = NumberField(x^2 - x + 2)
-            sage: OE = E.ring_of_integers(); OE.is_noetherian()
-            True
-        """
-        return True
-
     def is_integrally_closed(self) -> bool:
         r"""
         Return whether this ring is integrally closed.
@@ -823,7 +819,7 @@ class Order(Parent, sage.rings.abc.Order):
             from sage.matrix.constructor import Matrix
             self.__basis_matrix_inverse = Matrix([to_V(b) for b in self.basis()]).inverse()
             M = self.__basis_matrix_inverse
-        return to_V(K(x))*M
+        return to_V(K(x)) * M
 
     def free_module(self):
         r"""
@@ -1376,7 +1372,8 @@ class Order(Parent, sage.rings.abc.Order):
             sage: A.random_element().parent() is A
             True
         """
-        return sum([ZZ.random_element(*args, **kwds)*a for a in self.basis()])
+        return sum([ZZ.random_element(*args, **kwds) * a
+                    for a in self.basis()])
 
     def absolute_degree(self):
         r"""
@@ -1494,41 +1491,41 @@ class Order(Parent, sage.rings.abc.Order):
                 elements.append(self(a))
         return elements
 
-##     def absolute_polynomial(self):
-##         """
-##         Return the absolute polynomial of this order, which is just the absolute polynomial of the number field.
+#     def absolute_polynomial(self):
+#         """
+#         Return the absolute polynomial of this order, which is just the absolute polynomial of the number field.
 
-##         EXAMPLES::
+#         EXAMPLES::
 
-##         sage: K.<a, b> = NumberField([x^2 + 1, x^3 + x + 1]); OK = K.maximal_order()
-##         Traceback (most recent call last):
-##         ...
-##         NotImplementedError
+#         sage: K.<a, b> = NumberField([x^2 + 1, x^3 + x + 1]); OK = K.maximal_order()
+#         Traceback (most recent call last):
+#         ...
+#         NotImplementedError
 
-##         #sage: OK.absolute_polynomial()
-##         #x^6 + 5*x^4 - 2*x^3 + 4*x^2 + 4*x + 1
-##         """
-##         return self.number_field().absolute_polynomial()
+#         #sage: OK.absolute_polynomial()
+#         #x^6 + 5*x^4 - 2*x^3 + 4*x^2 + 4*x + 1
+#         """
+#         return self.number_field().absolute_polynomial()
 
-##     def polynomial(self):
-##         """
-##         Return the polynomial defining the number field that contains self.
-##         """
-##         return self.number_field().polynomial()
+#     def polynomial(self):
+#         """
+#         Return the polynomial defining the number field that contains self.
+#         """
+#         return self.number_field().polynomial()
 
-##     def polynomial_ntl(self):
-##         """
-##         Return defining polynomial of the parent number field as a
-##         pair, an ntl polynomial and a denominator.
+#     def polynomial_ntl(self):
+#         """
+#         Return defining polynomial of the parent number field as a
+#         pair, an ntl polynomial and a denominator.
 
-##         This is used mainly to implement some internal arithmetic.
+#         This is used mainly to implement some internal arithmetic.
 
-##         EXAMPLES::
+#         EXAMPLES::
 
-##             sage: NumberField(x^2 + 1,'a').maximal_order().polynomial_ntl()
-##             ([1 0 1], 1)
-##         """
-##         return self.number_field().polynomial_ntl()
+#             sage: NumberField(x^2 + 1,'a').maximal_order().polynomial_ntl()
+#             ([1 0 1], 1)
+#         """
+#         return self.number_field().polynomial_ntl()
 
 
 class Order_absolute(Order):
@@ -1605,7 +1602,7 @@ class Order_absolute(Order):
             3*a^2 + 2*a + 1
         """
         if isinstance(x, (tuple, list)):
-            x = sum(xi*gi for xi, gi in zip(x, self.gens()))
+            x = sum(xi * gi for xi, gi in zip(x, self.gens()))
         if not isinstance(x, Element) or x.parent() is not self._K:
             x = self._K(x)
         V, _, embedding = self._K.vector_space()

sage/rings/number_field/order_ideal.py

@@ -65,15 +65,13 @@ from sage.structure.richcmp import richcmp
 from sage.structure.sequence import Sequence
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
-from sage.arith.misc import gcd
-from sage.matrix.constructor import matrix
 from sage.modules.free_module_element import vector
 from sage.rings.polynomial.polynomial_ring import polygens
 from sage.rings.ideal import Ideal_generic
 
 import sage.rings.number_field.order
 
-#TODO I*u works when u lies in I.ring().number_field(), but u*I doesn't
+# TODO I*u works when u lies in I.ring().number_field(), but u*I doesn't
 
 
 def NumberFieldOrderIdeal(O, *args, **kwds):
@@ -779,9 +777,8 @@ def _random_for_testing():
     from sage.rings.number_field.number_field import QuadraticField
     from sage.arith.misc import primes
     from sage.rings.finite_rings.integer_mod_ring import Zmod
-    from sage.misc.misc_c import prod
     while True:
-        d = ZZ(choice((-1,+1)) * randrange(1,10**5))
+        d = ZZ(choice((-1, +1)) * randrange(1, 10**5))
         if not d.is_square():
             break
     K,t = QuadraticField(d).objgen()

sage/rings/polynomial/hilbert.pyx

@@ -132,7 +132,6 @@ cdef list quotient_by_var(list L, size_t index):
     Return the quotient of the ideal represented by ``L`` and the
     variable number ``index``.
     """
-    cdef ETuple m_j
     cdef list result = L[:len(L)] # creates a copy
     cdef size_t i
     for i in range(len(L)):
@@ -167,7 +166,6 @@ cdef bint HilbertBaseCase(Polynomial_integer_dense_flint fhs, Node D, tuple w) n
     Otherwiese, ``False`` is returned.
     """
     cdef size_t i, j, exp
-    cdef int e
     # First, the easiest cases:
     if not D.Id: # The zero ideal
         fmpz_poly_set_coeff_si(fhs._poly, 0, 1) # = PR(1)
@@ -228,7 +226,6 @@ cdef bint HilbertBaseCase(Polynomial_integer_dense_flint fhs, Node D, tuple w) n
 
     easy = True
     cdef ETuple m2
-    cdef list v
     for j in range(i+1, len(D.Id)):
         if (<ETuple>PyList_GET_ITEM(D.Id,j))._nonzero > 1:
             # i.e., another generator contains more than a single var
@@ -297,7 +294,7 @@ cdef make_children(Node D, tuple w):
     if ``D.Right`` is not ``None``.
     """
     cdef size_t j, m
-    cdef int i, ii
+    cdef int i
     # Determine the variable that appears most often in the monomials.
     # If "most often" means "only once", then instead we choose a variable that is
     # guaranteed to appear in a composed monomial.
@@ -491,9 +488,9 @@ def first_hilbert_series(I, grading=None, return_grading=False):
         br = S('basering')
         if S.eval('isQuotientRing(basering)')=='1':
             L = S('ringlist(basering)')
-            R = S('ring(list(%s[1..3],ideal(0)))'%L.name())
+            R = S('ring(list(%s[1..3],ideal(0)))' % L.name())
             R.set_ring()
-            I = S('fetch(%s,%s)+ideal(%s)'%(br.name(),I.name(),br.name()))
+            I = S('fetch(%s,%s)+ideal(%s)' % (br.name(), I.name(), br.name()))
 
         I = [ETuple([int(x) for x in S.eval('string(leadexp({}[{}]))'.format(I.name(), i)).split(',')])
               for i in range(1,int(S.eval('size({})'.format(I.name())))+1)]

sage/rings/polynomial/polynomial_integer_dense_flint.pyx

@@ -408,7 +408,6 @@ cdef class Polynomial_integer_dense_flint(Polynomial):
         cdef RealBall arb_a, arb_z
         cdef ComplexBall acb_a, acb_z
 
-        cdef unsigned long limbs
         cdef fmpz_t a_fmpz
         cdef fmpz_t z_fmpz
 
@@ -1648,16 +1647,15 @@ cdef class Polynomial_integer_dense_flint(Polynomial):
             sage: f = -30*x; f.factor()
             (-1) * 2 * 3 * 5 * x
         """
-        cdef int i
         cdef long deg = fmpz_poly_degree(self._poly)
         # it appears that pari has a window from about degrees 30 and 300
         # in which it beats NTL.
         c = self.content()
-        g = self//c
+        g = self // c
         if deg < 30 or deg > 300:
-            return c.factor()*g._factor_ntl()
+            return c.factor() * g._factor_ntl()
         else:
-            return c.factor()*g._factor_pari()
+            return c.factor() * g._factor_pari()
 
     def factor_mod(self, p):
         """

sage/rings/polynomial/polynomial_rational_flint.pxd

@@ -1,11 +1,11 @@
 # sage_setup: distribution = sagemath-flint
-###############################################################################
+# ############################################################################
 #          Copyright (C) 2010 Sebastian Pancratz <sfp@pancratz.org>           #
 #                                                                             #
 #     Distributed under the terms of the GNU General Public License (GPL)     #
 #                                                                             #
-#                        http://www.gnu.org/licenses/                         #
-###############################################################################
+#                        https://www.gnu.org/licenses/                        #
+# ############################################################################
 
 from sage.libs.flint.types cimport fmpq_poly_t
 

sage/rings/polynomial/polynomial_rational_flint.pyx

@@ -25,6 +25,7 @@ AUTHOR:
 
 from cysignals.signals cimport sig_on, sig_str, sig_off
 
+from libc.limits cimport LONG_MIN
 from cpython.long cimport PyLong_AsLong
 from sage.arith.long cimport pyobject_to_long
 
@@ -784,7 +785,7 @@ cdef class Polynomial_rational_flint(Polynomial):
     # Shifting                                                                #
     ###########################################################################
 
-    def __lshift__(self, n):
+    def __lshift__(self, long n):
         """
         Notationally multiply ``self`` by `t^n`.
 
@@ -797,27 +798,34 @@ cdef class Polynomial_rational_flint(Polynomial):
         TESTS::
 
             sage: R.<t> = QQ[]
+            sage: t << (-1)
+            1
+            sage: t << (-10)
+            0
             sage: f = R.random_element(1000)
             sage: (f << 23) >> 23 == f        # indirect doctest
             True
         """
-        cdef unsigned long k = <unsigned long> n
+        if n < 0:
+            assert n != LONG_MIN
+            return self >> (-n)
+
         cdef Polynomial_rational_flint f = <Polynomial_rational_flint> self
         cdef Polynomial_rational_flint res
         cdef bint do_sig
 
-        if k == 0 or fmpq_poly_is_zero(f._poly):
+        if n == 0 or fmpq_poly_is_zero(f._poly):
             return self
         else:
             res = f._new()
             do_sig = fmpq_poly_length(f._poly) > 5000 or n > 5000
 
             if do_sig: sig_str("FLINT exception")
-            fmpq_poly_shift_left(res._poly, f._poly, k)
+            fmpq_poly_shift_left(res._poly, f._poly, n)
             if do_sig: sig_off()
             return res
 
-    def __rshift__(self, n):
+    def __rshift__(self, long n):
         """
         Notationally return the quotient of Euclidean division of ``self``
         by `t^n`.
@@ -828,20 +836,25 @@ cdef class Polynomial_rational_flint(Polynomial):
             sage: f = 1 + t + t^2/2 + t^3/3 + t^4/4
             sage: f >> 2
             1/4*t^2 + 1/3*t + 1/2
+            sage: f >> (-2)
+            1/4*t^6 + 1/3*t^5 + 1/2*t^4 + t^3 + t^2
         """
-        cdef unsigned long k = <unsigned long> n
+        if n < 0:
+            assert n != LONG_MIN
+            return self << (-n)
+
         cdef Polynomial_rational_flint f = <Polynomial_rational_flint> self
         cdef Polynomial_rational_flint res
         cdef bint do_sig
 
-        if k == 0 or fmpq_poly_is_zero(f._poly):
+        if n == 0 or fmpq_poly_is_zero(f._poly):
             return self
         else:
             res = f._new()
             do_sig = _do_sig(f._poly)
 
             if do_sig: sig_str("FLINT exception")
-            fmpq_poly_shift_right(res._poly, f._poly, k)
+            fmpq_poly_shift_right(res._poly, f._poly, n)
             if do_sig: sig_off()
             return res
 
@@ -2218,9 +2231,9 @@ cdef class Polynomial_rational_flint(Polynomial):
                 from sage.groups.perm_gps.permgroup_named import TransitiveGroup
                 kash.eval('X := PolynomialRing(RationalField()).1')
                 s = self._repr(name='X')
-                G = kash('Galois(%s)'%s)
-                d = int(kash.eval('%s.ext1'%G.name()))
-                n = int(kash.eval('%s.ext2'%G.name()))
+                G = kash('Galois(%s)' % s)
+                d = int(kash.eval('%s.ext1' % G.name()))
+                n = int(kash.eval('%s.ext2' % G.name()))
                 return TransitiveGroup(d, n)
             except RuntimeError as msg:
                 raise NotImplementedError(str(msg) + "\nSorry, " +

sage/rings/polynomial/polynomial_zmod_flint.pyx

@@ -191,7 +191,6 @@ cdef class Polynomial_zmod_flint(Polynomial_template):
         """
         cdef list l_in = x
         cdef unsigned long length = len(l_in)
-        cdef unsigned long modulus = nmod_poly_modulus(&self.x)
         cdef int i
         if length == 0:
             nmod_poly_zero(&self.x)
@@ -409,9 +408,9 @@ cdef class Polynomial_zmod_flint(Polynomial_template):
         n = int(n)
         value = self.base_ring()(value)
         if n >= 0:
-            nmod_poly_set_coeff_ui(&self.x, n, int(value)%nmod_poly_modulus(&self.x))
+            nmod_poly_set_coeff_ui(&self.x, n, int(value) % nmod_poly_modulus(&self.x))
         else:
-            raise IndexError("Polynomial coefficient index must be nonnegative.")
+            raise IndexError("polynomial coefficient index must be nonnegative")
 
     cpdef Polynomial _mul_trunc_(self, Polynomial right, long n):
         """
@@ -645,7 +644,7 @@ cdef class Polynomial_zmod_flint(Polynomial_template):
         cdef Polynomial_zmod_flint s0 = self._new()
         cdef Polynomial_zmod_flint t0 = P.one()
         cdef Polynomial_zmod_flint s1 = m
-        cdef Polynomial_zmod_flint t1 = self%m
+        cdef Polynomial_zmod_flint t1 = self % m
 
         cdef Polynomial_zmod_flint q
         cdef Polynomial_zmod_flint r0

sage/rings/polynomial/real_roots.pyx

@@ -3751,7 +3751,7 @@ cdef class island:
 
         return self.known_done
 
-    def has_root(self):
+    def has_root(self) -> bool:
         """
         Assuming that the island is done (has either 0 or 1 roots),
         reports whether the island has a root.

sage/rings/polynomial/weil/weil_polynomials.pyx

@@ -299,7 +299,7 @@ class WeilPolynomials_iter():
             k = Integer(k)
             if len(modlist) == 0 and k != 0:
                 raise ValueError("Leading coefficient must be specified exactly")
-            if len(modlist) > 0 and ((k != 0 and modlist[-1]%k != 0) or (k == 0 and modlist[-1] != 0)):
+            if modlist and ((k != 0 and modlist[-1] % k != 0) or (k == 0 and modlist[-1] != 0)):
                 raise ValueError("Invalid moduli")
             coefflist.append(j)
             modlist.append(k)