Merge pull request #28416 from Jatinbhardwaj-093/update/from_list

[RingSeries]: Support higher-precision series elements beyond ring precision

Author: oscarbenjamin

sympy/polys/series/base.py

@@ -89,6 +89,10 @@ def from_list(self, coeffs: list[Er], prec: int | None = None, /) -> TSeries:
         """Create a power series from a list of coefficients."""
         ...
 
+    def from_element(self, s: TSeries, /) -> TSeries:
+        """Convert a power series element into the corresponding element of this ring."""
+        ...
+
     def to_list(self, s: TSeries, /) -> list[Er]:
         """Return the coefficients of a power series as a list."""
         ...

sympy/polys/series/ring.py

@@ -241,6 +241,14 @@ def from_element(self, element: TSeriesElement[Er]) -> PowerSeriesElement[Er]:
         """Convert a lower power series element to a PowerSeriesElement."""
         return PowerSeriesElement(self, element)
 
+    def from_powerserieselement(
+        self, element: PowerSeriesElement[Er]
+    ) -> PowerSeriesElement[Er]:
+        """Convert a power series element into the corresponding element of this ring."""
+        R = self.ring
+        s = R.from_element(element.series)
+        return self.from_element(s)
+
     def from_int(self, arg: int) -> PowerSeriesElement[Er]:
         """Convert an integer to a power series element."""
         g = self.domain_new(arg)
@@ -285,9 +293,13 @@ def domain_new(self, arg: Er | int) -> Er:
         """Convert arg to the element of ground domain of ring."""
         return self.domain.convert(arg, self.domain)
 
-    def ring_new(self, arg: Expr | Er | int) -> PowerSeriesElement[Er]:
+    def ring_new(
+        self, arg: PowerSeriesElement[Er] | Expr | Er | int
+    ) -> PowerSeriesElement[Er]:
         """Create a power series element from various types."""
-        if isinstance(arg, Expr):
+        if isinstance(arg, PowerSeriesElement):
+            return self.from_powerserieselement(arg)
+        elif isinstance(arg, Expr):
             return self.from_expr(arg)
         elif isinstance(arg, int):
             return self.from_int(arg)
@@ -1041,6 +1053,11 @@ def removeO(self) -> PowerSeriesElement[Er]:
         series = R.from_list(coeffs)
         return self._new(series)
 
+    @property
+    def prec(self) -> int | None:
+        """Return the precision of the series."""
+        return self.ring.series_prec(self.series)
+
     @property
     def is_ground(self) -> bool | None:
         """Check if the series is a ground element."""

sympy/polys/series/ringflint.py

@@ -11,13 +11,23 @@
 from sympy.utilities.decorator import doctest_depends_on
 from sympy.polys.polyerrors import NotReversible
 
+_require_flint_version = False
 
 if TYPE_CHECKING:
     from flint import fmpq_poly, fmpq_series, fmpz_poly, fmpz_series, ctx  # type: ignore
     from flint.utils.flint_exceptions import DomainError  # type: ignore
 elif GROUND_TYPES == "flint":
     from flint import fmpq_poly, fmpq_series, fmpz_poly, fmpz_series, ctx
     from flint.utils.flint_exceptions import DomainError
+
+    # Required in specific cases where the 0.8 implementation provides faster
+    # performance for working with Flint series methods.
+    # This can be removed when python-flint 0.8 becomes the minimum supported version.
+    import flint
+
+    _major, _minor, *_ = flint.__version__.split(".")
+    if (int(_major), int(_minor)) >= (0, 8):
+        _require_flint_version = True
 else:
     fmpq_poly = fmpq_series = fmpz_poly = fmpz_series = ctx = None
 
@@ -205,11 +215,23 @@ def from_list(self, coeffs: list[MPZ], prec: int | None = None) -> ZZSeries:
             if len(coeffs) <= self._prec:
                 return fmpz_poly(coeffs)
             prec = self._prec
-        else:
-            prec = min(prec, self._prec)
 
         return fmpz_series(coeffs, prec=prec)
 
+    def from_element(self, s: ZZSeries) -> ZZSeries:
+        """Convert a power series element into the corresponding element of this ring."""
+        ring_prec = self._prec
+        if isinstance(s, fmpz_poly):
+            if s.degree() >= ring_prec:
+                return fmpz_series(s, prec=ring_prec)
+            return s
+
+        prec = min(_get_series_precision(s), ring_prec)
+        if _require_flint_version:
+            return fmpz_series(s, prec=prec)
+        else:
+            return fmpz_series(s.coeffs(), prec=prec)
+
     def to_list(self, s: ZZSeries) -> list[MPZ]:
         """Returns the list of series coefficients."""
         return s.coeffs()
@@ -652,11 +674,23 @@ def from_list(self, coeffs: list[MPQ], prec: int | None = None) -> QQSeries:
             if len(coeffs) <= self._prec:
                 return fmpq_poly(coeffs)
             prec = self._prec
-        else:
-            prec = min(prec, self._prec)
 
         return fmpq_series(coeffs, prec=prec)
 
+    def from_element(self, s: QQSeries) -> QQSeries:
+        """Convert a power series element into the corresponding element of this ring."""
+        ring_prec = self._prec
+        if isinstance(s, fmpq_poly):
+            if s.degree() >= ring_prec:
+                return fmpq_series(s, prec=ring_prec)
+            return s
+
+        prec = min(_get_series_precision(s), ring_prec)
+        if _require_flint_version:
+            return fmpq_series(s, prec=prec)
+        else:
+            return fmpq_series(s.coeffs(), prec=prec)
+
     def to_list(self, s: QQSeries) -> list[MPQ]:
         """Returns the list of series coefficients."""
         return s.coeffs()

sympy/polys/series/ringpython.py

@@ -54,7 +54,7 @@ def _useries(
 
     prec = min(series_prec, ring_prec)
     if deg < prec:
-        return coeffs, series_prec
+        return coeffs, prec
 
     coeffs = dup_truncate(coeffs, prec, dom)
     return coeffs, prec
@@ -1194,14 +1194,17 @@ def from_list(self, coeffs: list[MPZ], prec: int | None = None) -> USeries[MPZ]:
                 return coeffs, None
             else:
                 prec = self._prec
-        else:
-            prec = min(prec, self._prec)
 
         if len(coeffs) > prec:
             coeffs = dup_truncate(coeffs, prec, self._domain)
 
         return coeffs, prec
 
+    def from_element(self, s: USeries[MPZ]) -> USeries[MPZ]:
+        """Convert a power series element into the corresponding element of this ring."""
+        coeffs, prec = s
+        return _useries(coeffs, prec, self._domain, self._prec)
+
     def to_list(self, s: USeries[MPZ]) -> list[MPZ]:
         """Returns the list of series coefficients."""
         coeffs, _ = s
@@ -1462,14 +1465,17 @@ def from_list(self, coeffs: list[MPQ], prec: int | None = None) -> USeries[MPQ]:
                 return coeffs, None
             else:
                 prec = self._prec
-        else:
-            prec = min(prec, self._prec)
 
         if len(coeffs) > prec:
             coeffs = dup_truncate(coeffs, prec, self._domain)
 
         return coeffs, prec
 
+    def from_element(self, s: USeries[MPQ]) -> USeries[MPQ]:
+        """Convert a power series element into the corresponding element of this ring."""
+        coeffs, prec = s
+        return _useries(coeffs, prec, self._domain, self._prec)
+
     def to_list(self, s: USeries[MPQ]) -> list[MPQ]:
         """Return the list of series coefficients."""
         coeffs, _ = s

sympy/polys/series/tests/test_ring.py

@@ -115,7 +115,7 @@ def test_basics(ring_int):
     assert R.series_prec(R([1, 2, 3])) == None
     assert R.series_prec(R([1, 2, 3], None)) == None
     assert R.series_prec(R([1, 2, 3, 4, 5, 6, 7])) == 6
-    assert R.series_prec(R([1, 2, 3, 4, 5, 6, 7], 10)) == 6
+    assert R.series_prec(R([1, 2, 3, 4, 5, 6, 7], 10)) == 10
 
 
 def test_positive(ring_int):
@@ -1315,10 +1315,21 @@ def test_PowerSeriesRing_from_expr():
 
 def test_PowerSeriesRing_ring_new():
     R = PowerSeriesRingRing(QQ, "x", 5)
+    R3 = PowerSeriesRingRing(QQ, "y", 3)
+    x = R.gen
+    y = R3.gen
 
     assert R.ring_new(QQ(7)) == R.from_ground(QQ(7))
     assert R.ring_new(3) == R.from_int(3)
 
+    assert R.ring_new(y + y**2 + y**3).ring == R.ring
+    assert R.ring_new(y + y**2 + y**3) == R.from_list([QQ(0), QQ(1), QQ(1)], 3)
+    assert (
+        R3.ring_new(R3.from_list([QQ(0), QQ(1), QQ(1), QQ(1)], 4))
+        == y + y**2 + R3.order_term()
+    )
+    assert R3.ring_new(x + x**4 + x**5) == y + R3.order_term()
+
 
 def test_PowerSeriesRing_arith(groundring_int):
     SeriesRing = groundring_int