In modern wireless communications, scaling up the number of antennas is the primary mechanism for boosting data rates and spectral efficiency. Technologies like Massive MIMO, Extremely Large-Scale MIMO (XL-MIMO), and Holographic MIMO pack dozens, hundreds, or even thousands of antennas onto base stations to serve multiple users simultaneously.
However, this architectural scaling hits a severe mathematical wall: the matrix inversion bottleneck. To eliminate multi-user interference or estimate wireless channels accurately, optimal linear signal processing techniques—such as Linear Minimum Mean Square Error (L-MMSE) equalization or Zero-Forcing (ZF) precoding—require the inversion of large covariance matrices. Because exact matrix inversion scales cubically ($O(M^3)$) with the number of antennas or users, computing these matrices in real time becomes computationally prohibitive.
Furthermore, exact matrix inversion is notoriously difficult to parallelize on specialized hardware like FPGAs or ASICs, creating severe processing latency and high power consumption. To deploy next-generation wireless networks, researchers have developed a suite of inversion-free approximations and iterative frameworks that transform this cubic bottleneck into highly parallelizable, lower-complexity operations.
The Intuition: Channel Hardening and Diagonal Dominance
To understand why we can bypass exact matrix inversion, we must look at the physics of large antenna arrays. As the number of base station antennas scales to infinity, the wireless channel vectors between different users tend to become mutually orthogonal. This phenomenon is known as channel hardening.
Mathematically, if $H$ is the channel matrix, the system matrix to be inverted (e.g., $A = H^H H + \sigma^2 I$) becomes increasingly diagonally dominant. The diagonal entries (representing the desired signal power) grow much larger than the off-diagonal entries (representing multi-user interference).
Because the matrix behaves almost like a diagonal matrix, we do not need to compute a full, expensive algebraic inverse. Instead, we can treat the off-diagonal elements as small perturbations and approximate the inverse using simpler, hardware-friendly operations.
Series Expansions: Turning Inversion into Multiplication
The most direct way to exploit diagonal dominance is through truncated series expansions, such as the Neumann series or optimized matrix polynomials.
A Neumann series approximates the inverse of a matrix $A$ by decomposing it into a diagonal matrix $D$ and a hollow matrix $E$ containing the off-diagonal elements ($A = D + E$). The inverse can then be expressed as an infinite geometric series:
$$A^{-1} = (D + E)^{-1} = \sum_{k=0}^{\infty} (-D^{-1}E)^k D^{-1}$$
Because $D$ is diagonal, its inverse $D^{-1}$ is trivial to compute (just the reciprocal of each diagonal element). If the matrix is strongly diagonally dominant, the terms $(-D^{-1}E)^k$ shrink rapidly as $k$ increases. This allows hardware designers to truncate the series after just a few terms (e.g., $k=1$ or $k=2$).
As shown by Michael Wu et al. in Large-Scale MIMO Detection for 3GPP LTE: Algorithms and FPGA Implementations, substituting exact inversion with a truncated Neumann series replaces $O(M^3)$ division-heavy operations with a sequence of matrix-vector multiplications. Matrix-vector multiplications scale at $O(M^2)$ complexity and are perfectly suited for the highly parallel multiply-accumulate (MAC) blocks inside FPGAs, enabling ultra-high throughput and low latency.
Beyond the standard Neumann series, the authors of Low-Complexity Channel Estimation in Large-Scale MIMO using Polynomial Expansion and Low-Complexity Polynomial Channel Estimation in Large-Scale MIMO With Arbitrary Statistics demonstrate that optimizing the coefficients of these matrix polynomials can provide near-optimal channel estimation accuracy while strictly maintaining an $O(M^2)$ complexity profile.
Exploiting Matrix Structure for Correlated Channels
While series expansions work beautifully when channels are perfectly independent, real-world wireless environments often suffer from spatial correlation. When users are close together or signal scattering is limited, the off-diagonal elements of the covariance matrix remain large, causing standard diagonal approximations to degrade.
To solve this, researchers look for richer structures that capture spatial correlation without triggering cubic complexity. For instance, Chuan Zhang et al. in On the Low-Complexity, Hardware-Friendly Tridiagonal Matrix Inversion for Correlated Massive MIMO Systems proposed a Tridiagonal Matrix Approximation (TMA). Instead of ignoring all off-diagonal interference, TMA preserves the main diagonal and the immediate sub- and super-diagonals, which capture the strongest correlations between adjacent antenna elements. Because tridiagonal systems can be solved in linear time ($O(M)$) using hardware-efficient pipelined solvers, this approach maintains high throughput even in highly correlated environments.
In other modulation schemes, such as Generalized Frequency Division Multiplexing (GFDM), the system matrices exhibit a block-circulant structure. As exploited by Maximilian Matthé et al. in Reduced Complexity Calculation of LMMSE Filter Coefficients for GFDM, circulant matrices can be diagonalized using the Discrete Fourier Transform (DFT). By shifting the problem into the frequency domain via the Fast Fourier Transform (FFT), the massive matrix inversion collapses into simple scalar divisions, dropping the computational overhead from $O(N^3)$ to $O(N \log N)$.
Iterative Solvers and Deep Unfolding
An alternative to explicitly approximating the inverse matrix $A^{-1}$ is to solve the linear system $Ax = b$ directly using iterative optimization algorithms, such as Coordinate Descent, Conjugate Gradient, or the Alternating Direction Method of Multipliers (ADMM).
Instead of performing a single massive calculation, these algorithms start with an initial guess for $x$ and iteratively nudge it closer to the true solution. For example, Xiaotong Zhao et al. in Decentralized Linear MMSE Equalizer Under Colored Noise for Massive MIMO Systems utilize a Block Coordinate Descent (BCD) algorithm to distribute the computational load across a decentralized base station architecture, completely avoiding centralized matrix inversion. Similarly, the authors of Low Complexity SLP: An Inversion-Free, Parallelizable ADMM Approach leverage ADMM to create an inversion-free framework for symbol-level precoding.
Deep Unfolding: The Best of Both Worlds
While iterative solvers bypass matrix inversion, they introduce a new problem: they can require dozens of iterations to converge, which introduces processing latency that violates the strict timing constraints of 5G and 6G networks.
To accelerate convergence, researchers have turned to deep unfolding (or deep unrolling). In this paradigm, a classical iterative algorithm is mapped directly onto the layers of a neural network. Each layer represents a single iteration of the optimization algorithm, but the step sizes and projection parameters are treated as learnable weights.
Classical Iterative Step: x_{k+1} = Proj( x_k - α * A^T(Ax_k - b) ) [α is fixed/hand-tuned]
↓
Deep Unfolded Layer: x_{k+1} = Proj( x_k - w_k * A^T(Ax_k - b) ) [w_k is learned offline]
By training the network offline on simulated channel data, the model learns the mathematically optimal step sizes ($w_k$) for each specific iteration. As a result, the unfolded network can achieve the same accuracy as a classical solver in a fraction of the steps.
Yi Wei et al. demonstrated this synergy in Learned Conjugate Gradient Descent Network for Massive MIMO Detection, where they unrolled a conjugate gradient descent algorithm into a neural network. By learning the optimization parameters on the fly, their network bypasses exact matrix inversions entirely and matches L-MMSE performance within just a few layers.
Similarly, Haochuan Song et al. in Soft-Output Joint Channel Estimation and Data Detection using Deep Unfolding utilized a hyper-network to dynamically tune an unfolded joint estimation framework, proving that model-driven deep learning can successfully mitigate the computational scaling bottlenecks of massive antenna arrays.