Linear Quadratic Gaussian Control

Linear Quadratic Gaussian control is a cornerstone of modern control theory, enabling you to design optimal controllers for complex, noisy systems where not all states are directly measurable. By merging the deterministic optimization of the Linear Quadratic Regulator (LQR) with the stochastic estimation of the Kalman filter, LQG provides a systematic, powerful framework for multivariable control design. Understanding LQG equips you to address real-world engineering challenges in aerospace, robotics, and process control, where performance must be balanced against uncertainty and practical sensor limitations.

The Foundation: LQR and Kalman Filter

To grasp LQG, you must first understand its two components. The Linear Quadratic Regulator (LQR) is an optimal full-state feedback controller for deterministic linear systems. Given a state-space model $\dot{x}=Ax+Bu$, LQR finds a control law $u=-Kx$ that minimizes a quadratic cost function $J={\int }_0^{\infty }(x^{T}Qx+u^{T}Ru)dt$. The matrices $Q$ and $R$ are design weights that let you balance state regulation against control effort. The solution involves solving an algebraic Riccati equation to find the optimal gain matrix $K$. However, LQR assumes you have perfect knowledge of all system states $x$, which is rarely true in practice due to sensor noise, cost, or physical constraints.

This is where the Kalman filter comes in. It is an optimal state estimator for linear systems disturbed by Gaussian noise. The system model is extended to include process noise $w$ and measurement noise $v$: $\dot{x}=Ax+Bu+w$ and $y=Cx+Du+v$. The Kalman filter provides an estimate $\hat{x}$ of the true state $x$ by dynamically combining predictions from the model with incoming noisy measurements $y$. It minimizes the mean-squared estimation error and is computed by solving another Riccati equation to find the estimator gain $L$. Essentially, while LQR tells you what to do if you know the state perfectly, the Kalman filter tells you what the state most likely is.

The Separation Principle: Enabling Optimal Output Feedback

The brilliance of Linear Quadratic Gaussian (LQG) control lies in its elegant solution to the output feedback problem. In most real systems, you cannot measure every state; you only have access to outputs $y$. LQG combines the LQR controller with the Kalman filter to form an optimal output-feedback controller. The key enabler is the separation principle (also known as the certainty-equivalence principle).

This principle guarantees that for linear systems with Gaussian white noise, you can independently design the LQR feedback gain $K$ (as if all states were known) and the Kalman filter gain $L$ (as if no control were applied), and the combination remains optimal. The final controller has a straightforward structure: the Kalman filter produces state estimates $\hat{x}$, and these estimates are fed directly into the LQR control law, yielding $u=-K\hat{x}$. This separation dramatically simplifies the design process, breaking a complex stochastic optimization problem into two more manageable, familiar ones. You tackle regulation and estimation separately, yet the combined system minimizes the overall stochastic cost.

Mathematical Formulation of the LQG Controller

The complete LQG problem is defined for a continuous-time, linear time-invariant system with additive Gaussian noise:

$$\dot{x}=Ax+Bu+w$$ $$y=Cx+v$$

Here, $x$ is the state vector, $u$ is the control input, and $y$ is the measured output. The process noise $w$ and measurement noise $v$ are assumed to be uncorrelated, zero-mean Gaussian white noise processes with covariance matrices $W$ and $V$, respectively. The goal is to find a control signal $u(t)$ based on the output history $y(\tau ),\tau \le t$ that minimizes the expected value of a quadratic cost:

$$J=E\left[{\int }_0^{\infty }(x^{T}Qx+u^{T}Ru)dt\right]$$

where $E[\cdot ]$ denotes the expectation over the noise statistics. The matrices $Q$ (positive semidefinite) and $R$ (positive definite) are the same tuning weights used in LQR. The solution, as dictated by the separation principle, consists of two distinct parts solved sequentially:

1. Optimal Estimator (Kalman Filter): Design the filter gain $L$ by solving the filter algebraic Riccati equation for the estimation error covariance. The estimator dynamics are:

$$\dot{\hat{x}}=A\hat{x}+Bu+L(y-C\hat{x})$$

1. Optimal Regulator (LQR): Design the state feedback gain $K$ by solving the control algebraic Riccati equation, ignoring noise.

The combined LQG controller is a dynamic system from measurements $y$ to control $u$: $$\dot{\hat{x}}=(A-LC-BK)\hat{x}+Ly$$ $$u=-K\hat{x}$$

This is the state-space representation of the optimal output-feedback controller.

Step-by-Step LQG Design Procedure

Let's walk through a concrete design process for a damped mass-spring system, where you can only measure the position, not the velocity. This practical example illustrates the systematic approach LQG provides.

Step 1: Define the System Model and Noise Characteristics Start with a state-space model $(\dot{x}=Ax+Bu,y=Cx)$. For a unit mass and spring with damping, states could be position and velocity: $x=[p;v]$. Define the output matrix $C$; here, $C=[1,0]$ meaning only position is measured. Then, specify the noise covariance matrices $W$ and $V$ based on your understanding of process disturbances (e.g., wind gusts) and sensor accuracy (e.g., position encoder noise). A common starting point is to use identity matrices scaled by the estimated noise intensities.

Step 2: Design the Kalman Filter (The "G" part) Solve the filter algebraic Riccati equation: $A{P}_e+P_e{A}^T-P_e{C}^T{V}^{-1}C{P}_e+W=0$ for the steady-state error covariance $P_e$. Then, compute the Kalman gain $L=P_e{C}^T{V}^{-1}$. This gain determines how aggressively the filter corrects its estimates based on new measurements versus trusting its internal model.

Step 3: Design the LQR Controller (The "LQ" part) Choose the cost matrices $Q$ and $R$. For the mass-spring, you might set $Q=\text{diag}([q_1,q_2])$ to weight position and velocity errors, and $R$ as a scalar to penalize control force. Solve the control Riccati equation: $A^T{P}_c+P_{c}A-P_{c}B{R}^{-1}{B}^T{P}_c+Q=0$ for $P_c$. The optimal state feedback gain is $K=R^{-1}{B}^T{P}_c$.

Step 4: Construct the LQG Controller Combine the filter and regulator using the equations from the previous section: $\dot{\hat{x}}=(A-LC-BK)\hat{x}+Ly$ and $u=-K\hat{x}$. This dynamic controller takes the noisy position measurement $y$ and generates the optimal control force $u$. You can implement this as a state-space model in simulation or on a digital processor.

Step 5: Validate and Iterate Simulate the closed-loop system performance. Adjust the design parameters—the noise covariances $W,V$ and the cost weights $Q,R$—to achieve the desired balance between fast response, control effort, and noise rejection. This iterative tuning is where engineering judgment is applied.

Applications and Practical Limitations

LQG finds application in numerous multivariable control domains. In aerospace, it is used for aircraft autopilots and satellite attitude control. In robotics, it governs the motion of robotic arms and autonomous drones. Industrial process control, such as chemical plant regulation, also leverages LQG for managing interacting variables like temperature, pressure, and flow rates. Its strength is providing a mathematically rigorous, single-methodology framework for complex systems where multiple, noisy measurements must be synthesized into stable, optimal control actions.

However, a critical practical limitation is robustness. The optimality of LQG is proven under the assumption of an exact system model and perfect knowledge of noise statistics. In reality, models are approximate, and noise is rarely perfectly Gaussian or white. More importantly, the separation principle does not extend to guarantee classical stability margins like gain and phase margin. An LQG-designed system can exhibit poor robustness to model uncertainties, such as unmodeled dynamics or parameter variations. This led to the development of robust control techniques like $H_{\infty }$ control. Therefore, while LQG gives you a powerful optimal controller, you must always supplement its design with a thorough robustness analysis before deployment.

Common Pitfalls

1. Ignoring the Assumptions of Linearity and Gaussian Noise. LQG theory is strictly valid for linear systems with additive Gaussian white noise. Applying it to highly nonlinear systems (e.g., aggressive aircraft maneuvers) or systems with non-Gaussian disturbances (e.g., impulsive shocks) without proper linearization or adaptation can lead to poor performance or instability.

• Correction: Always validate that your operating point permits a reliable linear approximation. For non-Gaussian noise, consider preprocessing filters or alternative stochastic control methods.

1. Blind Trust in the Separation Principle for Robustness. Engineers often mistakenly believe that because the filter and regulator designs are separable, the overall closed-loop system inherits the robustness properties of each part. This is false; the LQG loop transfer function has no guaranteed stability margins.

• Correction: After designing an LQG controller, you must perform a robustness analysis. Techniques like singular value plots (disk margins) or Monte Carlo simulations with model variations are essential to ensure the design can tolerate real-world uncertainties.

1. Poor Tuning of Noise Covariances and Cost Weights. Selecting the matrices $W,V,Q,$ and $R$ arbitrarily or without physical insight is a frequent error. For instance, setting process noise covariance $W$ too low makes the Kalman filter sluggish, while setting it too high makes it overreact to measurement noise.

• Correction: Base initial choices on physical insight or system identification. $Q$ and $R$ should reflect your true performance trade-offs (e.g., track error vs. fuel use). Treat the covariances $W$ and $V$ as tuning knobs for the filter's bandwidth: increasing $W$ relative to $V$ makes the filter faster but noisier.

1. Overlooking Computational Aspects in Implementation. The continuous-time Riccati equations assume analog computation. Implementing LQG on a digital computer requires careful discretization of both the system model and the controller equations. Using the wrong discretization method or sample time can destabilize the system.

• Correction: Always design the Kalman filter and LQR gain using a discrete-time model that matches your sampling period. Solve the discrete-time algebraic Riccati equations for consistency between design and implementation.

Summary

• LQG control is the optimal solution to the output-feedback problem for linear systems with Gaussian noise, formed by combining a Linear Quadratic Regulator (LQR) with a Kalman filter.
• The separation principle is the theoretical cornerstone that allows you to design the state-feedback gains and state-estimator gains independently while preserving overall stochastic optimality.
• The design procedure is systematic: model your system and noise, solve two algebraic Riccati equations (one for estimation, one for control), and combine the results into a dynamic controller.
• A major practical limitation is that LQG does not automatically provide good robustness to model errors; its optimality holds only for a perfect model, necessitating separate robustness analysis.
• Successful application requires careful tuning of the cost weights $(Q,R)$ and noise covariances $(W,V)$ based on physical insight and performance requirements.
• LQG remains a foundational methodology in multivariable control design, providing a rigorous starting point for controlling complex, noisy systems across aerospace, robotics, and industrial automation.