Spurious renaming in nested Function construct

Question

From the documentation of Function, I take this example (slightly simplified). Renaming the dummy or bound variable (y->y$ in the inner Function) is necessary in:

In[1206]:= Function[x, Function[y, f[x, y]]][y]
Out[1206]= Function[y$, f[y, y$]]

so that, for example,

In[1215]:= Function[x, Function[y, f[x, y]]][y][1]
Out[1215]= f[y, 1]

because

In[1211]:= Function[y$, f[y, y$]][1]
Out[1211]= f[y, 1]

Without renaming, we would obtain a different and generally wrong value

In[1212]:= Function[y, f[y, y]][1]
Out[1212]= f[1, 1]

The documentation shows that renaming occurs even if it is not necessary:

In[1213]:= Function[x, Function[y, f[x, y]]][1]
Out[1213]= Function[y$, f[1, y$]]

Indeed, the choice of parameter name y should have no consequence on the function value.

Now let me try:

 In[1214]:= Function[x, Function[y, f[x, y]]][y$]
 Out[1214]= Function[y$, f[y$, y$]]

which is the same as Function[y, f[y, y]] that is wrong, as explained above.

So it looks to me like a plain fat bug, is not it?

Edited after comments

The bug is equivalent to:

In[1335]:= With[{x = y$}, Function[y, f[x, y]]]
Out[1335]= Function[y$, f[y$, y$]]

In this related case on the contrary no renaming occurs:

In[1338]:= Function[y, f[x, y]] /. x -> y$
Out[1338]= Function[y, f[y$, y]]

That is because the job of ReplaceAll is just to replace, not to detect name conflict.

Answer 1

If you use $ signs at the end of variable names in Function in Manipulate, you're asking for trouble.

Manipulate[
 Function[x, Function[y, f[x, y$]]][y$$],
 {y, 0, 1}]

Manipulate[
 y$$$ + y$$$$ + y$$$$$ + Function[x, Function[y, f[x, y]]][y$$],
 {y$$$$$, 1, 2}]

Manipulate[
 y$$$ + y$$$$ + y$$$$$ + Function[x, Function[y, f[x, y]]][y$$$],
 {y$$$$$, 1, 2}]

The explanation is that Manipulate strips and adds dollar signs according to its own secret rules, maybe after thumb wrestling with Function, which is not really an explanation. The results always seem to be the same. Maybe not from version to version. I didn't check.

Answer 2

From the documentation of Function in Mathematica:

The named formal parameters Subscript[x, i] in Function[{Subscript[x, 1],\[Ellipsis]},body] are treated as local, and are renamed Subscript[x, i]$ when necessary to avoid confusion with actual arguments supplied to the function.

One missing information in this laconic description is that single \$-ended formal parameters, corresponding to the string expression ___ ~~ Except@"$" ~~ "$", e. g. t$, but not t$$, are never renamed.

The renaming mechanism (called α-conversion in λ-calculus) appears in the minimal case

In[3]:= Function[t, Function[u, y[t, u]]]@v
Out[3]= Function[u$, y[v, u$]]

Semantically, for a faithful model of a mathematical (partial) function, renaming is only needed if the value of v is u (v==u):

In[4]:= Function[t, Function[u, y[t, u]]]@u
Out[4]= Function[u$, y[u, u$]]

The Wolfram language model of function is thus overcautious. For example, renaming occurs without need in

In[7]:= Function[t, Function[u, y[t, u]]]@1
Out[7]= Function[u$, y[1, u$]]

I suppose that this overcautiousness is intended by design to save the test u==v run time.

If ever you want to avoid unneeded renaming, you can, by using single \$-ended in the first place:

In[9]:= Function[t, Function[u$, y[t, u$]]]@1
Out[9]= Function[u$, y[1, u$]]

Thus Michael E2's rule "Don't ever end your variables with a \$." is safe but also overcautious for the following reasons:

1. Single \$-ended names are useful (or intended by design) to avoid renaming.
2. Names ending with at least two \$ like t$$ are perfectly safe for Function (although elsewhere I can't assert).