One object, the entire solution
Stand back and look at what this rung built. You began with a loose list of solution vectors, filed them into a fundamental matrix, normalised that to the identity at the start, and recognised the result as something that deserved a name: the matrix exponential e^(At). Every guide since has been circling the same object from a different side. This capstone makes the claim plainly: e^(At) is not one tool among many for linear systems — it is the linear system, written as motion. Knowing e^(At) is knowing everything the equation x' = A x can do.
Hold the two headline formulas side by side. For the unforced system, x(t) = e^(At) x(0): the matrix exponential takes the starting state and carries it forward, and that is the complete answer to every initial value problem the system can pose. For the forced system x' = A x + g(t), the same object reappears inside the convolution formula x(t) = e^(At) x(0) + integral from 0 to t of e^(A(t - s)) g(s) ds: the free flow of the start, plus every past kick carried forward by that same flow and summed. One object answers both questions. The free case is just the forced case with nothing pushing.
free system: x' = A x => x(t) = e^(At) x(0)
forced system: x' = A x + g(t) => x(t) = e^(At) x(0)
+ integral_0^t e^(A(t - s)) g(s) ds
same e^(At) in both lines
| |
the flow the carrier inside the convolutionFour roads, one summit
If e^(At) is the whole story, then every computing trick from earlier in the rung is just a different road up the same mountain. You learned at least four. Diagonalisation decouples the system into independent scalar exponentials e^(lambda t) along an eigenbasis and reassembles them. When eigenvectors run short, the Jordan form method handles the defective blocks with a finite polynomial-times-exponential correction. The Putzer algorithm and Cayley-Hamilton theorem skip eigenvectors entirely, building e^(At) from powers of A alone. And the Laplace transform route reads it straight off as the inverse transform of (sI - A)^(-1).
These are not rival answers. They are four computations of one well-defined matrix, and they must agree to the last digit, because e^(At) is uniquely pinned down: it is the only matrix function satisfying both its own differential law and the value I at t = 0. The variety is purely practical. Diagonalisation is fastest when A has a clean eigenbasis; Jordan saves you when it does not; Putzer is a tidy hand computation for small A; Laplace is natural when you are already in the transform world. Pick the cheapest road for your matrix — the summit is the same.
The exact analogue of e^(at)
Why does this one object carry so much? Because it is the faithful matrix translation of the simplest equation you ever solved. The scalar problem x' = a x has the answer x(t) = e^(at) x(0); promote the number a to a matrix A and the number x to a vector x, and literally every symbol survives the upgrade. The defining law (e^(at))' = a e^(at) becomes (e^(At))' = A e^(At); the initial value e^(0) = 1 becomes e^(A0) = I; the scalar exponential that grows or decays at one rate becomes a matrix that grows and decays along several intertwined directions at once. The matrix exponential is what e^(at) was always going to be once you let the rate be a matrix.
One scalar habit, though, does NOT survive — and forgetting this is the classic blunder. For numbers, e^(a + b) = e^a e^b always. For matrices, e^(A + B) = e^A e^B holds only when A and B commute, that is when AB = BA. The proof of the scalar law silently reorders factors, and matrices refuse to be reordered. What does survive is the law in a single A: e^(A(t + s)) = e^(At) e^(As), because A always commutes with itself. That surviving identity is the semigroup property, and it is exactly the statement that the system's flow composes — run it for time s, then for time t, and you have run it for time t + s.
The eigenvalues already told you the ending
Here is where e^(At) reaches beyond a formula and into fate. You usually do not need the matrix itself to know how the system ends up — you need its eigenvalues. In the diagonalisable case every solution is a blend of terms e^(lambda t), and each mode's long-run behaviour is decided by the real part of its eigenvalue lambda. A negative real part makes that mode decay to zero; a positive real part makes it blow up; the imaginary part only sets how fast it spins on the way. So the entire qualitative future of x' = A x is encoded in where the eigenvalues of A sit in the complex plane.
This is the bridge from this rung straight into the phase plane. If every eigenvalue of A has negative real part, e^(At) shrinks every state toward the origin and the equilibrium at 0 is asymptotically stable — you have just read asymptotic stability directly off the spectrum, with no need to compute the exponential at all. The geometry that follows — whether trajectories spiral, settle into a node, or saddle past the origin — is the phase portrait, and its whole shape is dictated by the same eigenvalues that govern e^(At). The matrix exponential gives the exact trajectories; its eigenvalues give the picture you can sketch by hand.
Honest cautions before you crown it
A capstone owes you the limits, not just the triumph. The first boundary is sharp: this entire story is about linear, constant-coefficient systems. The matrix exponential exists, propagates states, and obeys the convolution formula because superposition holds and A does not depend on t. The moment the system is nonlinear, x' = f(x), there is no e^(At) and generally no closed form at all; those equations need the qualitative and numerical methods from later rungs. And if A(t) varies in time, a flow still exists but it is rarely a clean exponential. Treasure this clean story for exactly the class it serves.
The second caution is numerical, and it surprises people. 'We have a closed form' does not mean 'we can compute it reliably'. Actually evaluating e^(At) for a large matrix, or for a non-normal A whose eigenvectors are nearly parallel, is genuinely delicate — naive recipes lose accuracy badly, which is why a famous survey is titled 'Nineteen Dubious Ways to Compute the Exponential of a Matrix' (and a later follow-up found them no less dubious). The four hand methods you learned are perfect for understanding and for small problems; serious large-scale computation hands the job to carefully engineered algorithms, not to the textbook series.