# Algorithm for a tensorial Karhunen-Loeve Transformation?

Aimless
Does anyone happen to know a good algorithm for a numerical Karhunen-Loeve transformation for tensors?

Specifically, I'm trying to solve for the eigentensors of a correlation bitensor, along the lines of
$$\int_{-\infty}^{\infty} d^4x' \, C_{abc'd'}(x,x') \phi^{c'd'}(x') = \lambda \phi_{ab}(x) \,$$ where the primes represent indices which transform at the point $x'$. What I need to find is a numerical algorithm to solve this equation with support on a lattice of points.

I have a good handle on how to do this for scalars, but can't figure out how to adapt the algorithm to handle tensor expressions. Does anyone have any experience with this, and if so could you give me some pointers?

## Answers and Replies

Hey Aimless.

I'm not an expert by any means but just a few ideas.

One possibility that might help is to use some of the properties for finite-rank operators whereby transformations of the operators follow the conventional transformation. For example if you wanted to calculate I / (I - A) then you could calculate A, A^2, A^3 and so on as long as the operator norm is < 1. You would want to check the conditions on the norms and the spectrum for when you can do this (i.e. of the operator).

They use for example in applied probability when you need to find the transition matrix of a system and you've give a relationship between the time-derivative of the matrix in form of dP/dt = PQ where Q is a constant matrix, but P is a function of time (i.e. continuous time markov chains).

If your numerical schemes generalize effectively enough, then you can replace your scalar quantities with matrices and take it from there.

Aimless
If your numerical schemes generalize effectively enough, then you can replace your scalar quantities with matrices and take it from there.

I've thought about trying something along these lines, and I suspect that this is the right idea; I'm just stuck on the implementation.

For a scalar correlation function $C(x,x')$, the easy solution is to just treat the problem as having support only on the lattice, construct the correlation matrix $C(x_i,x_j); \, i,j=1...N$, and solve for the eigenvalues and eigenvectors.

Presumably, I could do the same thing for the tensor expression; then my eigenvalue problem turns into something like $$\sum_{j} C_{a_ib_ic_jd_j}(x_i,x_j) \phi^{c_jd_j}(x_j) = \lambda \phi_{a_ib_i}(x_i) \, .$$ However, this is where I start to get unsure about implementation.

The next step is presumably to rewrite this expression as something along the lines of $$\sum_{j} C_{a_ib_ic_jd_j}(x_i,x_j) \phi^{c_jd_j}(x_j) - \lambda \delta_{ij} g_{a_ic_j} g_{b_id_j} \phi^{c_jd_j}(x_j) = 0 \, ,$$ where $g_{a_ic_j}$ is the bivector of parallel transport. Thus giving my eigenvalue equation as $$det \left( C_{a_ib_ic_jd_j}(x_i,x_j) - \lambda \delta_{ij} g_{a_ic_j} g_{b_id_j}\right) = 0 \, .$$ However, I'm not sure what this means, or even if it's well-posed.

Have you looked at tensor libraries in something like C++ and see if the API of such implementations includes routines corresponding to the techniques used in your problem?

The tensor libraries should have exactly the same kind of implementation features as the normal matrix ones plus the other stuff for the generalized nature of the tensors.

I did a quick google search and I saw this:

http://www.gnu.org/software/gsl/

It has a tensor extension component which might help you out with regards to implementation, even if it leads to an implementation rather than being the whole solution in itself.