Why doesn't ParallelTable work on this very simple example?

Question

For some reason, I'd like to use ParallelTable with a variable number of iterators.

• Table[a[1], {a[1], 0, 10}] works fine:

Output: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

• ParallelTable[a[1], {a[1], 0, 10}] returns an error:

Output: ParallelTable::nopar1: ParallelTable[ci[1],{ci[1],0,10}] cannot be parallelized; proceeding with sequential evaluation. >>

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

---

I am also interested in workarounds to use ParallelTable and a variable number of indices (typically: ParallelTable[f[Table[a[i],{i,1,n}]],Table[a[j],{j,1,n}]] where f is a function of a list with variable size).

Answer 1

Using Trace we can see that the evaluation of ParallelTable[a[1], {a[1], 0, 10}] becomes:

Parallel`Combine`Private`parallelIterateE[
  ParallelTable, Table, Join, Identity, a[1], {a[1], 0, 10}, {Automatic, "Global`"}
]

Further using PrintDefinitions in the GeneralUtilities package lets us peek behind the curtain:

Needs["GeneralUtilities`"]

PrintDefinitions @ Parallel`Combine`Private`parallelIterateE

We see definitions specifically wanting a Symbol:

Parallel`Combine`Private`parallelIterateE[orig_, iter_, comb_, f_, 
  expr_, {i_Symbol, vals_List}, others___, {meth_, dist_, ___}] := . . .

Parallel`Combine`Private`parallelIterateE[orig_, iter_, comb_, f_, expr_, 
  it : {i_Symbol, w0_ : 1, w1_, dw_ : 1}, others___, {meth_, dist_, ___}] := . . .

If in each of these we replace i_Symbol with i_Symbol | i : _Symbol[___] and evaluate the cells we find that the problem is resolved:

ParallelTable[a[1], {a[1], 0, 10}]    (* no error message *)

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

In light of this I think it was an accident to restrict the iterators to bare Symbols, and I propose tagging this as a bug.

Answer 2

This seems to just be a limitation of ParallelTable, can't comment whether that has a deeper reason due to parallelism or is just a simple oversight. I think it was not possible to use expressions like a[i] as e.g. iterators in older versions but in newer version that has been added as a feature to many functions, but obviously not ParallelTable (as of 10.0.2, still doesn't work in 10.1.0). That is somewhat inconsistent, and it might work with future versions, but for the moment you'd have to use a workaround as Kattern has suggested and use explicit symbols instead of the a[i] like e.g.:

asym[i_Integer] := Symbol["a" <> ToString[i]];
With[{
    iter = Sequence @@ Table[{asym[j], -1, 1}, {j, 1, 3}]
  },
  ParallelTable[$KernelID -> f[Table[asym[i], {i, 1, 3}]], iter]
]

alternatives to create symbol names would include:

asym[i_Integer] := asym[i] = Module[{a}, a];
asym[i_Integer] := asym[i] = Unique["a"];

each has there advantages and disadvantages, a common problem is that you have to manually cleanup as they create a bunch of symbols instead of just one as your original approach...