RecurrenceTable iteration variable not localized? Bug or user error?

Question

I recently lost a lot of time on this and need to understand whether I have misunderstood MMA operations or there's a problem. I am using MMA 10.1 on Windows 7 64-bit.

The essence of the issue is this: I believed that Table, RecurrenceTable etc, per the description of Table in the documentation, localise the iterating variable, and thus that using e.g. "i" in a RecurrenceTable and elsewhere in a notebook for some other purpose should not cause a conflict.

(Related question: ParametricPlot iterator not "block"-ed)

However as the three cases below show, unless the iterating variable is not reused or explicitly shielded by e.g. a Module in a definition incorporating a RecurrenceTable, I get the error that "1", "2", etc. cannot be used as a variable.

Sample code follows (with forced clear for safety). The first two definitions of logisticMap cause no problems in subsequent use, but when the subsequent use reuses an unshielded iterating variable the error occurs.

Clear[Evaluate[Context[] <> "*"]]

1st def: OK (i as a module variable in RecurrenceTable, and i in For[])

logisticMap[x0_, μ_, n_] := 
 Module[{i}, 
  RecurrenceTable[{x[i + 1] == μ x[i] (1 - x[i]), x[1] == x0}, 
   x, {i, 1, n}]]
pRow = {};
dataSeries := logisticMap[0.1, 3.55, 10];
For[i = 1, i <= 10, i++, AppendTo[pRow, dataSeries[[i]]]];

2nd def: OK (use b as iterator for RecurrenceTable and i in For[])

logisticMap[x0_, μ_, n_] := 
 RecurrenceTable[{x[b + 1] == μ x[b] (1 - x[b]), x[1] == x0}, 
  x, {b, 1, n}]
pRow = {};
dataSeries := logisticMap[0.1, 3.55, 10];
For[i = 1, i <= 10, i++, AppendTo[pRow, dataSeries[[i]]]];

3rd def: error (i as unshielded iterator in RecurrenceTable, and in For[])

logisticMap[x0_, μ_, n_] := 
 RecurrenceTable[{x[i + 1] == μ x[i] (1 - x[i]), x[1] == x0}, 
  x, {i, 1, n}]
pRow = {};
dataSeries := logisticMap[0.1, 3.55, 10];
For[i = 1, i <= 10, i++, AppendTo[pRow, dataSeries[[i]]]];

The error being

RecurrenceTable::dsvar: 1 cannot be used as a variable. >> etc.

a) What exactly is happening (why is "1" being used as a variable) and

b) Is this user error or a bug (that I would then report)?

[BTW Do you think Wolfram would respond +vely to a request for a free upgrade if this is a bug as this is a seriously undermining issue AND I am still suffering from an unresolved startup issue in 10.1?]

Thanks,

Answer 1

As Bob Hanlon's answer points out, RecurrenceTable does not hold its arguments, but most especially, it does not hold its iterator arguments. This must surely be viewed as a bug as it departs completely from the iterator idiom established by Table, etc.

On the other hand, there is precedent for evaluating the iterator specifications. For example, Integrate:

Integrate[Sin[x], {x, 0, Pi}]
(* 2 *)

but

Module[{x = 1}
, Integrate[Sin[x], {x, 0, Pi}]
]

(* Integrate::ilim: Invalid integration variable or limit(s) in {1,0,\[Pi]}. *)

I would argue that this is a bug. But as Szabolcs notes in the comments, one could possibly argue that this behaviour is desirable in contexts that are heavily symbolic (e.g. mathematical expression manipulation). In any event, it is unlikely that long-standing mathematical functions like Integrate are going to be revised any time soon.

So to determine whether iterator evaluation for RecurrenceTable is a bug depends upon whether you think it is more like Table or Integrate.

Scoping

As to the necessity of localizing the iterator variable within the table expression itself, this is not a behavioural bug but rather a general idiom in Mathematica for functions that use iteration variables. Examples include Table, Sum, Plot, Do, For -- and RecurrenceTable. In all of these functions, the iteration variable is not fully localized. Its value is temporarily changed as if scoped using Block. See (94061) for a discussion of the consequences.

In most cases, the Details section of the documentation states this explicitly (see Table or Plot for example). RecurrenceTable does not make such an explicit statement, but it does obliquely mention that it acts similarly to Table. So perhaps we have a documentation bug here, but not a behavioural bug.

The canonical way to solve the scoping problem is to localize the iterator variable using Module as in the first example in the question. This, incidentally, also works around the premature evaluation of the iterator arguments.

Answer 2

Unlike many other functions that use an iterator, RecurrenceTable does not have the attribute HoldAll. Presumably, this indicates a different evaluation sequence (Evaluation in Iteration Functions).

Grid[
 Prepend[
  {#, Attributes[#]} & /@
   {Do, Product, Sum, Table, RecurrenceTable},
  Style[#, Bold] & /@ {"Function", "Attributes"}],
 Frame -> All]