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?

 

[chiro]

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.

 

[chiro]

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.

 

[blue_raver22]

I am familiar with the Karhunen-Loeve transformation and its applications in signal processing and data analysis. The algorithm for a tensorial Karhunen-Loeve transformation involves finding the eigentensors of a correlation bitensor, as described in the provided equation. This can be done numerically by solving the equation using a lattice of points, as mentioned.

One approach to solving this problem is to use the method of principal component analysis (PCA), which is commonly used for scalar data but can also be extended to handle tensor data. In this method, the correlation bitensor would be decomposed into its eigentensors, which represent the most dominant modes of variation in the data. This can be done using techniques such as singular value decomposition (SVD) or eigenvalue decomposition (EVD).

Another approach would be to use a multivariate statistical technique such as multilinear principal component analysis (MPCA) or higher-order singular value decomposition (HOSVD). These methods are specifically designed to handle tensor data and can be adapted to solve the provided equation.

In either case, it is important to carefully consider the choice of lattice points and the size of the tensor data in order to ensure accurate and efficient computation. Additionally, it may be helpful to consult with experts in the field or refer to existing literature on tensorial Karhunen-Loeve transformations for further guidance.

In conclusion, while there may not be a single algorithm that is universally accepted as the best for a tensorial Karhunen-Loeve transformation, there are various methods and techniques that can be applied to solve the provided equation numerically. It is important to carefully consider the specific problem at hand and choose an appropriate approach that will provide accurate and meaningful results.