Controllability & Observability
Two yes/no questions that decide whether a robot can be driven, and whether it can be known
A car with a jammed steering wheel still drives (perfectly, in a straight line) but you can never aim it. A car with a dead speedometer drives just fine too, yet the dashboard has no idea how fast you're going.
Two completely different failures. Control theory turns both into the same thing: a yes/no question you can answer by counting.
Every robot lives in a state: a few numbers that capture everything about where it is and how it's moving. You poke that state with inputs (motor torque, thrust) and you peek at it through sensors (encoders, a camera). Two questions decide whether you're actually in charge. Controllability asks: can your inputs steer the state to any configuration you want? Observability asks: can you reconstruct every internal number just from what the sensors report?
Span the plane, or don't
Below is the phase plane of a tiny two-state system, the same swirling vector field from the state-space lesson, now with arrows pinned to the origin. The legend under the plot names each one: the bright B arrow is the single direction your input can shove the state; the dashed AB arrow is where that push lands after the plant's dynamics twist it by one instant; the muted C and CA arrows are the directions your sensor reveals. Drag the angle, flip the plant, or tap collapse the rank to 1, and watch the verdicts flip with the picture.
Span the plane, or don't
what to try
The whole idea in one line: two arrows in a plane either spread apart to cover it (rank 2), or they fall onto one line (rank 1). If B and AB point different ways, your one input — bent and re-bent by the dynamics — can eventually steer anywhere. If they're parallel, a whole direction is forbidden, no matter how hard you push. Same story for the sensor pair C and CA.
- Tap collapse the rank to 1. The plant switches to decoupled and B points straight along x₁ — now AB lands on the same line as B. The steering readout drops to 1: x₂ is stranded, unreachable from this input.
- Still on decoupled, drag the B angle off the axes (toward 45°). The two arrows fan apart, the rank pops back to 2, and every direction is reachable again.
- For sensing on decoupled: set the sensor to sees x₁. Because the dynamics never mix x₂ into x₁, the sensor pair stays on one line — rank 1, and x₂ is a ghost you can't deduce. Switch to sees x₁ + x₂ and it spans the plane again.
- Switch back to spring: the dynamics swirl, so the arrows never line up — controllable and observable from any direction.
Here is the whole trick in one sentence: two arrows in a plane either spread out to cover the whole plane, or they collapse onto a single line. If B and AB point in genuinely different directions, your single input, bent and re-bent by the dynamics over time, can eventually reach anywhere. That is rank 2: controllable. But line them up parallel and you are trapped on one axis; an entire direction of state space becomes forbidden, no matter how hard or how long you push. That is rank 1: stuck.
Tap collapse the rank to 1 to see it happen. The plant switches to decoupled (the two states no longer talk to each other) and B points straight along x₁. Now AB lands on the same line as B, the two arrows fall flat, and the steering readout drops to 1: x₂ is stranded, unreachable no matter how hard the input pushes. Drag the B angle off the axes and the arrows fan apart, restoring rank 2. (On the spring plant the dynamics swirl so hard that the arrows never line up, which is why every direction is controllable there.)
Observability is the mirror image. Stay on the decoupled plant, point the sensor at x₁ only, and x₂ becomes a ghost: it never leaks into the measurement, so you can never deduce its value. The arrows for that test are built from C and CA instead of B and AB, but it is the same rank count, asked from the sensor's side of the loop.
Both ideas, controllability and observability, were named by Rudolf Kálmán in the 1960s. They didn't just clarify control; they founded it. Before him, engineers tuned loops by feel. Kálmán recast the whole subject in the language of state and matrices, and the first thing that language let you do was ask, precisely, whether a system was even drivable and knowable in the first place. (Yes, the same Kálmán whose filter shows up two lessons from now. He gets around.)
The math: two rank tests built from A, B, and C
A linear system is described by how the state evolves and how it's measured:
To test controllability, stack the input direction and its image under the dynamics side by side into the controllability matrix; for observability, stack the sensor direction above into the observability matrix:
For an -state system these grow to and the matching observability stack, but the rule never changes:
Full rank means the columns (or rows) span the entire state space: every direction is reachable, every direction is visible. A rank deficiency points straight at a forbidden direction: a combination of states your input can't push, or your sensor can't see. In the demo both arrows are drawn live, so you can literally watch them collapse onto a line at the instant the rank drops from 2 to 1. The duality falls out of the formulas too: for the pair is just the transpose of for .
Key takeaways
- Controllability = can your inputs steer the state to any configuration? It's full rank of .
- Observability = can your sensors reveal every internal state? It's full rank of the stacked .
- A rank deficiency names a concrete failure: a direction you can't drive (jammed wheel) or can't see (dead gauge).
- The two are duals, and observability is precisely the property that lets the next lesson's observers reconstruct what the sensors don't directly measure.
Two questions, two matrices, two yes-or-no answers. Before you tune a single gain, before you trust a single estimate, controllability and observability tell you whether the job is even possible: whether the robot can be driven, and whether it can be known.
Kálmán's gift was turning those existential questions into arithmetic. And the moment you confirm a state is observable but hidden, you've earned the right to ask the obvious follow-up: if the sensors don't measure it directly, can I estimate it anyway? That's an observer, and that's where we go next.