Performance Preserving Controller Order Reduction

35 concepts27 papers1 proposal

When designing controllers for complex, high-dimensional systems—such as power grids, flexible spacecraft, or systems governed by partial differential equations (PDEs)—modern robust control frameworks like $\mu$-synthesis, $H_\infty$, and Linear Quadratic Gaussian (LQG) control are highly effective. However, these methods typically yield controllers whose mathematical complexity (or dynamic order) matches or exceeds that of the plant itself.

Deploying a hundredth-order controller in a real-time embedded system introduces severe computational overhead and implementation risks. The goal of controller order reduction is to simplify these complex control policies into low-order, implementable architectures without sacrificing the stability or performance of the overall system.

The Closed-Loop Paradigm

The foundational insight of modern controller reduction is that a controller should never be simplified in isolation. Traditional model reduction techniques focus on minimizing the open-loop error between a high-order model and its low-order approximation. If applied directly to a controller, this approach can easily lead to closed-loop instability because it ignores how the controller interacts with the plant's dynamics.

To overcome this, Wang et al. introduced "closed-loop block balanced" and "structurally balanced" truncation methods. The core intuition is to prioritize preserving the performance of the entire closed-loop system. A state within the controller might seem insignificant in isolation, but it could be vital for stabilizing a critical plant mode. By balancing the controller states relative to closed-loop Gramians, the reduction process discards only the dynamics that have a negligible impact on the total system response.

This closed-loop perspective is essential when dealing with severe model mismatches. For instance, Benosman demonstrates that when controllers are designed for simplified approximations of infinite-dimensional systems (like PDEs), the resulting model mismatch can degrade stability unless the reduction process explicitly accounts for the unmodeled dynamics.

Mechanisms of Safe Simplification

How can we systematically strip away controller states while guaranteeing that the system won't fail? Researchers attack this problem through several distinct mathematical lenses.

Unstable Mode Truncation

Intuitively, one might assume that the unstable poles of a controller are untouchable, as they are responsible for compensating for plant instabilities or ensuring tracking performance. However, Fazel et al. established a theoretical framework for general, non-observer-based LQG controllers, proving that specific unstable modes can be safely truncated.

Crucially, the authors showed that removing these modes can sometimes unexpectedly improve overall closed-loop performance. This happens because high-order optimal synthesis can introduce suboptimal, over-parameterized dynamics; purging these redundant modes streamlines the control law.

Projective Mapping

Another approach is to map a high-order state feedback controller (which requires knowing every state of the system) into a low-order output feedback controller (which only requires measurable outputs).

Zhao et al. adapted projective control theory to accomplish this by retaining only the dominant oscillation modes of the high-order system. By projecting the high-order control trajectories onto a lower-dimensional subspace defined by these dominant modes, they successfully reduced a complex sixth-order controller down to a practical second-order controller while maintaining grid damping performance.

Information Bottlenecks and Water-Filling

From an information-theoretic perspective, controller complexity can be viewed as the rate of data processing required to maintain control. Fox et al. framed LQG control as a sequential rate-distortion problem.

They demonstrated a "water-filling" effect: when communication or computational resources are constrained, an optimal controller naturally sheds its own internal complexity. It allocates its limited capacity only to the most critical system modes, providing a rigorous mathematical justification for ignoring negligible dynamics.

High-Order Controller ───► [Information Bottleneck] ───► Low-Order Controller
                                   │
                     (Drops low-energy/costly modes via 
                          "water-filling" effect)

Unsupervised Mode Clustering

For hybrid systems like Markov Jump Systems (MJS), complexity stems not just from state dimensions, but from the sheer number of operational modes or environments the system switches between.

Du et al. developed a method that treats system dynamics as features for unsupervised learning, clustering similar operational modes into a smaller set of representative modes. The authors proved in Mode Reduction for Markov Jump Systems that a controller designed on this low-mode surrogate model maintains a suboptimality gap on the original system that is strictly bounded by the geometric similarity of the clusters.

Balancing Complexity and Performance in Practice

The ultimate motivation for controller reduction is practical deployment. As Kania et al. note, choosing controller complexity always involves a trade-off between mathematical degrees of freedom and the physical processing limits of industrial hardware.

In high-reliability environments like aerospace, simpler architectures are highly favored because they simplify verification and validation. Sreenatha demonstrated that a low-order controller designed via Quantitative Feedback Theory (QFT) could achieve performance parity with high-order $H_\infty$ methods for flexible spacecraft stabilization, while offering a much more transparent verification path.

Similarly, in power electronics, the robust frameworks designed by Chakraborty et al. for grid-forming inverters require model order reduction as a final step to fit within standard digital signal processors (DSPs).

Hierarchical and Multi-Rate Simplification

When systems scale up to massive cyber-physical networks, a common strategy is to distribute the computational load hierarchically or across different time scales:

  • Stochastic Abstraction: Engelaar et al. utilize knowledge filtering to simplify the noise and disturbance models of stochastic systems, allowing low-order controllers to be synthesized on an abstracted model and directly mapped back to the full system with strict performance guarantees.
  • Multi-Rate Architectures: Rosolia pairs a low-frequency Model Predictive Control (MPC) planner using a simplified model with a high-frequency, low-level safety controller. The high-frequency controller compensates for the high-level model's simplifications, reducing the overall computational burden.
  • Aggregated Dynamics: In large-scale agent networks, Hu et al. show that model reduction can stabilize complex systems by controlling the average discrepancy between individual agents and a simplified, lower-order collective model.

Ultimately, these diverse methods converge on a single principle: effective control does not require a perfect, high-order representation of reality. As shown by Bekiroglu et al. in autonomous tracking applications, and by Pan in singularly perturbed stochastic systems, focusing control authority strictly on dominant dynamics and key nonlinearities (like actuator saturation) is sufficient to guarantee robust, near-optimal real-world performance.

Key Foundational Work

Balanced performance preserving controller reduction (2002) — contributed 2 concept elements to this direction.
Model Simplification and Optimal Control of Stochastic Singularly Perturbed Systems under Exponentiated Quadratic Cost (1996) — 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_controller_order_reduction_ed409caf,
  title = {controller order reduction},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/controller-order-reduction/rdr_ed409caf56174a1190b62b6b7e8ebdc8},
  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_controller_order_reduction_ed409caf_v1,
  title = {controller order reduction},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/controller-order-reduction/rdr_ed409caf56174a1190b62b6b7e8ebdc8/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