Improve sympy conversions (#1534)

To start addressing #1533, this PR DRY the existing code, to avoid
inconsistencies when the separator character be changed.
Also, some constant names are changed to fullfil the Python conventions.

Author: mmatera

mathics/builtin/arithmetic.py

@@ -41,7 +41,7 @@
     SympyObject,
     Test,
 )
-from mathics.core.convert.sympy import SympyExpression, from_sympy, sympy_symbol_prefix
+from mathics.core.convert.sympy import SympyExpression, from_sympy
 from mathics.core.element import BaseElement
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
@@ -62,6 +62,7 @@
     SymbolPlus,
     SymbolTimes,
     SymbolTrue,
+    sympy_name,
 )
 from mathics.core.systemsymbols import (
     SymbolAnd,
@@ -377,7 +378,7 @@ def to_sympy(self, expr, **kwargs):
 
         sympy_cases = (
             (expr.to_sympy(**kwargs), sympy_cond),
-            (sympy.Symbol(sympy_symbol_prefix + "System`Undefined"), True),
+            (sympy.Symbol(sympy_name(SymbolUndefined)), True),
         )
         return sympy.Piecewise(*sympy_cases)
 

mathics/builtin/functional/application.py

@@ -14,7 +14,7 @@
 from mathics.core.convert.sympy import SymbolFunction
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
-from mathics.core.symbols import Symbol, sympy_slot_prefix
+from mathics.core.symbols import SYMPY_SLOT_PREFIX, Symbol
 from mathics.core.systemsymbols import SymbolSlot
 
 # This tells documentation how to sort this module
@@ -206,7 +206,7 @@ class Slot(SympyFunction, PrefixOperator):
 
     def to_sympy(self, expr: Expression, **kwargs):
         index: Integer = expr.elements[0]
-        return sympy.Symbol(f"{sympy_slot_prefix}{index.get_int_value()}")
+        return sympy.Symbol(f"{SYMPY_SLOT_PREFIX}{index.get_int_value()}")
 
 
 class SlotSequence(PrefixOperator, Builtin):

mathics/builtin/numbers/algebra.py

@@ -31,7 +31,7 @@
 from mathics.core.attributes import A_LISTABLE, A_PROTECTED
 from mathics.core.builtin import Builtin
 from mathics.core.convert.python import from_bool
-from mathics.core.convert.sympy import SympyExpression, from_sympy, sympy_symbol_prefix
+from mathics.core.convert.sympy import SympyExpression, from_sympy
 from mathics.core.element import BaseElement
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
@@ -42,6 +42,7 @@
 from mathics.core.list import ListExpression
 from mathics.core.rules import BasePattern
 from mathics.core.symbols import (
+    SYMPY_SYMBOL_PREFIX,
     Atom,
     Symbol,
     SymbolFalse,
@@ -183,7 +184,7 @@ def _expand(expr):
 
     def store_sub_expr(expr):
         sub_exprs.append(expr)
-        result = sympy.Symbol(sympy_symbol_prefix + str(len(sub_exprs) - 1))
+        result = sympy.Symbol(SYMPY_SYMBOL_PREFIX + str(len(sub_exprs) - 1))
         return result
 
     def get_sub_expr(expr):

mathics/builtin/numbers/calculus.py

@@ -41,18 +41,14 @@
 from mathics.core.convert.expression import to_expression, to_mathics_list
 from mathics.core.convert.function import expression_to_callable_and_args
 from mathics.core.convert.python import from_python
-from mathics.core.convert.sympy import (
-    SymbolRootSum,
-    SympyExpression,
-    from_sympy,
-    sympy_symbol_prefix,
-)
+from mathics.core.convert.sympy import SymbolRootSum, SympyExpression, from_sympy
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
 from mathics.core.number import MACHINE_EPSILON, dps
 from mathics.core.rules import BasePattern
 from mathics.core.symbols import (
+    SYMPY_SYMBOL_PREFIX,
     BaseElement,
     Symbol,
     SymbolFalse,
@@ -532,7 +528,7 @@ def to_sympy(self, expr, **kwargs):
             return
 
         func = exprs[1].elements[0]
-        sym_func = sympy.Function(str(sympy_symbol_prefix + func.__str__()))(*sym_args)
+        sym_func = sympy.Function(str(SYMPY_SYMBOL_PREFIX + func.__str__()))(*sym_args)
 
         counts = [element.get_int_value() for element in exprs[2].elements]
         if None in counts:

mathics/builtin/recurrence.py

@@ -3,25 +3,23 @@
 """
 Solving Recurrence Equations
 """
-
-# This tells documentation how to sort this module
-# Here we are also hiding "moments" since this erroneously appears at the
-# top level.
-sort_order = "mathics.builtin.solving-recurrence-equations"
-
-
 import sympy
 
 from mathics.core.atoms import IntegerM1
 from mathics.core.attributes import A_CONSTANT
 from mathics.core.builtin import Builtin
-from mathics.core.convert.sympy import from_sympy, sympy_symbol_prefix
+from mathics.core.convert.sympy import from_sympy
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
 from mathics.core.symbols import Atom, Symbol, SymbolPlus, SymbolTimes
 from mathics.core.systemsymbols import SymbolFunction, SymbolRule
 
+# This tells documentation how to sort this module
+# Here we are also hiding "moments" since this erroneously appears at the
+# top level.
+sort_order = "mathics.builtin.solving-recurrence-equations"
+
 
 class RSolve(Builtin):
     """
@@ -121,7 +119,7 @@ def is_relation(eqn):
                     r_sympy = ri.to_sympy()
                     if r_sympy is None:
                         raise ValueError
-                    conditions[le.elements[0].to_python()] = r_sympy
+                    conditions[le.elements[0]] = r_sympy
                     return False
             return True
 
@@ -137,18 +135,18 @@ def is_relation(eqn):
             SymbolPlus, left, Expression(SymbolTimes, IntegerM1, right)
         ).evaluate(evaluation)
 
-        sym_eq = relation.to_sympy(converted_functions={func.get_head_name()})
+        func_name = func.get_head_name()
+        sym_eq = relation.to_sympy(converted_functions={func_name})
         if sym_eq is None:
             return
-        sym_n = sympy.core.symbols(str(sympy_symbol_prefix + n.name))
-        sym_func = sympy.Function(str(sympy_symbol_prefix + func.get_head_name()))(
-            sym_n
-        )
+        sym_func = func._as_sympy_function(converted_functions={func_name})
 
         sym_conds = {}
         for cond in conditions:
             sym_conds[
-                sympy.Function(str(sympy_symbol_prefix + func.get_head_name()))(cond)
+                Expression(func.head, cond)._as_sympy_function(
+                    converted_functions={func_name}
+                )
             ] = conditions[cond]
 
         try:

mathics/core/convert/sympy.py

@@ -35,15 +35,16 @@
 from mathics.core.list import ListExpression
 from mathics.core.number import FP_MANTISA_BINARY_DIGITS
 from mathics.core.symbols import (
+    SYMPY_SLOT_PREFIX,
+    SYMPY_SYMBOL_PREFIX,
     Symbol,
     SymbolFalse,
     SymbolNull,
     SymbolPlus,
     SymbolPower,
     SymbolTimes,
     SymbolTrue,
-    sympy_slot_prefix,
-    sympy_symbol_prefix,
+    sympy_name,
 )
 from mathics.core.systemsymbols import (
     SymbolC,
@@ -109,7 +110,7 @@
 
 def is_Cn_expr(name: str) -> bool:
     """Check if name is of the form {prefix}Cnnn"""
-    if name.startswith(sympy_symbol_prefix) or name.startswith(sympy_slot_prefix):
+    if name.startswith(SYMPY_SYMBOL_PREFIX) or name.startswith(SYMPY_SLOT_PREFIX):
         return False
     if not name.startswith("C"):
         return False
@@ -238,13 +239,7 @@ def expression_to_sympy(expr: Expression, **kwargs):
 
         functions = kwargs.get("converted_functions", [])
         if head_name in functions:
-            sym_args = [element.to_sympy() for element in expr._elements]
-            if None in sym_args:
-                return None
-            func = sympy.Function(str(sympy_symbol_prefix + expr.get_head_name()))(
-                *sym_args
-            )
-            return func
+            return expr._as_sympy_function(**kwargs)
 
     lookup_name = expr.get_lookup_name()
     builtin = mathics_to_sympy.get(lookup_name)
@@ -269,7 +264,7 @@ def symbol_to_sympy(symbol: Symbol, **kwargs) -> Sympy_Symbol:
 
     builtin = mathics_to_sympy.get(symbol.name)
     if builtin is None or not builtin.sympy_name or not builtin.is_constant():  # nopep8
-        return Sympy_Symbol(sympy_symbol_prefix + symbol.name)
+        return Sympy_Symbol(sympy_name(symbol))
     return builtin.to_sympy(symbol, **kwargs)
 
 
@@ -369,15 +364,15 @@ def old_from_sympy(expr) -> BaseElement:
         if expr.is_Symbol:
             name = str(expr)
             if isinstance(expr, sympy.Dummy):
-                name = name + (f"__Dummy_{expr.dummy_index}")  # type: ignore[attr-defined]
+                name = f"sympy`dummy`Dummy${expr.dummy_index}"  # type: ignore[attr-defined]
                 # Probably, this should be the value attribute
                 return Symbol(name, sympy_dummy=expr)
             if is_Cn_expr(name):
                 return Expression(SymbolC, Integer(int(name[1:])))
-            if name.startswith(sympy_symbol_prefix):
-                name = name[len(sympy_symbol_prefix) :]
-            if name.startswith(sympy_slot_prefix):
-                index = int(name[len(sympy_slot_prefix) :])
+            if name.startswith(SYMPY_SYMBOL_PREFIX):
+                name = name[len(SYMPY_SYMBOL_PREFIX) :]
+            if name.startswith(SYMPY_SLOT_PREFIX):
+                index = int(name[len(SYMPY_SLOT_PREFIX) :])
                 return Expression(SymbolSlot, Integer(index))
         elif expr.is_NumberSymbol:
             name = str(expr)
@@ -497,7 +492,7 @@ def old_from_sympy(expr) -> BaseElement:
         return Expression(SymbolRoot, from_sympy(e_root), Integer(indx + 1))
     if isinstance(expr, sympy.Lambda):
         variables = [
-            sympy.Symbol(f"{sympy_slot_prefix}{index + 1}")
+            sympy.Symbol(f"{SYMPY_SLOT_PREFIX}{index + 1}")
             for index in range(len(expr.variables))
         ]
         return Expression(SymbolFunction, from_sympy(expr(*variables)))
@@ -540,8 +535,8 @@ def old_from_sympy(expr) -> BaseElement:
                     Expression(Symbol("C"), Integer(int(name[1:]))),
                     *[from_sympy(arg) for arg in expr.args],
                 )
-            if name.startswith(sympy_symbol_prefix):
-                name = name[len(sympy_symbol_prefix) :]
+            if name.startswith(SYMPY_SYMBOL_PREFIX):
+                name = name[len(SYMPY_SYMBOL_PREFIX) :]
         args = [from_sympy(arg) for arg in expr.args]
         builtin = sympy_to_mathics.get(name)
         if builtin is not None:

mathics/core/expression.py

@@ -60,30 +60,21 @@
     SymbolTimes,
     SymbolTrue,
     symbol_set,
+    sympy_name,
 )
 from mathics.core.systemsymbols import (
     SymbolAborted,
-    SymbolAlternatives,
-    SymbolBlank,
-    SymbolBlankNullSequence,
-    SymbolBlankSequence,
-    SymbolCondition,
     SymbolDirectedInfinity,
     SymbolFunction,
     SymbolMinus,
-    SymbolOptional,
-    SymbolOptionsPattern,
     SymbolOverflow,
-    SymbolPattern,
-    SymbolPatternTest,
     SymbolPower,
     SymbolSequence,
     SymbolSin,
     SymbolSlot,
     SymbolSqrt,
     SymbolSubtract,
     SymbolUnevaluated,
-    SymbolVerbatim,
 )
 from mathics.eval.tracing import trace_evaluate
 
@@ -331,9 +322,7 @@ def __str__(self) -> str:
         )
 
     def _as_sympy_function(self, **kwargs):
-        from mathics.core.convert.sympy import sympy_symbol_prefix
-
-        function_name = str(sympy_symbol_prefix + self.get_head_name())
+        function_name = sympy_name(self.head)
         f = sympy.Function(function_name)
 
         if kwargs.get("convert_functions_for_polynomial", False):

mathics/core/symbols.py

@@ -29,8 +29,8 @@
 # keep variable names short.  In tracing values, long names makes
 # output messy and harder to follow, since it detracts from the
 # important information
-sympy_symbol_prefix = "_u"
-sympy_slot_prefix = "_#"
+SYMPY_SYMBOL_PREFIX = "_u"
+SYMPY_SLOT_PREFIX = "_#"
 
 
 class NumericOperators:
@@ -109,6 +109,26 @@ def round_to_float(
         return None
 
 
+def strip_context(name) -> str:
+    """strip context from a symbol name"""
+    if "`" in name:
+        return name[name.rindex("`") + 1 :]
+    return name
+
+
+def sympy_strip_context(name) -> str:
+    """
+    Strip context from sympy names.
+    Currenty we use the same context marks for
+    mathics and sympy symbols. However,
+    when using sympy to compile code,
+    having '`' in symbol names
+    produce invalid code. In a next round, we would like
+    to use another character for split contexts in sympy variables.
+    """
+    return strip_context(name)
+
+
 # system_symbols_dict({'SomeSymbol': ...}) -> {Symbol('System`SomeSymbol'): ...}
 def system_symbols_dict(d):
     return {Symbol(k): v for k, v in d.items()}
@@ -123,12 +143,6 @@ def valid_context_name(ctx, allow_initial_backquote=False) -> bool:
     )
 
 
-def strip_context(name) -> str:
-    if "`" in name:
-        return name[name.rindex("`") + 1 :]
-    return name
-
-
 class Atom(BaseElement):
     """
     Atoms are the (some) leaves and the Heads of an S-Expression or an M-Expression.
@@ -745,6 +759,11 @@ def symbol_set(*symbols: Symbol) -> FrozenSet[Symbol]:
     return frozenset(symbols)
 
 
+def sympy_name(mathics_symbol: Symbol):
+    """Convert a mathics symbol name into a sympy symbol name"""
+    return SYMPY_SYMBOL_PREFIX + mathics_symbol.name
+
+
 # Symbols used in this module.
 
 # Note, below we are only setting SymbolConstant for Symbols which