Trac #24420: Laurent power series fail unique representation

{{{
sage: L.<q> = LaurentSeriesRing(QQ)
sage: LaurentSeriesRing(QQ, 'q') is L
False
}}}
to be compared with
{{{
sage: R.<q> = PolynomialRing(QQ)
sage: PolynomialRing(QQ, 'q') is R
True
}}}

We also fix
{{{
sage: LaurentSeriesRing(Zmod(4), 'x').category()
Category of fields
}}}

We also remove the classes `LaurentSeriesRing_generic`,
`LaurentSeriesRing_domain`, `LaurentSeriesRing_field` in favor of a
unique `LaurentSeriesRing`.

URL: https://trac.sagemath.org/24420
Reported by: vdelecroix
Ticket author(s): Vincent Delecroix
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/rings/laurent_series_ring.py

@@ -19,19 +19,38 @@
 """
 from __future__ import print_function, absolute_import
 
-from .laurent_series_ring_element import LaurentSeries
+from sage.categories.rings import Rings
+from sage.categories.integral_domains import IntegralDomains
+from sage.categories.fields import Fields
+from sage.categories.complete_discrete_valuation import CompleteDiscreteValuationFields
 
+from .laurent_series_ring_element import LaurentSeries
 from . import polynomial
-from . import ring
+from .ring import CommutativeRing
 
-from sage.libs.pari.all import pari_gen
-from sage.categories.fields import Fields
-from sage.categories.complete_discrete_valuation import CompleteDiscreteValuationFields
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.misc.cachefunc import cached_method
 
-def LaurentSeriesRing(base_ring, name=None, names=None, default_prec=None, sparse=False):
+def is_LaurentSeriesRing(x):
     """
+    Return ``True`` if this is a *univariate* Laurent series ring.
+
+    This is in keeping with the behavior of ``is_PolynomialRing``
+    versus ``is_MPolynomialRing``.
+
+    TESTS::
+
+        sage: from sage.rings.laurent_series_ring import is_LaurentSeriesRing
+        sage: K.<q> = LaurentSeriesRing(QQ)
+        sage: is_LaurentSeriesRing(K)
+        True
+    """
+    return isinstance(x, LaurentSeriesRing)
+
+class LaurentSeriesRing(UniqueRepresentation, CommutativeRing):
+    r"""
+    Univariate Laurent Series Ring.
+
     EXAMPLES::
 
         sage: R = LaurentSeriesRing(QQ, 'x'); R
@@ -73,6 +92,26 @@ def LaurentSeriesRing(base_ring, name=None, names=None, default_prec=None, spars
         sage: W is T
         False
 
+        sage: K = LaurentSeriesRing(CC, 'q')
+        sage: K
+        Laurent Series Ring in q over Complex Field with 53 bits of precision
+        sage: loads(K.dumps()) == K
+        True
+        sage: P = QQ[['x']]
+        sage: F = Frac(P)
+        sage: TestSuite(F).run()
+
+    When the base ring `k` is a field, the ring `k((x))` is a CDVF, that is
+    a field equipped with a discrete valuation for which it is complete.
+    The appropriate (sub)category is automatically set in this case::
+
+        sage: k = GF(11)
+        sage: R.<x> = k[[]]
+        sage: F = Frac(R)
+        sage: F.category()
+        Category of infinite complete discrete valuation fields
+        sage: TestSuite(F).run()
+
     TESTS:
 
     Check if changing global series precision does it right (and
@@ -87,85 +126,94 @@ def LaurentSeriesRing(base_ring, name=None, names=None, default_prec=None, spars
         sage: 1/(1 - 2*x)
         1 + 2*x + 4*x^2 + 8*x^3 + 16*x^4 + O(x^5)
         sage: set_series_precision(20)
-    """
-    if not names is None:
-        name = names
-    if name is None:
-        raise TypeError("you must specify the name of the indeterminate of the Laurent series ring")
-
-    if default_prec is None:
-        from sage.misc.defaults import series_precision
-        default_prec = series_precision()
-
-    if isinstance(base_ring, ring.Field):
-        return LaurentSeriesRing_field(base_ring, name, default_prec, sparse)
-    elif isinstance(base_ring, ring.IntegralDomain):
-        return LaurentSeriesRing_domain(base_ring, name, default_prec, sparse)
-    elif isinstance(base_ring, ring.CommutativeRing):
-        return LaurentSeriesRing_generic(base_ring, name, default_prec, sparse)
-    else:
-        raise TypeError("base_ring must be a commutative ring")
 
-def is_LaurentSeriesRing(x):
-    """
-    Return ``True`` if this is a *univariate* Laurent series ring.
-
-    This is in keeping with the behavior of ``is_PolynomialRing``
-    versus ``is_MPolynomialRing``.
-
-    TESTS::
+    Check categories (:trac:`24420`)::
 
-        sage: from sage.rings.laurent_series_ring import is_LaurentSeriesRing
-        sage: K.<q> = LaurentSeriesRing(QQ)
-        sage: is_LaurentSeriesRing(K)
-        True
+        sage: LaurentSeriesRing(ZZ, 'x').category()
+        Category of infinite integral domains
+        sage: LaurentSeriesRing(QQ, 'x').category()
+        Category of infinite complete discrete valuation fields
+        sage: LaurentSeriesRing(Zmod(4), 'x').category()
+        Category of infinite commutative rings
     """
-    return isinstance(x, LaurentSeriesRing_generic)
+    Element = LaurentSeries
 
-class LaurentSeriesRing_generic(UniqueRepresentation, ring.CommutativeRing):
-    r"""
-    Univariate Laurent Series Ring.
+    @staticmethod
+    def __classcall__(cls, *args, **kwds):
+        r"""
+        TESTS::
 
-    EXAMPLES::
+            sage: L = LaurentSeriesRing(QQ, 'q')
+            sage: L is LaurentSeriesRing(QQ, name='q')
+            True
+            sage: loads(dumps(L)) is L
+            True
+        """
+        from .power_series_ring import PowerSeriesRing, is_PowerSeriesRing
 
-        sage: K = LaurentSeriesRing(CC, 'q')
-        sage: K
-        Laurent Series Ring in q over Complex Field with 53 bits of precision
-        sage: loads(K.dumps()) == K
-        True
-        sage: P = QQ[['x']]
-        sage: F = Frac(P)
-        sage: TestSuite(F).run()
+        if not kwds and len(args) == 1 and is_PowerSeriesRing(args[0]):
+            power_series = args[0]
+        else:
+            power_series = PowerSeriesRing(*args, **kwds)
 
-    When the base ring `k` is a field, the ring `k((x))` is a CDVF, that is
-    a field equipped with a discrete valuation for which it is complete.
-    The appropriate (sub)category is automatically set in this case::
+        return UniqueRepresentation.__classcall__(cls, power_series)
 
-        sage: k = GF(11)
-        sage: R.<x> = k[[]]
-        sage: F = Frac(R)
-        sage: F.category()
-        Category of complete discrete valuation fields
-        sage: TestSuite(F).run()
-    """
-    def __init__(self, base_ring, name=None, default_prec=None, sparse=False, category=None):
+    def __init__(self, power_series):
         """
         Initialization
 
         EXAMPLES::
 
-            sage: K.<q> = LaurentSeriesRing(QQ,default_prec=4); K
+            sage: K.<q> = LaurentSeriesRing(QQ, default_prec=4); K
             Laurent Series Ring in q over Rational Field
             sage: 1 / (q-q^2)
             q^-1 + 1 + q + q^2 + O(q^3)
-        """
-        from .power_series_ring import PowerSeriesRing
-        ring.CommutativeRing.__init__(self, base_ring, names=name,
-                                      category=getattr(self, '_default_category', Fields()))
-        self._power_series_ring = PowerSeriesRing(self.base_ring(),
-                                                  self.variable_name(),
-                                                  default_prec=default_prec,
-                                                  sparse=sparse)
+
+            sage: RZZ = LaurentSeriesRing(ZZ, 't')
+            sage: RZZ.category()
+            Category of infinite integral domains
+            sage: TestSuite(RZZ).run()
+
+            sage: R1 = LaurentSeriesRing(Zmod(1), 't')
+            sage: R1.category()
+            Category of finite commutative rings
+            sage: TestSuite(R1).run()
+
+            sage: R2 = LaurentSeriesRing(Zmod(2), 't')
+            sage: R2.category()
+            Category of infinite complete discrete valuation fields
+            sage: TestSuite(R2).run()
+
+            sage: R4 = LaurentSeriesRing(Zmod(4), 't')
+            sage: R4.category()
+            Category of infinite commutative rings
+            sage: TestSuite(R4).run()
+
+            sage: RQQ = LaurentSeriesRing(QQ, 't')
+            sage: RQQ.category()
+            Category of infinite complete discrete valuation fields
+            sage: TestSuite(RQQ).run()
+        """
+        base_ring = power_series.base_ring()
+        if base_ring in Fields():
+            category = CompleteDiscreteValuationFields()
+        elif base_ring in IntegralDomains():
+            category = IntegralDomains()
+        elif base_ring in Rings().Commutative():
+            category = Rings().Commutative()
+        else:
+            raise ValueError('unrecognized base ring')
+
+        if base_ring.is_zero():
+            category = category.Finite()
+        else:
+            category = category.Infinite()
+
+        CommutativeRing.__init__(self, base_ring,
+                names=power_series.variable_names(),
+                category=category)
+
+        self._power_series_ring = power_series
 
     def base_extend(self, R):
         """
@@ -184,6 +232,38 @@ def base_extend(self, R):
         else:
             raise TypeError("no valid base extension defined")
 
+    def fraction_field(self):
+        r"""
+        Return the fraction field of this ring of Laurent series.
+
+        If the base ring is a field, then Laurent series are already a field.
+        If the base ring is a domain, then the Laurent series over its fraction
+        field is returned. Otherwise, raise a ``ValueError``.
+
+        EXAMPLES::
+
+            sage: R = LaurentSeriesRing(ZZ, 't', 30).fraction_field()
+            sage: R
+            Laurent Series Ring in t over Rational Field
+            sage: R.default_prec()
+            30
+
+            sage: LaurentSeriesRing(Zmod(4), 't').fraction_field()
+            Traceback (most recent call last):
+            ...
+            ValueError: must be an integral domain
+        """
+        from sage.categories.integral_domains import IntegralDomains
+        from sage.categories.fields import Fields
+        if self in Fields():
+            return self
+        elif self in IntegralDomains():
+            return LaurentSeriesRing(self.base_ring().fraction_field(),
+                    self.variable_names(),
+                    self.default_prec())
+        else:
+            raise ValueError('must be an integral domain')
+
     def change_ring(self, R):
         """
         EXAMPLES::
@@ -194,7 +274,7 @@ def change_ring(self, R):
             sage: R.default_prec()
             4
         """
-        return LaurentSeriesRing(R, self.variable_name(),
+        return LaurentSeriesRing(R, self.variable_names(),
                                  default_prec=self.default_prec(),
                                  sparse=self.is_sparse())
 
@@ -248,8 +328,6 @@ def _repr_(self):
             s = 'Sparse ' + s
         return s
 
-    Element = LaurentSeries
-
     def _element_constructor_(self, x, n=0):
         r"""
         Construct a Laurent series from `x`.
@@ -332,6 +410,7 @@ def _element_constructor_(self, x, n=0):
         from sage.rings.polynomial.polynomial_element import is_Polynomial
         from sage.rings.polynomial.multi_polynomial_element import is_MPolynomial
         from sage.structure.element import parent
+        from sage.libs.pari.all import pari_gen
 
         P = parent(x)
         if isinstance(x, self.element_class) and n == 0 and P is self:
@@ -606,22 +685,3 @@ def power_series_ring(self):
         """
         return self._power_series_ring
 
-class LaurentSeriesRing_domain(LaurentSeriesRing_generic, ring.IntegralDomain):
-    """
-    Laurent series ring over a domain.
-
-    TESTS::
-
-        sage: TestSuite(LaurentSeriesRing(ZZ,'t')).run()
-    """
-
-class LaurentSeriesRing_field(LaurentSeriesRing_generic, ring.Field):
-    """
-    Laurent series ring over a field.
-
-    TESTS::
-
-        sage: TestSuite(LaurentSeriesRing(QQ,'t')).run()
-    """
-    _default_category = CompleteDiscreteValuationFields()
-

src/sage/rings/laurent_series_ring_element.pyx

@@ -69,8 +69,6 @@ AUTHORS:
 
 from __future__ import print_function, absolute_import
 
-import operator
-
 from .infinity import infinity
 
 import sage.rings.polynomial.polynomial_element as polynomial
@@ -168,7 +166,7 @@ cdef class LaurentSeries(AlgebraElement):
                 self.__u = f >> val
 
     def __reduce__(self):
-        return make_element_from_parent, (self._parent, self.__u, self.__n)
+        return self._parent, (self.__u, self.__n)
 
     def change_ring(self, R):
         """
@@ -710,13 +708,13 @@ cdef class LaurentSeries(AlgebraElement):
     def O(self, prec):
         r"""
         Return the Laurent series of precision at most ``prec`` obtained by
-        adding `O(q^\text{prec})`, where `q` is the variable. 
-        
+        adding `O(q^\text{prec})`, where `q` is the variable.
+
         The precision of ``self`` and the integer ``prec`` can be arbitrary. The
         resulting Laurent series will have precision equal to the minimum of
         the precision of ``self`` and ``prec``. The term `O(q^\text{prec})` is the
         zero series with precision ``prec``.
-       
+
         EXAMPLES::
 
             sage: R.<t> = LaurentSeriesRing(QQ)
@@ -1183,7 +1181,7 @@ cdef class LaurentSeries(AlgebraElement):
     def precision_relative(self):
         """
         Return the relative precision of this series, that
-        is the difference between its absolute precision  
+        is the difference between its absolute precision
         and its valuation.
 
         By convention, the relative precision of `0` (or
@@ -1513,6 +1511,3 @@ cdef class LaurentSeries(AlgebraElement):
             x = x[0]
 
         return self.__u(*x)*(x[0]**self.__n)
-
-def make_element_from_parent(parent, *args):
-    return parent(*args)

src/sage/rings/power_series_pari.pyx

@@ -429,15 +429,15 @@ cdef class PowerSeries_pari(PowerSeries):
         from sage.rings.padics.padic_generic import pAdicGeneric
         from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
         from sage.rings.power_series_ring import PowerSeriesRing_generic
-        from sage.rings.laurent_series_ring import LaurentSeriesRing_generic
+        from sage.rings.laurent_series_ring import LaurentSeriesRing
         if isinstance(Q, pAdicGeneric):
             # Substitution of p-adic numbers in power series is
             # currently not implemented in PARI (2.8.0-development).
             t = a.valuation()
             if t <= 0:
                 raise ValueError("can only substitute elements of positive valuation")
             return Q(self.polynomial()(a)).add_bigoh(t * self._prec)
-        elif isinstance(Q, (PowerSeriesRing_generic, LaurentSeriesRing_generic)):
+        elif isinstance(Q, (PowerSeriesRing_generic, LaurentSeriesRing)):
             # In Sage, we want an error to be raised when trying to
             # substitute a series of non-positive valuation, but PARI
             # (2.8.0-development) does not do this.  For example,