03 Control Systems · #13 of 46

State-Space

Stop chasing one output at a time. Describe the whole machine as a single vector that knows where it's going next

A transfer function is a confession that you only care about one input and one output. The moment your robot has six joints, three accelerometers, and two wheels that talk to each other, that single fraction collapses under its own algebra.

So the 1960s threw it out and started over with a sentence: here is everything the machine remembers, and here is the rule for what it does next.

That "everything it remembers" is a list of numbers (position, velocity, angle, current) stacked into one vector called the state, written $x$ . Instead of asking "what comes out when I poke this input," state-space asks a humbler, deeper question: given exactly where the system is right now, which direction is it about to move? The answer is one matrix multiply.

The state is the smallest thing the system has to remember

There is a precise reason this short list of numbers is enough. The state variables are the smallest subset of quantities that pin down everything the system will do next, given the future inputs. Pick fewer and you cannot predict the future; pick more and the extras are redundant. In an electric circuit there is even a physical bookkeeping trick for spotting them: the number of state variables is usually the number of things that store energy, one per capacitor (which remembers a voltage) and one per inductor (which remembers a current). A spring-and-mass cart needs exactly two, position and velocity, because those are the two places motion can hide. The state is not a modelling choice you sweat over. It is just the system's memory, counted.

Watch a system decide where to go

The picture below is that rule made visible. Every tiny arrow shows the direction the state would slide from that point; long arrows mean fast motion, short ones mean slow. The four sliders are the entries of the $A$ matrix: change them and the entire arrow field re-flows. Tap anywhere to drop an initial condition, and the trajectory is integrated forward, obediently following the arrows. Drop several and watch the whole plane reveal its personality.

Tap to plant a trajectory

A₁₁ 0.00 A₁₂ 1.00 A₂₁ −1.00 A₂₂ −0.40

eigenvalues —

tr(A) —

det(A) —

type —

what to try

Press the "damped spring" preset. Then tap a few spots far from the origin. Every trajectory spirals inward and eventually dies at $(0, 0)$ . The eigenvalues in the metric row are a conjugate pair with negative real part: the classic stable-spiral signature.
Slide A₂₂ from −0.4 toward zero. Watch the spiraling slow down. At A₂₂ = 0, trajectories are perfect closed circles, no decay, no growth. The eigenvalues just crossed the imaginary axis: real part = 0. Keep going past zero, and trajectories now spiral outward: same shape, opposite time direction. The system became unstable.
Try the "saddle" preset. The eigenvalues are now one positive, one negative. There are two special directions (eigenvectors): trajectories along one come into the origin, along the other they run away. Generic trajectories follow a hyperbola-like path. This is the textbook unstable-equilibrium shape, like a ball on a saddle.
Watch the metrics as you slide. Notice that $d e t (A) = l amb d a_{1} l amb d a_{2}$ and $e x t t r (A) = l amb d a_{1} + l amb d a_{2}$ are the same numbers that decide the transfer-function pole locations.

The four presets are the canonical shapes you meet in any dynamics textbook: pure oscillation (a spring that never tires), a damped spiral (a spring with friction), a saddle (a ball balanced on a horse's saddle), and an unstable spiral (the same spring, run backward, flying apart). The eigenvalues in the metrics row are the system's fingerprint: their real part says how fast trajectories grow or decay, their imaginary part says how fast they spin.

The core idea is almost embarrassingly compact. A system is just a state vector $x$ evolving by a rule that says given where you are, here's the direction you must move. Inputs $u$ nudge that motion; outputs $y$ are whatever you happen to be able to measure. That is the entire grammar of modern control: four matrices, $A$ , $B$ , $C$ , $D$ , and a vector that remembers. It was Rudolf Kálmán who, in the 1960s, recast control around this state-vector equation.

A Boeing 747-400 cockpit instrument panel showing attitude, heading, airspeed, altitude, and navigation displays. — An aircraft's state vector at a glance: attitude, heading, airspeed, altitude, and position, all tracked at once. · Saschaporsche, CC BY-SA 4.0

The same equation now estimates the economy and reads brains

Once the idea escaped control engineering it kept going. Economists use state-space models to pull a noisy time series apart into a slow trend and a faster business cycle, to fuse scattered indicators into one composite index, and to estimate a country's GDP from messy, half-missing data by treating the true number as a hidden state. Neuroscientists fit state-space models to streams of neural spikes to recover what a population of cells is actually tracking. Image processing has its own discrete state-space form. In every one of these the trick is identical to the robot's: there is something real you cannot measure directly, so you write down how it evolves, watch the noisy outputs you can see, and back out the hidden state. The machinery that flies a spacecraft is the same machinery that guesses last quarter's GDP.

The math: ẋ = A x + B u, eigenvalues, and the trace-determinant shortcut

A linear system is described entirely by two equations: a state equation that says how the internal state evolves, and an output equation that says what you can observe:

\dot{x} = A x + B u, \qquad y = C x + D u

Here $x$ is the state vector, $u$ the inputs, $y$ the outputs, and $A$ , $B$ , $C$ , $D$ are matrices sized to fit. A second-order ODE like $\ddot{q} + 0.4\,\dot{q} + q = u$ becomes this form by naming $x_1 = q$ (position) and $x_2 = \dot{q}$ (velocity), giving a $2 \times 2$ matrix $A$ , exactly the four sliders in the demo.

For a $2 \times 2$ matrix $A$ , the eigenvalues are the roots of the characteristic polynomial

\lambda^2 - \operatorname{tr}(A)\,\lambda + \det(A) = 0

which is why the trace and determinant alone fix the dynamics: $\operatorname{tr}(A) = \lambda_1 + \lambda_2$ and $\det(A) = \lambda_1 \lambda_2$ . The real part of an eigenvalue sets how fast trajectories grow or decay; the imaginary part sets how fast they spin. So the same numbers that read "spiral inward" in this phase plane read "underdamped, stable" in the transfer-function picture. They are two languages for one elephant; we just point at different parts of it.

Once you write a system as $A$ , $B$ , $C$ , $D$ , two new questions become askable that the old fraction could not even phrase. Can my inputs actually reach every corner of the state, or are some directions locked away where no control can push them? And can my sensors actually see every corner, or do some states stay hidden no matter how long I watch the output? Kálmán gave both questions crisp yes-or-no tests, and they turned out to be mirror images of each other.

Controllability and observability: two tests that are secretly the same test

Controllability asks whether your inputs can steer the state anywhere you like. With admissible inputs you should be able to drive the system from any starting point to any target in a finite time. The test is a rank check on a matrix built from $A$ and $B$ :

\operatorname{rank}\begin{bmatrix} B & AB & A^2 B & \cdots & A^{n-1} B \end{bmatrix} = n

If that stack of columns has full rank $n$ (the number of states), every direction is reachable.

Observability asks the opposite: watching only the output $y$ , can you back out the full internal state you never measured directly? Same flavor of test, now built from $A$ and $C$ :

\operatorname{rank}\begin{bmatrix} C \\ CA \\ \vdots \\ CA^{n-1} \end{bmatrix} = n

The pretty part is that these two are mathematical duals. Controllability says an input exists that brings any state to any other state; observability says an output history carries enough information to reconstruct the starting state. Swap "push the state" for "read the state" and one test becomes the other. This is exactly the property a Kalman filter leans on: it can only estimate the hidden state if the system is observable, and a controller can only place the poles where it wants if the system is controllable.

You can pick the eigenvalues yourself

Here is the part that turns this from description into design. In the old picture, a system's eigenvalues were a fact you read off and lived with. In state-space, if the system is controllable, you can move them. Feed the state back into the input with a chosen gain matrix $K$ , so the input becomes a function of where the system currently sits, and the matrix that governs the motion changes from $A$ to $A + BK$ . Choose $K$ well and you place the new eigenvalues anywhere you like. A spring that wanted to ring forever can be told to settle in two seconds. An unstable rocket, the kind whose eigenvalue sits in the wrong half of the plane, can be dragged back to stable. The arrow field in the demo above is not a verdict. It is a starting point you get to redraw.

Key takeaways

State-space describes a system by a state vector $x$ that evolves as $\dot{x} = A x + B u$ , with output $y = C x + D u$ : four matrices and a vector that remembers.
It handles many inputs and outputs at once, where transfer functions get unwieldy. This was the heart of the 1960s "modern control" revolution.
The eigenvalues of $A$ classify the behavior; for a $2 \times 2$ system, the trace and determinant alone tell you the whole story.
This is the formulation the Apollo guidance computer used, and the one the EKF / Kalman filters later in this course are built on.

A transfer function watches one door. State-space watches the entire house at once: every room, every occupant, all evolving by a single rule you can write on a napkin, $\dot{x} = A x + B u$ .

That napkin took control theory to the Moon and gave it the vocabulary to estimate what it cannot directly see. The next time you tap the plane and watch a trajectory spiral home to the origin, remember: you are reading the same sentence Apollo read, and the same one the Kalman filter is about to whisper back.