Trac #8972: Inversion and fraction fields for power series rings

This ticket is about at least three bugs related with inversion of
elements of power series rings.

Here is the first:
{{{
sage: R.<x> = ZZ[[]]
sage: (1/x).parent()
Laurent Series Ring in x over Integer Ring
sage: (x/x).parent()
Power Series Ring in x over Integer Ring
}}}
''Both'' parents are wrong. Usually, the parent of ``a/b`` is the
fraction field of the parent of ``a,b``, even if ``a==b``. And neither
above parent is a field.

Next bug:
{{{
sage: (1/(2*x)).parent()
ERROR: An unexpected error occurred while tokenizing input
The following traceback may be corrupted or invalid
The error message is: ('EOF in multi-line statement', (919, 0))

------------------------------------------------------------------------
---
TypeError                                 Traceback (most recent call
last)
... very long traceback
TypeError: no conversion of this rational to integer
}}}

And the third:
{{{
sage: F = FractionField(R)
sage: 1/x in F
False
}}}

With the proposed patch, we solve all bugs except

{{{
sage: (x/x).parent()
Power Series Ring in x over Integer Ring
}}}

----

Apply (old):

 * [attachment:trac-8972_fraction_of_power_series_combined.patch]

URL: https://trac.sagemath.org/8972
Reported by: SimonKing
Ticket author(s): Simon King, Michael Jung
Reviewer(s): Robert Bradshaw, Travis Scrimshaw

Author: Release Manager

src/sage/rings/laurent_series_ring_element.pyx

@@ -1080,8 +1080,8 @@ cdef class LaurentSeries(AlgebraElement):
             raise ZeroDivisionError
         try:
             return type(self)(self._parent,
-                             self.__u / right.__u,
-                             self.__n - right.__n)
+                              self.__u / right.__u,
+                              self.__n - right.__n)
         except TypeError as msg:
             # todo: this could also make something in the formal fraction field.
             raise ArithmeticError("division not defined")

src/sage/rings/power_series_poly.pyx

@@ -610,8 +610,9 @@ cdef class PowerSeries_poly(PowerSeries):
         that `XY = 1`).
 
         The first nonzero coefficient must be a unit in
-        the coefficient ring. If the valuation of the series is positive,
-        this function will return a :doc:`laurent_series_ring_element`.
+        the coefficient ring. If the valuation of the series is positive or
+        `X` is not a unit, this function will return a
+        :class:`sage.rings.laurent_series_ring_element.LaurentSeries`.
 
         EXAMPLES::
 
@@ -666,15 +667,32 @@ cdef class PowerSeries_poly(PowerSeries):
             sage: u*v
             1 + O(t^12)
 
-        We try a non-zero, non-unit leading coefficient::
+        If we try a non-zero, non-unit constant term, we end up in
+        the fraction field, i.e. the Laurent series ring::
 
             sage: R.<t> = PowerSeriesRing(ZZ)
             sage: ~R(2)
-            Traceback (most recent call last):
-            ...
-            ValueError: constant term is not a unit
+            1/2
+            sage: parent(~R(2))
+            Laurent Series Ring in t over Rational Field
+
+        As for units, we stay in the power series ring::
+
             sage: ~R(-1)
             -1
+            sage: parent(~R(-1))
+            Power Series Ring in t over Integer Ring
+
+        However, inversion of non-unit elements must fail when the underlying
+        ring is not an integral domain::
+
+            sage: R = IntegerModRing(8)
+            sage: P.<s> = R[[]]
+            sage: ~P(2)
+            Traceback (most recent call last):
+            ...
+            ValueError: must be an integral domain
+
         """
         if self.is_one():
             return self
@@ -686,7 +704,12 @@ cdef class PowerSeries_poly(PowerSeries):
                 # constant series
                 a = self[0]
                 if not a.is_unit():
-                    raise ValueError("constant term is not a unit")
+                    from sage.categories.integral_domains import IntegralDomains
+                    if self._parent in IntegralDomains():
+                        R = self._parent.fraction_field()
+                        return 1 / R(a)
+                    else:
+                        raise ValueError('must be an integral domain')
                 try:
                     a = a.inverse_unit()
                 except (AttributeError, NotImplementedError):

src/sage/rings/power_series_ring.py

@@ -730,7 +730,8 @@ def _element_constructor_(self, f, prec=infinity, check=True):
             sage: R(1/x, 5)
             Traceback (most recent call last):
             ...
-            TypeError: no canonical coercion from Laurent Series Ring in t over Integer Ring to Power Series Ring in t over Integer Ring
+            TypeError: no canonical coercion from Laurent Series Ring in t over
+             Rational Field to Power Series Ring in t over Integer Ring
 
             sage: PowerSeriesRing(PowerSeriesRing(QQ,'x'),'y')(x)
             x
@@ -860,7 +861,8 @@ def _coerce_impl(self, x):
             sage: R._coerce_(1/t)
             Traceback (most recent call last):
             ...
-            TypeError: no canonical coercion from Laurent Series Ring in t over Integer Ring to Power Series Ring in t over Integer Ring
+            TypeError: no canonical coercion from Laurent Series Ring in t over
+             Rational Field to Power Series Ring in t over Integer Ring
             sage: R._coerce_(5)
             5
             sage: tt = PolynomialRing(ZZ,'t').gen()

src/sage/rings/power_series_ring_element.pyx

@@ -1064,6 +1064,24 @@ cdef class PowerSeries(AlgebraElement):
             t + O(t^21)
             sage: (t^5/(t^2 - 2)) * (t^2 -2 )
             t^5 + O(t^25)
+            
+        TESTS:
+
+        The following tests against bugs that were fixed in :trac:`8972`::
+
+            sage: P.<t> = ZZ[]
+            sage: R.<x> = P[[]]
+            sage: 1/(t*x)
+            1/t*x^-1
+            sage: R.<x> = ZZ[[]]
+            sage: (1/x).parent()
+            Laurent Series Ring in x over Rational Field
+            sage: F = FractionField(R)
+            sage: 1/x in F
+            True
+            sage: (1/(2*x)).parent()
+            Laurent Series Ring in x over Rational Field
+            
         """
         denom = <PowerSeries>denom_r
         if denom.is_zero():
@@ -1073,8 +1091,11 @@ cdef class PowerSeries(AlgebraElement):
 
         v = denom.valuation()
         if v > self.valuation():
-            R = self._parent.laurent_series_ring()
-            return R(self)/R(denom)
+            try:
+                R = self._parent.fraction_field()
+            except (TypeError, NotImplementedError):  # no integral domain
+                R = self._parent.laurent_series_ring()
+            return R(self) / R(denom)
 
         # Algorithm: Cancel common factors of q from top and bottom,
         # then invert the denominator.  We do the cancellation first