Trac #24171: Formal set membership function

To express solution sets from solvers an expression-is-element-of-set
relation is needed. For ease of implementation this can be made a formal
function `element_of`.

It depends on sets being made coercible into SR.  The present ticket
plays safe and only does this for finite sets and a few standard
infinite sets: `NN`, `ZZ`, `QQ`, `AA`; and `RealSet`s.

`element_of` converts to !SymPy's `Contains`. This is useful in
combination with #31931, which adds !SymPy conversions to some of the
above sets.

URL: https://trac.sagemath.org/24171
Reported by: rws
Ticket author(s): Ralf Stephan, Matthias Koeppe
Reviewer(s): Travis Scrimshaw, Matthias Koeppe

Author: Release Manager

src/sage/functions/other.py

@@ -2285,3 +2285,75 @@ 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,
+                                 conversions=dict(sympy='Contains'))
+
+    def _eval_(self, x, s):
+        """
+        EXAMPLES::
+
+            sage: from sage.functions.other import element_of
+            sage: element_of(x, SR(RealSet(-oo, oo)))
+            element_of(x, (-oo, +oo))
+            sage: element_of(x, 0)
+            Traceback (most recent call last):
+            ...
+            ValueError: not a set: 0
+        """
+        from sage.categories.sets_cat import Sets
+        if not s in Sets():
+            raise ValueError("not a set: {}".format(s))
+
+    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/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,17 @@ 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(RealSet(0, 1))
+            (0, 1)
+
         TESTS::
 
             sage: SR._coerce_(int(5))
@@ -364,6 +375,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 +404,14 @@ 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
+            if (x.is_finite() or x in (NN, ZZ, QQ, AA)
+                    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")