📊 statistics

High-Resolution Tensor-Network Fourier Methods for Exponentially Compressed Non-Gaussian Aggregate Distributions

This paper demonstrates that the characteristic functions of weighted sums of independent random variables possess a low-rank quantized tensor train (QTT) structure, enabling exponentially compressed representations that allow for high-resolution, efficient computation of non-Gaussian aggregate distributions and financial risk metrics like Value at Risk and Expected Shortfall.

Original authors: Juan José Rodríguez-Aldavero, Juan José García-Ripoll

Published 2026-03-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Juan José Rodríguez-Aldavero, Juan José García-Ripoll

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to predict the total weight of a giant bag of marbles. But these aren't just any marbles; some are heavy, some are light, some are bouncy, and some are sticky. You have thousands of them, and you want to know the exact probability of the bag weighing exactly 50 pounds, or 51 pounds, or any specific amount.

In the real world, this is like calculating the risk of a massive investment portfolio or the total signal interference in a wireless network. It's a "weighted sum" of many random things.

The problem is that doing this math is incredibly hard. Traditional methods are like trying to count every single grain of sand on a beach one by one (too slow) or guessing by throwing darts at a map (too inaccurate, especially for rare events like a massive financial crash).

This paper introduces a brilliant new way to solve this problem using a concept called "Tensor Networks" (specifically QTT). Here is the simple breakdown of how it works, using some everyday analogies.

1. The Problem: The "Curse of the Giant Spreadsheet"

Imagine you have a spreadsheet to calculate the outcome of 300 different random events.

The Old Way (Dense Methods): To get the answer, you need a spreadsheet with a row for every single possible combination. If you have 300 events, the number of rows becomes a number so huge it exceeds the number of atoms in the universe. Your computer would crash instantly trying to load it.
The Monte Carlo Way (Guessing): You simulate the scenario a million times. It's faster, but if you want to know the odds of a "once-in-a-lifetime" disaster (a rare event), you might need to simulate it a trillion times to see it happen even once. It's inefficient and slow.

2. The Solution: The "Magic Compression"

The authors discovered that while the list of all possibilities is huge, the pattern of the answer is actually very simple and smooth.

Think of a high-resolution photo of a sunset. It has millions of pixels. But if you look at the colors, they blend smoothly from orange to purple. You don't need to store the color of every single pixel individually; you can describe the whole image with a few simple rules about how the colors fade.

The authors found that the "mathematical picture" of these random sums (called the Characteristic Function) has this same smooth, simple pattern. It's like the sunset photo. Even though the underlying data is messy and non-Gaussian (not a simple bell curve), the "frequency map" of the data is smooth.

3. The Tool: The "Tensor Train" (The Origami Fold)

They use a technique called Quantized Tensor Train (QTT).

The Analogy: Imagine you have a massive, stiff piece of paper (the full data). Trying to move it is impossible. But if you fold it into a specific, intricate origami shape (the Tensor Train), it becomes a tiny, manageable object that still holds all the information of the original sheet.
How it works: Instead of storing the whole spreadsheet, the computer stores just the "folding instructions" (the low-rank structure). This allows them to compress the data by exponential amounts.
- Instead of needing a supercomputer to hold the data, they can run it on a standard laptop.
- Instead of taking days to calculate, it takes seconds.

4. The "Aha!" Moment: When Does It Work?

The paper tests this on two types of problems:

The "Messy" Discrete Case (The Jumbled Marbles):
Imagine adding up random integers. For a small number of items, the pattern is chaotic and impossible to compress. But the authors found a "tipping point." Once you have about 300 items, the chaos suddenly organizes itself. The "folding instructions" become incredibly short. It's like a crowd of people shouting; individually, it's noise, but once the crowd gets big enough, a smooth, predictable wave of sound emerges.
- Result: They can calculate the risk of a portfolio with 300+ assets in a fraction of a second, something that used to be impossible.
The "Smooth" Continuous Case (The Liquid Mixture):
Imagine mixing different liquids (like log-normal distributions). These are naturally smooth. The "folding" works perfectly here too, allowing them to zoom in with extreme precision (billions of data points) without the computer running out of memory.

5. Why Should You Care? (The Real-World Impact)

This isn't just abstract math. It changes how we handle risk in the real world:

Finance: Banks can calculate "Value at Risk" (how much money they might lose in a crash) and "Expected Shortfall" (how bad the crash would be) with extreme precision, even for complex portfolios. They can see the "tail risks" (the rare disasters) that other methods miss.
Engineering: It helps engineers predict signal interference in 5G/6G networks or the reliability of complex systems with thousands of parts.

Summary

The paper says: "Stop trying to count every grain of sand. Instead, look at the shape of the dune."

By realizing that the "shape" of these complex probability problems is smooth and compressible, the authors built a tool that turns an impossible calculation into a trivial one. They turned a mountain of data into a pebble, allowing us to solve problems that were previously too big for our computers.

1. Problem Statement

The paper addresses the computational challenge of evaluating the probability distribution of weighted sums of independent random variables ( $X = \sum w_d X_d$ ). These models are fundamental in fields like quantitative finance (credit risk, portfolio valuation), reliability engineering, and wireless communications.

Key Challenges:

Lack of Closed Forms: The probability density function (PDF) of such sums generally lacks a closed-form expression, especially for non-Gaussian components (e.g., lognormal or Bernoulli variables).
Curse of Dimensionality: Direct evaluation requires multidimensional convolution integrals, which scale exponentially with the number of components ( $D$ ).
Limitations of Existing Methods:
- Monte Carlo Sampling: Converges slowly ( $O(S^{-1/2})$ ) and requires prohibitively large sample sizes to accurately resolve tail probabilities (Value at Risk, Expected Shortfall).
- Recursive Convolution: Exact for discrete models but scales with the support size, which grows exponentially ( $M \approx 2^D$ ) for incommensurate weights.
- Standard Fourier Methods: While they convert convolution to pointwise multiplication, they suffer from Gibbs oscillations near discontinuities and require dense grids ( $N$ ) that become memory-prohibitive for high-resolution needs (e.g., $N > 2^{24}$ ).

2. Methodology

The authors propose a novel algorithm combining Fourier spectral methods with Tensor Network techniques, specifically Quantized Tensor Trains (QTT), also known as Matrix Product States (MPS).

Core Concept: Low-Rank Characteristic Functions

The method exploits the fact that the global characteristic function (CF) of a weighted sum, $\phi_X(\omega) = \prod \phi_{X_d}(w_d \omega)$ , exhibits a low-rank structure in the QTT representation, even when the underlying distribution is non-Gaussian.

QTT Representation: The frequency domain is discretized on a grid and reshaped into a binary (or $\ell$ -ary) representation. The CF is encoded as a sequence of low-rank tensors (cores).
Construction:
1. Local CFs: Individual characteristic functions are encoded as QTTs. For discrete variables, this is an exact sum of exponentials; for continuous variables, it uses Tensor Cross-Interpolation (TCI) or Gauss-Hermite quadrature (for lognormals).
2. Hadamard Products: The global CF is constructed by sequentially multiplying local CFs using QTT Hadamard products, followed by truncation (via TT-SVD) to maintain low bond dimensions.
3. Spectral Filtering: To mitigate Gibbs oscillations caused by discontinuities in the CDF, smooth spectral filters are applied directly to the tensor network representation.
4. Inversion: The Probability Density Function (PDF) and Cumulative Distribution Function (CDF) are recovered via a tensorized inverse Fourier transform (superfast Fourier transform), which operates efficiently on low-rank tensors.

Post-Processing

The compressed QTT representation allows for the direct computation of risk metrics without materializing the full dense vector:

Value at Risk (VaR): Computed via a binary search algorithm directly on the QTT cores.
Expected Shortfall (ES): Computed via masked integration (inner product) on the QTT representation.

3. Key Contributions

Discovery of CLT-Driven Compressibility:
The paper demonstrates that for discrete models (like weighted sums of Bernoulli variables), the QTT bond dimension undergoes a sharp collapse as the number of components $D$ increases (specifically $D \gtrsim 300$ ). This is driven by the Central Limit Theorem (CLT), which causes high-frequency quasiperiodic modes to decorrelate and be multiplicatively suppressed, concentrating spectral energy into a smooth, low-rank envelope. This occurs even when the target distribution is far from Gaussian.
Exponential Compression for Continuous Models:
For sums of lognormal variables (which have heavy tails and no closed-form CF), the method achieves high-resolution discretizations ( $N = 2^{30}$ frequency modes) on standard hardware. This far exceeds the $N \approx 2^{24}$ limit of dense implementations, enabled by the intrinsic spectral smoothness of the local CFs.
Polylogarithmic Complexity:
The algorithm achieves polylogarithmic time and memory scaling with respect to the grid size $N$ (i.e., $O(\log N)$ or $O(\log \log N)$ ) and linear/polylogarithmic scaling with $D$ . This contrasts with the linear scaling ( $O(N)$ ) of dense methods and the quadratic scaling ( $O(N^2)$ ) of Monte Carlo for equivalent accuracy.
Rigorous Convergence Guarantees:
The authors provide theoretical bounds showing that spectral filtering ensures pointwise convergence away from discontinuities and global $L^p$ convergence with rates determined by the filter order, independent of the specific distribution.

4. Results

Discrete Models (Weighted Poisson-Binomial):
- Small $D$ : The system is incompressible (adversarial regime) with near-maximal bond dimensions.
- Large $D$ ( $>300$ ): A phase transition occurs. The bond dimension collapses to a small constant, enabling memory savings of orders of magnitude (kilobytes vs. megabytes) and runtime speedups of several orders of magnitude compared to dense spectral methods.
- Accuracy: The method accurately captures non-Gaussian features and tail risks (VaR/ES) where Gaussian approximations fail.
Continuous Models (Lognormal Sums):
- The method successfully resolved $N=2^{30}$ frequency modes, a scale impossible for dense FFTs due to memory constraints.
- It achieved high precision in reconstructing heavy-tailed distributions, demonstrating that the low-rank structure persists despite the lack of a closed-form CF.
Performance Comparison:
- vs. Monte Carlo: The spectral method offers a quadratic speedup ( $O(\epsilon^{-1})$ vs $O(\epsilon^{-2})$ ) for a given error tolerance $\epsilon$ .
- vs. Dense Spectral: The QTT method provides exponential speedups in time and memory for high-resolution requirements.

5. Significance and Impact

Quantitative Finance: Enables the precise calculation of risk metrics (VaR, ES) for large, heterogeneous portfolios with non-Gaussian assets, a task previously limited by computational cost or reliance on inaccurate Gaussian approximations.
General Applicability: The framework is model-agnostic, applicable to both discrete and continuous variables, and does not require the underlying distribution to be close to Gaussian.
Scalability: By leveraging tensor networks, the method overcomes the "curse of dimensionality" for aggregate distributions, making high-resolution probabilistic modeling feasible on standard hardware.
Theoretical Insight: The identification of a "compressibility transition" in discrete sums driven by the CLT provides a new perspective on the spectral properties of aggregate random variables.

In summary, this work establishes a powerful, scalable framework for computing fully non-Gaussian aggregate distributions, bridging the gap between high-resolution spectral accuracy and the computational efficiency of tensor networks.