From "only zero" to a question worth asking
In the previous guide you met the boundary value problem and its unsettling habit: unlike an initial value problem, it does not promise exactly one solution. A homogeneous boundary value problem — equation equal to zero, conditions equal to zero at both ends — always has the trivial solution y = 0. The deep question is when it has anything *else*. Most of the time the answer is a flat no. But that "most of the time" is hiding the entire subject, because the exceptions are where the music is.
Here is the trick that makes the exceptions appear on cue. Take the homogeneous equation and slip an adjustable number into it. The cleanest example, the one the whole theory is built around, is y'' + lambda y = 0 on the interval 0 <= x <= L, with y(0) = 0 and y(L) = 0. The boundary conditions are fixed; the number lambda is a dial we may turn. For almost every setting of the dial the only solution is y = 0. But at certain special settings — and only those — a genuine nonzero solution clicks into existence. Turning lambda into a hunt for those special settings is exactly the eigenvalue problem.
The matrix picture, lifted to functions
It pays to hold the linear-algebra picture firmly before we compute, because every step here is a translation of something you already know. In finite dimensions, A x = lambda x says: feed the vector x to the matrix A and, instead of a generic new vector, you get the same x scaled by lambda. Such an x is an eigenvector and the scale factor lambda is its eigenvalue. The whole point is that this only happens for special directions — most vectors get rotated into something unrelated.
Now perform the lift. Replace the matrix A by the differential operator "take y'' (and obey y(0) = y(L) = 0)", replace the vector x by a function y(x), and replace ordinary scaling by the equation y'' = -lambda y. Read that last line slowly: it says applying the operator to y returns y itself, merely multiplied by the constant -lambda. The function survives the operator unchanged in shape, only rescaled — exactly what an eigenvector does. A function with that magical property is an eigenfunction, and the lambda that makes it work is its eigenvalue.
finite dimensions functions on [0, L] ----------------- ------------------------------- matrix A <--> operator y -> -y'' (with y(0)=y(L)=0) vector x <--> function y(x) A x = lambda x <--> -y'' = lambda y eigenvector x <--> eigenfunction y(x) eigenvalue lambda <--> eigenvalue lambda
Solving the model problem, sign by sign
Let us actually hunt the eigenvalues of y'' + lambda y = 0 with y(0) = y(L) = 0. The honest way is to solve the equation in general for each possible sign of lambda and then ask the boundary conditions whether anything nonzero survives. This is not a trick to memorize — it is the whole method, and every Sturm-Liouville problem you ever meet is solved by this same patient case-work.
- Case lambda < 0 (write lambda = -k^2). The general solution is built from e^(kx) and e^(-kx) — pure growth and decay, no wiggle. Forcing y(0) = 0 and y(L) = 0 on such curves leaves only y = 0. No eigenvalue here: exponentials cannot return to zero at a second point without being flat.
- Case lambda = 0. The equation is just y'' = 0, so y = a x + b, a straight line. The line through (0, 0) and (L, 0) is the flat line y = 0. Again only the trivial solution. Zero is not an eigenvalue of this problem either.
- Case lambda > 0 (write lambda = mu^2). Now the solutions oscillate: y = A cos(mu x) + B sin(mu x). The condition y(0) = 0 kills the cosine, leaving y = B sin(mu x). The remaining condition y(L) = 0 demands sin(mu L) = 0 — and THIS is the door that opens.
- Read the quantization. sin(mu L) = 0 forces mu L = n pi for a whole number n = 1, 2, 3, ... So the permitted values are lambda_n = (n pi / L)^2, each with its own shape y_n(x) = sin(n pi x / L). We can drop the constant B because any nonzero multiple of an eigenfunction is again an eigenfunction.
Step back and savour what just happened. A continuous dial, lambda, ranging over every real number, was forced by two innocent-looking boundary conditions to collapse onto a discrete ladder lambda_1, lambda_2, lambda_3, ... — the squares (pi/L)^2, (2 pi/L)^2, (3 pi/L)^2, climbing to infinity. Continuity in, discreteness out. That is quantization, and it is the exact mathematical reason a guitar string sounds a definite pitch and its overtones, and the reason a trapped quantum particle has discrete energy levels rather than a continuous smear. The eigenfunctions sin(n pi x / L) are precisely the standing-wave shapes: n = 1 is the fundamental arch, n = 2 has one interior node, n = 3 has two, and so on up the ladder.
What changes the answer — and what doesn't
A common beginner's belief is that eigenvalues belong to the equation y'' + lambda y = 0. They do not. They belong to the equation *together with its boundary conditions*; change the conditions and you generally change the whole ladder. Swap y(L) = 0 for the slope condition y'(L) = 0 (a free or insulated end instead of a clamped one) and the door opens at cos(mu L) = 0 instead, so the eigenvalues become ((2n-1) pi / 2L)^2 and the eigenfunctions become sin((2n-1) pi x / 2L) — a different ladder, different shapes, from the very same differential equation. This is precisely why the boundary value problem is a different animal from the initial value problem.
Two patterns do survive across all the standard cases, and they are worth trusting. First, the eigenvalues form an increasing sequence marching off to infinity, lambda_1 < lambda_2 < lambda_3 < ..., never bunching up and never coming back down. Second, the n-th eigenfunction has exactly n-1 interior zeros — one more wiggle each rung up the ladder. That second fact is no accident; it is the content of the oscillation theorem you will meet by name in the next guide, and it lets you sanity-check eigenfunctions just by counting their nodes.
Why anyone should care: the shapes are a basis
Finding a ladder of special functions would be a curiosity if it stopped there. It does not, and here is the payoff that makes the whole rung worth climbing. The eigenfunctions sin(n pi x / L) are mutually orthogonal: integrate the product of two different ones across [0, L] and you get exactly zero. They behave like perpendicular axes — but in a space whose "points" are entire functions. That orthogonality is the property that lets you treat them as a coordinate system, and it is the seed of everything in the next two guides.
Orthogonal axes are exactly what you need to write any reasonable function f(x) on the interval as a weighted sum of these basic shapes, f(x) = c_1 sin(pi x / L) + c_2 sin(2 pi x / L) + ..., and to read off each coefficient cleanly — that is the eigenfunction expansion, and in this particular case it is the Fourier sine series. It is also why the eigenvalue problem is the bridge to separation of variables: when you split a heat or wave equation into space-times-time, the spatial factor lands on exactly this problem, the eigenfunctions become the building-block modes, and each mode evolves in time on its own. The discrete ladder you found is, quite literally, the list of natural modes of the system.
So this guide is the pivot of the rung. Behind you sits the bare boundary value problem and its trivial solution; ahead lies the Sturm-Liouville theory that explains *why* the eigenvalues are real, why the ladder climbs to infinity, and why the eigenfunctions are always orthogonal — promises we have only sampled here on one lucky example. Take with you the one image that organizes all of it: a differential operator, like a matrix, has special inputs it merely rescales, and at a boundary those special inputs line up into a discrete, orthogonal ladder of shapes.