evaluating symbolic expressions (without conversion to SR, i.e., staying in ring of values)

[dkrenn]

This ticket proposes a new method evaluate which can evaluate symbolic expressions at values coming from a ring which not coerces into SR. The result again lives in the ring of the values. This forces the calculation to be done completely in the given ring (and not in the symbolic ring, where sometimes one does not know exactly what's going on).

For example:

sage: P.<p> = ZZ[[]]
sage: E = x.evaluate(x=p)
sage: E, E.parent()
(p, Power Series Ring in p over Integer Ring)

which is not possible with subs

sage: P.<p> = ZZ[[]]
sage: x.subs(x=p)
Traceback (most recent call last):
...
TypeError: no canonical coercion from Power Series Ring in p over Integer Ring to Symbolic Ring

sage: E = x.evaluate(x=p)
sage: E, E.parent()
p, Power Series Ring in p over Integer Ring)

CC: @cheuberg @mezzarobba

Component: symbolics

Keywords: sd66

Author: Daniel Krenn

Branch/Commit: u/dkrenn/SR/eval @ 276f0f3

Issue created by migration from https://trac.sagemath.org/ticket/18092

[dkrenn]

Branch: u/dkrenn/SR/eval

[dkrenn]

New commits:

9f8d483	create method eval
68b65ca	rename eval to evaluate
24348f7	docstring: output clearified
c3d0670	rename ring to convert_to
6449f20	implement automatic detection when convert_to=None
cd29dca	examples rewritten
bc2bb47	add seealso-block
9419e1f	fix typo
9e83cb2	docstring for helper function _evaluate_
c3696a8	fix links in doc

[dkrenn]

Commit: c3696a8

[dkrenn]

Author: Daniel Krenn

[rwst]

comment:4

+        The reason is that :meth:`subs` convert its arguments to the
+        symbolic ring, so we even have::
+
+            sage: x.subs(x=RIF(3.42)).parent()
+            Symbolic Ring
+
+        The :meth:`evaluate`-method prevents this conversion and

I think you misunderstand. x is not converted, it is wrapped in an expression:

sage: x.subs(x=RIF(3.42)).pyobject().parent()
Real Interval Field with 53 bits of precision

I have no idea if your idea is worth the effort, but suspect that not if it is only based on the necessity to prevent "conversion".

[dkrenn]

Description changed:

--- 
+++ 
@@ -1,4 +1,4 @@
-`subs` of a symbolic expression converts its values to the symbolic ring before performing the actual substitution. This ticket proposes a new method `evaluate` which comes over this.
+`subs` of a symbolic expression wraps its values to the symbolic ring (if possible) before performing the actual substitution. This ticket proposes a new method `evaluate` which comes over this.
 
 ```
 sage: E = (1+x).evaluate(x=RIF(3.42))
@@ -7,4 +7,17 @@
 sage: E.parent()
 Real Interval Field with 53 bits of precision
 ```
+While in the example above you can come over this by doing a conversion afterwards, it changes with power series:
 
+```
+sage: P.<p> = ZZ[[]]
+sage: x.subs(x=p)
+Traceback (most recent call last):
+...
+TypeError: no canonical coercion from Power Series Ring in p over Integer Ring to Symbolic Ring
+
+sage: E = x.evaluate(x=p)
+sage: E, E.parent()
+p, Power Series Ring in p over Integer Ring)
+```
+

[dkrenn]

comment:5

Replying to @rwst:

I think you misunderstand. x is not converted, it is wrapped in an expression:

Ok, I used the wrong word; however, this example was to point out the differences between the two commands.

sage: x.subs(x=RIF(3.42)).pyobject().parent()
Real Interval Field with 53 bits of precision

I have no idea if your idea is worth the effort, but suspect that not if it is only based on the necessity to prevent "conversion".

subs is not possible with something that does go into the symbolic ring, like power series:

sage: P.<p> = ZZ[[]]
sage: x.subs(x=p)
Traceback (most recent call last):
...
TypeError: no canonical coercion from Power Series Ring in p over Integer Ring to Symbolic Ring

sage: E = x.evaluate(x=p)
sage: E, E.parent()
p, Power Series Ring in p over Integer Ring)

[dkrenn]

Changed keywords from none to sd66

[rwst]

comment:7

I thought everything coerces to SR? Maybe this is just a coercion bug?

[dkrenn]

comment:8

Replying to @rwst:

I thought everything coerces to SR? Maybe this is just a coercion bug?

IMHO, not everything coerces into SR and this for a good reason. But this is not (or should not) under discussion here.

The following is not possible at with subs:

sage: sage: P.<p> = ZZ[[]]
sage: var('a,b')
(a, b)
sage: (a+b).subs({a: p, b: p^2})

evaluate can do.