Scaling Kalman Filters via State Space Dimensioned Updates

15 concepts11 papers1 proposal

In state estimation tasks like robotic localization, drone navigation, and 3D object tracking, the Extended Kalman Filter (EKF) is a foundational tool. However, modern autonomous systems no longer rely solely on sparse landmarks; they ingest dense, high-fidelity data from sensors like LiDAR and depth cameras that output thousands of data points per frame.

This influx of data exposes a massive computational bottleneck in the traditional Kalman filter framework. A wave of recent research addresses this challenge by restructuring the measurement update step, fundamentally shifting the computational complexity from the size of the sensor data to the size of the physical state being tracked.

The Bottleneck: The Curse of Measurement Dimensionality

To understand why dense sensors break traditional filters, we have to look at the standard Kalman gain calculation. In the measurement update step, the filter computes the innovation covariance matrix $S$:

$$S = HPH^T + R$$

and inverts it to calculate the Kalman gain:

$$K = PH^T S^{-1}$$

Here, $P$ is the state covariance matrix, $H$ is the measurement Jacobian, and $R$ is the measurement noise covariance.

If the system state vector has a dimension of $N$ (for instance, 15 variables representing a robot's 3D position, velocity, and orientation biases) and the incoming measurement vector has a dimension of $M$ (representing thousands of points in a LiDAR scan), the matrix $S$ becomes an $M \times M$ matrix.

Inverting $S$ requires a computational complexity of $O(M^3)$. When $M$ scales into the thousands, computing this inversion in real-time on low-power embedded hardware becomes impossible.

Flipping the Inversion: State-Space Dimensioned Gain

The core insight behind overcoming this bottleneck is a realization about redundancy: even though a LiDAR scan provides thousands of measurements ($M$), they are all observing the same low-dimensional physical state ($N$). The actual information space is bounded by $N$, meaning the massive $M \times M$ matrix inversion is highly inefficient.

By applying matrix identities such as the Woodbury matrix identity (or the binomial inverse theorem), the Kalman gain equation can be mathematically refactored into an equivalent form where the matrix inversion occurs in the state space rather than the measurement space. Instead of inverting an $M \times M$ matrix, the filter inverts an $N \times N$ matrix.

As demonstrated by Xu et al. in the FAST-LIO2 framework, this mathematical reformulation allows direct registration of raw LiDAR points without needing downsampling or feature extraction. Because the computational cost scales with the state dimension $N$ rather than the measurement count $M$, the system easily runs in real-time on embedded platforms.

Sun et al. leveraged this exact optimization in the LUOJIA Explorer autonomous UAV, proving that calculating the Kalman gain based on state dimensions prevents onboard computational bottlenecks during high-speed exploration of GNSS-denied environments.

Dimension-Adaptive Gain Selection

Is it always optimal to compute the gain in state space? Not necessarily. If a robot receives a sparse measurement—such as a single GPS coordinate or a sparse landmark update—the measurement dimension $M$ might be much smaller than the state dimension $N$. In that specific scenario, the traditional measurement-space inversion is faster.

To achieve the best of both worlds, Jia et al. proposed a dimension-adaptive gain computation strategy in Manifold-Optimized Error-State Kalman Filter for Robust Pose Estimation in Unmanned Aerial Vehicles. The filter dynamically evaluates the dimensions of the incoming observation vector and selects the mathematically equivalent formula that inverts the smaller matrix. This optimization reduces processing times for high-dimensional observations from seconds to milliseconds while maintaining exact mathematical rigor.

Jacobian Space Residual Projection

Another elegant strategy for bypassing the $O(M^3)$ bottleneck is to compress the high-dimensional measurement space before it ever reaches the inversion step.

In visual-inertial navigation systems (VINS), standard algorithms often use QR decomposition to project measurements into a lower-dimensional space. However, computing a full QR decomposition on a massive measurement matrix is itself a heavy computational burden.

As an alternative, Fan et al. introduced SchurVINS, a system that projects high-dimensional measurement residuals directly into the Jacobian space. This projection constructs a set of compact, equivalent equations for the filter update step. By avoiding standard QR decompositions while preserving the underlying observation model's accuracy, this method dramatically cuts processing latency on low-power devices like smartphones and consumer drones.

Factorization via Independent Sensor Decomposition

Instead of modifying the matrix algebra of a single massive update, we can change how the filter ingests data. If we treat a dense sensor array or a point cloud not as a single high-dimensional measurement vector, but as a collection of independent, individual sensors, the joint update can be factorized.

Issac et al. demonstrated this concept in Depth-Based Object Tracking Using a Robust Gaussian Filter. By treating individual pixels in a dense depth image as independent sensors, the authors factorized the filter update step into a simple summation of individual contributions. This architectural shift reduces the computational complexity from cubic ($O(M^3)$) to linear ($O(M)$) relative to the number of measurements, enabling real-time 3D tracking on a standard single-core CPU.

Traditional Update:
[Dense Measurement (M)] ---> [Invert M x M Matrix] ---> Complexity: O(M³)

Factorized / State-Space Update:
[Dense Measurement (M)] ---> [Project to State Space (N)] ---> [Invert N x N Matrix] ---> Complexity: O(N³) + O(M)

This concept also applies to distributed networks. Hespanha et al. showed in D-SLATS that implementing a distributed filter in its information form allows individual nodes to replace complex matrix inversions with simpler additive updates, distributing the computational load seamlessly across a sensor network.

Enabling Robustness "For Free"

Minimizing the computational overhead of the measurement update does more than just save battery life—it frees up processing cycles to handle non-Gaussian noise and outliers. Standard Kalman filters assume clean, Gaussian noise distributions, but real-world sensor data is often corrupted by anomalies, multi-path interference, or sudden structural changes.

When the underlying filter structure is highly optimized, advanced statistical techniques can be introduced without breaking the real-time execution budget. For example, Feng et al. published a series of papers—including work on AGMC-Based Robust Cubature Kalman Filters, Robust Cubature Kalman Filters with Adaptive Fading, and Robust Central Difference Kalman Filters—that integrate robust "correntropy" criteria to suppress non-Gaussian measurement outliers. By optimizing the derivations of the Kalman gain to minimize matrix inversions, the authors proved that sophisticated error-correction logic can run on tactical navigation hardware with zero latency penalties.

Similarly, Gultekin et al. demonstrated in Nonlinear Kalman Filtering With Divergence Minimization that directly optimizing divergence measures can yield tracking accuracy competitive with particle filters. Because their approach avoids the computationally expensive resampling steps inherent to particle filters, it maintains the efficiency required for real-time deployment.

By shifting the mathematical perspective from the measurement space to the state space, these diverse techniques allow modern state estimators to digest high-density sensor streams efficiently, safely, and robustly.

Key Foundational Work

Depth-Based Object Tracking Using a Robust Gaussian Filter (2016) — contributed 2 concept elements to this direction.
D-SLATS: Distributed Simultaneous Localization and Time Synchronization (2017) — contributed 1 concept elements to this direction.
Nonlinear Kalman Filtering With Divergence Minimization (2017) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_jacobian_space_residual_projection_f59c90bc,
  title = {Jacobian space residual projection},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/jacobian-space-residual-projection/rdr_f59c90bc0ed747c39d01a3938d2455e1},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_jacobian_space_residual_projection_f59c90bc_v1,
  title = {Jacobian space residual projection},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/jacobian-space-residual-projection/rdr_f59c90bc0ed747c39d01a3938d2455e1/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake