Here is my extremly basic understanding of Replace and ReplaceAll.

This post is also a way for me to check if I understood the mechanism behind, if you see mistakes in my explanation don't hesitate to correct me !

Replace is a function that will apply replacement rules on part of expression.

However, it will apply the replacement rules at specific level given in parameters (by default it will be {0} corresponding to the whole tree).

So here :

Replace[x^2 + 1, x^2 -> a]

It doesn't do anything as x^2 is a subpart of the tree but it is not the whole tree in itself.

I could do :

Replace[x^2 + 1, x^2 -> a, All]

To make it work. Then the code will look at all the levels of the trees (thus all the subtrees) and look for a matching replacement.

I could also do :

ReplaceAll[x^2 + 1, x^2 -> a]

And here is my question : is there actually any difference between using

Replace[expr, rule, All]

and

ReplaceAll[expr,rule]

or it is indeed the same thing ?

Another question linked to the answer

Then I don't understand this behavior :

diffReplaceReplaceAll = g[g[x]];

Replace[diffReplaceReplaceAll, g -> c, All]

g[g[x]]

g[g[x]][[1]]

g[x]

ReplaceAll[diffReplaceReplaceAll, g -> c]

c[c[x]]

If I take strictly what you say, ReplaceAll shoud return c[g[x]]

Indeed, it goes from the outside which is g[g[x]] (the whole tree), it looks at each part. So first it tries with the Head (the 0 part), which is $g$, it replaces it by $c$. And... it should stop here right ? Thus we would have c[g[x]] as a result. But it continues and replaces the second g. Why ?

My problem is very probably linked to a not fully understanding of what a part precisely is. But if I'm not wrong the 0'th part is the head and the 1st part is g[x] here right ?

I also have a problem with Replace : why if it goes from the inside to the outside I don't have at least g[c[x]] ?

Remark : I don't fully get your example as I'm not familiar with ":>", I am reading about it now.

I'm sorry but I still have problem to understand, here is the code I consider :

    expr = g[g[x]];
ReplaceAll[expr, g -> fonction]
ReplaceAll[expr, g[x_] -> fonction[x]]

fonction[fonction[x]]

fonction[g[x]]

I will write what I understand step by step of what is happening : the first ReplaceAll : ReplaceAll[expr, g -> fonction]

ReplaceAll looks at each part of expr, tries all the rules on it, and then goes on to the next part of expr. The first rule that applies to a particular part is used; no further rules are tried on that part or on any of its subparts.

Allright, I will look at each part of expr.

• I look at the 0'th part of expr which is the Head : g. I have a matching pattern, g becomes fonction. I don't have to look at subparts of g as I had a matching (but even in this case, g doesn't have subparts so it wouldn't change anything).
• I go at the next part (1st part) of expr : fonction[g[x]][[1]] = g[x] it doesn't match.
• I go at the first subpart of g[x] : g[x][[0]] = g, it matches. I replace. I don't have to look at the subparts of g as it matched. At this point I thus have fonction[fonction[x]]
• I look at the 2ndt part of expr : fonction[fonction[x]][[2]] : it doesn't exist.

Thus the code stops and the function returns : fonction[fonction[x]]

Now for the second ReplaceAll : ReplaceAll[expr, g[x_] -> fonction[x]]

• I look at the 0'th part of expr : g[g[x]][[0]] = g : no matching
• I look at the subparts of g : it doesn't have, so it stops for that.
• Thus, now I look at the 1st part of expr : g[g[x]][[1]] = g[x] It matches : g[x] -> fonction[x]. I thus now have g[fonction[x]]... which I know is wrong.

Here is how I understood the algorithm and I still have a problem. I don't understand what precisely does the algorithm then.

And is the 0'th part really the head or the full expression ? Because in the documentation of Replace for example :

The default value for levelspec in Replace is {0}, corresponding to the whole expression.