Add auto-reduction example to buchberger_naive. Reflow to 88 chars

Author: Jake-Moss

src/flint/types/fmpz_mpoly.pyx

@@ -934,16 +934,15 @@ cdef class fmpz_mpoly(flint_mpoly):
 
     def spoly(self, g):
         """
-        Compute the S-polynomial of `self` and `g`, scaled to an integer polynomial by computing the LCM of the
-        leading coefficients.
+        Compute the S-polynomial of `self` and `g`, scaled to an integer polynomial
+        by computing the LCM of the leading coefficients.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> f = ctx.from_dict({(2, 0): 1, (0, 1): -1})
             >>> g = ctx.from_dict({(3, 0): 1, (1, 0): -1})
             >>> f.spoly(g)
             -x*y + x
-
         """
         cdef fmpz_mpoly res = create_fmpz_mpoly(self.ctx)
 
@@ -956,8 +955,8 @@ cdef class fmpz_mpoly(flint_mpoly):
 
     def reduction_primitive_part(self, vec):
         """
-        Compute the the primitive part of the reduction (remainder of multivariate quasi-division with remainder)
-        with respect to the polynomials `vec`.
+        Compute the the primitive part of the reduction (remainder of multivariate
+        quasi-division with remainder) with respect to the polynomials `vec`.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
@@ -970,7 +969,6 @@ cdef class fmpz_mpoly(flint_mpoly):
             fmpz_mpoly_vec([x^2 + y^2 + 1, x*y - 2], ctx=fmpz_mpoly_ctx(2, '<Ordering.lex: 0>', ('x', 'y')))
             >>> f.reduction_primitive_part(vec)
             x - y^3
-
         """
         cdef fmpz_mpoly res = create_fmpz_mpoly(self.ctx)
         if not typecheck(vec, fmpz_mpoly_vec):
@@ -986,7 +984,9 @@ cdef class fmpz_mpoly_vec:
     A class representing a vector of fmpz_mpolys.
     """
 
-    def __cinit__(self, iterable_or_len, fmpz_mpoly_ctx ctx, bint double_indirect = False):
+    def __cinit__(
+            self, iterable_or_len, fmpz_mpoly_ctx ctx, bint double_indirect = False
+    ):
         if isinstance(iterable_or_len, int):
             length = iterable_or_len
         else:
@@ -996,7 +996,9 @@ cdef class fmpz_mpoly_vec:
         fmpz_mpoly_vec_init(self.val, length, self.ctx.val)
 
         if double_indirect:
-            self.double_indirect = <fmpz_mpoly_struct **> libc.stdlib.malloc(length * sizeof(fmpz_mpoly_struct *))
+            self.double_indirect = <fmpz_mpoly_struct **> libc.stdlib.malloc(
+                length * sizeof(fmpz_mpoly_struct *)
+            )
             if self.double_indirect is NULL:
                 raise MemoryError("malloc returned a null pointer")  # pragma: no cover
 
@@ -1034,7 +1036,9 @@ cdef class fmpz_mpoly_vec:
         elif (<fmpz_mpoly>y).ctx is not self.ctx:
             raise IncompatibleContextError(f"{(<fmpz_mpoly>y).ctx} is not {self.ctx}")
 
-        fmpz_mpoly_set(fmpz_mpoly_vec_entry(self.val, x), (<fmpz_mpoly>y).val, self.ctx.val)
+        fmpz_mpoly_set(
+            fmpz_mpoly_vec_entry(self.val, x), (<fmpz_mpoly>y).val, self.ctx.val
+        )
 
     def __len__(self):
         return self.val.length
@@ -1054,7 +1058,10 @@ cdef class fmpz_mpoly_vec:
         if not (op == Py_EQ or op == Py_NE):
             return NotImplemented
         elif typecheck(other, fmpz_mpoly_vec):
-            if (<fmpz_mpoly_vec>self).ctx is (<fmpz_mpoly_vec>other).ctx and len(self) == len(other):
+            if (
+                    (<fmpz_mpoly_vec>self).ctx is (<fmpz_mpoly_vec>other).ctx
+                    and len(self) == len(other)
+            ):
                 return (op == Py_NE) ^ all(x == y for x, y in zip(self, other))
             else:
                 return op == Py_NE
@@ -1066,7 +1073,8 @@ cdef class fmpz_mpoly_vec:
 
     def is_groebner(self, other=None) -> bool:
         """
-        Check if self is a Gröbner basis. If `other` is not None then check if self is a Gröbner basis for `other`.
+        Check if self is a Gröbner basis. If `other` is not None then check if self
+        is a Gröbner basis for `other`.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
@@ -1082,15 +1090,18 @@ cdef class fmpz_mpoly_vec:
             True
             >>> vec.is_groebner(fmpz_mpoly_vec([f, x**3], ctx))
             False
-
         """
         if other is None:
             return <bint>fmpz_mpoly_vec_is_groebner(self.val, NULL, self.ctx.val)
         elif typecheck(other, fmpz_mpoly_vec):
             self.ctx.compatible_context_check((<fmpz_mpoly_vec>other).ctx)
-            return <bint>fmpz_mpoly_vec_is_groebner(self.val, (<fmpz_mpoly_vec>other).val, self.ctx.val)
+            return <bint>fmpz_mpoly_vec_is_groebner(
+                self.val, (<fmpz_mpoly_vec>other).val, self.ctx.val
+            )
         else:
-            raise TypeError(f"expected either None or a fmpz_mpoly_vec, got {type(other)}")
+            raise TypeError(
+                f"expected either None or a fmpz_mpoly_vec, got {type(other)}"
+            )
 
     def is_autoreduced(self) -> bool:
         """
@@ -1115,8 +1126,9 @@ cdef class fmpz_mpoly_vec:
 
     def autoreduction(self, groebner=False) -> fmpz_mpoly_vec:
         """
-        Compute the autoreduction of `self`. If `groebner` is True and `self` is a Gröbner basis, compute the reduced
-        reduced Gröbner basis of `self`, throws an `RuntimeError` otherwise.
+        Compute the autoreduction of `self`. If `groebner` is True and `self` is a
+        Gröbner basis, compute the reduced reduced Gröbner basis of `self`, throws an
+        `RuntimeError` otherwise.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
@@ -1132,14 +1144,16 @@ cdef class fmpz_mpoly_vec:
             True
             >>> vec2
             fmpz_mpoly_vec([3*x^2 - y, x*y - x, y^2 - y], ctx=fmpz_mpoly_ctx(2, '<Ordering.lex: 0>', ('x', 'y')))
-
         """
 
         cdef fmpz_mpoly_vec h = fmpz_mpoly_vec(0, self.ctx)
 
         if groebner:
             if not self.is_groebner():
-                raise RuntimeError("reduced Gröbner basis construction requires that `self` is a Gröbner basis.")
+                raise RuntimeError(
+                    "reduced Gröbner basis construction requires that `self` is a "
+                    "Gröbner basis."
+                )
             fmpz_mpoly_vec_autoreduction_groebner(h.val, self.val, self.ctx.val)
         else:
             fmpz_mpoly_vec_autoreduction(h.val, self.val, self.ctx.val)
@@ -1148,18 +1162,22 @@ cdef class fmpz_mpoly_vec:
 
     def buchberger_naive(self, limits=None):
         """
-        Compute the Gröbner basis of `self` using a naive implementation of Buchberger’s algorithm.
-
-        Provide `limits` in the form of a tuple of `(ideal_len_limit, poly_len_limit, poly_bits_limit)` to halt
-        execution if the length of the ideal basis set exceeds `ideal_len_limit`, the length of any polynomial exceeds
-        `poly_len_limit`, or the size of the coefficients of any polynomial exceeds `poly_bits_limit`.
+        Compute the Gröbner basis of `self` using a naive implementation of
+        Buchberger’s algorithm.
 
-        If limits is provided return a tuple of `(result, success)`. If `success` is False then `result` is a valid
-        basis for `self`, but it may not be a Gröbner basis.
+        Provide `limits` in the form of a tuple of `(ideal_len_limit, poly_len_limit,
+        poly_bits_limit)` to halt execution if the length of the ideal basis set exceeds
+        `ideal_len_limit`, the length of any polynomial exceeds `poly_len_limit`, or the
+        size of the coefficients of any polynomial exceeds `poly_bits_limit`.
 
-        NOTE: This function is exposed only for convenience, it is a naive implementation and does not compute a reduced
+        If limits is provided return a tuple of `(result, success)`. If `success` is
+        False then `result` is a valid basis for `self`, but it may not be a Gröbner
         basis.
 
+        NOTE: This function is exposed only for convenience, it is a naive
+        implementation and does not compute a reduced basis. To construct a reduced
+        basis use `autoreduce`.
+
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
@@ -1168,10 +1186,15 @@ cdef class fmpz_mpoly_vec:
             >>> vec = fmpz_mpoly_vec([f, g], ctx)
             >>> vec.is_groebner()
             False
-            >>> vec.buchberger_naive()
+            >>> vec2 = vec.buchberger_naive()
+            >>> vec2
             fmpz_mpoly_vec([x^2 - y, x^3*y - x, x*y^2 - x, y^3 - y], ctx=fmpz_mpoly_ctx(2, '<Ordering.lex: 0>', ('x', 'y')))
             >>> vec.buchberger_naive(limits=(2, 2, 512))
             (fmpz_mpoly_vec([x^2 - y, x^3*y - x], ctx=fmpz_mpoly_ctx(2, '<Ordering.lex: 0>', ('x', 'y'))), False)
+            >>> vec2.is_autoreduced()
+            False
+            >>> vec2.autoreduction()
+            fmpz_mpoly_vec([x^2 - y, y^3 - y, x*y^2 - x], ctx=fmpz_mpoly_ctx(2, '<Ordering.lex: 0>', ('x', 'y')))
         """
 
         cdef:
@@ -1180,7 +1203,14 @@ cdef class fmpz_mpoly_vec:
 
         if limits is not None:
             ideal_len_limit, poly_len_limit, poly_bits_limit = limits
-            if fmpz_mpoly_buchberger_naive_with_limits(g.val, self.val, ideal_len_limit, poly_len_limit, poly_bits_limit, self.ctx.val):
+            if fmpz_mpoly_buchberger_naive_with_limits(
+                    g.val,
+                    self.val,
+                    ideal_len_limit,
+                    poly_len_limit,
+                    poly_bits_limit,
+                    self.ctx.val
+            ):
                 return g, True
             else:
                 return g, False