24171: Formal set membership function

Author: rwst

src/sage/functions/other.py

@@ -2285,3 +2285,58 @@ def _evalf_(self, poly, index, parent=None, algorithm=None):
 
 complex_root_of = Function_crootof()
 
+
+class Function_elementof(BuiltinFunction):
+    """
+    Formal set membership function that is only accessible internally.
+
+    This function is called to express a set membership statement,
+    usually as part of a solution set returned by ``solve()``.
+    See :class:`sage.sets.set.Set` and :class:`sage.sets.real_set.RealSet`
+    for possible set arguments.
+
+    EXAMPLES::
+
+        sage: from sage.functions.other import element_of
+        sage: element_of(x, SR(ZZ))
+        element_of(x, Integer Ring)
+        sage: element_of(sin(x), SR(QQ))
+        element_of(sin(x), Rational Field)
+        sage: element_of(x, SR(RealSet.open_closed(0,1)))
+        element_of(x, (0, 1])
+        sage: element_of(x, SR(Set([4,6,8])))
+        element_of(x, {8, 4, 6})
+    """
+    def __init__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.functions.other import element_of
+            sage: loads(dumps(element_of))
+            element_of
+        """
+        BuiltinFunction.__init__(self, "element_of", nargs=2)
+
+    def _latex_(self):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.functions.other import element_of
+            sage: latex(element_of)
+            \in
+        """
+        return r'\in'
+
+    def _print_latex_(self, ex, s):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.functions.other import element_of
+            sage: latex(element_of(x, SR(ZZ)))
+            x \in \Bold{Z}
+            sage: latex(element_of(x, SR(Set([4,6,8]))))
+            x \in \left\{8, 4, 6\right\}
+        """
+        return r"{} \in {}".format(latex(ex), latex(s))
+
+element_of = Function_elementof()

src/sage/libs/pynac/pynac.pyx

@@ -1190,7 +1190,7 @@ cdef bint py_is_real(a):
             return False
     except NotImplementedError:
         return False
-    except AttributeError:
+    except (TypeError, AttributeError):
         pass
     return py_imag(a) == 0
 

src/sage/sets/real_set.py

@@ -986,6 +986,21 @@ def is_empty(self):
         """
         return len(self._intervals) == 0
 
+    def is_finite(self):
+        """
+        Return whether the set is finite.
+
+        EXAMPLES::
+
+            sage: RealSet().is_finite()
+            True
+            sage: RealSet(0, 0).is_finite()
+            True
+            sage: RealSet(0, 1).is_finite()
+            False
+        """
+        return self.is_empty() or all(i.is_point() for i in self._intervals)
+
     def get_interval(self, i):
         """
         Return the ``i``-th connected component.

src/sage/symbolic/random_tests.py

@@ -20,7 +20,7 @@
 from sage.symbolic.constants import (pi, e, golden_ratio, log2, euler_gamma,
                                      catalan, khinchin, twinprime, mertens)
 from sage.functions.hypergeometric import hypergeometric
-from sage.functions.other import cases
+from sage.functions.other import (cases, element_of)
 from sage.symbolic.comparison import mixed_order
 
 ###################################################################
@@ -48,13 +48,13 @@ def _mk_full_functions():
     Note that this doctest will produce different output whenever a
     symbolic function is added or removed.
     """
+    excluded = [hypergeometric, cases, element_of]
     items = sorted(symbol_table['functions'].items())
     return [(1.0, f, f.number_of_arguments())
             for (name, f) in items
             if hasattr(f, 'number_of_arguments') and
                f.number_of_arguments() > 0 and
-               f != hypergeometric and
-               f != cases]
+               f not in excluded]
 
 # For creating simple expressions
 

src/sage/symbolic/ring.pyx

@@ -254,6 +254,19 @@ cdef class SymbolicRing(CommutativeRing):
             sage: SR(complex(2,-3))
             (2-3j)
 
+        Any proper subset of the complex numbers::
+
+            sage: SR(NN)
+            Non negative integer semiring
+            sage: SR(ZZ)
+            Integer Ring
+            sage: SR(Set([1/2, 2/3, 3/4]))
+            {3/4, 2/3, 1/2}
+            sage: SR(QQ.completion(oo, oo))
+            Real Field
+            sage: SR(RealSet(0, 1))
+            (0, 1)
+
         TESTS::
 
             sage: SR._coerce_(int(5))
@@ -364,6 +377,7 @@ cdef class SymbolicRing(CommutativeRing):
         from sage.rings.infinity import (infinity, minus_infinity,
                                          unsigned_infinity)
         from sage.structure.factorization import Factorization
+        from sage.categories.sets_cat import Sets
 
         if isinstance(x, RealNumber):
             if x.is_NaN():
@@ -392,6 +406,15 @@ cdef class SymbolicRing(CommutativeRing):
         elif isinstance(x, Factorization):
             from sage.misc.all import prod
             return prod([SR(p)**e for p,e in x], SR(x.unit()))
+        elif x in Sets():
+            from sage.rings.all import NN, ZZ, QQ, AA
+            from sage.sets.real_set import RealSet
+            oo = infinity
+            if (x.is_finite() or x in (NN, ZZ, QQ, AA, QQ.completion(oo,oo))
+                    or isinstance(x, RealSet)):
+                exp = x
+            else:
+                raise TypeError(f"unable to convert {x!r} to a symbolic expression")
         else:
             raise TypeError(f"unable to convert {x!r} to a symbolic expression")