gh-38821: let the category setup handle the ideals
    
This is removing the `ideal` methods in the old `Ring` and `Field`
classes, moving them to the category setup.

Also removing one custom `ideal` method in multiple polynomial rings.

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.
    
URL: #38821
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Martin Rubey

Author: Release Manager

src/doc/en/thematic_tutorials/coercion_and_categories.rst

@@ -129,7 +129,6 @@ This base class provides a lot more methods than a general parent::
      'fraction_field',
      'gen',
      'gens',
-     'ideal',
      'integral_closure',
      'is_commutative',
      'is_field',

src/sage/categories/fields.py

@@ -193,7 +193,7 @@ def _call_(self, x):
 
     class ParentMethods:
 
-        def is_field( self, proof=True ):
+        def is_field(self, proof=True):
             r"""
             Return ``True`` as ``self`` is a field.
 
@@ -458,6 +458,38 @@ def fraction_field(self):
             """
             return self
 
+        def ideal(self, *gens, **kwds):
+            """
+            Return the ideal generated by ``gens``.
+
+            INPUT:
+
+            - an element or a list/tuple/sequence of elements, the generators
+
+            Any named arguments are ignored.
+
+            EXAMPLES::
+
+                sage: QQ.ideal(2)
+                Principal ideal (1) of Rational Field
+                sage: QQ.ideal(0)
+                Principal ideal (0) of Rational Field
+
+            TESTS::
+
+                sage: QQ.ideal(2, 4)
+                Principal ideal (1) of Rational Field
+
+                sage: QQ.ideal([2, 4])
+                Principal ideal (1) of Rational Field
+            """
+            if len(gens) == 1 and isinstance(gens[0], (list, tuple)):
+                gens = gens[0]
+            for x in gens:
+                if not self(x).is_zero():
+                    return self.unit_ideal()
+            return self.zero_ideal()
+
         def _squarefree_decomposition_univariate_polynomial(self, f):
             r"""
             Return the square-free decomposition of ``f`` over this field.
@@ -585,7 +617,7 @@ def quo_rem(self, other):
                 raise ZeroDivisionError
             return (self/other, self.parent().zero())
 
-        def is_unit( self ):
+        def is_unit(self):
             r"""
             Return ``True`` if ``self`` has a multiplicative inverse.
 
@@ -602,7 +634,7 @@ def is_unit( self ):
         # Of course, in general gcd and lcm in a field are not very interesting.
         # However, they should be implemented!
         @coerce_binop
-        def gcd(self,other):
+        def gcd(self, other):
             """
             Greatest common divisor.
 

src/sage/categories/rings.py

@@ -12,12 +12,14 @@
 #                  https://www.gnu.org/licenses/
 # *****************************************************************************
 from functools import reduce
+from types import GeneratorType
 
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import LazyImport
 from sage.categories.category_with_axiom import CategoryWithAxiom
 from sage.categories.rngs import Rngs
 from sage.structure.element import Element
+from sage.structure.parent import Parent
 
 
 class Rings(CategoryWithAxiom):
@@ -815,32 +817,34 @@ def ideal(self, *args, **kwds):
             """
             Create an ideal of this ring.
 
-            .. NOTE::
+            INPUT:
 
-                The code is copied from the base class
-                :class:`~sage.rings.ring.Ring`. This is
-                because there are rings that do not inherit
-                from that class, such as matrix algebras.
-                See :issue:`7797`.
+            - an element or a list/tuple/sequence of elements, the generators
 
-            INPUT:
+            - ``coerce`` -- boolean (default: ``True``); whether to first coerce
+              the elements into this ring. This must be a keyword
+              argument. Only set it to ``False`` if you are certain that each
+              generator is already in the ring.
 
-            - an element or a list/tuple/sequence of elements
-            - ``coerce`` -- boolean (default: ``True``);
-              first coerce the elements into this ring
-            - ``side`` -- (optional) string, one of ``'twosided'``
-              (default), ``'left'``, ``'right'``; determines
-              whether the resulting ideal is twosided, a left
-              ideal or a right ideal
+            - ``ideal_class`` -- callable (default: ``self._ideal_class_()``);
+              this must be a keyword argument. A constructor for ideals, taking
+              the ring as the first argument and then the generators.
+              Usually a subclass of :class:`~sage.rings.ideal.Ideal_generic` or
+              :class:`~sage.rings.noncommutative_ideals.Ideal_nc`.
 
-            EXAMPLES::
+            - Further named arguments (such as ``side`` in the case of
+              non-commutative rings) are forwarded to the ideal class.
+
+            The keyword ``side`` can be one of ``'twosided'``,
+            ``'left'``, ``'right'``. It determines whether
+            the resulting ideal is twosided, a left ideal or a right ideal.
+
+            EXAMPLES:
+
+            Matrix rings::
 
                 sage: # needs sage.modules
                 sage: MS = MatrixSpace(QQ, 2, 2)
-                sage: isinstance(MS, Ring)
-                False
-                sage: MS in Rings()
-                True
                 sage: MS.ideal(2)
                 Twosided Ideal
                 (
@@ -858,6 +862,36 @@ def ideal(self, *args, **kwds):
                   [0 0]
                 )
                  of Full MatrixSpace of 2 by 2 dense matrices over Rational Field
+
+            Polynomial rings::
+
+                sage: R.<x,y> = QQ[]
+                sage: R.ideal(x,y)
+                Ideal (x, y) of Multivariate Polynomial Ring in x, y over Rational Field
+                sage: R.ideal(x+y^2)
+                Ideal (y^2 + x) of Multivariate Polynomial Ring in x, y over Rational Field
+                sage: R.ideal( [x^3,y^3+x^3] )
+                Ideal (x^3, x^3 + y^3) of Multivariate Polynomial Ring in x, y over Rational Field
+
+            Non-commutative rings::
+
+                sage: A = SteenrodAlgebra(2)                                                # needs sage.combinat sage.modules
+                sage: A.ideal(A.1, A.2^2)                                                   # needs sage.combinat sage.modules
+                Twosided Ideal (Sq(2), Sq(2,2)) of mod 2 Steenrod algebra, milnor basis
+                sage: A.ideal(A.1, A.2^2, side='left')                                      # needs sage.combinat sage.modules
+                Left Ideal (Sq(2), Sq(2,2)) of mod 2 Steenrod algebra, milnor basis
+
+            TESTS:
+
+            Make sure that :issue:`11139` is fixed::
+
+                sage: R.<x> = QQ[]
+                sage: R.ideal([])
+                Principal ideal (0) of Univariate Polynomial Ring in x over Rational Field
+                sage: R.ideal(())
+                Principal ideal (0) of Univariate Polynomial Ring in x over Rational Field
+                sage: R.ideal()
+                Principal ideal (0) of Univariate Polynomial Ring in x over Rational Field
             """
             if 'coerce' in kwds:
                 coerce = kwds['coerce']
@@ -866,8 +900,7 @@ def ideal(self, *args, **kwds):
                 coerce = True
 
             from sage.rings.ideal import Ideal_generic
-            from types import GeneratorType
-            if len(args) == 0:
+            if not args:
                 gens = [self(0)]
             else:
                 gens = args
@@ -889,26 +922,23 @@ def ideal(self, *args, **kwds):
                     elif isinstance(first, (list, tuple, GeneratorType)):
                         gens = first
                     else:
-                        try:
-                            if self.has_coerce_map_from(first):
-                                gens = first.gens()  # we have a ring as argument
-                            elif isinstance(first, Element):
-                                gens = [first]
-                            else:
-                                raise ArithmeticError("there is no coercion from %s to %s" % (first, self))
-                        except TypeError:  # first may be a ring element
-                            pass
                         break
-            if coerce:
+
+            if not gens:
+                gens = [self.zero()]
+            elif coerce:
                 gens = [self(g) for g in gens]
+
             from sage.categories.principal_ideal_domains import PrincipalIdealDomains
             if self in PrincipalIdealDomains():
                 # Use GCD algorithm to obtain a principal ideal
                 g = gens[0]
                 if len(gens) == 1:
                     try:
-                        g = g.gcd(g)  # note: we set g = gcd(g, g) to "canonicalize" the generator: make polynomials monic, etc.
-                    except (AttributeError, NotImplementedError):
+                        # note: we set g = gcd(g, g) to "canonicalize" the generator:
+                        # make polynomials monic, etc.
+                        g = g.gcd(g)
+                    except (AttributeError, NotImplementedError, IndexError):
                         pass
                 else:
                     for h in gens[1:]:

src/sage/rings/number_field/number_field.py

@@ -3534,7 +3534,7 @@ def ideal(self, *gens, **kwds):
         try:
             return self.fractional_ideal(*gens, **kwds)
         except ValueError:
-            return Ring.ideal(self, gens, **kwds)
+            return self.zero_ideal()
 
     def idealchinese(self, ideals, residues):
         r"""
@@ -3600,9 +3600,10 @@ def idealchinese(self, ideals, residues):
     def fractional_ideal(self, *gens, **kwds):
         r"""
         Return the ideal in `\mathcal{O}_K` generated by ``gens``.
+
         This overrides the :class:`sage.rings.ring.Field` method to
         use the :class:`sage.rings.ring.Ring` one instead, since
-        we're not really concerned with ideals in a field but in its ring
+        we are not concerned with ideals in a field but in its ring
         of integers.
 
         INPUT:

src/sage/rings/polynomial/multi_polynomial_ring.py

@@ -949,31 +949,3 @@ def is_field(self, proof=True):
         if self.ngens() == 0:
             return self.base_ring().is_field(proof)
         return False
-
-    def ideal(self, *gens, **kwds):
-        """
-        Create an ideal in this polynomial ring.
-        """
-        do_coerce = False
-        if len(gens) == 1:
-            from sage.rings.ideal import Ideal_generic
-            if isinstance(gens[0], Ideal_generic):
-                if gens[0].ring() is self:
-                    return gens[0]
-                gens = gens[0].gens()
-            elif isinstance(gens[0], (list, tuple)):
-                gens = gens[0]
-        if not self._has_singular:
-            # pass through
-            MPolynomialRing_base.ideal(self, gens, **kwds)
-
-        from sage.rings.polynomial.multi_polynomial_ideal import MPolynomialIdeal
-
-        if isinstance(gens, (sage.interfaces.abc.SingularElement, sage.interfaces.abc.Macaulay2Element)):
-            gens = list(gens)
-            do_coerce = True
-        elif not isinstance(gens, (list, tuple)):
-            gens = [gens]
-        if ('coerce' in kwds and kwds['coerce']) or do_coerce:
-            gens = [self(x) for x in gens]  # this will even coerce from singular ideals correctly!
-        return MPolynomialIdeal(self, gens, **kwds)