Taylor series wrt grading

One can naturally extend the expression for the Taylor series in several variables around

(1)

to the case of an infinite-dimensional vector

(2)

If one wants to consider this expession, let's say, to the order , they are left with an infinite amount of terms. Of course, the terms can be with some effort arranged into an infinite sum with some very concrete general expression for the summands. And if it's your goal then you won't find the following text useful.

But if you want to feed this expression to the computer and make it do the sanity checks for you order by order, then you need this expansion to be over some finite-dimensional parameter. Grading serves well for this purpose. If you don't have natural grading on your infinite-dimensional vector space you'd better introduce one. Now the multi‐index can be identified with the partition (Young diagram)

(3)

where is the number of parts of size . Hence

(4)

We can count the grading of with the help of the substitution

(5)

so the total power of in front of will be equal to the grading. It will provide us the only expansion parameter since with this substitution becomes

(6)

So restricting ourselves with partitions of maximum size we obtain the finite sum which computer can understand and process. At the same time taking we obtain the full original function as an infinite series.

Computation primer

Let's expand the exponent of an infinite sum

(7)

to the 4-th order in grading using the described technology to do the sanity check of computation here.

After the substitution (5) the desired exponent becomes

(8)

so we can safely enter the finite sum up to the desired order being sure that we've taken into account everything relevant. On the language of sage this reads as 

R = PolynomialRing(QQ, "t", 4 + 1)
t = R.gens()
k, epsilon = var('k,epsilon')

f = exp(sum(epsilon**k * t[k] for k in range(1, 4 + 1)))

f
(9)

Computer algebra systems are in general very fast in Taylor series expanding, so let's delegate this task to sage 

expand(f.taylor(epsilon, 0, 4))
(10)

Of course, we don't need anymore, let's throw it out 

f_taylor = expand(f.taylor(epsilon, 0, 4)).subs(epsilon==1)

f_taylor
(11)

Now we can compare the result with S we've obtained here 

bool(f_taylor == S)

True