So now for more examples, well, how about the last example I gave, the exponential factorial. The function I gave was defined as: using tuple-notation as opposed to matrix-notation.

Whatever happens with this tensor power series stuff, it should produce the known power series for a function. So for the 2-variable case (actually, this only applies to one component), the power series should be the same as:

First thing to notice is that we can't make a series about (0, 0), because is indeterminate, and the next derivative involves which is infinite. So what we really need is a series about (0, 1) since which is finite, but unfortunately, this is not a fixed point, so we can't use regular iteration. That's OK, though, because we're just talking about power series. Using the standard term for Taylor series where each of the X's are vectors, we find that so the tensor power series will look like:

where actually represents k tensor contractions.

The second thing to notice is that using Taylor-Puiseux conversion (from my Abel function post), We can actually find the power series for the top part of the vector function about (0, 1), which is:

So what do all of the look like? Well, a simple way to look at it is that each term in the tensor power series is a vector that contains all polynomials of degree k. So, for example, the 2nd term will be a vector that holds all coefficients of , , and since these are all polynomials of degree 2. The 3rd term will be a vector that holds all coefficients of , , , and , and so on.

Here is the Mathematica code for calculating the multiple-gradients:

and here is the Mathematica code for the tensor power series of the exponential factorial:

To show you exactly how Mathematica evaluates these expressions:

and the next term:

and the next term:

Just to wrap up, and take a step back: although this may seem a bit messy, if this is the only way to convert current (univariate) analytic iteration theory to apply to multi-dimensional dynamical systems, then I think it is worth it.

Besides... we have computers now

Andrew Robbins

Whatever happens with this tensor power series stuff, it should produce the known power series for a function. So for the 2-variable case (actually, this only applies to one component), the power series should be the same as:

First thing to notice is that we can't make a series about (0, 0), because is indeterminate, and the next derivative involves which is infinite. So what we really need is a series about (0, 1) since which is finite, but unfortunately, this is not a fixed point, so we can't use regular iteration. That's OK, though, because we're just talking about power series. Using the standard term for Taylor series where each of the X's are vectors, we find that so the tensor power series will look like:

where actually represents k tensor contractions.

The second thing to notice is that using Taylor-Puiseux conversion (from my Abel function post), We can actually find the power series for the top part of the vector function about (0, 1), which is:

So what do all of the look like? Well, a simple way to look at it is that each term in the tensor power series is a vector that contains all polynomials of degree k. So, for example, the 2nd term will be a vector that holds all coefficients of , , and since these are all polynomials of degree 2. The 3rd term will be a vector that holds all coefficients of , , , and , and so on.

Here is the Mathematica code for calculating the multiple-gradients:

Code:

`GradientD[expr_List, vars_List, 0] := expr;`

GradientD[expr_List, vars_List, 1] := GradientD[expr, vars];

GradientD[expr_List, vars_List, n_] :=

GradientD[GradientD[expr, vars], vars, n - 1];

GradientD[expr_List, vars_List] :=

Map[Function[{f}, Map[Function[{x}, D[f, x]], vars]], expr];

Code:

`{1, 2} +`

{{0, 0},

{0, 1}}.{z, n-1} +

{{{0, 1}, {1, 0}},

{{0, 0}, {0, 0}}}.{z, n-1}.{z, n-1}/2! +

{{{{0, 0}, {0, -1}},

{{0, -1}, {-1, 0}}},

{{{0, 0}, {0, 0}},

{{0, 0}, {0, 0}}}}.{z, n-1}.{z, n-1}.{z, n-1}/3! +

{{{{{0, 0}, {0, 2}},

{{0, 2}, {2, 2}}},

{{{0, 2}, {2, 2}},

{{2, 2}, {2, 0}}}},

{{{{0, 0}, {0, 0}},

{{0, 0}, {0, 0}}},

{{{0, 0}, {0, 0}},

{{0, 0}, {0, 0}}}}}.{z, n-1}.{z, n-1}.{z, n-1}.{z, n-1}/4!

To show you exactly how Mathematica evaluates these expressions:

Code:

`{{0, 0}, {0, 1}}.{z, n-1}`

= {0, n - 1}

Code:

`{{{0, 1}, {1, 0}}, {{0, 0}, {0, 0}}}.{z, n-1}.{z, n-1}/2!`

= {{n - 1, z}, {0, 0}}.{z, n-1}/2!

= {2 (n - 1) z, 0}/2!

= {(n - 1) z, 0}

Code:

`{{{{0,0},{0,-1}},{{0,-1},{-1,0}}},{{{0,0},{0,0}},{{0,0},{0,0}}}}.{z, n-1}.{z, n-1}.{z, n-1}/3!`

= {{{0, 1 - n}, {1 - n, -z}}, {{0, 0}, {0, 0}}}.{z, n-1}.{z, n-1}/3!

= {{-(n - 1)^2, -2 (n - 1) z}, {0, 0}}.{z, n-1}/3!

= {-3 (n - 1)^2 z, 0}/3!

= {-(n - 1)^2 z/2, 0}

Just to wrap up, and take a step back: although this may seem a bit messy, if this is the only way to convert current (univariate) analytic iteration theory to apply to multi-dimensional dynamical systems, then I think it is worth it.

Besides... we have computers now

Andrew Robbins