Delayed/Conditional Substitution

[cheuberg]

Mathematica (see ​http://reference.wolfram.com/language/ref/RuleDelayed.html) has a very useful feature called delayed rule. Instead of a static rule, a function is invoked which decides looking at the argument how the actual substitution should be carried out. This is a useful feature when simplifying some symbolic expressions.

This ticket shall implement such a delayed substitution in SageMath.

[cheuberg]

New commits:

​0f55981	Trac #24773: delayed substitution: first version
​b801825	Trac #24773: remove input argument self
​6d0793a	Trac #24773: Shorten references
​5581894	Trac #24773: Fix see also block

[dkrenn]

LGTM, but I want to raise the following to be discussed: the name delayed_substitution of the method. The other substitute-methods are called substitute*, so maybe an substitute_delayed would fit more into this scheme. However, I do not have a strong opinion on this topic.

The first basic Mathematica example is

{x, x, x} /. x :> RandomReal[]

so maybe adding this example as well could be a benefit.

[rws]

Replying to dkrenn:

LGTM, but I want to raise the following to be discussed: the name delayed_substitution of the method. The other substitute-methods are called substitute*, so maybe an substitute_delayed would fit more into this scheme.

Agree, mostly because it makes it easier to be found by TAB completion.

[git]

Branch pushed to git repo; I updated commit sha1. New commits:

​d2b835c

Trac #24773: delayed_substitution -> substitution_delayed

[cheuberg]

I renamed the method as suggested.

Concerning the Mathematica example: I have two problems with that example. The first being that a list is not a symbolic expression. So we would need something like

sage: var('a b c')
sage: e1 = a*x + b*x + c*x

But then, it does not work as expected:

sage: e1.substitution_delayed(x, lambda d: random())
0.7859203112304044*a + 0.7859203112304044*b + 0.7859203112304044*c

The reason is that the code proposed here tries to do the job with as little effort as possible. This means that first, I look for all matches of the pattern:

sage: e1.find(x)
[x]

And then, I simply replace all occurrences.

One possibility would be:

sage: var('a b c x y z')
sage: w = SR.wild(0)
sage: e2 = a*sin(x) + b*sin(y) + c*sin(z)
sage: e2.substitution_delayed(sin(w), lambda d: random())
0.9299473549632423*a + 0.1776245598330548*b + 0.5870609216512541*c

[dkrenn]

Replying to cheuberg:

Concerning the Mathematica example: I have two problems with that example. The first being that a list is not a symbolic expression. So we would need something like

sage: var('a b c')
sage: e1 = a*x + b*x + c*x

But then, [...]

Ok, I understand. Then I suggest to skip this example completely to not get confused.

[jdemeyer]

I think this is badly missing documentation. I just read the docstring and have absolutely no clue what this is about.

What does the "delayed" in the name refer to? How does this differ from subs or subs_expr? Can you add an example which is actually meant to explain what this method does?

[git]

Branch pushed to git repo; I updated commit sha1. New commits:

​224476e

Trac #24773: additional test and explanation

[cheuberg]

I have added an example and some more explanation.

[rws]

I think it's worth to have. LGTM too.