Finding Eigenvectors

Hunting down an eigenvalue with the characteristic equation is the hard part — it means factoring a polynomial with no guarantee of nice roots. The good news: once you actually have an eigenvalue \lambda in hand, finding its matching eigenvector is a much gentler, completely mechanical last step. Just plug that specific number back into

(A - \lambda I)\vec{v} = \vec{0}

and solve it like any other system of equations. Here's the reassuring part: because \lambda was chosen precisely to make A - \lambda I non-invertible, this system is 100% guaranteed to have a non-zero solution. You will never do all this work and come up empty-handed — the characteristic equation already did the hard guarantee-work for you.

Think of it like a locksmith who has already confirmed a door can be opened before handing you the tools — the characteristic equation was that confirmation. All that's left now is the comparatively routine job of turning the handle: substitute, row-reduce, read off the direction.

The process: solving for a direction, not a point

Substitute your eigenvalue into A - \lambda I and row-reduce it as usual. Something different happens compared with a normal system, though: instead of pinning down one exact point, you'll always be left with one free variable. That's not a mistake — it means the solutions form an entire line through the origin, called the null space of A - \lambda I. Every point on that line (except the origin itself) is a perfectly valid eigenvector: pick any value for the free variable, and the rest of the vector falls out from the equations.

Worked example: the first eigenvector

Take A = \begin{bmatrix} 2 & 1 \\ 1 & 2 \end{bmatrix}, whose characteristic equation gives eigenvalues \lambda = 3 and \lambda = 1. Start with \lambda = 3. Subtract it from the diagonal:

A - 3I = \begin{bmatrix} -1 & 1 \\ 1 & -1 \end{bmatrix}.

Written out as equations, (A-3I)\vec{v} = \vec{0} says:

-v_1 + v_2 = 0 \qquad\text{and}\qquad v_1 - v_2 = 0.

Both equations say exactly the same thing (v_2 = v_1) — that's the guaranteed dependency showing up right on schedule. Since v_1 is free, the simplest choice is v_1 = 1, giving v_2 = 1. So one eigenvector for \lambda = 3 is \vec{v} = (1, 1).

Worked example: the second eigenvector

Now repeat the exact same recipe for the other eigenvalue, \lambda = 1:

A - I = \begin{bmatrix} 1 & 1 \\ 1 & 1 \end{bmatrix}.

Both rows are now identical, so the system collapses to a single equation:

v_1 + v_2 = 0 \quad\Longrightarrow\quad v_2 = -v_1.

Choosing the free variable v_1 = 1 gives v_2 = -1, so an eigenvector for \lambda = 1 is \vec{v} = (1, -1) — a completely different direction from the first one, and (for this symmetric matrix) at right angles to it.

Verifying both answers

Never trust an eigenvector without checking it. Plug each one straight back into A\vec{v} = \lambda\vec{v}:

A(1,1) = \begin{bmatrix} 2\cdot 1 + 1\cdot 1 \\ 1\cdot 1 + 2\cdot 1 \end{bmatrix} = (3, 3) = 3\cdot(1,1). \quad\checkmark A(1,-1) = \begin{bmatrix} 2\cdot 1 + 1\cdot(-1) \\ 1\cdot 1 + 2\cdot(-1) \end{bmatrix} = (1, -1) = 1\cdot(1,-1). \quad\checkmark

Both check out exactly: multiplying by A sends each vector straight back onto its own line, scaled by its own eigenvalue. Pick either eigenvalue below and watch the diagram confirm the same thing visually — the red arrow A\vec{v} always lands right on top of the blue eigenvector's line.

Worked example: a triangular shortcut

One family of matrices makes the eigenvalue step almost free: for a triangular matrix (everything above or below the diagonal is zero), the eigenvalues are simply the diagonal entries themselves — no characteristic-equation work required. Take A = \begin{bmatrix} 5 & 3 \\ 0 & 2 \end{bmatrix}, whose eigenvalues are \lambda = 5 and \lambda = 2 by inspection. The eigenvector step still needs the full recipe, though. For \lambda = 5:

A - 5I = \begin{bmatrix} 0 & 3 \\ 0 & -3 \end{bmatrix} \quad\Longrightarrow\quad 3v_2 = 0 \quad\Longrightarrow\quad v_2 = 0,

with v_1 free, so \vec{v} = (1, 0). For \lambda = 2:

A - 2I = \begin{bmatrix} 3 & 3 \\ 0 & 0 \end{bmatrix} \quad\Longrightarrow\quad 3v_1 + 3v_2 = 0 \quad\Longrightarrow\quad v_1 = -v_2,

so choosing v_2 = -1 gives \vec{v} = (1, -1). Notice the pattern: the eigenvector for the largest diagonal entry of an upper-triangular matrix always ends up pointing along the first axis — a useful sanity check to have in your back pocket.

Worked example: eigenvectors don't have to be at right angles

In the very first example, the eigenvectors (1,1) and (1,-1) happened to be perpendicular. It's tempting to assume that's always true — it isn't. That neat right angle only shows up for symmetric matrices (where flipping rows and columns gives back the same matrix). Try a non-symmetric example: A = \begin{bmatrix} 4 & 2 \\ 1 & 3 \end{bmatrix}. Its characteristic equation is \lambda^2 - 7\lambda + 10 = 0, which factors as (\lambda-5)(\lambda-2)=0, giving \lambda = 5 and \lambda = 2. For \lambda = 5:

A - 5I = \begin{bmatrix} -1 & 2 \\ 1 & -2 \end{bmatrix} \quad\Longrightarrow\quad v_1 = 2v_2 \quad\Longrightarrow\quad \vec{v} = (2, 1).

And for \lambda = 2:

A - 2I = \begin{bmatrix} 2 & 2 \\ 1 & 1 \end{bmatrix} \quad\Longrightarrow\quad v_1 = -v_2 \quad\Longrightarrow\quad \vec{v} = (-1, 1).

Check the angle between (2,1) and (-1,1): their dot product is 2\cdot(-1) + 1\cdot 1 = -1, not zero — so they are not perpendicular. Both are still perfectly valid eigenvectors (double-check: A(2,1) = (10,5) = 5(2,1) and A(-1,1) = (-2,2) = 2(-1,1), both correct). The lesson: expect a right angle only when you already know the matrix is symmetric.

The recipe, start to finish

  1. Solve \det(A - \lambda I) = 0 for the eigenvalues.
  2. For each \lambda, solve (A - \lambda I)\vec{v} = \vec{0} for the eigenvector direction.

That pair of steps unlocks the payoff: a matrix with a full set of independent eigenvectors can be diagonalized — rewritten as a pure stretch along its own axes. Notice how the two steps divide the labour neatly: step 1 is the creative, sometimes-tricky search (factoring an unknown polynomial), while step 2 is the reliable, repeatable clean-up — the same handful of row operations, every single time, guaranteed to succeed because of how \lambda was chosen.

Row-reducing a 100×100 system by hand is out of the question, and even the eigenvalue you're plugging in usually only comes from a numerical approximation rather than an exact number. Software libraries lean on a beautifully simple trick called power iteration instead: start with almost any random vector, multiply it by A over and over, and rescale it back to length one after each step. Every repeated multiplication stretches the component lying along the dominant eigenvector (the one with the largest eigenvalue) more than every other component, so after enough rounds the vector swings around and lines up with that eigenvector almost exactly — the very same "line that doesn't move" idea you've been solving for algebraically, just discovered by brute repetition instead of algebra.

This two-step dance — solve the characteristic equation, then solve (A-\lambda I)\vec{v}=\vec{0} for each root — is exactly what's running under the hood every time an engineer or data scientist calls numpy.linalg.eig() in Python or eig() in MATLAB. Real software doesn't factor the polynomial by hand the way we just did; for large matrices it uses clever iterative numerical methods that home in on the same answers. But the underlying idea — hunt the eigenvalues, then solve for each eigenvector's direction — is precisely the process you just worked by hand, running millions of times a day inside everything from bridge simulations to Google's search-ranking algorithm.

One especially famous use: in machine learning, the eigenvectors of a dataset's covariance matrix point along the directions where the data varies the most and least. Those directions are called the principal components, and finding them (via exactly this eigenvector recipe) is the engine behind Principal Component Analysis — a cornerstone technique for compressing and understanding high-dimensional data.

See it explained