Fix mpoly.deflation, fix invariant tests

Author: Jake-Moss

src/flint/test/test_all.py

@@ -3241,21 +3241,26 @@ def quick_poly():
 
         f1 = 3*x0**2*x1**2 + 6*x0*x1**2 + 9*x1**2
         res, stride = f1.deflation()
-        assert res == 3*x0**2 + 6*x0 + 9
-        assert tuple(stride) == (1, 0)
+        assert res == 3*x0**2*x1 + 6*x0*x1 + 9*x1
+        assert tuple(stride) == (1, 2)
 
         g1 = ((x0**2 + x1**2)**3 + (x0**2 + x1**2)**2 + 1)
         res, stride = g1.deflation()
         assert res == x0**3 + 3*x0**2*x1 + x0**2 + 3*x0*x1**2 + 2*x0*x1 + x1**3 + x1**2 + 1
         assert tuple(stride) == (2, 2)
 
         for p in [f1, g1]:
-            n, m = p.deflation_monom()
-            assert m * p.deflate(n).inflate(n) == p
+            pd, n = p.deflation()
+            assert pd.inflate(n) == p
+            assert p.deflate(n).inflate(n) == p
 
-            n, i = p.deflation_index()
-            m = ctx.term(exp_vec=i)
-            assert p.deflate(n).inflate(n) * m == p
+            pd, n, m = p.deflation_monom()
+            assert m * pd.inflate(n) == p
+
+            if not composite_characteristic:
+                n, i = p.deflation_index()
+                m = ctx.term(exp_vec=i)
+                assert (p / m).deflate(n).inflate(n) * m == p
 
         if P is flint.fmpz_mpoly:
             assert (x0**2 * x1 + x0 * x1).primitive() == (1, x0**2*x1 + x0*x1)

src/flint/types/fmpq_mpoly.pyx

@@ -1058,25 +1058,31 @@ cdef class fmpq_mpoly(flint_mpoly):
             >>> from flint import Ordering
             >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
-            >>> f = x**3 * y + x * y**4 + x * y
+            >>> f = x**2 * y**2 + x * y**2
             >>> q, N = f.deflation()
             >>> q, N
-            (x + y + 1, [2, 3])
+            (x^2*y + x*y, [1, 2])
+            >>> q.inflate(N) == f
+            True
         """
         cdef:
-            fmpz_vec _shift = fmpz_vec(self.ctx.nvars())
-            fmpz_vec stride = fmpz_vec(self.ctx.nvars())
+            slong nvars = self.ctx.nvars()
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
             fmpq_mpoly res = create_fmpq_mpoly(self.ctx)
 
-        fmpz_mpoly_deflation(_shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx)
+        fmpz_mpoly_deflation(shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx)
+
+        for i in range(nvars):
+            stride[i] = shift[i].gcd(stride[i])
+            shift[i] = 0
 
-        cdef fmpz_vec zero_shift = fmpz_vec(self.ctx.nvars())
-        fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, zero_shift.val, stride.val, self.ctx.val.zctx)
+        fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx)
         fmpq_set(res.val.content, self.val.content)
 
         return res, list(stride)
 
-    def deflation_monom(self) -> tuple[list[int], fmpq_mpoly]:
+    def deflation_monom(self) -> tuple[fmpq_mpoly, list[int], fmpq_mpoly]:
         """
         Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N))
         = m * q(X^N)`` for maximal N. Importantly the deflation itself is not computed
@@ -1086,21 +1092,25 @@ cdef class fmpq_mpoly(flint_mpoly):
             >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
             >>> f = x**3 * y + x * y**4 + x * y
-            >>> N, m = f.deflation_monom()
-            >>> N, m
-            ([2, 3], x*y)
-            >>> f_deflated = f.deflate(N)
-            >>> f_deflated
-            x + y + 1
-            >>> m * f_deflated.inflate(N)
+            >>> fd, N, m = f.deflation_monom()
+            >>> fd, N, m
+            (x + y + 1, [2, 3], x*y)
+            >>> m * fd.inflate(N)
             x^3*y + x*y^4 + x*y
         """
-        cdef fmpq_mpoly monom = create_fmpq_mpoly(self.ctx)
+        cdef:
+            slong nvars = self.ctx.nvars()
+            fmpq_mpoly res = create_fmpq_mpoly(self.ctx)
+            fmpq_mpoly monom = create_fmpq_mpoly(self.ctx)
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
 
-        stride, _shift = self.deflation_index()
+        fmpz_mpoly_deflation(shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx)
+        fmpq_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val)
+        fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx)
+        fmpq_set(res.val.content, self.val.content)
 
-        fmpq_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(_shift).val, self.ctx.val)
-        return list(stride), monom
+        return res, list(stride), monom
 
     def deflation_index(self) -> tuple[list[int], list[int]]:
         """

src/flint/types/fmpz_mod_mpoly.pyx

@@ -1137,24 +1137,30 @@ cdef class fmpz_mod_mpoly(flint_mpoly):
             >>> from flint import Ordering
             >>> ctx = fmpz_mod_mpoly_ctx.get_context(2, Ordering.lex, 11, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
-            >>> f = x**3 * y + x * y**4 + x * y
+            >>> f = x**2 * y**2 + x * y**2
             >>> q, N = f.deflation()
             >>> q, N
-            (x + y + 1, [2, 3])
+            (x^2*y + x*y, [1, 2])
+            >>> q.inflate(N) == f
+            True
         """
         cdef:
-            fmpz_vec _shift = fmpz_vec(self.ctx.nvars())
-            fmpz_vec stride = fmpz_vec(self.ctx.nvars())
+            slong nvars = self.ctx.nvars()
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
             fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx)
 
-        fmpz_mod_mpoly_deflation(_shift.val, stride.val, self.val, self.ctx.val)
+        fmpz_mod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+
+        for i in range(nvars):
+            stride[i] = shift[i].gcd(stride[i])
+            shift[i] = 0
 
-        cdef fmpz_vec zero_shift = fmpz_vec(self.ctx.nvars())
-        fmpz_mod_mpoly_deflate(res.val, self.val, zero_shift.val, stride.val, self.ctx.val)
+        fmpz_mod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
         return res, list(stride)
 
-    def deflation_monom(self) -> tuple[list[int], fmpz_mod_mpoly]:
+    def deflation_monom(self) -> tuple[fmpz_mod_mpoly, list[int], fmpz_mod_mpoly]:
         """
         Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N))
         = m * q(X^N)`` for maximal N. Importantly the deflation itself is not computed
@@ -1164,21 +1170,24 @@ cdef class fmpz_mod_mpoly(flint_mpoly):
             >>> ctx = fmpz_mod_mpoly_ctx.get_context(2, Ordering.lex, 11, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
             >>> f = x**3 * y + x * y**4 + x * y
-            >>> N, m = f.deflation_monom()
-            >>> N, m
-            ([2, 3], x*y)
-            >>> f_deflated = f.deflate(N)
-            >>> f_deflated
-            x + y + 1
-            >>> m * f_deflated.inflate(N)
+            >>> fd, N, m = f.deflation_monom()
+            >>> fd, N, m
+            (x + y + 1, [2, 3], x*y)
+            >>> m * fd.inflate(N)
             x^3*y + x*y^4 + x*y
         """
-        cdef fmpz_mod_mpoly monom = create_fmpz_mod_mpoly(self.ctx)
+        cdef:
+            slong nvars = self.ctx.nvars()
+            fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx)
+            fmpz_mod_mpoly monom = create_fmpz_mod_mpoly(self.ctx)
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
 
-        stride, _shift = self.deflation_index()
+        fmpz_mod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+        fmpz_mod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val)
+        fmpz_mod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
-        fmpz_mod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(_shift).val, self.ctx.val)
-        return list(stride), monom
+        return res, list(stride), monom
 
     def deflation_index(self) -> tuple[list[int], list[int]]:
         """

src/flint/types/fmpz_mpoly.pyx

@@ -1156,24 +1156,30 @@ cdef class fmpz_mpoly(flint_mpoly):
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
-            >>> f = x**3 * y + x * y**4 + x * y
+            >>> f = x**2 * y**2 + x * y**2
             >>> q, N = f.deflation()
             >>> q, N
-            (x + y + 1, [2, 3])
+            (x^2*y + x*y, [1, 2])
+            >>> q.inflate(N) == f
+            True
         """
         cdef:
-            fmpz_vec _shift = fmpz_vec(self.ctx.nvars())
-            fmpz_vec stride = fmpz_vec(self.ctx.nvars())
+            slong nvars = self.ctx.nvars()
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
             fmpz_mpoly res = create_fmpz_mpoly(self.ctx)
 
-        fmpz_mpoly_deflation(_shift.val, stride.val, self.val, self.ctx.val)
+        fmpz_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+
+        for i in range(nvars):
+            stride[i] = shift[i].gcd(stride[i])
+            shift[i] = 0
 
-        cdef fmpz_vec zero_shift = fmpz_vec(self.ctx.nvars())
-        fmpz_mpoly_deflate(res.val, self.val, zero_shift.val, stride.val, self.ctx.val)
+        fmpz_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
         return res, list(stride)
 
-    def deflation_monom(self) -> tuple[list[int], fmpz_mpoly]:
+    def deflation_monom(self) -> tuple[fmpz_mpoly, list[int], fmpz_mpoly]:
         """
         Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N))
         = m * q(X^N)`` for maximal N. Importantly the deflation itself is not computed
@@ -1183,21 +1189,24 @@ cdef class fmpz_mpoly(flint_mpoly):
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
             >>> f = x**3 * y + x * y**4 + x * y
-            >>> N, m = f.deflation_monom()
-            >>> N, m
-            ([2, 3], x*y)
-            >>> f_deflated = f.deflate(N)
-            >>> f_deflated
-            x + y + 1
-            >>> m * f_deflated.inflate(N)
+            >>> fd, N, m = f.deflation_monom()
+            >>> fd, N, m
+            (x + y + 1, [2, 3], x*y)
+            >>> m * fd.inflate(N)
             x^3*y + x*y^4 + x*y
         """
-        cdef fmpz_mpoly monom = create_fmpz_mpoly(self.ctx)
+        cdef:
+            slong nvars = self.ctx.nvars()
+            fmpz_mpoly res = create_fmpz_mpoly(self.ctx)
+            fmpz_mpoly monom = create_fmpz_mpoly(self.ctx)
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
 
-        stride, _shift = self.deflation_index()
+        fmpz_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+        fmpz_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val)
+        fmpz_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
-        fmpz_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(_shift).val, self.ctx.val)
-        return list(stride), monom
+        return res, list(stride), monom
 
     def deflation_index(self) -> tuple[list[int], list[int]]:
         """

src/flint/types/fmpz_poly.pyx

@@ -630,8 +630,11 @@ cdef class fmpz_poly(flint_poly):
         n. returns ``q, n`` such that ``self == q.inflate(n)``.
 
             >>> f = fmpz_poly([1, 0, 1])
-            >>> f.deflation()
+            >>> q, n = f.deflation()
+            >>> q, n
             (x + 1, 2)
+            >>> q.inflate(n) == f
+            True
         """
         cdef ulong n
         if fmpz_poly_is_zero(self.val):
@@ -647,14 +650,17 @@ cdef class fmpz_poly(flint_poly):
 
             >>> f = fmpz_poly([1, 0, 1])
             >>> f.deflation_monom()
-            (1, x)
+            (x^2 + 1, 1, x)
         """
         n, m = self.deflation_index()
 
         cdef fmpz_poly monom = fmpz_poly.__new__(fmpz_poly)
+        cdef fmpz_poly res = fmpz_poly.__new__(fmpz_poly)
+
         fmpz_poly_set_coeff_ui(monom.val, m, 1)
+        fmpz_poly_deflate(res.val, self.val, n)
 
-        return n, monom
+        return res, n, monom
 
     def deflation_index(self) -> tuple[int, int]:
         """

src/flint/types/nmod_mpoly.pyx

@@ -1107,24 +1107,30 @@ cdef class nmod_mpoly(flint_mpoly):
             >>> from flint import Ordering
             >>> ctx = nmod_mpoly_ctx.get_context(2, Ordering.lex, 11, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
-            >>> f = x**3 * y + x * y**4 + x * y
+            >>> f = x**2 * y**2 + x * y**2
             >>> q, N = f.deflation()
             >>> q, N
-            (x + y + 1, [2, 3])
+            (x^2*y + x*y, [1, 2])
+            >>> q.inflate(N) == f
+            True
         """
         cdef:
-            fmpz_vec _shift = fmpz_vec(self.ctx.nvars())
-            fmpz_vec stride = fmpz_vec(self.ctx.nvars())
+            slong nvars = self.ctx.nvars()
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
             nmod_mpoly res = create_nmod_mpoly(self.ctx)
 
-        nmod_mpoly_deflation(_shift.val, stride.val, self.val, self.ctx.val)
+        nmod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+
+        for i in range(nvars):
+            stride[i] = shift[i].gcd(stride[i])
+            shift[i] = 0
 
-        cdef fmpz_vec zero_shift = fmpz_vec(self.ctx.nvars())
-        nmod_mpoly_deflate(res.val, self.val, zero_shift.val, stride.val, self.ctx.val)
+        nmod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
         return res, list(stride)
 
-    def deflation_monom(self) -> tuple[list[int], nmod_mpoly]:
+    def deflation_monom(self) -> tuple[nmod_mpoly, list[int], nmod_mpoly]:
         """
         Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N))
         = m * q(X^N)`` for maximal N. Importantly the deflation itself is not computed
@@ -1134,21 +1140,24 @@ cdef class nmod_mpoly(flint_mpoly):
             >>> ctx = nmod_mpoly_ctx.get_context(2, Ordering.lex, 11, nametup=('x', 'y'))
             >>> x, y = ctx.gens()
             >>> f = x**3 * y + x * y**4 + x * y
-            >>> N, m = f.deflation_monom()
-            >>> N, m
-            ([2, 3], x*y)
-            >>> f_deflated = f.deflate(N)
-            >>> f_deflated
-            x + y + 1
-            >>> m * f_deflated.inflate(N)
+            >>> fd, N, m = f.deflation_monom()
+            >>> fd, N, m
+            (x + y + 1, [2, 3], x*y)
+            >>> m * fd.inflate(N)
             x^3*y + x*y^4 + x*y
         """
-        cdef nmod_mpoly monom = create_nmod_mpoly(self.ctx)
+        cdef:
+            slong nvars = self.ctx.nvars()
+            nmod_mpoly res = create_nmod_mpoly(self.ctx)
+            nmod_mpoly monom = create_nmod_mpoly(self.ctx)
+            fmpz_vec shift = fmpz_vec(nvars)
+            fmpz_vec stride = fmpz_vec(nvars)
 
-        stride, _shift = self.deflation_index()
+        nmod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val)
+        nmod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val)
+        nmod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val)
 
-        nmod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(_shift).val, self.ctx.val)
-        return list(stride), monom
+        return res, list(stride), monom
 
     def deflation_index(self) -> tuple[list[int], list[int]]:
         """