Getting l1 normalized eigenvectors from python instead of l2?

Question

Consider this matrix:

[.6, .7]
[.4, .3]

This is a Markov chain matrix; the columns each sum to 1. This can represent a population distribution, transition rates, etc.

To get the population at equilibrium, take the eigenvalues and eigenvectors...

From wolfram alpha, the eigenvalues and their corresponding eigenvectors are:

l1 = 1, v1 = [4/7, 1]
l2 = -1/10, v2 = [-1,1]

For the population at equilibrium, take the eigenvector that corresponds to the eigenvalue of 1, and scale it so the total = 1.

Vector = [7/4, 1]
Total = 11/4

So multiply the vector by 4/11...

4/11 * [7/4, 1] = [7/11, 4/11]

Therefore at equilibrium the first state has 7/11 of the population and the other state has 4/11.

If you take the desired eigenvector, [7/4, 1] and l2 normalize it (so all squared values sum up to 1), you get roughly [.868, .496] .

That's all fine. But when you get the eigenvectors from python...

mat = np.array([[.6, .7], [.4, .3]])
vals, vecs = np.linalg.eig(mat)
vecs = vecs.T #(because you want left eigenvectors)

One of the eigenvectors it spits out is the [.868, .496] one, for l2 normed ones. Now, you can pretty easily scale it again so the sum of each value is 1 (instead of the sum of THE SQUARE of each value) being 1... just do the vector * 1/sum(vector). But is there a way to skip this step? Why add the computaitonal expense to my script, having to sum up the vector each time I do this? Can you get numpy, scipy, etc to spit out the l1 normalized vector instead of the l2 normalized vector? Also, is that the correct usage of the terms l1 and l2...?

Note: I have seen previous questions asking how to get the markov steady states in this manner. My qusetion is different, I am asking how to get numpy to spit out a vector normalized in the way I want, and I am explaining my reasoning by including the markov part.

Answer 1

I think you're assuming that np.linalg.eig computes eigenvectors and eigenvalues like you would by hand. It doesn't. Under the hood, it uses a highly optimized (and famous) FORTRAN library called LAPACK. This library uses numerical techniques that are sort of out of scope, but long story short it doesn't compute the eigenvalues for a 2x2 like you would by hand. I believe it uses the QR algorithm most of the time, and sometimes QZ, or even others. It's not all that simple: I think it even chooses different algorithms based on the matrix structure/size sometimes (I'm not a LAPACK expert, so don't quote me here). What I do know is that LAPACK has been vetted over about 40 years and it is pretty darned fast, and with great speed comes great complexity.

Wolfram Alpha, on the other hand, is using Mathematica on the backend, which is a symbolic solver (ie not floating point arithmetic). That's why you get the "same" result as if you'd do it by hand.

Long story short, asking to get you the L1 norm from np.linalg.eig just isn't possible: if you look at the QR algorithm, each iteration will have the L2 normalized vector (that converges to an eigenvector). You'll have trouble getting it from most numerical libraries for the simple reason that a lot of them depend on LAPACK or use similar algorithms (for instance MATLAB outputs unit vectors as well).

At the end of the day, it doesn't really matter if the vector is normalized or not. It really just has to be in the right direction. If you need to scale it for a proportion, then do that. It'll be vectorized (ie fast) by numpy since it's a simple multiply.

HTH.