Computing a subproduct tree Consider the following description of a subproduct tree.

We define a tree T for some points x[0] to x[n-1], and define m = log_2(n).

Tree T is represented as a matrix where each row-column entry i, j is the product of pairwise nodes in the row above it. In total, there are m rows; the 1st row is has n column entries, and the last row has 1 column entry.

In short, how does one compute the coefficients for a large n? Once m > 4, the coefficients of the entries become greater than 64-bits. Consider the product of (x - i) for i = 0 to 15. The coefficients become very large.

Unless we are working in a finite field, it seems as though one cannot construct such a subproduct tree for say n = 2^20.

Formally: http://specfun.inria.fr/bostan/publications/BoSc05.pdf



Addendum:

I understand the complexity of the operation, as stated in the next section of the paper. However, I'm unsure how one would practically approach computing the coefficients of this subproduct tree as size n grows to be large (say 2^20).

Ex, consider the following simple example:
How does the computation scale?

Keep reading!  The paper describes how this scales for $n$, in the very next line after the excerpt you show.  In particular, the next line is Proposition 1, which states the running time of computing the subproduct tree, as a function of $n$.  That tells you how the running time scales for large $n$.

How do you compute the coefficients?

Follow the algorithm described in the paper!  You already described the algorithm.  Use exactly what you described.

Don't the coefficients become large, when $n$ is large?

Yes, potentially.  This is inherent to the task: if you want to compute some polynomial (the product) whose coefficients are large, then yes, the coefficients produced by such an algorithm will be large.  This is pretty much a tautological statement.