use underscore as context mark in sympy symbols and function names

Author: mmatera

mathics/builtin/numbers/calculus.py

@@ -57,6 +57,7 @@
     SymbolPower,
     SymbolTimes,
     SymbolTrue,
+    sympy_name,
 )
 from mathics.core.systemsymbols import (
     SymbolAnd,
@@ -528,7 +529,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(sympy_name(func))(*sym_args)
 
         counts = [element.get_int_value() for element in exprs[2].elements]
         if None in counts:

mathics/core/convert/sympy.py

@@ -236,7 +236,6 @@ def expression_to_sympy(expr: Expression, **kwargs):
     """
     Convert `expr` to its sympy form.
     """
-
     if len(expr.elements) > 0:
         head_name = expr.get_head_name()
         if head_name.startswith("Global`"):
@@ -250,6 +249,7 @@ def expression_to_sympy(expr: Expression, **kwargs):
 
     lookup_name = expr.get_lookup_name()
     builtin = mathics_to_sympy.get(lookup_name)
+
     if builtin is not None:
         sympy_expr = builtin.to_sympy(expr, **kwargs)
         if sympy_expr is not None:
@@ -346,7 +346,6 @@ def old_from_sympy(expr) -> BaseElement:
     """
     converts a SymPy object to a Mathics3 element.
     """
-
     if isinstance(expr, (tuple, list)):
         return to_mathics_list(*expr, elements_conversion_fn=from_sympy)
     if isinstance(expr, int):
@@ -371,16 +370,16 @@ def old_from_sympy(expr) -> BaseElement:
             name = str(expr)
             if isinstance(expr, sympy.Dummy):
                 name = name[1:]
-                if "`" not in name:
+                if "_" not in name:
                     name = f"sympy`dummy`Dummy${expr.dummy_index}"  # type: ignore[attr-defined]
                 else:
-                    name = name[len(SYMPY_SYMBOL_PREFIX) :]
+                    name = name[len(SYMPY_SYMBOL_PREFIX) :].replace("_", "`")
                 # Probably, this should be the value attribute
                 return Symbol(name)
             if is_Cn_expr(name):
                 return Expression(SymbolC, Integer(int(name[1:])))
             if name.startswith(SYMPY_SYMBOL_PREFIX):
-                name = name[len(SYMPY_SYMBOL_PREFIX) :]
+                name = name[len(SYMPY_SYMBOL_PREFIX) :].replace("_", "`")
             if name.startswith(SYMPY_SLOT_PREFIX):
                 index = int(name[len(SYMPY_SLOT_PREFIX) :])
                 return Expression(SymbolSlot, Integer(index))
@@ -419,7 +418,8 @@ def old_from_sympy(expr) -> BaseElement:
         if isinstance(expr, sympy.core.numbers.NaN):
             return SymbolIndeterminate
         if isinstance(expr, sympy.core.function.FunctionClass):
-            return Symbol(str(expr))
+            name = str(expr).replace("_", "`")
+            return Symbol(name)
         if expr is sympy.true:
             return SymbolTrue
         if expr is sympy.false:
@@ -546,7 +546,7 @@ def old_from_sympy(expr) -> BaseElement:
                     *[from_sympy(arg) for arg in expr.args],
                 )
             if name.startswith(SYMPY_SYMBOL_PREFIX):
-                name = name[len(SYMPY_SYMBOL_PREFIX) :]
+                name = name[len(SYMPY_SYMBOL_PREFIX) :].replace("_", "`")
         args = [from_sympy(arg) for arg in expr.args]
         builtin = sympy_to_mathics.get(name)
         if builtin is not None:

mathics/core/symbols.py

@@ -126,7 +126,7 @@ def sympy_strip_context(name) -> str:
     produce invalid code. In a next round, we would like
     to use another character for split contexts in sympy variables.
     """
-    return strip_context(name)
+    return name.split("_")[-1]
 
 
 # system_symbols_dict({'SomeSymbol': ...}) -> {Symbol('System`SomeSymbol'): ...}
@@ -342,6 +342,7 @@ class Symbol(Atom, NumericOperators, EvalMixin):
 
     name: str
     hash: int
+    sympy_dummy: Any
     _short_name: str
 
     # Dictionary of Symbols defined so far.
@@ -354,7 +355,7 @@ class Symbol(Atom, NumericOperators, EvalMixin):
 
     # __new__ instead of __init__ is used here because we want
     # to return the same object for a given "name" value.
-    def __new__(cls, name: str):
+    def __new__(cls, name: str, sympy_dummy=None):
         """
         Allocate an object ensuring that for a given ``name`` and ``cls`` we get back the same object,
         id(object) is the same and its object.__hash__() is the same.
@@ -384,6 +385,18 @@ def __new__(cls, name: str):
             # For example, this can happen with String constants.
 
             self.hash = hash((cls, name))
+
+            # TODO: revise how we convert sympy.Dummy
+            # symbols.
+            #
+            # In some cases, SymPy returns a sympy.Dummy
+            # object. It is converted to Mathics as a
+            # Symbol. However, we probably should have
+            # a different class for this kind of symbols.
+            # Also, sympy_dummy should be stored as the
+            # value attribute.
+            self.sympy_dummy = sympy_dummy
+
             self._short_name = strip_context(name)
 
         return self
@@ -392,7 +405,7 @@ def __eq__(self, other) -> bool:
         return self is other
 
     def __getnewargs__(self):
-        return (self.name,)
+        return (self.name, self.sympy_dummy)
 
     def __hash__(self) -> int:
         """
@@ -690,12 +703,6 @@ def __new__(cls, name, value):
             self.hash = hash((cls, name))
         return self
 
-    def __getnewargs__(self):
-        return (
-            self.name,
-            self._value,
-        )
-
     @property
     def is_literal(self) -> bool:
         """
@@ -754,7 +761,7 @@ def symbol_set(*symbols: Symbol) -> FrozenSet[Symbol]:
 
 def sympy_name(mathics_symbol: Symbol):
     """Convert a mathics symbol name into a sympy symbol name"""
-    return SYMPY_SYMBOL_PREFIX + mathics_symbol.name
+    return SYMPY_SYMBOL_PREFIX + mathics_symbol.name.replace("`", "_")
 
 
 # Symbols used in this module.

mathics/eval/drawing/plot_compile.py

@@ -19,7 +19,7 @@
 import sympy
 
 from mathics.core.convert.sympy import SympyExpression, mathics_to_sympy
-from mathics.core.symbols import strip_context
+from mathics.core.symbols import sympy_strip_context
 from mathics.core.util import print_expression_tree, print_sympy_tree
 
 
@@ -82,7 +82,8 @@ def plot_compile(evaluation, expr, names, debug=0):
 
     # Strip symbols in sympy expression of context.
     subs = {
-        sym: sympy.Symbol(strip_context(str(sym))) for sym in sympy_expr.free_symbols
+        sym: sympy.Symbol(sympy_strip_context(str(sym)))
+        for sym in sympy_expr.free_symbols
     }
     sympy_expr = sympy_expr.subs(subs)
 

test/core/test_sympy_python_convert.py

@@ -49,10 +49,10 @@ def compare(self, mathics_expr, sympy_expr, **kwargs):
         self.compare_to_mathics(mathics_expr, sympy_expr)
 
     def testSymbol(self):
-        self.compare(Symbol("Global`x"), sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"))
+        self.compare(Symbol("Global`x"), sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"))
         self.compare(
-            Symbol("_Mathics_User_x"),
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}System`_Mathics_User_x"),
+            Symbol("Mathics`User`x"),
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Mathics_User_x"),
         )
 
     def testReal(self):
@@ -88,24 +88,24 @@ def testString(self):
     def testAdd(self):
         self.compare(
             Expression(SymbolPlus, Integer1, Symbol("Global`x")),
-            sympy.Add(sympy.Integer(1), sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x")),
+            sympy.Add(sympy.Integer(1), sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x")),
         )
 
     def testIntegrate(self):
         self.compare(
             Expression(SymbolIntegrate, Symbol("Global`x"), Symbol("Global`y")),
             sympy.Integral(
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"),
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`y"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_y"),
             ),
         )
 
     def testDerivative(self):
         self.compare(
             Expression(SymbolD, Symbol("Global`x"), Symbol("Global`y")),
             sympy.Derivative(
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"),
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`y"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_y"),
             ),
         )
 
@@ -118,12 +118,12 @@ def testDerivative2(self):
         )
         expr = Expression(head, Symbol("Global`x"), Symbol("Global`y"))
 
-        sfxy = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global`f"))(
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"),
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`y"),
+        sfxy = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global_f"))(
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"),
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_y"),
         )
         sym_expr = sympy.Derivative(
-            sfxy, sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x")
+            sfxy, sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x")
         )
 
         self.compare_to_sympy(expr, sym_expr, **kwargs)
@@ -133,28 +133,28 @@ def testConvertedFunctions(self):
         kwargs = {"converted_functions": set(["Global`f"])}
 
         marg1 = Expression(Symbol("Global`f"), Symbol("Global`x"))
-        sarg1 = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global`f"))(
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x")
+        sarg1 = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global_f"))(
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x")
         )
         self.compare(marg1, sarg1, **kwargs)
 
         marg2 = Expression(Symbol("Global`f"), Symbol("Global`x"), Symbol("Global`y"))
-        sarg2 = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global`f"))(
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"),
-            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`y"),
+        sarg2 = sympy.Function(str(f"{SYMPY_SYMBOL_PREFIX}Global_f"))(
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"),
+            sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_y"),
         )
         self.compare(marg2, sarg2, **kwargs)
 
         self.compare(
             Expression(SymbolD, marg2, Symbol("Global`x")),
-            sympy.Derivative(sarg2, sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x")),
+            sympy.Derivative(sarg2, sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x")),
             **kwargs,
         )
 
     def testExpression(self):
         self.compare(
             Expression(SymbolSin, Symbol("Global`x")),
-            sympy.sin(sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x")),
+            sympy.sin(sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x")),
         )
 
     def testConstant(self):
@@ -164,13 +164,13 @@ def testConstant(self):
     def testGamma(self):
         self.compare(
             Expression(SymbolGamma, Symbol("Global`z")),
-            sympy.gamma(sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`z")),
+            sympy.gamma(sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_z")),
         )
         self.compare(
             Expression(SymbolGamma, Symbol("Global`z"), Symbol("Global`x")),
             sympy.uppergamma(
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`z"),
-                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global`x"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_z"),
+                sympy.Symbol(f"{SYMPY_SYMBOL_PREFIX}Global_x"),
             ),
         )