Recursive Least Squares (RLS) is an adaptive algorithm that recursively updates filter coefficients to minimize a weighted linear least squares cost function of the error signal. Unlike gradient-descent methods, RLS computes the exact minimizer of the deterministic normal equations at each iteration, leveraging all available input data from the initialization point to the current sample.
Glossary
Recursive Least Squares (RLS)

What is Recursive Least Squares (RLS)?
An adaptive filtering algorithm that recursively finds the filter coefficients minimizing a weighted linear least squares cost function, offering faster convergence than LMS at the cost of higher computational complexity.
The algorithm achieves significantly faster convergence than the Least Mean Squares (LMS) algorithm, particularly for highly correlated input signals, by maintaining and updating an inverse correlation matrix. This superior tracking performance comes at the expense of O(N²) computational complexity per iteration, where N is the filter length, making it suitable for applications like fast channel estimation where rapid adaptation is critical.
RLS vs. LMS: A Technical Comparison
A direct technical comparison of Recursive Least Squares and Least Mean Squares for channel estimation and equalization tasks.
| Feature | Recursive Least Squares (RLS) | Least Mean Squares (LMS) | Normalized LMS (NLMS) |
|---|---|---|---|
Cost Function | Weighted least squares sum | Instantaneous squared error | Instantaneous squared error with normalized step size |
Convergence Speed | Fast (order of 2N iterations) | Slow (order of 10N iterations) | Moderate (order of 5N iterations) |
Computational Complexity per Iteration | O(N²) | O(N) | O(N) |
Memory Requirement | O(N²) for inverse correlation matrix | O(N) for weight vector only | O(N) for weight vector only |
Sensitivity to Eigenvalue Spread | Insensitive | Highly sensitive | Reduced sensitivity |
Steady-State Misadjustment | Low | Higher | Moderate |
Numerical Stability | Prone to instability with finite precision | Stable | Stable |
Tracking of Non-Stationary Channels | Excellent with appropriate forgetting factor | Adequate | Adequate |
Core Properties of RLS
The defining characteristics that distinguish the Recursive Least Squares algorithm from simpler gradient-based adaptive filters, making it suitable for fast-converging channel compensation tasks.
Weighted Least Squares Cost Function
RLS minimizes a deterministic cost function consisting of the exponentially weighted sum of squared errors. Unlike LMS, which minimizes the instantaneous squared error, RLS considers all past errors from the moment the algorithm was initialized. The forgetting factor (λ), typically between 0.95 and 0.999, assigns exponentially less weight to older data, enabling the filter to track time-varying channel statistics. This formulation provides the exact least squares solution for the finite data record available at each time step.
Recursive Inverse Covariance Update
The computational core of RLS is the recursive update of the inverse of the input signal's autocorrelation matrix. Using the Woodbury matrix identity (also known as the matrix inversion lemma), RLS avoids explicitly inverting a large matrix at each iteration. Instead, it computes a rank-1 update to the inverse correlation matrix with O(N²) complexity, where N is the filter length. This recursive formulation is what gives the algorithm its name and enables its fast convergence properties.
Kalman Gain Vector
At each iteration, RLS computes a Kalman gain vector that determines the optimal step size for updating filter coefficients. This gain vector is data-dependent and adjusts automatically based on the statistical properties of the input signal. Unlike the fixed step-size parameter in LMS, the Kalman gain provides an optimal variable learning rate for each filter tap, ensuring rapid convergence without manual tuning. The gain vector is computed from the inverse correlation matrix and the current input regressor.
Convergence Rate Independence
A critical property of RLS is that its convergence rate is independent of the eigenvalue spread of the input signal's autocorrelation matrix. In LMS, a wide eigenvalue spread—common in signals with strong spectral dynamics—causes dramatically slow convergence. RLS whitens the input data implicitly through its inverse correlation matrix, achieving convergence within approximately 2N iterations, where N is the filter order. This makes RLS ideal for channel estimation in frequency-selective fading environments.
Computational Complexity Trade-off
The superior convergence performance of RLS comes at a significant computational cost. Standard RLS requires O(N²) operations per iteration due to the matrix-vector multiplications in the gain vector and inverse correlation matrix updates. In contrast, LMS requires only O(N) operations. For a 32-tap equalizer, RLS may require over 1,000 multiply-accumulate operations per sample. Fast RLS variants, such as the QR-decomposition-based RLS and lattice RLS, reduce complexity to O(N) while preserving numerical stability.
Numerical Stability and Regularization
RLS is susceptible to numerical instability due to the accumulation of round-off errors in the recursive inverse correlation matrix update. The matrix may lose symmetry or positive definiteness over time, causing algorithm divergence. To mitigate this, regularization is applied by initializing the inverse correlation matrix as δ⁻¹I, where δ is a small positive constant. Additionally, square-root formulations—such as QR-RLS—propagate the Cholesky factor of the inverse correlation matrix, guaranteeing positive definiteness and improving numerical robustness in fixed-point implementations.
Frequently Asked Questions
Clear, technically precise answers to the most common questions about the Recursive Least Squares algorithm and its role in adaptive filtering and channel compensation.
The Recursive Least Squares (RLS) algorithm is an adaptive filtering technique that recursively computes the filter coefficients which minimize a weighted linear least squares cost function of the error signal. Unlike the simpler Least Mean Squares (LMS) algorithm, which uses a stochastic gradient descent based on the instantaneous error, RLS considers all past input data from the moment the algorithm was initialized. It achieves this by recursively updating the inverse of the input signal's autocorrelation matrix, effectively whitening the input data. This provides RLS with an order-of-magnitude faster convergence speed compared to LMS, making it highly effective in non-stationary environments where the underlying statistics change rapidly. The trade-off is a significantly higher computational complexity, scaling with O(N^2) arithmetic operations per iteration, where N is the filter length.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
Recursive Least Squares belongs to a family of adaptive algorithms that dynamically adjust filter coefficients to track time-varying channel conditions. These related techniques offer different trade-offs between convergence speed, computational complexity, and steady-state performance.
Least Mean Squares (LMS)
A stochastic gradient descent algorithm that updates filter coefficients using only the instantaneous estimate of the gradient. Unlike RLS, LMS does not require matrix inversion, making it computationally lightweight but significantly slower to converge.
- Complexity: O(N) per iteration vs RLS O(N²)
- Convergence: Slower, especially for correlated inputs
- Use case: Real-time applications where simplicity outweighs speed
- Trade-off: Lower computational cost at the expense of slower adaptation to channel changes
Kalman Filter Tracking
A recursive Bayesian estimator that predicts and corrects the state of a dynamic system using a state-space model. While RLS is a special case of the Kalman filter for static parameter estimation, the full Kalman filter explicitly models process noise and measurement noise covariances.
- State-space formulation: Models both system dynamics and observations
- Optimality: Minimum variance estimator for linear Gaussian systems
- RLS relationship: RLS emerges when the state transition matrix is identity
- Application: Tracking rapid phase and amplitude fluctuations in mobile channels
Minimum Mean Square Error (MMSE)
A statistical estimation framework that computes the optimal linear filter by minimizing the expected value of the squared error. Unlike RLS, which operates recursively on streaming data, MMSE typically requires batch knowledge of second-order statistics.
- Requires: Auto-correlation matrix R and cross-correlation vector p
- Solution: Wiener-Hopf equation w = R⁻¹p
- RLS connection: RLS recursively approximates the Wiener solution as new data arrives
- Benchmark: MMSE provides the theoretical performance bound that RLS asymptotically approaches
Constant Modulus Algorithm (CMA)
A blind adaptive equalization algorithm that exploits the constant envelope property of PSK and FM signals. Unlike RLS, which requires a known training sequence, CMA updates filter taps by penalizing deviations from a fixed modulus.
- Cost function: Minimizes (|y(n)|² - R₂)² where R₂ is a constant
- No training required: Operates without a reference signal
- Convergence: Generally slower than trained RLS
- Application: Initial acquisition phase before switching to decision-directed RLS for fine tracking
Decision Feedback Equalizer (DFE)
A non-linear equalization architecture that uses previously detected symbols to cancel post-cursor ISI. RLS is frequently employed as the coefficient update mechanism within the feedforward and feedback filters of a DFE.
- Structure: Feedforward filter + feedback filter + slicer
- RLS role: Adaptively updates both filter sections simultaneously
- Advantage: Handles severe multipath without noise enhancement
- Complexity: RLS-DFE provides faster convergence than LMS-DFE at higher computational cost
Forgetting Factor Selection
The exponential weighting parameter λ (0 < λ ≤ 1) controls RLS memory. Values closer to 1 provide better steady-state performance in stationary environments, while smaller values enable faster tracking of non-stationary channels.
- λ = 1: Infinite memory, optimal for stationary channels
- λ = 0.99: Effective memory of ~100 samples
- λ = 0.95: Effective memory of ~20 samples, aggressive tracking
- Trade-off: Smaller λ increases misadjustment noise but improves Doppler tracking capability

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us