Added refinement of categories for IntegralDomains.

Similar to the check x in Fields(), x in IntegralDomains() now changes the
category of x to contain the category of integral domains if x turns out to be
an integral domain.

Author: saraedum

src/sage/categories/integral_domains.py

@@ -1,23 +1,33 @@
 r"""
 Integral domains
+
+AUTHORS:
+
+- Teresa Gomez-Diaz (2008): initial version
+
+- Julian Rueth (2013-09-10): added category refinement similar to the one done by Fields
+
 """
 #*****************************************************************************
 #  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <[email protected]>
+#                2013 Julian Rueth <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #                  http://www.gnu.org/licenses/
 #******************************************************************************
 
 from sage.categories.category import Category
-from sage.categories.category_singleton import Category_singleton
+from sage.categories.category_singleton import Category_singleton, Category_contains_method_by_parent_class
 from sage.misc.cachefunc import cached_method
 from sage.categories.commutative_rings import CommutativeRings
+from sage.misc.lazy_attribute import lazy_class_attribute
 from sage.categories.domains import Domains
+import sage.rings.ring
 
 class IntegralDomains(Category_singleton):
     """
-    The category of integral domains
-    commutative rings with no zero divisors
+    The category of integral domains, i.e., non-trivial commutative rings with
+    no zero divisors
 
     EXAMPLES::
 
@@ -40,6 +50,60 @@ def super_categories(self):
         """
         return [CommutativeRings(), Domains()]
 
+    def __contains__(self, x):
+        """
+        Return whether ``x`` is in the category of integral domains.
+
+        EXAMPLES::
+
+            sage: GF(4, "a") in IntegralDomains()
+            True
+            sage: QQ in IntegralDomains()
+            True
+            sage: ZZ in IntegralDomains()
+            True
+            sage: IntegerModRing(4) in IntegralDomains()
+            False
+
+        Test that :trac:`15183` has been fixed::
+
+            sage: IntegerModRing(2) in IntegralDomains()
+            True
+
+        """
+        try:
+            return self._contains_helper(x) or sage.rings.ring._is_IntegralDomain(x)
+        except StandardError:
+            return False
+
+    @lazy_class_attribute
+    def _contains_helper(cls):
+        """
+        Helper for containment tests in the category of integral domains.
+
+        This helper just tests whether the given object's category is already
+        known to be a sub-category of the category of integral domains. There
+        are, however, rings that are initialised as plain commutative rings and
+        found out to be integral domains only afterwards. Hence, this helper
+        alone is not enough for a proper containment test.
+
+        TESTS::
+
+            sage: P.<x> = QQ[]
+            sage: Q = P.quotient(x^2+2)
+            sage: Q.category()
+            Join of Category of commutative algebras over Rational Field and Category of subquotients of monoids and Category of quotients of semigroups
+            sage: ID = IntegralDomains()
+            sage: ID._contains_helper(Q)
+            False
+            sage: Q in ID  # This changes the category!
+            True
+            sage: ID._contains_helper(Q)
+            True
+
+        """
+        return Category_contains_method_by_parent_class(cls())
+
     class ParentMethods:
         def is_integral_domain(self):
             """

src/sage/rings/ring.pyx

@@ -2096,11 +2096,46 @@ def is_Field(x):
     deprecation(13370, "use 'R in Fields()', not 'is_Field(R)'")
     return _is_Field(x)
 
+cpdef bint _is_IntegralDomain(x) except -2:
+    """
+    Return whether ``x`` is an integral domain.
+
+    EXAMPLES::
+
+        sage: from sage.rings.ring import _is_IntegralDomain
+        sage: _is_IntegralDomain(QQ)
+        True
+        sage: _is_IntegralDomain(IntegerModRing(2))
+        True
+        sage: _is_IntegralDomain(IntegerModRing(4))
+        False
+        sage: _is_IntegralDomain(5)
+        False
+
+    .. NOTE::
+
+        ``_is_IntegralDomain(R)`` is for internal use. It is better (and
+        faster) to use ``R in IntegralDomains()`` instead.
+
+    """
+    # The result is not immediately returned, since we want to refine x's
+    # category, so that calling x in IntegralDomains() will be faster next
+    # time.
+    try:
+        result = isinstance(x, IntegralDomain) or x.is_integral_domain()
+    except AttributeError:
+        result = False
+    if result:
+        x._refine_category_(_IntegralDomains)
+    return result
+
 # This imports is_Field, so must be executed after is_Field is defined.
 from sage.categories.algebras import Algebras
 from sage.categories.commutative_algebras import CommutativeAlgebras
 from sage.categories.fields import Fields
+from sage.categories.integral_domains import IntegralDomains
 _Fields = Fields()
+_IntegralDomains = IntegralDomains()
 
 cdef class Field(PrincipalIdealDomain):
     """