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
- Solve \det(A - \lambda I) = 0 for the eigenvalues.
- 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.
-
The system (A - \lambda I)\vec{v} = \vec{0} is
designed to be dependent. After substituting the correct
\lambda, expect to see a row of all zeros, or two rows that are
identical or proportional to each other — exactly what happened in both worked examples above.
If instead you get a system that pins v_1 and
v_2 down to a single point (usually just the origin), you very likely
made an arithmetic slip finding \lambda in the first place — go back
and re-check the characteristic equation.
-
Eigenvectors have a free scale: any non-zero multiple of a valid eigenvector is
equally valid. (1,1), (2,2), and
(-5,-5) are all "the" eigenvector for \lambda=3
above — they all point along the same line. By convention, authors report the simplest
whole-number version (the shortest one with no common factor), but there is no single "correct"
eigenvector, only a correct direction.
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