⚛️ quantum physics

Representational separation between unitary and channel quantum generative models via shared classical randomness at shallow depth

This paper proves that augmenting shallow, bounded-connectivity unitary quantum circuits with shared classical randomness creates a strictly more powerful generative model capable of producing long-range correlations that would otherwise require linear depth in a purely unitary setting, with measurement-based quantum computation offering a natural implementation for this advantage.

Original authors: Arunava Majumder, Marius Krumm, Hendrik Poulsen Nautrup, Hans J. Briegel

Published 2026-08-06

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Arunava Majumder, Marius Krumm, Hendrik Poulsen Nautrup, Hans J. Briegel

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 build a machine that can learn to paint like a master artist. In the world of quantum computing, these machines are called "quantum generative models." Their job is to take a blank canvas (a quantum state) and, through a series of twists and turns (quantum gates), create a specific pattern of colors (a probability distribution) that looks just like the data they were trained on. But here's the catch: the quantum computers we have right now are like clumsy, short-attention-span artists. They can only perform a few quick moves before they get tired and make mistakes. This limit is called "shallow depth." Because they can't move far, they struggle to connect dots that are far apart on the canvas. If you want the top-left corner of the painting to match the bottom-right corner, a shallow machine usually can't do it; the information just doesn't have time to travel that far.

Scientists have been asking a big question: Can we make these clumsy, shallow quantum artists better at connecting distant dots without giving them more time or stronger muscles? Usually, the answer seems to be "no," unless you add complex new hardware. But what if the secret ingredient isn't a stronger quantum tool, but something much simpler and classical, like a shared coin flip? This paper explores whether a tiny bit of shared randomness—something two distant parts of the machine can agree on instantly, without talking—can help a shallow quantum model create patterns that a standard, purely quantum model simply cannot.

The researchers, Arunava Majumder and his team from the University of Innsbruck, set out to test this idea. They discovered that yes, sharing a simple classical random bit (like a coin toss result) between two far-apart parts of a quantum circuit can strictly improve what the machine can create. They proved that by adding this shared randomness, the model can generate long-range correlations—patterns where distant bits of data are linked together—that a standard shallow quantum model is mathematically incapable of producing, no matter how you tune its knobs.

To understand how this works, imagine a line of people passing a secret message. In a standard shallow quantum circuit, the message can only travel a few steps before the process stops. If person #1 needs to coordinate with person #6, and the message can only travel two steps, they can never sync up. However, the researchers showed that if you give person #1 and person #6 a shared piece of paper with a random number on it (the shared classical randomness), they can both react to that number at the exact same time. Even though they never passed a message between them, their actions become perfectly coordinated.

In the language of the paper, they took a standard "brickwall" quantum circuit (a common design where gates act on neighbors) and inserted a special "stochastic Pauli string." This is a fancy way of saying they applied a random flip (like a coin toss) to specific qubits (quantum bits) at the same time. If the coin lands heads, they flip both distant qubits; if tails, they do nothing. Because this decision is made by a single classical random bit shared across the system, the two distant qubits become correlated. The authors proved analytically that for a one-dimensional line of qubits, a purely quantum model would need a circuit depth that grows linearly with the distance between the qubits (specifically, a depth of at least $N-1$ for $N$ qubits) to achieve the same result. In contrast, their shallow model with shared randomness achieved it with a fixed, shallow depth.

The team didn't just do the math; they also ran simulations to see if this worked in practice. They trained both a standard quantum model and their new "shared randomness" model to learn a specific pattern: a mix of two distinct states (one where all bits are 0, and another where all bits are 1). The results were clear. The model with shared randomness consistently learned the pattern much better, achieving lower error rates and finding the solution more reliably than the standard model. They found that the standard model often got stuck, unable to figure out how to link the distant parts of the pattern, while the shared-randomness model breezed through it.

Importantly, the paper is careful to clarify what this doesn't mean. This isn't a claim that quantum computers are now beating classical computers at everything. Instead, it's a proof that within the specific, limited world of shallow quantum circuits, adding a tiny bit of classical coordination creates a strictly larger family of possible outputs. It's a "representational separation," meaning the two types of models can create different things, and the new one can do things the old one physically cannot.

The researchers also showed how this could be naturally implemented in a different style of quantum computing called Measurement-Based Quantum Computation (MBQC). In MBQC, the computation happens by measuring a giant entangled state. The results of these measurements are inherently random. The paper suggests that by simply choosing to keep or correct these random measurement outcomes in a coordinated way, you can naturally create this shared randomness without needing any extra hardware. It's like realizing that the "noise" in the system is actually a feature you can use.

In conclusion, the paper demonstrates that shared classical randomness is a powerful, low-cost resource. It allows shallow quantum models to punch above their weight class, creating complex, long-range patterns that would otherwise require much deeper, more error-prone circuits. For the future of quantum hardware, where deep circuits are hard to build, this suggests a clever workaround: don't just try to build bigger quantum machines; instead, let them share a little bit of classical luck.

Technical Summary: Representational Separation via Shared Classical Randomness

Problem Statement
Near-term quantum hardware imposes strict constraints on quantum generative models, specifically limiting circuit depth and enforcing geometrically local connectivity. These restrictions hinder the ability of shallow unitary Born models to establish long-range correlations between distant qubits, as information propagation is confined to finite light cones. While introducing stochasticity (channel models) has been shown to improve empirical performance and representational power in restricted small-scale architectures, it remained an open question whether shared classical randomness could provide a provable, strictly scalable representational separation over purely unitary shallow-depth models for arbitrarily large systems. Specifically, can the family of output distributions be strictly enlarged without increasing circuit depth, adding long-range entangling gates, or utilizing adaptive mid-circuit measurements?

Methodology
The authors propose a "minimal correlated channel model" that augments bounded-connectivity shallow unitary circuits with shared classical randomness.

Model Construction: The model consists of a standard shallow unitary circuit (e.g., a 1D brickwall architecture) followed by computational-basis measurements. An intermediate layer is augmented with a stochastic Pauli string $P^s_M = \bigotimes_{j \in M} P^s_j$ , where $M$ is a subset of spatially separated qubits.
Shared Randomness Mechanism: The application of this Pauli string is controlled by a single classically sampled random bit $s \sim \text{Bernoulli}(p)$ . If $s=1$ , the Pauli string is applied; if $s=0$ , it is omitted. This creates a stochastic channel where the joint application of local Pauli operations on distant qubits is correlated by a single classical variable.
MBQC Realization: The paper demonstrates that this shared randomness arises naturally in Measurement-Based Quantum Computation (MBQC). In variational MBQC (VMBQC), measurement outcomes are inherently random. By adaptively choosing whether to correct or retain (or even anti-correct) measurement-induced Pauli byproducts based on a shared classical control variable, one can natively implement the required correlated stochastic channel without additional quantum resources.
Learning Framework: The models are trained using the Maximum Mean Discrepancy (MMD) loss to approximate target distributions. The study compares the learning performance of the pure unitary model against the shared-randomness channel model.

Key Contributions

Provable Representational Separation: The paper establishes a strict inclusion $P_{\text{unit}}(D) \subsetneq P_{\text{ch}}(D)$ for shallow depths $D$ . It proves that there exist output distributions generated by the channel model that cannot be reproduced by any unitary model of the same depth on a bounded-degree local architecture.
Depth Lower Bound: For one-dimensional nearest-neighbor architectures, the authors show that reproducing the long-range correlations generated by the channel model using a purely unitary model requires a circuit depth scaling linearly with the distance between the correlated regions, i.e., $D = \Omega(\text{dist}(a,b))$ . In the worst case for a system of size $N$ , this implies a depth requirement of $\Omega(N)$ , whereas the channel model achieves this at constant shallow depth.
Mechanism of Separation: The separation is not due to trivial classical post-processing of measurement outcomes. Instead, the shared randomness encodes correlated sign flips in the non-Clifford rotation angles of intermediate layers. These angle flips alter the circuit dynamics non-trivially, generating long-range correlations in the final probability distribution that disjoint light cones in a shallow unitary circuit cannot access.
MBQC Integration: The work provides a concrete mapping of this theoretical construct to VMBQC, showing that the "shared randomness" resource is effectively a classical coordination of byproduct corrections, requiring no extra quantum hardware overhead.

Results

Analytical: Theorem 4 formally demonstrates that for a 1D brickwall circuit with $N \ge 6$ qubits, a channel model with a single stochastic Pauli string acting on distant qubits $a$ and $b$ can generate a distribution $Q^*$ that is $\delta^*$ -far (in total variation distance) from any distribution generated by a unitary model of depth $D < \text{dist}(a,b)/4$ .
Numerical: Experiments on a 6-qubit, depth-2 architecture trained to approximate a "branch-peaked mixture" distribution (a mixture of two distributions peaked at $000000$ and $111111$) show that the correlated channel model consistently achieves significantly lower MMD loss and exhibits less variance across random initializations compared to the unitary baseline. The channel model successfully learns the target distribution, while the unitary model struggles to capture the long-range correlations inherent in the target.

Significance and Claims
The authors explicitly state that these results do not claim a quantum advantage over classical computation. Instead, the significance lies in establishing a representational separation between two classes of quantum generative models subject to identical shallow, local quantum resource constraints.

Resource Efficiency: The additional resource required is "shared classical randomness," which is described as a comparatively weak resource from entanglement theory and is "classically cheap" to implement.
Hardware Implications: For hardware with limited connectivity (e.g., nearest-neighbor superconducting qubits or neutral atoms), this approach offers a method to generate long-range correlations without the need for deep circuits (which suffer from barren plateaus) or long-range gates.
MBQC Relevance: In MBQC implementations, the resource is even more natural, as the randomness is intrinsic to the measurement process, requiring only classical feedforward logic to coordinate the retention of byproducts.

The paper concludes that shared classical randomness, when structured to coordinate local operations, provides a genuine representational advantage at shallow depth, strictly enlarging the family of accessible output distributions beyond what is possible with unitary evolution alone under the same architectural constraints.

Technical Summary: Representational Separation via Shared Classical Randomness

More like this