When executing MCTS' expansion phase, where you create a number of child nodes, select one of the numbers, and simulate from that child, how can you efficiently and non-biased-ly decide which child(ren) to generate?
One strategy is to always generate all possible children. I believe that this answer says that AlphaZero always generates all possible (~300) children. If it were expensive to compute the children or if there were many of them, this might not be efficient.
One strategy is to generate a lazy stream of possible children. That is, generate one child and a promise to generate the rest. You could then randomly select one by flipping a coin: heads you take the first child, tails you keep going. This is clearly biased in favor of children earlier in the stream.
Another strategy is to compute how many N children there are and provide a function to generate child X < N (of type Nat -> State). You could then randomly select one by choosing uniformly in the range [0, N). This may be harder to implement than the previous version because computing the number of children may be as hard as computing the children themselves. Alternatively, you could compute an upper-bound on the number of children and the function is partial (of type Nat -> Maybe State), but you'd be doing something like rejection sampling.
I believe that if the number of iterations of MCTS remaining, X_t, is larger than the number of children, N, then it doesn't matter what you do, because you'll find this node again the next iteration and expand one of the children. This seems to suggest that the only time it matters is when X_t < N and in situations like AlphaZero, N is so much smaller than X_0, that this basically never matters.
In cases, where X_0 and N are of similar size, then it seems like the number of iterations really needs to be changed into something like an amount of time and sometimes you spend your time doing playouts while other times you spend your time computing children.
Have I thought about this correctly?