⚛️ quantum physics

Interferometric Quantum Polynomial Chaos Expansion as a Generative Model for Calorimeter Shower Simulation

This paper introduces Interferometric Quantum Polynomial Chaos Expansion (IQPCE), a generative quantum model that learns calorimeter shower data by fitting gate angles to encode correlations via entanglement, demonstrating superior expressivity, certified non-classical correlations, and the ability to overcome classical limitations in tail dependence when executed on superconducting hardware.

Original authors: Jamal Slim, Saverio Monaco, Florian Rehm, Dirk Kruecker, Frank Gaede, Kerstin Borras

Published 2026-08-07

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Jamal Slim, Saverio Monaco, Florian Rehm, Dirk Kruecker, Frank Gaede, Kerstin Borras

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

The Quantum Kitchen and the Shower of Particles

Imagine you are trying to simulate a massive, chaotic explosion, like a star collapsing or a particle smashing into another at near-light speed. In the world of high-energy physics, scientists use giant detectors called calorimeters to catch the debris of these collisions. But simulating how these particles spread out and interact is incredibly hard. It's like trying to predict exactly how a million drops of water will splash when they hit a floor, but the water is made of quantum particles that behave in weird, unpredictable ways. Currently, supercomputers spend a huge amount of time and energy just to generate these "shower" images, which are needed to understand what happens in experiments like those at the Large Hadron Collider.

To speed things up, scientists have tried using "generative models"—computer programs that learn from real data and then create new, fake images that look just like the real ones. Usually, these are classical computer programs. But recently, a team of researchers asked: "What if we used a quantum computer?" Quantum computers are special machines that use the rules of quantum mechanics, where things can be in multiple states at once. The big challenge has been figuring out how to make a quantum computer generate complex, realistic images without getting lost in the noise or needing a classical computer to do the heavy lifting. This paper introduces a new method called "Interferometric Quantum Polynomial Chaos Expansion" (QPCE) that tries to solve this by making the quantum circuit itself the entire artist, with no classical helpers needed.

The Quantum Artist Who Paints with Light

Think of a quantum computer as a very complex, magical kaleidoscope. In the past, if you wanted to use a kaleidoscope to paint a picture, you might have needed a human artist (a classical computer) to arrange the mirrors and then look through the tube to see what came out. But the researchers in this paper built a kaleidoscope that paints the picture for you, all by itself.

They call their creation a Quantum Polynomial Chaos Expansion. That's a mouthful, so let's break it down with a simpler story. Imagine you are baking a cake, and the "randomness" of the ingredients (like how much sugar or flour you add) is the secret sauce that makes every cake unique. In a normal recipe, you write down the exact amounts of ingredients (the coefficients) and mix them. In this new quantum recipe, the "ingredients" are just random numbers (called "germs") that you feed into the machine. The machine doesn't have a recipe book; instead, it has a set of knobs (gates) that it turns.

Here is the magic trick: The researchers found a way to feed these random numbers into the machine over and over again at every step of the process. It's like adding a pinch of salt, then mixing, then adding another pinch, then mixing again. By doing this, the machine builds up a complex pattern. The deeper the machine goes (the more steps it takes), the more complex the pattern becomes. They proved that the "depth" of the machine is exactly the same as the "order" of the complexity, meaning the machine knows exactly how complicated its own painting is.

The "Shower" and the Quantum Circuit

The team tested this on a specific problem: simulating a "calorimeter shower." When a high-energy particle hits a detector, it creates a cascade of other particles, looking like a shower of sparks spreading across a grid of sensors. They used data from a simulation called Geant4 (which is like the gold standard for these particle showers) to train their quantum model.

Instead of using a hybrid system where a classical computer does most of the work, they made the quantum circuit the entire model.

The Input: They fed the machine random numbers.
The Process: The machine ran a specific sequence of quantum gates (rotations and entanglements).
The Output: They measured the machine, and the results were converted into the intensity of the "pixels" in the shower image.

The most exciting part is that they didn't have to fit any classical numbers. The only things they "trained" were the angles of the quantum gates. It's as if they taught the kaleidoscope how to turn its mirrors, and once it learned, it could generate infinite new, realistic showers just by spinning the random numbers.

Proving the Magic is Real (and Not a Trick)

One of the biggest problems with quantum models is that it's hard to tell if the quantum part is actually doing anything special, or if a classical computer could have done it just as well. The authors of this paper were very clever about this. They built a "switch" into their model.

They designed the circuit so that they could turn off the "entanglers" (the parts that make the quantum particles talk to each other).

When the switch was ON: The model generated a realistic shower with all the correct correlations (the sparks were connected in the right way).
When the switch was OFF: The model generated completely independent, random sparks. No correlations at all.

This proved that the "magic" of the correlations came only from the quantum entanglement. They also tested a "shared wire" concept, where one random number was fed to every part of the machine. This acted like a common mood for the whole shower, helping to create a global pattern. By turning this on and off, they could measure exactly how much of the pattern came from the global mood versus the local quantum connections.

The Results: Simulated and on Real Hardware

The team ran their model in two ways:

Perfect Simulation: They simulated the quantum computer on a classical supercomputer with no errors. Here, the model was incredibly good. It captured 99.1% of the complex dependencies found in the real data. The images looked almost identical to the Geant4 simulations.
Real Hardware: They ran the exact same circuit on a real quantum computer at IBM (called ibm fez). This machine has noise and errors, just like a real-world instrument. Even with these imperfections, the model still worked! It captured 87.3% of the dependencies.

The researchers were very careful to predict how much the "shot noise" (the randomness of measuring quantum particles) would weaken the results before they even ran the experiment. They found that the real machine performed almost exactly as their math predicted, with only a tiny bit of extra error from the hardware itself.

What This Means (and What It Doesn't)

This paper is a big step forward because it shows a quantum computer can generate complex, realistic data without needing a classical computer to help it interpret the results. It also proves that the quantum part is actually responsible for the correlations, not just a fancy wrapper around a classical trick.

However, the authors are very honest about the limits.

It's not a "quantum advantage" yet: They admit that for the size of the problem they solved (8 "pixels" or cells), a classical computer could still simulate it easily. They didn't claim to have beaten classical computers at speed.
The "Tail" Problem: They found that while their model was great at capturing the main features of the shower, it struggled a little bit with the very rare, extreme events (the "tails" of the distribution). They proved mathematically that their specific type of smooth quantum model cannot perfectly reproduce these extreme tails in the long run. This isn't a failure; it's a discovery that tells them what kind of new quantum architecture they will need to build next time.

In short, this paper presents a new, self-contained quantum artist that can paint realistic particle showers. It proves that the quantum part is doing the heavy lifting, it works on real hardware, and it gives scientists a clear map of what works and what needs to be improved for the next generation of quantum simulators. It's a solid, verified step toward using quantum computers to help us understand the universe, one shower at a time.

Technical Summary: Interferometric Quantum Polynomial Chaos Expansion as a Generative Model for Calorimeter Shower Simulation

Problem Statement
Calorimeter simulation in high-energy physics represents a significant computational burden, with the High-Luminosity LHC expected to generate $O(10^{10})$ events annually. While classical generative models (e.g., GANs, VAEs, diffusion models) can reproduce shower images, they require millions of trainable parameters. Quantum generative models offer a potential advantage by representing distributions over $2^n$ dimensions with only $O(n)$ parameters. However, existing quantum approaches face two primary hurdles:

The Attribution Problem: In hybrid quantum-classical models, the classical network absorbs most of the fitting capacity, making it impossible to isolate the contribution of the quantum circuit.
Readout Limitations: Fully quantum models (e.g., Born machines) typically output bitstrings, which are unsuitable for the continuous, calibrated intensities required for calorimeter data. Furthermore, many fully quantum models lack a mechanism to verify that correlations arise from entanglement rather than classical shared inputs.

Methodology: Quantum Polynomial Chaos Expansion (QPCE)
The authors propose the Quantum Polynomial Chaos Expansion (QPCE), a fully quantum generative model where a single quantum circuit serves as the entire model. The architecture is defined by three core principles:

Circuit as the Expansion: Unlike classical Polynomial Chaos Expansions (PCE) where coefficients are fitted to a fixed basis, QPCE treats the quantum circuit itself as the expansion. The randomness (germs) is the only input, entering the circuit as rotation angles.
Germ Re-uploading: The model employs a "re-uploading" strategy where $n$ private uniform germs ( $\epsilon$ ) and one shared germ ( $\epsilon_0$ ) are injected as rotation angles at the beginning of every block of the circuit. If the circuit has depth $L$ , this construction ensures that the expectation value of any observable is a trigonometric polynomial of exact degree $L$ in the germs. Thus, the circuit depth $L$ acts as the truncation order of the chaos expansion.
Linear Readout without Data Embedding: The circuit receives no data encoding; it is conditioned solely on noise. The output intensities for $n$ calorimeter cells are derived linearly from the expectation values of Pauli-Z operators on $n$ qubits: $Y_i = m_i + s_i \langle Z_i \rangle$ . The constants $m_i$ and $s_i$ are fixed unit conversions derived from the training data range and are never fitted.

Key Architectural Features

Entanglement Channels: Dependence is generated through two designed channels: (1) Two-qubit couplers (continuous $R_{ZZ}$ gates) and (2) A single shared germ wire ( $\epsilon_0$ ) read by every qubit.
Verification Protocol: The model includes a built-in verification mechanism. By setting the coupler angles to zero and freezing the shared germ, the model is provably reduced to a state of exact conditional independence. This allows the authors to isolate and measure the contribution of entanglement versus the shared latent channel.
Hardware-Native Topology: The model is designed for the heavy-hex lattice of the IBM hardware. It uses a 7-edge path graph (native to the hardware, requiring zero SWAPs) rather than a dense ring graph, minimizing circuit depth and error accumulation.

Key Contributions

Zero Fitted Classical Parameters: The model contains no classical trainable parameters (no linear layers, no classical heads). The only fitted quantities are the 154 gate angles of the quantum circuit.
Provable Attribution: The paper establishes that switching off the entanglers yields exactly independent outputs (Proposition 1). This allows for a decomposition of the generated dependence into an "entangler channel" and a "shared-latent channel," a capability absent in hybrid models.
Bell Violation Certification: The trained model violates the Bell bound (CHSH inequality) obeyed by every classical generative model with local response. This certification is achieved by choosing between two measurement bases shot-by-shot, proving the model generates non-classical correlations without needing a specific Bell objective in the loss function.
No-Go Theorem for Tail Dependence: The authors prove a no-go theorem (Proposition 4) stating that any smooth expectation-value readout of absolutely continuous latents cannot produce intermediate asymptotic tail dependence (values strictly between 0 and 1). This identifies a fundamental limitation of the current architecture for asymptotic tails, distinguishing it from the target data's behavior.

Results
The model was trained on Geant4 shower data for an 8-cell CLIC calorimeter ( $n=8$ ) and executed on the ibm_fez processor.

Simulation Performance: In noiseless simulation, the model achieved a rank-dependence effect size $D = 0.991$ (where 1.0 is perfect match to data dependence) and a mean Spearman rank correlation $|\rho_S| = 0.566$ (compared to 0.576 in data).
Hardware Execution: On the ibm_fez device, the model achieved $D = 0.873$ and mean $|\rho_S| = 0.5246$ . The authors predicted the shot-noise contraction analytically before deployment; after deconvolving this effect, the residual device error was isolated to a small deficit of 0.02 in mean $|\rho_S|$ .
Tail Asymmetry: The model successfully reproduced the sign and 62% of the magnitude of the target's tail asymmetry ( $\Lambda = 0.060$ vs. data's $0.097$), a feature that standard elliptical models (like Gaussian references) fail to capture entirely (fixing it at 0).
Verification: The verification protocol confirmed that removing entanglers reduced correlations to sampling noise levels ( $|\rho_S| \approx 0.019$ ), while the shared wire alone contributed a mean $|\rho_S| = 0.112$ .

Significance and Claims
The paper does not claim computational quantum advantage in terms of hardness (the $n=8$ model is classically simulable with polynomial cost). Instead, its significance lies in verifiability, attribution, and deployability:

Attribution: It demonstrates a generative model where the source of correlations (entanglement vs. shared noise) can be measured and certified, solving the attribution problem inherent in hybrid models.
Deployability: It presents a fully quantum model that runs on current hardware with a predictable error budget and zero classical overhead, successfully generating continuous physical observables.
Architectural Insight: The work identifies that while smooth expectation-value readouts are limited in asymptotic tail dependence, the finite-quantile asymmetry observed in calorimeter data is reproducible. It suggests that future architectures requiring intermediate asymptotic tail dependence would need discrete common latents (e.g., via mid-circuit measurement and feed-forward), a direction identified as a specific architectural requirement rather than a tuning problem.

The authors conclude that the QPCE framework proves a generative model can be entirely quantum, carry rich dependence structures suitable for real detector data, and certify its own quantum resources through measurement rather than argument.