gh-41031: some details in multi_power_series_rings
    
small details, including the removal of one method now provided by the
category

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #41031
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Martin Rubey, user202729

Author: Release Manager

src/sage/rings/multi_power_series_ring.py

@@ -193,15 +193,15 @@
 - Simon King (2012-08, 2013-02): Use category and coercion framework, :issue:`13412` and :issue:`14084`
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2010 Niles Johnson <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 import sage.misc.latex as latex
 
@@ -216,18 +216,15 @@
 from sage.structure.nonexact import Nonexact
 from sage.structure.parent import Parent
 
+from sage.rings.laurent_series_ring import LaurentSeriesRing
 from sage.categories.commutative_rings import CommutativeRings
-_CommutativeRings = CommutativeRings()
-
 from sage.categories.integral_domains import IntegralDomains
+_CommutativeRings = CommutativeRings()
 _IntegralDomains = IntegralDomains()
 
-try:
-    from sage.rings.laurent_series_ring import LaurentSeriesRing
-except ImportError:
-    LaurentSeriesRing = ()
 
-lazy_import('sage.rings.lazy_series_ring', ('LazyPowerSeriesRing', 'LazyLaurentSeriesRing'))
+lazy_import('sage.rings.lazy_series_ring', ('LazyPowerSeriesRing',
+                                            'LazyLaurentSeriesRing'))
 
 
 def is_MPowerSeriesRing(x):
@@ -272,7 +269,9 @@ def is_MPowerSeriesRing(x):
 
 class MPowerSeriesRing_generic(PowerSeriesRing_generic, Nonexact):
     r"""
-    A multivariate power series ring.  This class is implemented as a
+    A multivariate power series ring.
+
+    This class is implemented as a
     single variable power series ring in the variable ``T`` over a
     multivariable polynomial ring in the specified generators.  Each
     generator ``g`` of the multivariable polynomial ring (called the
@@ -283,7 +282,7 @@ class MPowerSeriesRing_generic(PowerSeriesRing_generic, Nonexact):
 
     For usage and examples, see above, and :meth:`PowerSeriesRing`.
     """
-    ### methods from PowerSeriesRing_generic that we *don't* override:
+    # ## methods from PowerSeriesRing_generic that we *don't* override:
     #
     # variable_names_recursive : works just fine
     #
@@ -302,14 +301,14 @@ class MPowerSeriesRing_generic(PowerSeriesRing_generic, Nonexact):
     # __setitem__ : works just fine
     #
     #
-    #### notes
+    # ### notes
     #
     # sparse setting may not be implemented completely
     Element = MPowerSeries
 
     @staticmethod
     def __classcall__(cls, base_ring, num_gens, name_list,
-                 order='negdeglex', default_prec=10, sparse=False):
+                      order='negdeglex', default_prec=10, sparse=False):
         """
         Preprocessing of arguments: The term order can be given as string
         or as a :class:`~sage.rings.polynomial.term_order.TermOrder` instance.
@@ -326,7 +325,7 @@ def __classcall__(cls, base_ring, num_gens, name_list,
                                      order, default_prec, sparse)
 
     def __init__(self, base_ring, num_gens, name_list,
-                 order='negdeglex', default_prec=10, sparse=False):
+                 order='negdeglex', default_prec=10, sparse=False) -> None:
         """
         Initialize a multivariate power series ring.  See PowerSeriesRing
         for complete documentation.
@@ -371,6 +370,11 @@ def __init__(self, base_ring, num_gens, name_list,
             Category of integral domains
             sage: TestSuite(P).run()
 
+            sage: M = PowerSeriesRing(QQ,4,'v'); M
+            Multivariate Power Series Ring in v0, v1, v2, v3 over Rational Field
+            sage: M.is_integral_domain()
+            True
+
         Otherwise, it belongs to the category of commutative rings::
 
             sage: P = Integers(15)[['x','y']]
@@ -385,10 +389,10 @@ def __init__(self, base_ring, num_gens, name_list,
         if n < 0:
             raise ValueError("Multivariate Polynomial Rings must have more than 0 variables.")
         self._ngens = n
-        self._has_singular = False #cannot convert to Singular by default
+        self._has_singular = False  # cannot convert to Singular by default
         # Multivariate power series rings inherit from power series rings. But
         # apparently we can not call their initialisation. Instead, initialise
-        # CommutativeRing and Nonexact:
+        # Parent and Nonexact:
         Parent.__init__(self, base=base_ring, names=name_list,
                         category=_IntegralDomains if base_ring in
                         _IntegralDomains else _CommutativeRings)
@@ -405,10 +409,10 @@ def __init__(self, base_ring, num_gens, name_list,
 
         self._is_sparse = sparse
         self._params = (base_ring, num_gens, name_list,
-                         order, default_prec, sparse)
+                        order, default_prec, sparse)
         self._populate_coercion_lists_()
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Print out a multivariate power series ring.
 
@@ -431,7 +435,7 @@ def _repr_(self):
             s = 'Sparse ' + s
         return s
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         """
         Return latex representation of power series ring.
 
@@ -445,21 +449,7 @@ def _latex_(self):
         generators_latex = ", ".join(self.latex_variable_names())
         return "%s[[%s]]" % (latex.latex(self.base_ring()), generators_latex)
 
-    def is_integral_domain(self, proof=False):
-        """
-        Return ``True`` if the base ring is an integral domain; otherwise
-        return False.
-
-        EXAMPLES::
-
-            sage: M = PowerSeriesRing(QQ,4,'v'); M
-            Multivariate Power Series Ring in v0, v1, v2, v3 over Rational Field
-            sage: M.is_integral_domain()
-            True
-        """
-        return self.base_ring().is_integral_domain()
-
-    def is_noetherian(self, proof=False):
+    def is_noetherian(self, proof=False) -> bool:
         """
         Power series over a Noetherian ring are Noetherian.
 
@@ -478,8 +468,9 @@ def is_noetherian(self, proof=False):
 
     def term_order(self):
         """
-        Print term ordering of ``self``.  Term orderings are implemented by the
-        TermOrder class.
+        Return the term ordering of ``self``.
+
+        Term orderings are implemented by the ``TermOrder`` class.
 
         EXAMPLES::
 
@@ -547,7 +538,7 @@ def construction(self):
             True
         """
         from sage.categories.pushout import CompletionFunctor
-        extras = {'order':self.term_order(), 'num_gens':self.ngens()}
+        extras = {'order': self.term_order(), 'num_gens': self.ngens()}
         if self.is_sparse():
             extras['sparse'] = True
         return (CompletionFunctor(self._names, self.default_prec(),
@@ -557,6 +548,7 @@ def construction(self):
     def change_ring(self, R):
         """
         Return the power series ring over `R` in the same variable as ``self``.
+
         This function ignores the question of whether the base ring of self
         is or can extend to the base ring of `R`; for the latter, use
         ``base_extend``.
@@ -613,11 +605,11 @@ def remove_var(self, *var):
         vars = list(self.variable_names())
         for v in var:
             vars.remove(str(v))
-        if len(vars) == 0:
+        if not vars:
             return self.base_ring()
         return PowerSeriesRing(self.base_ring(), names=vars)
 
-    ## this is defined in PowerSeriesRing_generic
+    # this is defined in PowerSeriesRing_generic
     # def __call__(self, f, prec=infinity):
     #     """
     #     Coerce object to this multivariate power series ring.
@@ -682,7 +674,7 @@ def _coerce_impl(self, f):
         else:
             return self(self.base_ring().coerce(f))
 
-    def _is_valid_homomorphism_(self, codomain, im_gens, base_map=None):
+    def _is_valid_homomorphism_(self, codomain, im_gens, base_map=None) -> bool:
         """
         Replacement for method of PowerSeriesRing_generic.
 
@@ -902,14 +894,14 @@ def laurent_series_ring(self):
             Traceback (most recent call last):
             ...
             NotImplementedError: Laurent series not implemented for
-            multivariate power series.
+            multivariate power series
         """
-        raise NotImplementedError("Laurent series not implemented for multivariate power series.")
+        raise NotImplementedError("Laurent series not implemented for multivariate power series")
 
     def _poly_ring(self, x=None):
         """
         Return the underlying polynomial ring used to represent elements of
-        this power series ring.  If given an input x, returns x coerced
+        this power series ring.  If given an input ``x``, returns ``x`` coerced
         into this polynomial ring.
 
         EXAMPLES::
@@ -922,8 +914,7 @@ def _poly_ring(self, x=None):
         """
         if x is None:
             return self._poly_ring_
-        else:
-            return self._poly_ring_(x)
+        return self._poly_ring_(x)
 
     def _mpoly_ring(self, x=None):
         """
@@ -955,10 +946,9 @@ def _bg_ps_ring(self, x=None):
         """
         if x is None:
             return self._bg_power_series_ring
-        else:
-            return self._bg_power_series_ring(x)
+        return self._bg_power_series_ring(x)
 
-    def is_sparse(self):
+    def is_sparse(self) -> bool:
         """
         Check whether ``self`` is sparse.
 
@@ -975,7 +965,7 @@ def is_sparse(self):
         """
         return self._is_sparse
 
-    def is_dense(self):
+    def is_dense(self) -> bool:
         """
         Is ``self`` dense? (opposite of sparse)
 
@@ -1003,8 +993,8 @@ def gen(self, n=0):
             v6
         """
         if n < 0 or n >= self._ngens:
-            raise ValueError("Generator not defined.")
-        #return self(self._poly_ring().gens()[int(n)])
+            raise IndexError("generator not defined")
+        # return self(self._poly_ring().gens()[int(n)])
         return self.element_class(parent=self, x=self._poly_ring().gens()[int(n)], is_gen=True)
 
     def ngens(self):
@@ -1033,9 +1023,10 @@ def gens(self) -> tuple:
 
     def prec_ideal(self):
         """
-        Return the ideal which determines precision; this is the ideal
-        generated by all of the generators of our background polynomial
-        ring.
+        Return the ideal which determines precision.
+
+        This is the ideal generated by all of the generators of our
+        background polynomial ring.
 
         EXAMPLES::
 
@@ -1048,7 +1039,9 @@ def prec_ideal(self):
 
     def bigoh(self, prec):
         """
-        Return big oh with precision ``prec``.  The function ``O`` does the same thing.
+        Return big oh with precision ``prec``.
+
+        The function ``O`` does the same thing.
 
         EXAMPLES::
 
@@ -1063,7 +1056,9 @@ def bigoh(self, prec):
 
     def O(self, prec):
         """
-        Return big oh with precision ``prec``.  This function is an alias for ``bigoh``.
+        Return big oh with precision ``prec``.
+
+        This function is an alias for ``bigoh``.
 
         EXAMPLES::
 
@@ -1091,12 +1086,12 @@ def _send_to_bg(self, f):
             sage: M._send_to_bg(bg)
             Traceback (most recent call last):
             ...
-            TypeError: Cannot coerce input to polynomial ring.
+            TypeError: cannot coerce input to polynomial ring
         """
         try:
             f = self._poly_ring(f)
         except TypeError:
-            raise TypeError("Cannot coerce input to polynomial ring.")
+            raise TypeError("cannot coerce input to polynomial ring")
         return self._bg_ps_ring(f.homogeneous_components())
 
     def _send_to_fg(self, f):
@@ -1136,4 +1131,5 @@ def unpickle_multi_power_series_ring_v0(base_ring, num_gens, names, order, defau
         sage: loads(dumps(P)) == P # indirect doctest
         True
     """
-    return PowerSeriesRing(base_ring, num_gens=num_gens, names=names, order=order, default_prec=default_prec, sparse=sparse)
+    return PowerSeriesRing(base_ring, num_gens=num_gens, names=names,
+                           order=order, default_prec=default_prec, sparse=sparse)

src/sage/rings/multi_power_series_ring_element.py

@@ -350,7 +350,7 @@ def __init__(self, parent, x=0, prec=infinity, is_gen=False, check=False):
             sage: B(z)
             Traceback (most recent call last):
             ...
-            TypeError: Cannot coerce input to polynomial ring.
+            TypeError: cannot coerce input to polynomial ring
 
             sage: D.<s> = PowerSeriesRing(QQ)
             sage: s.parent() is D
@@ -366,19 +366,21 @@ def __init__(self, parent, x=0, prec=infinity, is_gen=False, check=False):
         self._PowerSeries__is_gen = is_gen
 
         try:
-            prec = min(prec, x.prec()) # use precision of input, if defined
+            prec = min(prec, x.prec())  # use precision of input, if defined
         except AttributeError:
             pass
 
         # set the correct background value, depending on what type of input x is
         try:
-            xparent = x.parent() # 'int' types have no parent
+            xparent = x.parent()  # 'int' types have no parent
         except AttributeError:
             xparent = None
 
         # test whether x coerces to background univariate
         # power series ring of parent
-        if isinstance(xparent, (PowerSeriesRing_generic, MPowerSeriesRing_generic, LazyPowerSeriesRing)):
+        if isinstance(xparent, (PowerSeriesRing_generic,
+                                MPowerSeriesRing_generic,
+                                LazyPowerSeriesRing)):
             # x is either a multivariate or univariate power series
             #
             # test whether x coerces directly to designated parent