You can give a list of rules to apply. Each rule will be tried once on each part of the expression.

In[2]:=

Out[2]=

expr/.{rules1,rules2,…}

give a list of the results from applying each of the rulesi to expr

Applying lists of transformation rules.

If you give a list of lists of rules, you get a list of results.

In[3]:=

Out[3]=

Functions such as Solve and NSolve return lists whose elements are lists of rules, each representing a solution.

In[4]:=

Out[4]=

When you apply these rules, you get a list of results, one corresponding to each solution.

In[5]:=

Out[5]=

When you use expr/.rules, each rule is tried in turn on each part of expr. As soon as a rule applies, the appropriate transformation is made, and the resulting part is returned.

The rule for x^3 is tried first; if it does not apply, the rule for x^n_ is used.

In[6]:=

Out[6]=

A result is returned as soon as the rule has been applied, so the inner instance of h is not replaced.

In[7]:=

Out[7]=

The replacement expr/.rules tries each rule just once on each part of expr.

Since each rule is tried just once, this serves to swap x and y.

In[8]:=

Out[8]=

You can use this notation to apply one set of rules, followed by another.

In[9]:=

Out[9]=

Sometimes you may need to go on applying rules over and over again, until the expression you are working on no longer changes. You can do this using the repeated replacement operation expr//.rules (or ReplaceRepeated[expr,rules]).

expr/.rules

try rules once on each part of expr

expr//.rules

try rules repeatedly until the result no longer changes

Single and repeated rule application.

With the single replacement operator /. each rule is tried only once on each part of the expression.

In[10]:=

Out[10]=

With the repeated replacement operator //. the rules are tried repeatedly until the expression no longer changes.

In[11]:=

Out[11]=

Here the rule is applied only once.

In[12]:=

Out[12]=

With the repeated replacement operator, the rule is applied repeatedly, until the result no longer changes.

In[13]:=

Out[13]=

When you use //. (pronounced "slash‐slash‐dot"), the Wolfram Language repeatedly passes through your expression, trying each of the rules given. It goes on doing this until it gets the same result on two successive passes.

If you give a set of rules that is circular, then //. can keep on getting different results forever. In practice, the maximum number of passes that //. makes on a particular expression is determined by the setting for the option MaxIterations. If you want to keep going for as long as possible, you can use ReplaceRepeated[expr,rules,MaxIterations->Infinity]. You can always stop by explicitly interrupting the Wolfram Language.

The replacement operators /. and //. share the feature that they try each rule on every subpart of your expression. On the other hand, Replace[expr,rules] tries the rules only on the whole of expr, and not on any of its subparts.

You can use Replace, together with functions like Map and MapAt, to control exactly which parts of an expression a replacement is applied to. Remember that you can use the function ReplacePart[expr,new,pos] to replace part of an expression with a specific object.

The operator /. applies rules to all subparts of an expression.

In[15]:=

Out[15]=

Without a level specification, Replace applies rules only to the whole expression.