State-Space Models & the Kalman Filter

Every sensor lies a little. A GPS reading, a thermometer, a noisy estimate of a moving object's position — each is the true value plus some measurement error. The Kalman filter is an elegant, hugely influential algorithm for recovering the true, hidden value from a stream of noisy measurements in real time — and it does it by a beautiful idea: at every step, it blends what it predicted would happen with what it actually measured, weighting each by how trustworthy it is.

It's the engine behind GPS, spacecraft navigation, object tracking, and sensor fusion, and it's a distinct tool from the ARIMA-style time series page — that one models a single observed series; this estimates a hidden state as data streams in. This page builds it from the state-space idea, through the predict-update loop, to the intuition that makes it click. It ties to Bayesian updating and streaming.

The hidden true state

The core framing is the state-space model, and it cleanly separates two things we usually muddle: the true state of the world, and our noisy glimpses of it. There is a hidden state — an object's real position and velocity, say — that we cannot observe directly. It evolves over time according to some dynamics. All we get are observations: measurements that are the true state, corrupted by noise.

The task is to estimate the hidden state from the noisy observations, as they arrive, one at a time. That word "recursive" is key — the filter doesn't reprocess all history at each step; it carries forward a running best estimate and updates it with each new measurement, which is exactly what makes it work on a live stream with tiny memory.

Two equations: dynamics and measurement

A linear state-space model is just two equations. The state-transition equation says how the hidden state $\mathbf{x}$ evolves from one step to the next:

\mathbf{x}_t = F\,\mathbf{x}_{t-1} + \mathbf{w}_t

And the observation equation says how a measurement $\mathbf{z}$ relates to the (unseen) state:

\mathbf{z}_t = H\,\mathbf{x}_t + \mathbf{v}_t

Here $F$ encodes the dynamics (how the state moves — e.g. position updates by velocity), $H$ maps state to measurement, and the two noise terms $\mathbf{w}_t$ , $\mathbf{v}_t$ are the process and measurement uncertainty. The whole filter's job is to estimate $\mathbf{x}_t$ given all the noisy $\mathbf{z}$ 's so far — and crucially, to track how uncertain that estimate is, because that uncertainty is what drives the whole thing.

The recursion: predict, then update

The Kalman filter cycles through two steps for every new measurement — a rhythm of guess-then-correct:

The Kalman filter loop. PREDICT: use the dynamics to project the state (and its uncertainty) forward — the estimate drifts and uncertainty grows. UPDATE: a new measurement arrives; correct the prediction toward it, shrinking uncertainty. Repeat for every measurement, forever.

Predict — use the dynamics ( $F$ ) to project the current estimate forward to the next time step. The estimate moves, and — because the world is uncertain — its uncertainty grows. This is the filter's best guess before seeing new data.
Update — a new measurement arrives. Correct the prediction toward it, by an amount that depends on the relative uncertainties, and the estimate's uncertainty shrinks(you've learned something). This corrected estimate becomes the starting point for the next predict.

Predict-then-correct, forever. The result is a continuously updated best estimate that's smoother and more accurate than the raw measurements — and it's optimal, in a precise sense, for linear-Gaussian systems.

The Kalman gain: who to trust

The heart of the update is one quantity: the Kalman gain $K$ . It decides how much to move the prediction toward the new measurement — i.e. how much to trust the measurement versus your own prediction. The corrected estimate is essentially:

\hat{\mathbf{x}}_t = \hat{\mathbf{x}}_{t}^{-} + K\big(\mathbf{z}_t - H\hat{\mathbf{x}}_{t}^{-}\big)

That bracket — measurement minus prediction — is the innovation, the surprise. The gain $K$ scales how much of the surprise you absorb, and it's set by the relative uncertainties:

Where it's used

The Kalman filter is one of the most deployed algorithms in engineering — it literally helped land Apollo on the Moon. Its homes:

Tracking & navigation — estimating the position and velocity of a moving object (aircraft, missiles, your phone's location) from noisy, intermittent fixes.
Sensor fusion — optimally combining multiple noisy sensors (GPS + accelerometer + gyroscope) into one coherent estimate, each weighted by its reliability. This is its killer application — it's how a phone or drone knows where it is.
Smoothing noisy signals — anywhere you have a real-time signal buried in noise and want a clean running estimate (finance, control systems, biomedical signals).

Beyond linear-Gaussian

The classic Kalman filter is provably optimal under two assumptions: the dynamics are linear and the noise is Gaussian. The real world often breaks both — so the family has extensions:

Extended / Unscented Kalman filters (EKF/UKF) — handle nonlinear dynamics by linearising (EKF) or cleverly sampling (UKF) around the current estimate.
Particle filters — drop the Gaussian assumption entirely, representing the state's uncertainty with a cloud of weighted samples (the Monte Carlo idea applied to filtering). More flexible, more expensive.

Underneath, all of these are doing recursive Bayesian estimation — the filter's predict-update is exactly the Bayesian prior→posterior cycle, run once per measurement. The Kalman filter is the special, beautifully closed-form case where everything is linear and Gaussian.

Where it shows up in my work

A clean estimate from a noisy stream

The Kalman filter is the right tool whenever there's a true value evolving over time that I only see through noisy measurements, and I want a clean, continuously-updated estimate — real-time tracking, smoothing a jittery operational signal, or fusing several imperfect sources into one. The idea I carry from it is the most useful part: an estimate is a weighted blend of what you expected and what you observed, weighted by their relative uncertainty — a principle that applies far beyond the formal filter.

It also stitches together threads from across this section: it's recursive Bayesian updating (Bayes once per step), it's a streaming, one-pass algorithm by nature, and it's a different lens on time series (hidden state vs observed series). Knowing it's optimal only for linear-Gaussian — and what to reach for when that breaks — is what keeps its use honest.

Refresh in 60 seconds

A state-space model separates a hidden true state (evolving) from noisy observations. Two equations: state-transition ( $F$ ) + observation ( $H$ ).
The Kalman filter estimates the hidden state recursively — one pass, tiny memory — via a predict → update loop.
Predict: project the state forward, uncertainty grows. Update: a measurement arrives, correct toward it, uncertainty shrinks.
The Kalman gain sets how far to move toward the measurement — a weighted average of prediction and measurement, by relative trust. Noisy sensor → small gain; uncertain prediction → large gain.
Used for tracking, navigation, sensor fusion (GPS + IMU), signal smoothing. Optimal for linear-Gaussian; EKF/UKF/particle filters relax that.
It's recursive Bayesian updating — Bayes once per measurement.

The state-space formulation, the predict-update recursion, the Kalman-gain intuition, and the nonlinear extensions reflect current estimation/sensor-fusion references alongside coursework.